Add lots of extra logs

bindings/matrix-sdk-ffi/src/platform/mod.rs

@@ -745,10 +745,10 @@ fn setup_multithreaded_tokio_runtime() {
 
         let mut builder = tokio::runtime::Builder::new_multi_thread();
         builder.enable_all();
-        #[cfg(target_os = "android")]
-        builder.on_thread_start(|| {
-            _ = android_platform::android_attach_current_thread_permanently();
-        });
+        // #[cfg(target_os = "android")]
+        // builder.on_thread_start(|| {
+        //     _ = android_platform::android_attach_current_thread_permanently();
+        // });
         builder
     }));
 }

crates/matrix-sdk/src/event_cache/caches/event_focused/mod.rs

@@ -42,7 +42,7 @@ use tokio::sync::{
     RwLock,
     broadcast::{Receiver, Sender},
 };
-use tracing::{instrument, trace};
+use tracing::{instrument, trace, warn};
 
 #[cfg(feature = "e2e-encryption")]
 use crate::event_cache::redecryptor::ResolvedUtd;
@@ -312,6 +312,8 @@ impl EventFocusedCacheInner {
             }
         };
 
+        warn!("received {} events from /messages endpoint", events.len());
+
         // Events are in the reverse order, per the API contracts defined in the two
         // fetch methods.
         events.reverse();
@@ -319,10 +321,13 @@ impl EventFocusedCacheInner {
         let hit_end = new_token.is_none();
         let new_gap = new_token.map(|t| Gap { token: t });
 
+        warn!("calling push_backwards_pagination_events");
         // Replace the gap and insert the new events.
         self.chunk.push_backwards_pagination_events(Some(gap_id), new_gap, &events);
 
+        warn!("calling propagate_changes");
         self.propagate_changes();
+        warn!("calling notify_subscribers");
         self.notify_subscribers(EventsOrigin::Pagination);
 
         Ok(PaginationResult { events, hit_end_of_timeline: hit_end })

crates/matrix-sdk/src/event_cache/caches/room/mod.rs

@@ -389,8 +389,11 @@ impl RoomEventCache {
     pub(crate) async fn save_events(&self, events: impl IntoIterator<Item = Event>) {
         match self.inner.state.write().await {
             Ok(mut state_guard) => {
+                warn!("Got write lock in the event cache");
                 if let Err(err) = state_guard.save_events(events).await {
                     warn!("couldn't save event in the event cache: {err}");
+                } else {
+                    warn!("Successfully saved events in the event cache. Write lock is now gone.");
                 }
             }
 

crates/matrix-sdk/src/event_cache/caches/room/state.rs

@@ -1348,17 +1348,22 @@ impl<'a> RoomEventCacheStateLockWriteGuard<'a> {
         let store = self.store.clone();
         let room_id = self.state.room_id.clone();
         let events = events.into_iter().collect::<Vec<_>>();
+        let size = events.len();
+        warn!("Saving events into cache: {size}");
 
         // Spawn a task so the save is uninterrupted by task cancellation.
         spawn(async move {
-            for event in events {
+            for (idx,event) in events.into_iter().enumerate() {
                 store.save_event(&room_id, event).await?;
+                warn!("Saving item {}/{}", idx+1, size);
             }
             super::Result::Ok(())
         })
         .await
         .expect("joining failed")?;
 
+        warn!("Finished saving events: {}", size);
+
         Ok(())
     }
 

crates/matrix-sdk/src/room/mod.rs

@@ -30,6 +30,7 @@ use futures_util::{
     StreamExt, future::join_all, stream as futures_stream, stream::FuturesUnordered,
 };
 use http::StatusCode;
+use itertools::Itertools;
 #[cfg(feature = "e2e-encryption")]
 pub use identity_status_changes::IdentityStatusChanges;
 #[cfg(feature = "experimental-encrypted-state-events")]
@@ -613,16 +614,33 @@ impl Room {
         let http_response = self.client.send(request).await?;
 
         let push_ctx = self.push_context().await?;
+        warn!("Decrypting events: {}", http_response.chunk.len());
         let chunk = join_all(
-            http_response.chunk.into_iter().map(|ev| self.try_decrypt_event(ev, push_ctx.as_ref())),
+            http_response.chunk.into_iter().map(|ev| {
+                timeout(self.try_decrypt_event(ev, push_ctx.as_ref()), Duration::from_secs(5))
+            }),
         )
         .await;
 
+        let chunk = chunk.into_iter().filter_map(|event| {
+            match event {
+                Ok(event) => Some(event),
+                Err(e) => {
+                    error!(?e, "Failed to decrypt event (timeout)");
+                    None
+                }
+            }
+        }).collect_vec();
+
+        warn!("Saving eventsΩ");
         // Save the loaded events into the event cache, if it's set up.
         if let Ok((cache, _handles)) = self.event_cache().await {
+            warn!("Got room event cache to save events");
             cache.save_events(chunk.clone()).await;
         }
 
+        warn!("Saved events, returning from 'messages'");
+
         Ok(Messages {
             start: http_response.start,
             end: http_response.end,