wip: set logging level

demo/react-ts-webpack/app.tsx

@@ -1,6 +1,6 @@
 import React, { ReactElement, useCallback, useEffect, useState } from 'react';
 import { createRoot } from 'react-dom/client';
-import { prove, verify } from 'tlsn-js';
+import { prove, verify, set_log_level_filter } from 'tlsn-js';
 import { Proof } from 'tlsn-js/build/types';
 import { Watch } from 'react-loader-spinner';
 
@@ -21,11 +21,12 @@ function App(): ReactElement {
 
   const onClick = useCallback(async () => {
     setProcessing(true);
+    // set_log_level_filter("debug");
     const p = await prove('https://swapi.dev/api/people/1', {
       method: 'GET',
       maxTranscriptSize: 16384,
-      notaryUrl: 'http://localhost:7047',
-      websocketProxyUrl: 'ws://localhost:55688',
+      notaryUrl: 'https://notary.pse.dev/v0.1.0-alpha.5',
+      websocketProxyUrl: 'wss://notary.pse.dev/proxy?token=swapi.dev',
     });
     setProof(p);
   }, [setProof, setProcessing]);

demo/react-ts-webpack/package.json

@@ -12,7 +12,7 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-loader-spinner": "^6.1.6",
-    "tlsn-js": "0.1.0-alpha.5.2"
+    "tlsn-js": "../../tlsn-js-dev"
   },
   "devDependencies": {
     "@types/react": "^18.0.26",
@@ -27,4 +27,4 @@
     "webpack-cli": "^4.10.0",
     "webpack-dev-server": "^4.11.1"
   }
-}
+}

src/index.ts

@@ -81,6 +81,11 @@ export const verify = async (
   };
 };
 
+export const set_log_level_filter = async (level: string): Promise<void> => {
+  const tlsn = await getTLSN();
+  await tlsn.set_log_level_filter(level);
+};
+
 async function fetchPublicKeyFromNotary(notaryUrl: string) {
   const res = await fetch(notaryUrl + '/info');
   const json: any = await res.json();

src/tlsn.ts

@@ -2,6 +2,7 @@ import init, {
   initThreadPool,
   prover,
   verify,
+  set_log_level_filter
 } from '../wasm/prover/pkg/tlsn_extension_rs';
 
 export default class TLSN {
@@ -26,12 +27,18 @@ export default class TLSN {
     // console.log('!@# res.memory.buffer.length=', res.memory.buffer.byteLength);
     await initThreadPool(numConcurrency);
     this.resolveStart();
+
+    await set_log_level_filter("trace");
   }
 
   async waitForStart() {
     return this.startPromise;
   }
 
+  async set_log_level_filter(level: string) {
+    await set_log_level_filter(level);
+  }
+
   async prove(
     url: string,
     options?: {

wasm/prover/src/lib.rs

@@ -7,6 +7,8 @@ pub use prover::prover;
 
 pub mod verify;
 use tracing::error;
+use tracing::level_filters::LevelFilter;
+use tracing_subscriber::reload::Handle;
 pub use verify::verify;
 
 use wasm_bindgen::prelude::*;
@@ -21,13 +23,33 @@ use wasm_bindgen_futures::JsFuture;
 use web_sys::{Request, RequestInit, Response};
 
 use std::panic;
+use std::sync::OnceLock;
 use tracing_subscriber::fmt::format::Pretty;
 use tracing_subscriber::fmt::time::UtcTime;
-use tracing_subscriber::prelude::*;
+use tracing_subscriber::{filter, reload};
+use tracing_subscriber::{prelude::*, Registry};
 use tracing_web::{performance_layer, MakeWebConsoleWriter};
 
 extern crate console_error_panic_hook;
 
+struct LogReloadHandle {
+    filter: LevelFilter,
+    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,
+        }
+    })
+}
+
 #[wasm_bindgen(start)]
 pub fn setup_tracing_web() {
     let fmt_layer = tracing_subscriber::fmt::layer()
@@ -36,8 +58,10 @@ pub fn setup_tracing_web() {
         .with_writer(MakeWebConsoleWriter::new()); // write events to the console
     let perf_layer = performance_layer().with_details_from_fields(Pretty::default());
 
+    let filter = reload_handle().filter;
+
     tracing_subscriber::registry()
-        .with(tracing_subscriber::filter::LevelFilter::DEBUG)
+        .with(filter)
         .with(fmt_layer)
         .with(perf_layer)
         .init(); // Install these as subscribers to tracing events
@@ -49,6 +73,35 @@ pub fn setup_tracing_web() {
     }));
 }
 
+#[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!(
+                "Invalid log level: '{}'",
+                level
+            ))),
+        }
+    }
+
+    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(())
+}
+
 pub async fn fetch_as_json_string(url: &str, opts: &RequestInit) -> Result<String, JsValue> {
     let request = Request::new_with_str_and_init(url, opts)?;
     let window = web_sys::window().expect("Window object");