Adrien/beau-gosse-du-92
1
0
Fork 0
Code Issues 2 Pull Requests 1 Packages Projects Releases Wiki Activity

🔊 Trace events from Matrix client callbacks to domain methods

Browse Source
This commit is contained in:
Adrien
2024-05-21 12:22:04 +02:00
parent b5da0ee992
commit cd6506fb03
11 changed files with 405 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/infrastructure/messaging/matrix/account_event.rs
View File

@@ -1,6 +1,7 @@
use std::fmt::{Debug, Formatter};
use matrix_sdk::{ruma::OwnedRoomId, RoomState};
use tracing::Span;
use super::room_event::RoomEventsReceiver;
use crate::{domain::model::space::SpaceId, utils::Sender};
@@ -16,6 +17,7 @@ pub enum AccountEvent {
RoomState,
RoomEventsReceiver,
Sender<bool>,
Span,
),
NewSpace(
@@ -24,23 +26,33 @@ pub enum AccountEvent {
Option<String>,
RoomEventsReceiver,
Sender<bool>,
Span,
),
}
impl Debug for AccountEvent {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::NewRoom(id, spaces, name, topic, is_direct, state, _events_receiver, _sender) => {
f.debug_tuple("AccountEvent::NewRoom")
.field(id)
.field(spaces)
.field(name)
.field(topic)
.field(is_direct)
.field(state)
.finish()
}
Self::NewSpace(id, name, topic, _events_receiver, _sender) => f
Self::NewRoom(
id,
spaces,
name,
topic,
is_direct,
state,
_events_receiver,
_sender,
_span,
) => f
.debug_tuple("AccountEvent::NewRoom")
.field(id)
.field(spaces)
.field(name)
.field(topic)
.field(is_direct)
.field(state)
.finish(),
Self::NewSpace(id, name, topic, _events_receiver, _sender, _span) => f
.debug_tuple("AccountEvent::NewSpace")
.field(id)
.field(name)

209
src/infrastructure/messaging/matrix/client.rs
View File

@@ -28,13 +28,12 @@ use matrix_sdk::{
},
Client as MatrixClient, RoomMemberships, RoomState,
};
use tokio::sync::{
broadcast,
broadcast::{error::SendError, Receiver, Sender},
mpsc::{unbounded_channel, UnboundedReceiver},
};
use tracing::{debug, error, warn};
use tracing::{debug, debug_span, error, instrument, warn, Instrument, Span};
use super::{
account_event::AccountEvent,
@@ -75,7 +74,7 @@ impl Senders {
if let Some(room_sender) = room_senders.get(room_id) {
if let Err(err) = room_sender.send(event) {
error!("Unable to send event to the {room_id} room: {err}");
warn!("Unable to send event to the {room_id} room: {err}");
return Err(err);
}
} else {
@@ -117,12 +116,15 @@ impl Client {
}
}
#[instrument(skip_all)]
async fn create_space(
senders: &Ctx<Senders>,
room_id: &OwnedRoomId,
room: Option<&Room>,
) -> anyhow::Result<(), SendError<AccountEvent>> {
if let Some(receiver) = senders.add_room(&room_id) {
if let Some(receiver) = senders.add_room(room_id) {
let current_span = Span::current();
let mut name = None;
let mut topic = None;
if let Some(room) = room {
@@ -139,19 +141,21 @@ impl Client {
topic.clone(),
receiver,
reply,
current_span.clone(),
);
if let Err(err) = senders.account_events_sender.send(event) {
return Err(err);
}
senders.account_events_sender.send(event)?;
// We're expecting a response indicating that the client is able to compute the next RoomEvent
response.recv().await;
let events = vec![RoomEvent::NewTopic(topic), RoomEvent::NewName(name)];
let events = vec![
RoomEvent::NewTopic(topic, current_span.clone()),
RoomEvent::NewName(name, current_span),
];
for event in events {
if let Err(_err) = senders.send(&room_id, event.clone()) {
if let Err(_err) = senders.send(room_id, event.clone()) {
// TODO: Return an error
}
}
@@ -160,6 +164,7 @@ impl Client {
Ok(())
}
#[instrument(skip_all)]
async fn create_room(
senders: &Ctx<Senders>,
room: &Room,
@@ -172,7 +177,7 @@ impl Client {
let is_direct = match room.is_direct().await {
Ok(is_direct) => Some(is_direct),
Err(err) => {
error!("Unable to know if the {room_id} room is direct: {err}");
warn!("Unable to know if the {room_id} room is direct: {err}");
None
}
};
@@ -205,11 +210,10 @@ impl Client {
room.state(),
receiver,
reply,
Span::current(),
);
if let Err(err) = senders.account_events_sender.send(event) {
return Err(err);
}
senders.account_events_sender.send(event)?;
// We're expecting a response indicating that the client is able to compute the next RoomEvent
response.recv().await;
@@ -217,6 +221,7 @@ impl Client {
Ok(())
}
#[instrument(skip_all)]
async fn add_room(
senders: &Ctx<Senders>,
room: &Room,
@@ -255,7 +260,7 @@ impl Client {
let _ = Self::create_space(senders, &parent, None).await;
}
let event = RoomEvent::NewChild(room_id.clone());
let event = RoomEvent::NewChild(room_id.clone(), Span::current());
if let Err(_err) = senders.send(&parent, event) {
// TODO: Return an error
}
@@ -270,7 +275,9 @@ impl Client {
room: Room,
senders: Ctx<Senders>,
) {
let _ = Self::add_room(&senders, &room).await;
let span = debug_span!("Matrix::NewRoom", r = ?room.room_id());
let _ = Self::add_room(&senders, &room).instrument(span).await;
}
// SyncStateEvent: A possibly-redacted state event without a room_id.
@@ -279,9 +286,12 @@ impl Client {
room: Room,
senders: Ctx<Senders>,
) {
let _ = Self::add_room(&senders, &room).await;
let span = debug_span!("Matrix::NewRoom", r = ?room.room_id());
let _ = Self::add_room(&senders, &room).instrument(span).await;
}
#[instrument(skip_all)]
fn on_invite_room_member_event(
user_id: OwnedUserId,
inviter_id: OwnedUserId,
@@ -290,15 +300,16 @@ impl Client {
senders: &Ctx<Senders>,
) {
if let Some(client_user_id) = matrix_client.user_id() {
let is_account_user = user_id == client_user_id;
let room_id = room.room_id();
let is_account_user = user_id == client_user_id;
debug!(
"{} (account user: {is_account_user}) invited by {} to join the {} room",
&user_id, &inviter_id, &room_id
);
let event = RoomEvent::Invitation(user_id, inviter_id, is_account_user);
let event =
RoomEvent::Invitation(user_id, inviter_id, is_account_user, Span::current());
if let Err(_err) = senders.send(room_id, event) {
// TODO: Return an error
@@ -306,6 +317,7 @@ impl Client {
}
}
#[instrument(skip_all)]
fn on_join_room_member_event(
user_id: OwnedUserId,
displayname: Option<String>,
@@ -318,9 +330,15 @@ impl Client {
let is_account_user = user_id == client_user_id;
let room_id = room.room_id();
error!("{} has joined the {} room", &user_id, &room_id);
debug!("{} has joined the {} room", &user_id, &room_id);
let event = RoomEvent::Join(user_id, displayname, avatar_url, is_account_user);
let event = RoomEvent::Join(
user_id,
displayname,
avatar_url,
is_account_user,
Span::current(),
);
if let Err(_err) = senders.send(room_id, event) {
// TODO: Return an error
@@ -340,21 +358,35 @@ impl Client {
let user_id = &ev.state_key;
match ev.content.membership {
MembershipState::Invite => Self::on_invite_room_member_event(
user_id.clone(),
ev.sender,
&room,
&matrix_client,
&senders,
),
MembershipState::Join => Self::on_join_room_member_event(
ev.sender,
ev.content.displayname,
ev.content.avatar_url,
&room,
&matrix_client,
&senders,
),
MembershipState::Invite => {
let span = debug_span!("Matrix::RoomInvitation", r = ?room.room_id());
span.in_scope(|| {
Self::on_invite_room_member_event(
user_id.clone(),
ev.sender,
&room,
&matrix_client,
&senders,
)
});
}
MembershipState::Join => {
let span =
debug_span!("Matrix::RoomJoin", r = ?room.room_id(), u = ?user_id)
.entered();
span.in_scope(|| {
Self::on_join_room_member_event(
ev.sender,
ev.content.displayname,
ev.content.avatar_url,
&room,
&matrix_client,
&senders,
)
});
}
_ => {
error!("TODO: {:?}", ev);
}
@@ -377,33 +409,42 @@ impl Client {
if let SyncStateEvent::Original(ev) = ev {
match ev.content.membership {
MembershipState::Invite => {
let invitee_id = ev.state_key;
let span = debug_span!("Matrix::RoomInvitation", r = ?room.room_id());
Self::on_invite_room_member_event(
invitee_id,
ev.sender,
&room,
&matrix_client,
&senders,
)
// .await
span.in_scope(|| {
let invitee_id = ev.state_key;
Self::on_invite_room_member_event(
invitee_id,
ev.sender,
&room,
&matrix_client,
&senders,
)
});
}
MembershipState::Join => {
Self::on_join_room_member_event(
ev.sender,
ev.content.displayname,
ev.content.avatar_url,
&room,
&matrix_client,
&senders,
)
// .await
let user_id = ev.sender;
let span = debug_span!("Matrix::RoomJoin", r = ?room.room_id(), u = ?user_id)
.entered();
span.in_scope(|| {
Self::on_join_room_member_event(
user_id,
ev.content.displayname,
ev.content.avatar_url,
&room,
&matrix_client,
&senders,
)
});
}
_ => error!("TODO"),
}
}
}
#[instrument(skip_all)]
async fn on_room_avatar_event(room: &Room, senders: &Ctx<Senders>) {
let room_id = room.room_id();
let avatar = match room
@@ -416,12 +457,12 @@ impl Client {
{
Ok(avatar) => avatar,
Err(err) => {
error!("Unable to fetch avatar for {}: {err}", &room_id);
warn!("Unable to fetch avatar for {}: {err}", &room_id);
None
}
};
let event = RoomEvent::NewAvatar(avatar);
let event = RoomEvent::NewAvatar(avatar, Span::current());
if let Err(_err) = senders.send(room_id, event) {
// TODO: Return an error
@@ -433,7 +474,11 @@ impl Client {
room: Room,
senders: Ctx<Senders>,
) {
Self::on_room_avatar_event(&room, &senders).await;
let span = debug_span!("Matrix::RoomAvatar", r = ?room.room_id());
Self::on_room_avatar_event(&room, &senders)
.instrument(span)
.await;
}
async fn on_sync_room_avatar_event(
@@ -443,13 +488,18 @@ impl Client {
) {
if let SyncStateEvent::Original(_ev) = ev {
dioxus::prelude::spawn(async move {
Self::on_room_avatar_event(&room, &senders).await;
let span = debug_span!("Matrix::RoomAvatar", r = ?room.room_id());
Self::on_room_avatar_event(&room, &senders)
.instrument(span)
.await;
});
}
}
#[instrument(skip_all)]
fn on_room_name_event(name: Option<String>, room: &Room, senders: &Ctx<Senders>) {
let event = RoomEvent::NewName(name);
let event = RoomEvent::NewName(name, Span::current());
if let Err(_err) = senders.send(room.room_id(), event) {
// TODO: Return an error
@@ -461,7 +511,11 @@ impl Client {
room: Room,
senders: Ctx<Senders>,
) {
Self::on_room_name_event(ev.content.name, &room, &senders);
let span = debug_span!("Matrix::RoomName", r = ?room.room_id());
span.in_scope(|| {
Self::on_room_name_event(ev.content.name, &room, &senders);
});
}
async fn on_sync_room_name_event(
@@ -470,12 +524,17 @@ impl Client {
senders: Ctx<Senders>,
) {
if let SyncStateEvent::Original(ev) = ev {
Self::on_room_name_event(Some(ev.content.name), &room, &senders);
let span = debug_span!("Matrix::RoomName", r = ?room.room_id());
span.in_scope(|| {
Self::on_room_name_event(Some(ev.content.name), &room, &senders);
});
}
}
#[instrument(skip_all)]
fn on_room_topic_event(topic: Option<String>, room: &Room, senders: &Ctx<Senders>) {
let event = RoomEvent::NewTopic(topic);
let event = RoomEvent::NewTopic(topic, Span::current());
if let Err(_err) = senders.send(room.room_id(), event) {
// TODO: Return an error
@@ -487,7 +546,11 @@ impl Client {
room: Room,
senders: Ctx<Senders>,
) {
Self::on_room_topic_event(ev.content.topic, &room, &senders);
let span = debug_span!("Matrix::RoomTopic", r = ?room.room_id());
span.in_scope(|| {
Self::on_room_topic_event(ev.content.topic, &room, &senders);
});
}
async fn on_sync_room_topic_event(
@@ -496,7 +559,11 @@ impl Client {
senders: Ctx<Senders>,
) {
if let SyncStateEvent::Original(ev) = ev {
Self::on_room_topic_event(Some(ev.content.topic), &room, &senders);
let span = debug_span!("Matrix::RoomTopic", r = ?room.room_id());
span.in_scope(|| {
Self::on_room_topic_event(Some(ev.content.topic), &room, &senders);
});
}
}
@@ -629,7 +696,7 @@ impl Client {
Err(err) => Err(err.into()),
}
} else {
error!("No room found with the \"{}\" id", room_id.as_str());
warn!("No room found with the \"{}\" id", room_id.as_str());
// TODO: Return an error if the room has not been found
Ok(None)
}
@@ -644,7 +711,7 @@ impl Client {
Err(err) => Err(err.into()),
}
} else {
error!("No room found with the \"{}\" id", room_id.as_str());
warn!("No room found with the \"{}\" id", room_id.as_str());
// TODO: Return an error if the room has not been found
Ok(vec![])
}
@@ -681,8 +748,8 @@ impl Client {
// TODO: Check if we can get member before fetching the data and received an error...
match room.get_member(user_id).await {
Ok(room_member) => match room_member {
Some(room_member) => {
Ok(room_member) => {
if let Some(room_member) = room_member {
let res = match room_member
.avatar(MediaFormat::Thumbnail(MediaThumbnailSize {
method: Method::Scale,
@@ -696,16 +763,14 @@ impl Client {
};
return res;
}
// TODO: Error msg
None => (),
},
}
Err(err) => {
error!("Unable to get room member {user_id}: {err}");
warn!("Unable to get room member {user_id}: {err}");
if let Some(avatar_url) = avatar_url {
let thumbnail = self.get_thumbnail(avatar_url.clone()).await;
return Ok(Some(thumbnail?));
} else {
error!("No avatar url set for the {room_id} room");
debug!("No avatar url set for the {room_id} room");
}
}
}

183
src/infrastructure/messaging/matrix/requester.rs
View File

@@ -1,12 +1,13 @@
use std::{collections::HashMap, rc::Rc};
use async_trait::async_trait;
use matrix_sdk::ruma::{OwnedMxcUri, OwnedRoomId, OwnedUserId};
use tokio::{
select,
sync::{broadcast::Receiver, mpsc::UnboundedSender},
};
use tokio_stream::{wrappers::BroadcastStream, StreamExt, StreamMap};
use tracing::error;
use tracing::{error, instrument, Instrument};
use super::{
account_event::AccountEvent,
@@ -96,6 +97,96 @@ impl Requester {
pub async fn login(&self, style: LoginStyle) -> anyhow::Result<()> {
request_to_worker!(self, WorkerTask::Login, style)
}
#[instrument(skip_all)]
async fn on_room_invitation(
consumer: &Rc<dyn RoomMessagingConsumerInterface>,
user_id: OwnedUserId,
sender_id: OwnedUserId,
is_account_user: bool,
) {
let invitation = Invitation::new(user_id, sender_id, is_account_user);
consumer.on_invitation(invitation).await;
}
#[instrument(skip_all)]
async fn on_room_join(
consumer: &Rc<dyn RoomMessagingConsumerInterface>,
room_id: OwnedRoomId,
user_id: OwnedUserId,
user_name: Option<String>,
avatar_url: Option<OwnedMxcUri>,
is_account_user: bool,
messaging_provider: Rc<dyn MemberMessagingProviderInterface>,
) {
let member = RoomMember::new(
UserId::from(user_id),
user_name,
avatar_url,
room_id,
is_account_user,
messaging_provider,
);
consumer.on_membership(member).await;
}
#[instrument(skip_all)]
async fn on_room_new_topic(
consumer: &Rc<dyn RoomMessagingConsumerInterface>,
topic: Option<String>,
) {
consumer.on_new_topic(topic).await;
}
#[instrument(skip_all)]
async fn on_room_new_name(
consumer: &Rc<dyn RoomMessagingConsumerInterface>,
name: Option<String>,
) {
consumer.on_new_name(name).await;
}
#[instrument(skip_all)]
async fn on_room_new_avatar(
consumer: &Rc<dyn RoomMessagingConsumerInterface>,
avatar: Option<Avatar>,
) {
consumer.on_new_avatar(avatar).await;
}
#[instrument(skip_all)]
async fn on_space_new_child(
consumer: &Rc<dyn SpaceMessagingConsumerInterface>,
child_id: RoomId,
) {
// TODO: Make name consistent
consumer.on_child(child_id).await;
}
#[instrument(skip_all)]
async fn on_space_new_topic(
consumer: &Rc<dyn SpaceMessagingConsumerInterface>,
topic: Option<String>,
) {
consumer.on_new_topic(topic).await;
}
#[instrument(skip_all)]
async fn on_space_new_name(
consumer: &Rc<dyn SpaceMessagingConsumerInterface>,
name: Option<String>,
) {
consumer.on_new_name(name).await;
}
// #[instrument(name="SpaceAvatar", skip_all, fields(s = %space_id, a = avatar.is_some()))]
// async fn on_space_new_avatar(
// consumer: &Rc<dyn SpaceMessagingConsumerInterface>,
// space_id: OwnedRoomId,
// avatar: Option<Avatar>,
// ) {
// consumer.on_new_avatar(avatar).await;
// }
}
#[async_trait(?Send)]
@@ -140,7 +231,17 @@ impl AccountMessagingProviderInterface for Requester {
res = account_events_receiver.recv() => {
if let Ok(account_event) = res {
match account_event {
AccountEvent::NewRoom(id, spaces, name, topic, is_direct, state, receiver, new_room_tx) => {
AccountEvent::NewRoom(
id,
spaces,
name,
topic,
is_direct,
state,
receiver,
new_room_tx,
span
) => {
let mut room = Room::new(id, spaces, name, topic, is_direct, Some(state));
let room_id = room.id().clone();
@@ -151,13 +252,15 @@ impl AccountMessagingProviderInterface for Requester {
let stream = BroadcastStream::new(receiver.into());
rooms_events_streams.insert(room_id.clone(), stream);
let room_events_consumer = account_events_consumer.on_new_room(room).await;
let room_events_consumer = account_events_consumer.on_new_room(room)
.instrument(span)
.await;
room_events_consumers.insert(room_id, room_events_consumer);
// We're now ready to recv and compute RoomEvent.
new_room_tx.send(true).await;
},
AccountEvent::NewSpace(id, name, topic, receiver, new_space_tx) => {
AccountEvent::NewSpace(id, name, topic, receiver, new_space_tx, span) => {
let mut space = Space::new(id, name, topic);
let space_id = space.id().clone();
@@ -168,12 +271,14 @@ impl AccountMessagingProviderInterface for Requester {
let stream = BroadcastStream::new(receiver.into());
spaces_events_streams.insert(space_id.clone(), stream);
let space_events_consumer = account_events_consumer.on_new_space(space).await;
let space_events_consumer = account_events_consumer.on_new_space(space)
.instrument(span)
.await;
space_events_consumers.insert(space_id, space_events_consumer);
// We're now ready to recv and compute SpaceEvent.
new_space_tx.send(true).await;
}
},
};
}
},
@@ -181,33 +286,43 @@ impl AccountMessagingProviderInterface for Requester {
if let Ok(room_event) = room_event {
if let Some(consumer) = room_events_consumers.get(&room_id) {
match room_event {
RoomEvent::Invitation(user_id, sender_id, is_account_user) => {
let invitation = Invitation::new(user_id, sender_id, is_account_user);
consumer.on_invitation(invitation).await;
RoomEvent::Invitation(user_id, sender_id, is_account_user, span) => {
Self::on_room_invitation(consumer, user_id, sender_id, is_account_user)
.instrument(span)
.await;
},
RoomEvent::Join(user_id, user_name, avatar_url, is_account_user) => {
let member = RoomMember::new(
UserId::from(user_id),
RoomEvent::Join(user_id, user_name, avatar_url, is_account_user, span) => {
Self::on_room_join(
consumer,
room_id,
user_id,
user_name,
avatar_url,
room_id,
is_account_user,
client.clone());
consumer.on_membership(member).await;
client.clone())
.instrument(span)
.await;
},
RoomEvent::NewTopic(topic) => {
consumer.on_new_topic(topic).await;
RoomEvent::NewTopic(topic, span) => {
Self::on_room_new_topic(consumer, topic)
.instrument(span)
.await;
},
RoomEvent::NewName(name) => {
consumer.on_new_name(name).await;
RoomEvent::NewName(name, span) => {
Self::on_room_new_name(consumer, name)
.instrument(span)
.await;
},
RoomEvent::NewAvatar(avatar) => {
consumer.on_new_avatar(avatar).await;
RoomEvent::NewAvatar(avatar, span) => {
Self::on_room_new_avatar(consumer, avatar)
.instrument(span)
.await;
}
_ => {}
// RoomEvent::NewAvatar(avatar) => Self::on_room_new_avatar(consumer, avatar).await,
_ => error!("TODO: {:?}", &room_event),
}
} else {
error!("No consumer found for \"{}\" room", room_id);
error!("No consumer found for {} room", &room_id);
}
}
},
@@ -215,19 +330,25 @@ impl AccountMessagingProviderInterface for Requester {
if let Ok(room_event) = room_event {
if let Some(consumer) = space_events_consumers.get(&space_id) {
match room_event {
RoomEvent::NewTopic(topic) => {
consumer.on_new_topic(topic).await;
RoomEvent::NewTopic(topic, span) => {
Self::on_space_new_topic(consumer, topic)
.instrument(span)
.await;
},
RoomEvent::NewName(name) => {
consumer.on_new_name(name).await;
RoomEvent::NewName(name, span) => {
Self::on_space_new_name(consumer, name)
.instrument(span)
.await;
},
RoomEvent::NewChild(child_id) => {
consumer.on_child(child_id).await;
RoomEvent::NewChild(child_id, span) => {
Self::on_space_new_child(consumer, child_id)
.instrument(span)
.await;
},
_ => {}
_ => error!("TODO: {:?}", &room_event),
}
} else {
error!("No consumer found for \"{}\" space", space_id);
error!("No consumer found for {} space", &space_id);
}
}
}

28
src/infrastructure/messaging/matrix/room_event.rs
View File

@@ -2,43 +2,47 @@ use std::fmt::{Debug, Formatter};
use matrix_sdk::ruma::{OwnedMxcUri, OwnedRoomId, OwnedUserId};
use tokio::sync::broadcast::Receiver;
use tracing::Span;
use crate::domain::model::common::Avatar;
#[derive(Clone)]
pub enum RoomEvent {
Invitation(OwnedUserId, OwnedUserId, bool),
Join(OwnedUserId, Option<String>, Option<OwnedMxcUri>, bool),
Invitation(OwnedUserId, OwnedUserId, bool, Span),
Join(OwnedUserId, Option<String>, Option<OwnedMxcUri>, bool, Span),
NewTopic(Option<String>),
NewName(Option<String>),
NewAvatar(Option<Avatar>),
NewChild(OwnedRoomId),
NewTopic(Option<String>, Span),
NewName(Option<String>, Span),
NewAvatar(Option<Avatar>, Span),
NewChild(OwnedRoomId, Span),
}
impl Debug for RoomEvent {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
match self {
Self::Invitation(invitee_id, sender_id, is_account_user) => f
Self::Invitation(invitee_id, sender_id, is_account_user, _span) => f
.debug_tuple("RoomEvent::Invitation")
.field(invitee_id)
.field(sender_id)
.field(is_account_user)
.finish(),
Self::Join(user_id, user_name, avatar_url, is_account_user) => f
Self::Join(user_id, user_name, avatar_url, is_account_user, _span) => f
.debug_tuple("RoomEvent::Join")
.field(user_id)
.field(user_name)
.field(avatar_url)
.field(is_account_user)
.finish(),
Self::NewTopic(topic) => f.debug_tuple("RoomEvent::NewTopic").field(topic).finish(),
Self::NewName(name) => f.debug_tuple("RoomEvent::NewName").field(name).finish(),
Self::NewAvatar(avatar) => f
Self::NewTopic(topic, _span) => {
f.debug_tuple("RoomEvent::NewTopic").field(topic).finish()
}
Self::NewName(name, _span) => f.debug_tuple("RoomEvent::NewName").field(name).finish(),
Self::NewAvatar(avatar, _span) => f
// Self::NewAvatar(avatar) => f
.debug_tuple("RoomEvent::NewAvatar")
.field(&format!("is_some: {}", &avatar.is_some()))
.finish(),
Self::NewChild(room_id) => f
Self::NewChild(room_id, _span) => f
.debug_tuple("SpaceEvent::NewChild")
.field(room_id)
.finish(),