refactor(wasm): replace tracing-web with wasm-tracing, move logging to sdk-core

- Move platform-agnostic logging types (LoggingLevel, LoggingConfig,
  CrateLogFilter, SpanEvent) and filter logic to sdk-core so mobile
  can reuse them
- Replace tracing-web with wasm-tracing to remove web-sys from the
  WASM dependency tree
- Remove unused time crate dependency
- Clean up dead .with_timer().without_time() chain

Author: heeckhau

Cargo.lock

@@ -33,6 +33,7 @@ spansy = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["rt", "sync"] }
 tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
 wasm-bindgen-futures = { workspace = true, optional = true }
 
 [dev-dependencies]

crates/sdk-core/Cargo.toml

@@ -45,6 +45,7 @@ pub mod config;
 pub mod error;
 pub mod handler;
 pub mod io;
+pub mod logging;
 pub mod prover;
 mod spawn;
 pub mod types;

crates/sdk-core/src/lib.rs

@@ -0,0 +1,128 @@
+//! Platform-agnostic logging configuration and filtering.
+//!
+//! This module provides logging types and filter logic that can be reused
+//! across platforms (WASM, iOS, Android, native). Each platform provides
+//! its own tracing Layer/writer — this module only handles configuration.
+
+use serde::Deserialize;
+use tracing::{Level, Metadata};
+use tracing_subscriber::fmt::format::FmtSpan;
+
+/// Logging verbosity level.
+#[derive(Debug, Default, Clone, Copy, Deserialize)]
+pub enum LoggingLevel {
+    /// Disable all logging for this target.
+    Off,
+    /// Most verbose — includes all messages.
+    Trace,
+    /// Detailed debugging information.
+    Debug,
+    /// Informational messages (default).
+    #[default]
+    Info,
+    /// Warnings only.
+    Warn,
+    /// Errors only.
+    Error,
+}
+
+impl LoggingLevel {
+    /// Returns true if this level disables all logging.
+    pub fn is_off(&self) -> bool {
+        matches!(self, LoggingLevel::Off)
+    }
+}
+
+impl From<LoggingLevel> for Level {
+    fn from(value: LoggingLevel) -> Self {
+        match value {
+            // Off maps to ERROR as a fallback, but is_off() should be checked first.
+            LoggingLevel::Off => Level::ERROR,
+            LoggingLevel::Trace => Level::TRACE,
+            LoggingLevel::Debug => Level::DEBUG,
+            LoggingLevel::Info => Level::INFO,
+            LoggingLevel::Warn => Level::WARN,
+            LoggingLevel::Error => Level::ERROR,
+        }
+    }
+}
+
+/// Span lifecycle events to log.
+#[derive(Debug, Clone, Copy, Deserialize)]
+pub enum SpanEvent {
+    /// Log when a span is created.
+    New,
+    /// Log when a span is closed.
+    Close,
+    /// Log when a span becomes active.
+    Active,
+}
+
+impl From<SpanEvent> for FmtSpan {
+    fn from(value: SpanEvent) -> Self {
+        match value {
+            SpanEvent::New => FmtSpan::NEW,
+            SpanEvent::Close => FmtSpan::CLOSE,
+            SpanEvent::Active => FmtSpan::ACTIVE,
+        }
+    }
+}
+
+/// Top-level logging configuration.
+#[derive(Debug, Default, Clone, Deserialize)]
+pub struct LoggingConfig {
+    /// Global default log level.
+    pub level: Option<LoggingLevel>,
+    /// Per-crate log level overrides.
+    pub crate_filters: Option<Vec<CrateLogFilter>>,
+    /// Which span lifecycle events to log.
+    pub span_events: Option<Vec<SpanEvent>>,
+}
+
+/// Per-crate log level override.
+#[derive(Debug, Clone, Deserialize)]
+pub struct CrateLogFilter {
+    /// Log level for this crate.
+    pub level: LoggingLevel,
+    /// Crate name to match (case-insensitive).
+    pub name: String,
+}
+
+/// Creates a filter function from a [`LoggingConfig`].
+///
+/// The returned closure checks each tracing event's target against the
+/// configured crate filters (case-insensitive match on the first path
+/// segment). Events that don't match any filter use the global default level.
+pub fn filter(config: LoggingConfig) -> impl Fn(&Metadata) -> bool {
+    let default_level = config.level.unwrap_or(LoggingLevel::Info);
+    let crate_filters = config
+        .crate_filters
+        .unwrap_or_default()
+        .into_iter()
+        .map(|filter| (filter.name, filter.level))
+        .collect::<Vec<_>>();
+
+    move |meta| {
+        let logging_level = if let Some(crate_name) = meta.target().split("::").next() {
+            crate_filters
+                .iter()
+                .find_map(|(filter_name, filter_level)| {
+                    if crate_name.eq_ignore_ascii_case(filter_name) {
+                        Some(*filter_level)
+                    } else {
+                        None
+                    }
+                })
+                .unwrap_or(default_level)
+        } else {
+            default_level
+        };
+
+        // Off disables all logging for this target.
+        if logging_level.is_off() {
+            return false;
+        }
+
+        meta.level() <= &Level::from(logging_level)
+    }
+}

crates/sdk-core/src/logging.rs

@@ -68,6 +68,16 @@ impl State {
 impl SdkProver {
     /// Creates a new SDK Prover with the given configuration.
     pub fn new(config: ProverConfig) -> Result<Self> {
+        if config.server_name.is_empty() {
+            return Err(SdkError::config("server_name cannot be empty"));
+        }
+        if config.max_sent_data == 0 {
+            return Err(SdkError::config("max_sent_data must be > 0"));
+        }
+        if config.max_recv_data == 0 {
+            return Err(SdkError::config("max_recv_data must be > 0"));
+        }
+
         Ok(SdkProver {
             config,
             state: State::Initialized,
@@ -332,3 +342,59 @@ async fn send_request(conn: TlsConnection, request: HttpRequest) -> Result<HttpR
         },
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        config::{NetworkSetting, ProverConfig},
+        error::ErrorKind,
+    };
+
+    fn valid_config() -> ProverConfig {
+        ProverConfig::builder("example.com")
+            .max_sent_data(4096)
+            .max_recv_data(16384)
+            .network(NetworkSetting::Latency)
+            .build()
+    }
+
+    #[test]
+    fn new_with_valid_config() {
+        let prover = SdkProver::new(valid_config());
+        assert!(prover.is_ok());
+    }
+
+    #[test]
+    fn new_rejects_empty_server_name() {
+        let config = ProverConfig::builder("")
+            .max_sent_data(4096)
+            .max_recv_data(16384)
+            .build();
+        let err = SdkProver::new(config).err().expect("should fail");
+        assert_eq!(err.kind(), ErrorKind::Config);
+        assert!(err.to_string().contains("server_name"));
+    }
+
+    #[test]
+    fn new_rejects_zero_max_sent_data() {
+        let config = ProverConfig::builder("example.com")
+            .max_sent_data(0)
+            .max_recv_data(16384)
+            .build();
+        let err = SdkProver::new(config).err().expect("should fail");
+        assert_eq!(err.kind(), ErrorKind::Config);
+        assert!(err.to_string().contains("max_sent_data"));
+    }
+
+    #[test]
+    fn new_rejects_zero_max_recv_data() {
+        let config = ProverConfig::builder("example.com")
+            .max_sent_data(4096)
+            .max_recv_data(0)
+            .build();
+        let err = SdkProver::new(config).err().expect("should fail");
+        assert_eq!(err.kind(), ErrorKind::Config);
+        assert!(err.to_string().contains("max_recv_data"));
+    }
+}

crates/sdk-core/src/prover.rs

@@ -112,9 +112,7 @@ impl TryFrom<HttpRequest> for hyper::Request<Full<Bytes>> {
             let body = match body {
                 // If the JSON value is a plain string, use its contents directly
                 // to avoid double-serialization (wrapping in extra quotes).
-                Body::Json(serde_json::Value::String(s)) => {
-                    Full::new(Bytes::from(s))
-                }
+                Body::Json(serde_json::Value::String(s)) => Full::new(Bytes::from(s)),
                 // For other JSON values, serialize to bytes (infallible).
                 Body::Json(value) => Full::new(Bytes::from(
                     serde_json::to_vec(&value).expect("Value serialization is infallible"),

crates/sdk-core/src/types.rs

@@ -34,10 +34,9 @@ rayon = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { version = "1.0" }
 serde-wasm-bindgen = { version = "0.6" }
-time = { version = "=0.3.37", features = ["wasm-bindgen"] }
 tracing = { workspace = true }
-tracing-subscriber = { workspace = true, features = ["time"] }
-tracing-web = { version = "0.1" }
+tracing-subscriber = { workspace = true }
+wasm-tracing = { version = "0.1" }
 tsify-next = { version = "0.5", default-features = false, features = ["js"] }
 wasm-bindgen = { version = "0.2" }
 wasm-bindgen-futures = { version = "0.4" }

crates/wasm/Cargo.toml

@@ -52,10 +52,6 @@ struct AdapterState {
     eof: bool,
     /// Pending read future.
     pending_read: Option<JsFuture>,
-    /// Pending write future.
-    pending_write: Option<JsFuture>,
-    /// Pending close future.
-    pending_close: Option<JsFuture>,
     /// Waker for when data becomes available.
     read_waker: Option<Waker>,
     /// Whether the stream is closed.
@@ -88,8 +84,6 @@ impl JsIoAdapter {
                 read_buffer: VecDeque::new(),
                 eof: false,
                 pending_read: None,
-                pending_write: None,
-                pending_close: None,
                 read_waker: None,
                 closed: false,
                 error: None,
@@ -205,7 +199,7 @@ impl AsyncRead for JsIoAdapter {
 impl AsyncWrite for JsIoAdapter {
     fn poll_write(
         self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
+        _cx: &mut Context<'_>,
         buf: &[u8],
     ) -> Poll<std::io::Result<usize>> {
         let this = self.get_mut();