Config logging (#51)

* feat: Configurable logging

#48

* feat: allow to set logging filter at start of app

* chore: fix linter

---------

Co-authored-by: tsukino <[email protected]>

Author: heeckhau

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_logging_filter } from 'tlsn-js';
 import { Proof } from 'tlsn-js/build/types';
 import { Watch } from 'react-loader-spinner';
 
@@ -21,6 +21,7 @@ function App(): ReactElement {
 
   const onClick = useCallback(async () => {
     setProcessing(true);
+    await set_logging_filter('info,tlsn_extension_rs=debug');
     const p = await prove('https://swapi.dev/api/people/1', {
       method: 'GET',
       maxTranscriptSize: 16384,

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": "../../"
   },
   "devDependencies": {
     "@types/react": "^18.0.26",
@@ -27,4 +27,4 @@
     "webpack-cli": "^4.10.0",
     "webpack-dev-server": "^4.11.1"
   }
-}
+}

src/index.ts

@@ -1,15 +1,30 @@
 import TLSN from './tlsn';
+import { DEFAULT_LOGGING_FILTER } from './tlsn';
 import { Proof } from './types';
 
 let _tlsn: TLSN;
+const current_logging_filter = DEFAULT_LOGGING_FILTER;
 
-async function getTLSN(): Promise<TLSN> {
-  if (_tlsn) return _tlsn;
+async function getTLSN(logging_filter?: string): Promise<TLSN> {
+  const logging_filter_changed =
+    logging_filter && logging_filter == current_logging_filter;
+
+  if (!logging_filter_changed && _tlsn) return _tlsn;
   // @ts-ignore
-  _tlsn = await new TLSN();
+  if (logging_filter) _tlsn = await new TLSN(logging_filter);
+  else _tlsn = await new TLSN();
   return _tlsn;
 }
 
+/**
+ * If you want to change the default logging filter, call this method before calling prove or verify
+ * For the filter syntax consult: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#example-syntax
+ * @param logging_filter
+ */
+export const set_logging_filter = async (logging_filter: string) => {
+  getTLSN(logging_filter);
+};
+
 export const prove = async (
   url: string,
   options: {

src/tlsn.ts

@@ -2,13 +2,25 @@ import init, {
   initThreadPool,
   prover,
   verify,
+  setup_tracing_web,
 } from '../wasm/prover/pkg/tlsn_extension_rs';
 
+export const DEFAULT_LOGGING_FILTER: string = 'info,tlsn_extension_rs=debug';
+
 export default class TLSN {
-  private startPromise: any;
-  private resolveStart: any;
+  private startPromise: Promise<void>;
+  private resolveStart!: () => void;
+  private logging_filter: string;
+
+  /**
+   * Initializes a new instance of the TLSN class.
+   *
+   * @param logging_filter - Optional logging filter string.
+   *                         Defaults to DEFAULT_LOGGING_FILTER
+   */
+  constructor(logging_filter: string = DEFAULT_LOGGING_FILTER) {
+    this.logging_filter = logging_filter;
 
-  constructor() {
     this.startPromise = new Promise((resolve) => {
       this.resolveStart = resolve;
     });
@@ -20,6 +32,7 @@ export default class TLSN {
     const numConcurrency = navigator.hardwareConcurrency;
     // console.log('!@# navigator.hardwareConcurrency=', numConcurrency);
     await init();
+    setup_tracing_web(this.logging_filter);
     // const res = await init();
     // console.log('!@# res.memory=', res.memory);
     // 6422528 ~= 6.12 mb

wasm/prover/Cargo.toml

@@ -32,7 +32,7 @@ pin-project-lite = "0.2.4"
 http-body-util = "0.1"
 hyper = { version = "1.1", features = ["client", "http1"] }
 hyper-util = { version = "0.1", features = ["http1"] }
-tracing-subscriber = { version = "0.3", features = ["time"] }
+tracing-subscriber = { version = "0.3", features = ["time","env-filter"] }
 tracing-web = "0.1.2"
 
 ring = { version = "0.17", features = ["wasm32_unknown_unknown_js"] }

wasm/prover/src/lib.rs

@@ -21,23 +21,32 @@ use wasm_bindgen_futures::JsFuture;
 use web_sys::{Request, RequestInit, Response};
 
 use std::panic;
+use tracing::debug;
 use tracing_subscriber::fmt::format::Pretty;
 use tracing_subscriber::fmt::time::UtcTime;
 use tracing_subscriber::prelude::*;
+use tracing_subscriber::EnvFilter;
+
 use tracing_web::{performance_layer, MakeWebConsoleWriter};
 
 extern crate console_error_panic_hook;
 
-#[wasm_bindgen(start)]
-pub fn setup_tracing_web() {
+#[wasm_bindgen]
+pub fn setup_tracing_web(logging_filter: &str) {
     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_thread_ids(true)
+        // .with_thread_names(true)
         .with_writer(MakeWebConsoleWriter::new()); // write events to the console
     let perf_layer = performance_layer().with_details_from_fields(Pretty::default());
 
+    let filter_layer = EnvFilter::builder()
+        .parse(logging_filter)
+        .unwrap_or_default();
+
     tracing_subscriber::registry()
-        .with(tracing_subscriber::filter::LevelFilter::DEBUG)
+        .with(filter_layer)
         .with(fmt_layer)
         .with(perf_layer)
         .init(); // Install these as subscribers to tracing events
@@ -47,6 +56,8 @@ pub fn setup_tracing_web() {
         error!("panic occurred: {:?}", info);
         console_error_panic_hook::hook(info);
     }));
+
+    debug!("🪵 Logging set up 🪵")
 }
 
 pub async fn fetch_as_json_string(url: &str, opts: &RequestInit) -> Result<String, JsValue> {

wasm/prover/src/prover.rs

@@ -12,8 +12,8 @@ use crate::requests::{ClientType, NotarizationSessionRequest, NotarizationSessio
 
 pub use wasm_bindgen_rayon::init_thread_pool;
 
+use crate::fetch_as_json_string;
 pub use crate::request_opt::VerifyResult;
-use crate::{fetch_as_json_string, setup_tracing_web};
 use futures::AsyncWriteExt;
 use http_body_util::{BodyExt, Full};
 use hyper::{body::Bytes, Request, StatusCode};
@@ -25,7 +25,7 @@ use url::Url;
 use wasm_bindgen::prelude::*;
 use web_sys::{Headers, RequestInit, RequestMode};
 
-use tracing::{debug, info};
+use tracing::{debug, info, trace};
 
 #[derive(strum_macros::EnumMessage, Debug, Clone, Copy)]
 #[allow(dead_code)]
@@ -77,24 +77,22 @@ pub async fn prover(
     secret_headers: JsValue,
     secret_body: JsValue,
 ) -> Result<String, JsValue> {
-    info!("target_url: {}", target_url_str);
+    debug!("target_url: {}", target_url_str);
     let target_url = Url::parse(target_url_str)
         .map_err(|e| JsValue::from_str(&format!("Could not parse target_url: {:?}", e)))?;
 
-    info!(
+    debug!(
         "target_url.host: {}",
         target_url
             .host()
             .ok_or(JsValue::from_str("Could not get target host"))?
     );
     let options: RequestOptions = serde_wasm_bindgen::from_value(val)
         .map_err(|e| JsValue::from_str(&format!("Could not deserialize options: {:?}", e)))?;
-    info!("options.notary_url: {}", options.notary_url.as_str());
+    debug!("options.notary_url: {}", options.notary_url.as_str());
 
     let start_time = Instant::now();
 
-
-
     /*
      * Connect Notary with websocket
      */
@@ -150,7 +148,7 @@ pub async fn prover(
             .map_err(|e| JsValue::from_str(&format!("Could not deserialize response: {:?}", e)))?;
     debug!("Response: {}", rust_string);
 
-    info!("Notarization response: {:?}", notarization_response,);
+    debug!("Notarization response: {:?}", notarization_response,);
     let notary_wss_url = format!(
         "{}://{}{}/notarize?sessionId={}",
         if notary_ssl { "wss" } else { "ws" },

wasm/prover/src/verify.rs

@@ -1,7 +1,7 @@
 use tracing::info;
 use wasm_bindgen::prelude::*;
 
-use crate::{request_opt::VerifyResult, setup_tracing_web};
+use crate::request_opt::VerifyResult;
 
 use elliptic_curve::pkcs8::DecodePublicKey;
 use std::time::Duration;