wip

livekit/src/room/mod.rs

@@ -221,6 +221,7 @@ impl Room {
             let dispatcher = dispatcher.clone();
             let e2ee_manager = e2ee_manager.clone();
             move |participant, publication| {
+                log::info!("local track published: {:?}", publication);
                 let track = publication.track().unwrap();
                 let event = RoomEvent::LocalTrackPublished {
                     participant: participant.clone(),
@@ -236,6 +237,7 @@ impl Room {
             let dispatcher = dispatcher.clone();
             let e2ee_manager = e2ee_manager.clone();
             move |participant, publication| {
+                log::info!("local track unpublished: {:?}", publication);
                 let event = RoomEvent::LocalTrackUnpublished {
                     participant: participant.clone(),
                     publication: publication.clone(),
@@ -442,19 +444,18 @@ impl RoomSession {
     ) {
         loop {
             tokio::select! {
-                res = engine_events.recv() => {
-                    if let Some(event) = res {
-                        if let Err(err) = self.on_engine_event(event).await {
-                            log::error!("failed to handle engine event: {:?}", err);
-                        }
+                Some(event) = engine_events.recv() => {
+                    if let Err(err) = self.on_engine_event(event).await {
+                        log::error!("failed to handle engine event: {:?}", err);
                     }
                 },
                  _ = &mut close_receiver => {
-                    log::trace!("closing room_task");
                     break;
                 }
             }
         }
+
+        log::debug!("room_task closed");
     }
 
     async fn on_engine_event(self: &Arc<Self>, event: EngineEvent) -> RoomResult<()> {
@@ -564,7 +565,6 @@ impl RoomSession {
             if let Some(remote_participant) = remote_participant {
                 if pi.state == proto::participant_info::State::Disconnected as i32 {
                     // Participant disconnected
-                    log::info!("Participant disconnected: {:?}", participant_sid);
                     self.clone()
                         .handle_participant_disconnect(remote_participant)
                 } else {
@@ -573,7 +573,7 @@ impl RoomSession {
                 }
             } else {
                 // Create a new participant
-                log::info!("Participant connected: {:?}", participant_sid);
+                log::info!("new participant: {:?}", pi);
                 let remote_participant = {
                     let pi = pi.clone();
                     self.create_participant(
@@ -781,7 +781,7 @@ impl RoomSession {
     }
 
     fn handle_disconnected(&self, reason: DisconnectReason) {
-        log::info!("disconnected from room,: {:?}", reason);
+        log::info!("disconnected from room: {:?}", reason);
         if self.update_connection_state(ConnectionState::Disconnected) {
             self.dispatcher
                 .dispatch(&RoomEvent::Disconnected { reason });
@@ -830,6 +830,7 @@ impl RoomSession {
             let dispatcher = self.dispatcher.clone();
             let e2ee_manager = self.e2ee_manager.clone();
             move |participant, publication, track| {
+                log::info!("track subscribed: {:?}", track);
                 let event = RoomEvent::TrackSubscribed {
                     participant: participant.clone(),
                     track: track.clone(),
@@ -844,6 +845,7 @@ impl RoomSession {
             let dispatcher = self.dispatcher.clone();
             let e2ee_manager = self.e2ee_manager.clone();
             move |participant, publication, track| {
+                log::info!("track unsubscribed: {:?}", track);
                 let event = RoomEvent::TrackUnsubscribed {
                     participant: participant.clone(),
                     track: track.clone(),
@@ -888,13 +890,13 @@ impl RoomSession {
         });
 
         self.participants.write().insert(sid, participant.clone());
-
         participant
     }
 
     /// A participant has disconnected
     /// Cleanup the participant and emit an event
     fn handle_participant_disconnect(self: Arc<Self>, remote_participant: RemoteParticipant) {
+        log::info!("handle_participant_disconnect: {:?}", remote_participant);
         for (sid, _) in remote_participant.tracks() {
             remote_participant.unpublish_track(&sid);
         }

livekit/src/room/participant/local_participant.rs

@@ -195,7 +195,6 @@ impl LocalParticipant {
         let publication = LocalTrackPublication::new(track_info.clone(), track.clone());
         track.update_info(track_info); // Update sid + source
 
-        log::debug!("publishing track with cid {:?}", track.rtc_track().id());
         let transceiver = self
             .inner
             .rtc_engine

livekit/src/room/participant/remote_participant.rs

@@ -139,8 +139,6 @@ impl RemoteParticipant {
 
             track.set_transceiver(Some(transceiver));
 
-            log::debug!("starting track: {:?}", sid);
-
             //track.set_muted(remote_publication.is_muted());
             track.update_info(proto::TrackInfo {
                 sid: remote_publication.sid().to_string(),

livekit/src/room/track/mod.rs

@@ -166,7 +166,6 @@ pub(super) fn new_inner(
 /// This is only called for local tracks
 pub(super) fn set_muted(inner: &Arc<TrackInner>, track: &Track, muted: bool) {
     let info = inner.info.read();
-    log::debug!("set_muted: {:?} {:?}", info.sid, muted);
     if info.muted == muted {
         return;
     }

livekit/src/rtc_engine/lk_runtime.rs

@@ -38,7 +38,7 @@ impl LkRuntime {
         if let Some(lk_runtime) = lk_runtime_ref.upgrade() {
             lk_runtime
         } else {
-            log::trace!("LkRuntime::new()");
+            log::debug!("LkRuntime::new()");
             let new_runtime = Arc::new(Self {
                 pc_factory: PeerConnectionFactory::default(),
             });
@@ -54,6 +54,6 @@ impl LkRuntime {
 
 impl Drop for LkRuntime {
     fn drop(&mut self) {
-        log::trace!("LkRuntime::drop()");
+        log::debug!("LkRuntime::drop()");
     }
 }

livekit/src/rtc_engine/mod.rs

@@ -283,19 +283,18 @@ impl EngineInner {
     ) {
         loop {
             tokio::select! {
-                res = session_events.recv() => {
-                    if let Some(event) = res {
-                        if let Err(err) = self.on_session_event(event).await {
-                            log::error!("failed to handle session event: {:?}", err);
-                        }
+                Some(event) = session_events.recv() => {
+                    if let Err(err) = self.on_session_event(event).await {
+                        log::error!("failed to handle session event: {:?}", err);
                     }
                 },
                  _ = &mut close_receiver => {
-                    log::trace!("closing engine task");
                     break;
                 }
             }
         }
+
+        log::debug!("engine task closed");
     }
 
     async fn on_session_event(self: &Arc<Self>, event: SessionEvent) -> EngineResult<()> {
@@ -492,7 +491,7 @@ impl EngineInner {
                 inner.reconnecting.store(false, Ordering::Release);
 
                 if res.is_ok() {
-                    log::info!("RtcEngine successfully reconnected")
+                    log::info!("RtcEngine successfully recovered")
                 } else {
                     log::error!("failed to reconnect after {} attempts", RECONNECT_ATTEMPTS);
                     inner.close(DisconnectReason::UnknownReason).await;

livekit/src/rtc_engine/peer_transport.rs

@@ -136,7 +136,6 @@ impl PeerTransport {
         let mut inner = self.inner.lock().await;
 
         if options.ice_restart {
-            log::debug!("restarting ICE");
             inner.restarting_ice = true;
         }