chore(sdk): Utilize the root span in more places

Author: poljar

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

@@ -69,7 +69,7 @@ use serde::de::DeserializeOwned;
 use tokio::sync::OnceCell;
 #[cfg(feature = "e2e-encryption")]
 use tracing::error;
-use tracing::{debug, field::display, info, instrument, Span};
+use tracing::{debug, field::display, info, instrument, Instrument, Span};
 use url::Url;
 
 #[cfg(feature = "e2e-encryption")]
@@ -2340,9 +2340,11 @@ impl Client {
             sync_settings.token = self.sync_token().await;
         }
 
+        let parent_span = Span::current();
+
         async_stream::stream! {
             loop {
-                yield self.sync_loop_helper(&mut sync_settings).await;
+                yield self.sync_loop_helper(&mut sync_settings).instrument(parent_span.clone()).await;
 
                 Client::delay_sync(&mut last_sync_time).await
             }

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

@@ -31,9 +31,7 @@ use ruma::{
     EventId, OwnedTransactionId, TransactionId, UserId,
 };
 use serde_json::Value;
-use tracing::debug;
-#[cfg(feature = "e2e-encryption")]
-use tracing::instrument;
+use tracing::{debug, instrument};
 
 use super::Left;
 use crate::{
@@ -84,6 +82,7 @@ impl Joined {
     }
 
     /// Leave this room.
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn leave(&self) -> Result<Left> {
         self.inner.leave().await
     }
@@ -95,6 +94,7 @@ impl Joined {
     /// * `user_id` - The user to ban with `UserId`.
     ///
     /// * `reason` - The reason for banning this user.
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn ban_user(&self, user_id: &UserId, reason: Option<&str>) -> Result<()> {
         let request = assign!(
             ban_user::v3::Request::new(self.inner.room_id().to_owned(), user_id.to_owned()),
@@ -112,6 +112,7 @@ impl Joined {
     ///   room.
     ///
     /// * `reason` - Optional reason why the room member is being kicked out.
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn kick_user(&self, user_id: &UserId, reason: Option<&str>) -> Result<()> {
         let request = assign!(
             kick_user::v3::Request::new(self.inner.room_id().to_owned(), user_id.to_owned()),
@@ -126,6 +127,7 @@ impl Joined {
     /// # Arguments
     ///
     /// * `user_id` - The `UserId` of the user to invite to the room.
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn invite_user_by_id(&self, user_id: &UserId) -> Result<()> {
         let recipient = InvitationRecipient::UserId { user_id: user_id.to_owned() };
 
@@ -140,6 +142,7 @@ impl Joined {
     /// # Arguments
     ///
     /// * `invite_id` - A third party id of a user to invite to the room.
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn invite_user_by_3pid(&self, invite_id: Invite3pid) -> Result<()> {
         let recipient = InvitationRecipient::ThirdPartyId(invite_id);
         let request = invite_user::v3::Request::new(self.inner.room_id().to_owned(), recipient);
@@ -207,35 +210,44 @@ impl Joined {
         };
 
         if send {
-            let typing = if typing {
-                self.client
-                    .inner
-                    .typing_notice_times
-                    .insert(self.inner.room_id().to_owned(), Instant::now());
-                Typing::Yes(TYPING_NOTICE_TIMEOUT)
-            } else {
-                self.client.inner.typing_notice_times.remove(self.inner.room_id());
-                Typing::No
-            };
-
-            let request = TypingRequest::new(
-                self.inner.own_user_id().to_owned(),
-                self.inner.room_id().to_owned(),
-                typing,
-            );
-            self.client.send(request, None).await?;
+            self.send_typing_notice(typing).await?;
         }
 
         Ok(())
     }
 
+    #[instrument(name = "typing_notice", skip(self), parent = &self.client.root_span)]
+    async fn send_typing_notice(&self, typing: bool) -> Result<()> {
+        let typing = if typing {
+            self.client
+                .inner
+                .typing_notice_times
+                .insert(self.inner.room_id().to_owned(), Instant::now());
+            Typing::Yes(TYPING_NOTICE_TIMEOUT)
+        } else {
+            self.client.inner.typing_notice_times.remove(self.inner.room_id());
+            Typing::No
+        };
+
+        let request = TypingRequest::new(
+            self.inner.own_user_id().to_owned(),
+            self.inner.room_id().to_owned(),
+            typing,
+        );
+
+        self.client.send(request, None).await?;
+
+        Ok(())
+    }
+
     /// Send a request to notify this room that the user has read specific
     /// event.
     ///
     /// # Arguments
     ///
     /// * `event_id` - The `EventId` specifies the event to set the read receipt
     ///   on.
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn read_receipt(&self, event_id: &EventId) -> Result<()> {
         let request = create_receipt::v3::Request::new(
             self.inner.room_id().to_owned(),
@@ -256,6 +268,7 @@ impl Joined {
     ///
     /// * read_receipt - An `EventId` to specify the event to set the read
     ///   receipt on.
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn read_marker(
         &self,
         fully_read: &EventId,
@@ -301,6 +314,7 @@ impl Joined {
     /// }
     /// # anyhow::Ok(()) });
     /// ```
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn enable_encryption(&self) -> Result<()> {
         use ruma::{
             events::room::encryption::RoomEncryptionEventContent, EventEncryptionAlgorithm,
@@ -401,6 +415,7 @@ impl Joined {
     /// Warning: This waits until a sync happens and does not return if no sync
     /// is happening! It can also return early when the room is not a joined
     /// room anymore!
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn sync_up(&self) {
         while !self.is_synced() && self.room_type() == RoomType::Joined {
             self.client.inner.sync_beat.listen().wait_timeout(Duration::from_secs(1));
@@ -671,6 +686,7 @@ impl Joined {
     /// }
     /// # anyhow::Ok(()) });
     /// ```
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn send_attachment(
         &self,
         body: &str,
@@ -824,6 +840,7 @@ impl Joined {
     /// joined_room.send_state_event(content).await?;
     /// # anyhow::Ok(()) };
     /// ```
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn send_state_event(
         &self,
         content: impl StateEventContent<StateKey = EmptyStateKey>,
@@ -923,6 +940,7 @@ impl Joined {
     /// }
     /// # anyhow::Ok(()) });
     /// ```
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn send_state_event_raw(
         &self,
         content: Value,
@@ -973,6 +991,7 @@ impl Joined {
     /// }
     /// # anyhow::Ok(()) });
     /// ```
+    #[instrument(skip_all, parent = &self.client.root_span)]
     pub async fn redact(
         &self,
         event_id: &EventId,

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

@@ -372,7 +372,7 @@ impl Timeline {
     ///
     /// [`MessageLikeUnsigned`]: ruma::events::MessageLikeUnsigned
     /// [`SyncMessageLikeEvent`]: ruma::events::SyncMessageLikeEvent
-    #[instrument(skip(self, content), fields(room_id = ?self.room().room_id()))]
+    #[instrument(skip(self, content), parent = &self.inner.room().client.root_span, fields(room_id = ?self.room().room_id()))]
     pub async fn send(&self, content: AnyMessageLikeEventContent, txn_id: Option<&TransactionId>) {
         let txn_id = txn_id.map_or_else(TransactionId::new, ToOwned::to_owned);
         self.inner.handle_local_event(txn_id.clone(), content.clone()).await;