Merge pull request #251 from matrix-org/rav/jslogger

Allow JS side to pass a `logger` instance in

Author: richvdh

CHANGELOG.md

@@ -4,6 +4,8 @@
 
     -   Add support for received room key bundle data, as required by encrypted history sharing ((MSC4268)[https://github.com/matrix-org/matrix-spec-proposals/pull/4268)). ([#5276](https://github.com/matrix-org/matrix-rust-sdk/pull/5276))
 
+-   Extend `OlmMachine` constructor functions to accept an optional `logger` instance. This logger is associated with the machine for its lifetime, and used instead of the global `console` to write any log messages from the underlying rust library. Similarly, the legacy store migration functions (in the `Migration` class), and the `StoreHandle` open functions are extended to accept an optional logger, to be used for the duration of that operation. ([#251](https://github.com/matrix-org/matrix-rust-sdk-crypto-wasm/pull/251))
+
 -   Add a new error code for `MegolmDecryptionError`, `DecryptionErrorCode::MismatchedSender`, indicating that the sender of the event does not match the owner of the device that established the Megolm session. ([#248](https://github.com/matrix-org/matrix-rust-sdk-crypto-wasm/pull/248))
 
 # matrix-sdk-crypto-wasm v15.0.0

Cargo.toml

@@ -74,7 +74,7 @@ thiserror = "2.0.12"
 tracing = { version = "0.1.36", default-features = false, features = ["std"] }
 tracing-subscriber = { version = "0.3.14", default-features = false, features = ["registry", "std", "ansi"] }
 url = "2.5.0"
-wasm-bindgen = "0.2.89"
+wasm-bindgen = "0.2.100"
 wasm-bindgen-futures = "0.4.33"
 zeroize = "1.6.0"
 wasm-bindgen-test = "0.3.37"

index.d.ts

@@ -51,6 +51,13 @@ export declare function initAsync(url?: URL | string): Promise<void>;
 // The auto-generated typescript definitions are a good start, but could do with tightening up in a lot of areas.
 // The following is a manually-curated set of typescript definitions.
 declare module "./pkg/matrix_sdk_crypto_wasm.js" {
+    interface JsLogger {
+        debug(data: any): void;
+        info(data: any): void;
+        warn(data: any): void;
+        error(data: any): void;
+    }
+
     /** The types returned by {@link OlmMachine.outgoingRequests}. */
     type OutgoingRequest =
         | KeysUploadRequest

src/future.rs

@@ -1,6 +1,7 @@
 use std::future::Future;
 
 use js_sys::Promise;
+use tracing::instrument::WithSubscriber;
 use wasm_bindgen::{JsError, JsValue, UnwrapThrowExt};
 use wasm_bindgen_futures::spawn_local;
 
@@ -9,6 +10,10 @@ use wasm_bindgen_futures::spawn_local;
  * Javascript [`Promise`] which either resolves with an object of type `T`,
  * or rejects with an error of type [`Error`].
  *
+ * Also applies [`WithSubscriber::with_current_subscriber`] to the future,
+ * to ensure that the active tracing subscriber remains active while the
+ * future is polled.
+ *
  * [`Error`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
  */
 pub(crate) fn future_to_promise<F, T>(future: F) -> Promise
@@ -23,14 +28,18 @@ where
  * Convert a Rust [`Future`] which returns [`Result<T, E>`] into a
  * Javascript [`Promise`] which either resolves with an object of type `T`,
  * or rejects with an error of type `E`.
+ *
+ * Also applies [`WithSubscriber::with_current_subscriber`] to the future,
+ * to ensure that the active tracing subscriber remains active while the
+ * future is polled.
  */
 pub(crate) fn future_to_promise_with_custom_error<F, T, E>(future: F) -> Promise
 where
     F: Future<Output = Result<T, E>> + 'static,
     T: Into<JsValue>,
     E: Into<JsValue>,
 {
-    let mut future = Some(future);
+    let mut future = Some(future.with_current_subscriber());
 
     Promise::new(&mut |resolve, reject| {
         let future = future.take().unwrap_throw();

src/libolm_migration.rs

@@ -16,9 +16,10 @@
 
 use std::time::Duration;
 
-use js_sys::{Date, Uint8Array};
-use matrix_sdk_common::ruma::{
-    DeviceKeyAlgorithm, MilliSecondsSinceUnixEpoch, SecondsSinceUnixEpoch, UInt,
+use js_sys::{Date, Promise, Uint8Array};
+use matrix_sdk_common::{
+    js_tracing::JsLogger,
+    ruma::{DeviceKeyAlgorithm, MilliSecondsSinceUnixEpoch, SecondsSinceUnixEpoch, UInt},
 };
 use matrix_sdk_crypto::{
     olm::PrivateCrossSigningIdentity,
@@ -31,11 +32,14 @@ use matrix_sdk_crypto::{
     vodozemac::{Curve25519PublicKey, Ed25519PublicKey},
     Session,
 };
+use tracing::dispatcher;
 use wasm_bindgen::prelude::*;
 
 use crate::{
+    future::future_to_promise,
     identifiers::{DeviceId, RoomId, UserId},
     store::StoreHandle,
+    tracing::logger_to_dispatcher,
 };
 
 type Result<T, E = JsError> = std::result::Result<T, E>;
@@ -52,7 +56,7 @@ pub struct Migration {}
 ///
 /// Can be imported into the rust store with {@link Migration::migrateBaseData}.
 #[wasm_bindgen(getter_with_clone)]
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub struct BaseMigrationData {
     /// The user id of the account owner.
     #[wasm_bindgen(js_name = "userId")]
@@ -115,15 +119,23 @@ impl Migration {
     ///   account objects.
     /// * `store_handle` - A connection to the CryptoStore which will be used to
     ///   store the vodozemac data.
-    #[wasm_bindgen(js_name = "migrateBaseData")]
-    pub async fn migrate_base_data(
+    /// * `logger` - An optional logger instance to use for writing log messages
+    ///   during the migration operation. An instance of `JsLogger`.
+    #[wasm_bindgen(js_name = "migrateBaseData", unchecked_return_type = "Promise<void>")]
+    pub fn migrate_base_data(
         data: &BaseMigrationData,
         pickle_key: Uint8Array,
         store_handle: &StoreHandle,
-    ) -> Result<JsValue, JsError> {
-        migrate_base_data_to_store(data, &(pickle_key.to_vec()), store_handle.store.as_ref())
-            .await?;
-        Ok(JsValue::UNDEFINED)
+        logger: Option<JsLogger>,
+    ) -> Promise {
+        let _guard = dispatcher::set_default(&logger_to_dispatcher(logger));
+        let store_handle = store_handle.clone();
+        let data = data.clone();
+        future_to_promise(async move {
+            migrate_base_data_to_store(&data, &(pickle_key.to_vec()), store_handle.store.as_ref())
+                .await?;
+            Ok(JsValue::UNDEFINED)
+        })
     }
 }
 
@@ -241,21 +253,30 @@ impl Migration {
     ///   session objects.
     /// * `store_handle` - A connection to the CryptoStore which will be used to
     ///   store the vodozemac data.
-    #[wasm_bindgen(js_name = "migrateOlmSessions")]
-    pub async fn migrate_olm_sessions(
+    /// * `logger` - An optional logger instance to use for writing log messages
+    ///   during the migration operation. An instance of `JsLogger`.
+    #[wasm_bindgen(js_name = "migrateOlmSessions", unchecked_return_type = "Promise<void>")]
+    pub fn migrate_olm_sessions(
         sessions: Vec<PickledSession>,
         pickle_key: Uint8Array,
         store_handle: &StoreHandle,
-    ) -> Result<JsValue, JsError> {
+        logger: Option<JsLogger>,
+    ) -> Result<Promise, JsError> {
+        let _guard = dispatcher::set_default(&logger_to_dispatcher(logger));
+
         let pickle_key = pickle_key.to_vec();
 
         let rust_sessions = sessions
             .into_iter()
             .map(|session| libolm_pickled_session_to_rust_pickled_session(session, &pickle_key))
             .collect::<Result<_>>()?;
 
-        import_olm_sessions_to_store(rust_sessions, store_handle.store.as_ref()).await?;
-        Ok(JsValue::UNDEFINED)
+        let store_handle = store_handle.clone();
+
+        Ok(future_to_promise(async move {
+            import_olm_sessions_to_store(rust_sessions, store_handle.store.as_ref()).await?;
+            Ok(JsValue::UNDEFINED)
+        }))
     }
 }
 
@@ -393,12 +414,16 @@ impl Migration {
     ///   megolm session objects.
     /// * `store_handle` - A connection to the CryptoStore which will be used to
     ///   store the vodozemac data.
-    #[wasm_bindgen(js_name = "migrateMegolmSessions")]
-    pub async fn migrate_megolm_sessions(
+    /// * `logger` - An optional logger instance to use for writing log messages
+    ///   during the migration operation. An instance of `JsLogger`.
+    #[wasm_bindgen(js_name = "migrateMegolmSessions", unchecked_return_type = "Promise<void>")]
+    pub fn migrate_megolm_sessions(
         sessions: Vec<PickledInboundGroupSession>,
         pickle_key: Uint8Array,
         store_handle: &StoreHandle,
-    ) -> Result<JsValue, JsError> {
+        logger: Option<JsLogger>,
+    ) -> Result<Promise, JsError> {
+        let _guard = dispatcher::set_default(&logger_to_dispatcher(logger));
         let pickle_key = pickle_key.to_vec();
 
         let rust_sessions = sessions
@@ -408,8 +433,11 @@ impl Migration {
             })
             .collect::<Result<_>>()?;
 
-        import_megolm_sessions_to_store(rust_sessions, store_handle.store.as_ref()).await?;
-        Ok(JsValue::UNDEFINED)
+        let store_handle = store_handle.clone();
+        Ok(future_to_promise(async move {
+            import_megolm_sessions_to_store(rust_sessions, store_handle.store.as_ref()).await?;
+            Ok(JsValue::UNDEFINED)
+        }))
     }
 }