feat: add tracing for evaluate_script, ipc_handler and custom_protocols

.changes/tracing.md

@@ -0,0 +1,5 @@
+---
+"wry": patch
+---
+
+Added tracing spans for `evaluate_script`, `ipc_handler` and `custom_protocols` behind the `tracing` feature flag.

Cargo.toml

@@ -43,13 +43,15 @@ os-webview = [
   "x11-dl",
   "gdkx11"
 ]
+tracing = [ "dep:tracing" ]
 
 [build-dependencies]
 cfg_aliases = "0.1"
 
 [dependencies]
 libc = "0.2"
 log = "0.4"
+tracing = { version = "0.1", optional = true }
 once_cell = "1"
 serde = { version = "1.0", features = [ "derive" ] }
 serde_json = "1.0"

src/android/binding.rs

@@ -10,13 +10,13 @@ use jni::errors::Result as JniResult;
 pub use jni::{
   self,
   objects::{GlobalRef, JClass, JMap, JObject, JString},
-  sys::{jboolean, jobject, jstring},
+  sys::{jboolean, jint, jobject, jstring},
   JNIEnv,
 };
 pub use ndk;
 
 use super::{
-  ASSET_LOADER_DOMAIN, IPC, ON_LOAD_HANDLER, REQUEST_HANDLER, TITLE_CHANGE_HANDLER,
+  ASSET_LOADER_DOMAIN, EVAL_CALLBACKS, IPC, ON_LOAD_HANDLER, REQUEST_HANDLER, TITLE_CHANGE_HANDLER,
   URL_LOADING_OVERRIDE, WITH_ASSET_LOADER,
 };
 
@@ -72,6 +72,7 @@ macro_rules! android_binding {
       [JString],
       jboolean
     );
+    android_fn!($domain, $package, RustWebView, onEval, [jint, JString]);
     android_fn!(
       $domain,
       $package,
@@ -103,6 +104,10 @@ fn handle_request(
   is_document_start_script_enabled: jboolean,
 ) -> JniResult<jobject> {
   if let Some(handler) = REQUEST_HANDLER.get() {
+    #[cfg(feature = "tracing")]
+    let span =
+      tracing::info_span!("wry::custom_protocol::handle", uri = tracing::field::Empty).entered();
+
     let mut request_builder = Request::builder();
 
     let uri = env
@@ -112,7 +117,12 @@ fn handle_request(
       .call_method(&uri, "toString", "()Ljava/lang/String;", &[])?
       .l()?
       .into();
-    request_builder = request_builder.uri(&env.get_string(&url)?.to_string_lossy().to_string());
+    let url = env.get_string(&url)?.to_string_lossy().to_string();
+
+    #[cfg(feature = "tracing")]
+    span.record("uri", &url);
+
+    request_builder = request_builder.uri(&url);
 
     let method = env
       .call_method(&request, "getMethod", "()Ljava/lang/String;", &[])?
@@ -152,7 +162,11 @@ fn handle_request(
       }
     };
 
-    let response = (handler.handler)(final_request, is_document_start_script_enabled != 0);
+    let response = {
+      #[cfg(feature = "tracing")]
+      let _span = tracing::info_span!("wry::custom_protocol::call_handler").entered();
+      (handler.handler)(final_request, is_document_start_script_enabled != 0)
+    };
     if let Some(response) = response {
       let status = response.status();
       let status_code = status.as_u16() as i32;
@@ -267,9 +281,31 @@ pub unsafe fn shouldOverride(mut env: JNIEnv, _: JClass, url: JString) -> jboole
   .into()
 }
 
+#[allow(non_snake_case)]
+pub unsafe fn onEval(mut env: JNIEnv, _: JClass, id: jint, result: JString) {
+  match env.get_string(&result) {
+    Ok(result) => {
+      if let Some(cb) = EVAL_CALLBACKS
+        .get_or_init(Default::default)
+        .lock()
+        .unwrap()
+        .get(&id)
+      {
+        cb(result.into());
+      }
+    }
+    Err(e) => {
+      log::warn!("Failed to parse JString: {}", e);
+    }
+  }
+}
+
 pub unsafe fn ipc(mut env: JNIEnv, _: JClass, arg: JString) {
   match env.get_string(&arg) {
     Ok(arg) => {
+      #[cfg(feature = "tracing")]
+      let _span = tracing::info_span!("wry::ipc::handle").entered();
+
       let arg = arg.to_string_lossy().to_string();
       if let Some(ipc) = IPC.get() {
         (ipc.handler)(arg)

src/android/kotlin/RustWebView.kt

@@ -67,6 +67,14 @@ class RustWebView(context: Context, val initScripts: Array<String>): WebView(con
         }
     }
 
+    fun evalScript(id: Int, script: String) {
+        post {
+            super.evaluateJavascript(script) { result ->
+                onEval(id, result)
+            }
+        }
+    }
+
     fun clearAllBrowsingData() {
         try {
             super.getContext().deleteDatabase("webviewCache.db")
@@ -90,6 +98,7 @@ class RustWebView(context: Context, val initScripts: Array<String>): WebView(con
     }
 
     private external fun shouldOverride(url: String): Boolean
+    private external fun onEval(id: Int, result: String)
 
     {{class-extension}}
 }

src/android/main_pipe.rs

@@ -10,9 +10,9 @@ use jni::{
   JNIEnv,
 };
 use once_cell::sync::Lazy;
-use std::os::unix::prelude::*;
+use std::{os::unix::prelude::*, sync::atomic::Ordering};
 
-use super::{find_class, PACKAGE};
+use super::{find_class, EvalCallback, EVAL_CALLBACKS, EVAL_ID_GENERATOR, PACKAGE};
 
 static CHANNEL: Lazy<(Sender<WebViewMessage>, Receiver<WebViewMessage>)> = Lazy::new(|| bounded(8));
 pub static MAIN_PIPE: Lazy<[RawFd; 2]> = Lazy::new(|| {
@@ -194,14 +194,39 @@ impl<'a> MainPipe<'a> {
 
           self.webview = Some(webview);
         }
-        WebViewMessage::Eval(script) => {
+        WebViewMessage::Eval(script, callback) => {
           if let Some(webview) = &self.webview {
+            let id = EVAL_ID_GENERATOR
+              .get_or_init(Default::default)
+              .fetch_add(1, Ordering::Relaxed);
+
+            #[cfg(feature = "tracing")]
+            let span = std::sync::Mutex::new(Some(SendEnteredSpan(
+              tracing::debug_span!("wry::eval").entered(),
+            )));
+
+            EVAL_CALLBACKS
+              .get_or_init(Default::default)
+              .lock()
+              .unwrap()
+              .insert(
+                id,
+                Box::new(move |result| {
+                  #[cfg(feature = "tracing")]
+                  span.lock().unwrap().take();
+
+                  if let Some(callback) = &callback {
+                    callback(result);
+                  }
+                }),
+              );
+
             let s = self.env.new_string(script)?;
             self.env.call_method(
               webview.as_obj(),
-              "evaluateJavascript",
-              "(Ljava/lang/String;Landroid/webkit/ValueCallback;)V",
-              &[(&s).into(), JObject::null().as_ref().into()],
+              "evalScript",
+              "(ILjava/lang/String;)V",
+              &[id.into(), (&s).into()],
             )?;
           }
         }
@@ -340,7 +365,7 @@ fn set_background_color<'a>(
 
 pub(crate) enum WebViewMessage {
   CreateWebView(CreateWebViewAttributes),
-  Eval(String),
+  Eval(String, Option<EvalCallback>),
   SetBackgroundColor(RGBA),
   GetWebViewVersion(Sender<Result<String, Error>>),
   GetUrl(Sender<String>),
@@ -362,3 +387,10 @@ pub(crate) struct CreateWebViewAttributes {
   pub user_agent: Option<String>,
   pub initialization_scripts: Vec<String>,
 }
+
+// SAFETY: only use this when you are sure the span will be dropped on the same thread it was entered
+#[cfg(feature = "tracing")]
+struct SendEnteredSpan(tracing::span::EnteredSpan);
+
+#[cfg(feature = "tracing")]
+unsafe impl Send for SendEnteredSpan {}

src/android/mod.rs

@@ -20,7 +20,11 @@ use kuchiki::NodeRef;
 use ndk::looper::{FdEvent, ForeignLooper};
 use once_cell::sync::OnceCell;
 use sha2::{Digest, Sha256};
-use std::{borrow::Cow, sync::mpsc::channel};
+use std::{
+  borrow::Cow,
+  collections::HashMap,
+  sync::{atomic::AtomicI32, mpsc::channel, Mutex},
+};
 use url::Url;
 
 pub(crate) mod binding;
@@ -64,6 +68,12 @@ pub static ASSET_LOADER_DOMAIN: OnceCell<String> = OnceCell::new();
 
 pub(crate) static PACKAGE: OnceCell<String> = OnceCell::new();
 
+type EvalCallback = Box<dyn Fn(String) + Send + 'static>;
+
+pub static EVAL_ID_GENERATOR: OnceCell<AtomicI32> = OnceCell::new();
+pub static EVAL_CALLBACKS: once_cell::sync::OnceCell<Mutex<HashMap<i32, EvalCallback>>> =
+  once_cell::sync::OnceCell::new();
+
 /// Sets up the necessary logic for wry to be able to create the webviews later.
 pub unsafe fn android_setup(
   package: &str,
@@ -299,8 +309,11 @@ impl InnerWebView {
     Url::parse(uri.as_str()).unwrap()
   }
 
-  pub fn eval(&self, js: &str, _callback: Option<impl Fn(String) + Send + 'static>) -> Result<()> {
-    MainPipe::send(WebViewMessage::Eval(js.into()));
+  pub fn eval(&self, js: &str, callback: Option<impl Fn(String) + Send + 'static>) -> Result<()> {
+    MainPipe::send(WebViewMessage::Eval(
+      js.into(),
+      callback.map(|c| Box::new(c) as Box<dyn Fn(String) + Send + 'static>),
+    ));
     Ok(())
   }
 
@@ -344,7 +357,7 @@ impl InnerWebView {
     }
   }
 
-  pub fn set_bounds(&self, bounds: crate::Rect) {
+  pub fn set_bounds(&self, _bounds: crate::Rect) {
     // Unsupported
   }
 

src/lib.rs

@@ -160,6 +160,7 @@
 //! libraries and prevent from building documentation on doc.rs fails.
 //! - `linux-body`: Enables body support of custom protocol request on Linux. Requires
 //! webkit2gtk v2.40 or above.
+//! - `tracing`: enables [tracing] for `evaluate_script`, `ipc_handler` and `custom_protocols.
 //!
 //! [`tao`]: https://docs.rs/tao
 //! [`winit`]: https://docs.rs/winit

src/webkitgtk/mod.rs

@@ -238,6 +238,9 @@ impl InnerWebView {
 
     // Connect before registering as recommended by the docs
     manager.connect_script_message_received(None, move |_m, msg| {
+      #[cfg(feature = "tracing")]
+      let _span = tracing::info_span!("wry::ipc::handle").entered();
+
       if let Some(js) = msg.js_value() {
         if let Some(ipc_handler) = &ipc_handler {
           ipc_handler(js.to_string());
@@ -487,24 +490,27 @@ impl InnerWebView {
     } else {
       let cancellable: Option<&Cancellable> = None;
 
-      match callback {
-        Some(callback) => {
-          self.webview.run_javascript(js, cancellable, |result| {
-            let mut result_str = String::new();
+      #[cfg(feature = "tracing")]
+      let span = SendEnteredSpan(tracing::debug_span!("wry::eval").entered());
 
-            if let Ok(js_result) = result {
-              if let Some(js_value) = js_result.js_value() {
-                if let Some(json_str) = js_value.to_json(0) {
-                  result_str = json_str.to_string();
-                }
+      self.webview.run_javascript(js, cancellable, |result| {
+        #[cfg(feature = "tracing")]
+        drop(span);
+
+        if let Some(callback) = callback {
+          let mut result_str = String::new();
+
+          if let Ok(js_result) = result {
+            if let Some(js_value) = js_result.js_value() {
+              if let Some(json_str) = js_value.to_json(0) {
+                result_str = json_str.to_string();
               }
             }
+          }
 
-            callback(result_str);
-          });
+          callback(result_str);
         }
-        None => self.webview.run_javascript(js, cancellable, |_| ()),
-      };
+      });
     }
 
     Ok(())
@@ -700,3 +706,10 @@ pub fn platform_webview_version() -> Result<String> {
   };
   Ok(format!("{}.{}.{}", major, minor, patch))
 }
+
+// SAFETY: only use this when you are sure the span will be dropped on the same thread it was entered
+#[cfg(feature = "tracing")]
+struct SendEnteredSpan(tracing::span::EnteredSpan);
+
+#[cfg(feature = "tracing")]
+unsafe impl Send for SendEnteredSpan {}

src/webkitgtk/web_context.rs

@@ -296,9 +296,16 @@ where
     .register_uri_scheme_as_secure(name);
 
   context.register_uri_scheme(name, move |request| {
+    #[cfg(feature = "tracing")]
+    let span =
+      tracing::info_span!("wry::custom_protocol::handle", uri = tracing::field::Empty).entered();
+
     if let Some(uri) = request.uri() {
       let uri = uri.as_str();
 
+      #[cfg(feature = "tracing")]
+      span.record("uri", uri);
+
       // FIXME: Read the body (forms post)
       #[allow(unused_mut)]
       let mut http_request = Request::builder().uri(uri).method("GET");
@@ -393,6 +400,8 @@ where
           request_.finish_with_response(&response);
         });
 
+      #[cfg(feature = "tracing")]
+      let _span = tracing::info_span!("wry::custom_protocol::call_handler").entered();  
       handler(http_request, RequestAsyncResponder { responder });
     } else {
       request.finish_error(&mut glib::Error::new(