seems to be working

src/tlsn.ts

@@ -28,7 +28,7 @@ export default class TLSN {
     await initThreadPool(numConcurrency);
     this.resolveStart();
 
-    await set_log_level_filter("trace");
+    await set_log_level_filter("info");
   }
 
   async waitForStart() {

wasm/prover/Cargo.toml

@@ -81,6 +81,7 @@ console_error_panic_hook = { version = "0.1.7" }
 
 strum = { version = "0.26.1" }
 strum_macros = "0.26.1"
+once_cell = "1.17.2"
 
 [dev-dependencies]
 wasm-bindgen-test = "0.3.34"

wasm/prover/src/lib.rs

@@ -7,6 +7,7 @@ pub use prover::prover;
 
 pub mod verify;
 use tracing::error;
+use tracing::info;
 use tracing::level_filters::LevelFilter;
 use tracing_subscriber::reload::Handle;
 pub use verify::verify;
@@ -22,13 +23,16 @@ use js_sys::JSON;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::{Request, RequestInit, Response};
 
+use once_cell::sync::OnceCell;
 use std::panic;
+use std::sync::Mutex;
 use std::sync::OnceLock;
 use tracing_subscriber::fmt::format::Pretty;
 use tracing_subscriber::fmt::time::UtcTime;
-use tracing_subscriber::{filter, reload};
-use tracing_subscriber::{prelude::*, Registry};
+use tracing_subscriber::prelude::*;
+use tracing_subscriber::{filter, fmt, reload, Registry};
 use tracing_web::{performance_layer, MakeWebConsoleWriter};
+use wasm_bindgen::prelude::*;
 
 extern crate console_error_panic_hook;
 
@@ -37,68 +41,56 @@ struct LogReloadHandle {
     reload_handle: Handle<LevelFilter, Registry>,
 }
 
-fn reload_handle() -> &'static LogReloadHandle {
-    static HANDLE: OnceLock<LogReloadHandle> = OnceLock::new();
-    HANDLE.get_or_init(|| {
-        //default level
-        let filter = filter::LevelFilter::TRACE;
-        let (_, reload_handle) = reload::Layer::new(filter);
-        LogReloadHandle {
-            filter,
-            reload_handle,
-        }
-    })
-}
+static SUBSCRIBER: OnceCell<Mutex<reload::Handle<filter::LevelFilter, Registry>>> = OnceCell::new();
 
 #[wasm_bindgen(start)]
 pub fn setup_tracing_web() {
-    let fmt_layer = tracing_subscriber::fmt::layer()
-        .with_ansi(false) // Only partially supported across browsers
-        .with_timer(UtcTime::rfc_3339()) // std::time is not available in browsers
-        .with_writer(MakeWebConsoleWriter::new()); // write events to the console
-    let perf_layer = performance_layer().with_details_from_fields(Pretty::default());
+    let fmt_layer = fmt::layer()
+        .with_ansi(false)
+        .with_timer(UtcTime::rfc_3339())
+        .with_writer(MakeWebConsoleWriter::new());
 
-    let filter = reload_handle().filter;
+    let (filter_layer, handle) = reload::Layer::new(filter::LevelFilter::TRACE);
 
-    tracing_subscriber::registry()
-        .with(filter)
+    let _subscriber = tracing_subscriber::registry()
+        .with(filter_layer)
         .with(fmt_layer)
-        .with(perf_layer)
-        .init(); // Install these as subscribers to tracing events
+        .with(performance_layer().with_details_from_fields(Pretty::default()))
+        .init();
 
-    // https://github.com/rustwasm/console_error_panic_hook
-    panic::set_hook(Box::new(|info| {
-        error!("panic occurred: {:?}", info);
-        console_error_panic_hook::hook(info);
-    }));
+    SUBSCRIBER
+        .set(Mutex::new(handle))
+        .expect("Failed to set subscriber handle");
 }
 
 #[wasm_bindgen]
 pub async fn set_log_level_filter(level: &str) -> Result<(), JsValue> {
-    fn level_from_str(level: &str) -> Result<LevelFilter, JsValue> {
-        match level.to_lowercase().as_str() {
-            "trace" => Ok(LevelFilter::TRACE),
-            "debug" => Ok(LevelFilter::DEBUG),
-            "info" => Ok(LevelFilter::INFO),
-            "warn" => Ok(LevelFilter::WARN),
-            "error" => Ok(LevelFilter::ERROR),
-            "off" => Ok(LevelFilter::OFF),
-            _ => Err(JsValue::from_str(&format!(
+    let level = match level.to_lowercase().as_str() {
+        "trace" => filter::LevelFilter::TRACE,
+        "debug" => filter::LevelFilter::DEBUG,
+        "info" => filter::LevelFilter::INFO,
+        "warn" => filter::LevelFilter::WARN,
+        "error" => filter::LevelFilter::ERROR,
+        "off" => filter::LevelFilter::OFF,
+        _ => {
+            return Err(JsValue::from_str(&format!(
                 "Invalid log level: '{}'",
                 level
-            ))),
+            )))
         }
+    };
+
+    info!("Setting log level to {}", level);
+
+    if let Some(handle) = SUBSCRIBER.get() {
+        let handle = handle.lock().expect("Lock poisoned");
+        handle
+            .reload(level)
+            .map_err(|e| JsValue::from_str(&format!("Failed to modify log level filter: {}", e)))?;
+    } else {
+        return Err(JsValue::from_str("Logging subsystem not initialized"));
     }
 
-    let filter = level_from_str(level)?;
-    println!("{:?}", filter);
-
-    // Assume reload_handle() is a function or struct that provides access to modify the log level
-    reload_handle()
-        .reload_handle
-        .modify(|f: &mut LevelFilter| *f = filter)
-        .map_err(|e| JsValue::from_str(&format!("Failed to modify log level filter: {}", e)))?;
-
     Ok(())
 }
 

wasm/prover/src/verify.rs

@@ -1,4 +1,4 @@
-use tracing::info;
+use tracing::{info, trace};
 use wasm_bindgen::prelude::*;
 
 use crate::{request_opt::VerifyResult, setup_tracing_web};