daemon: Only run SLS log relay in root daemon

src/daemon/mod.rs

@@ -14,13 +14,9 @@ use tokio::sync::mpsc::{self, Receiver, Sender};
 use tokio::task::JoinSet;
 use tokio_util::sync::CancellationToken;
 use tracing::{debug, error, info};
-use tracing_subscriber::layer::SubscriberExt;
-use tracing_subscriber::registry::LookupSpan;
-use tracing_subscriber::EnvFilter;
 use zbus::connection::Connection;
 
 use crate::daemon::config::{read_config, read_state, write_state};
-use crate::sls::{LogLayer, LogReceiver};
 use crate::Service;
 
 mod config;
@@ -72,28 +68,19 @@ pub(crate) enum DaemonCommand<T> {
 }
 
 impl<C: DaemonContext> Daemon<C> {
-    pub(crate) async fn new<S: SubscriberExt + Send + Sync + for<'a> LookupSpan<'a>>(
+    pub(crate) async fn new(
-        subscriber: S,
         connection: Connection,
         channel: Receiver<DaemonCommand<C::Command>>,
     ) -> Result<Daemon<C>> {
         let services = JoinSet::new();
         let token = CancellationToken::new();
 
-        let log_receiver = LogReceiver::new(connection.clone()).await?;
+        let daemon = Daemon {
-        let remote_logger = LogLayer::new(&log_receiver);
-        let subscriber = subscriber
-            .with(EnvFilter::from_default_env())
-            .with(remote_logger);
-        tracing::subscriber::set_global_default(subscriber)?;
-
-        let mut daemon = Daemon {
             services,
             token,
             connection,
             channel,
         };
-        daemon.add_service(log_receiver);
 
         Ok(daemon)
     }

src/daemon/root.rs

@@ -12,8 +12,9 @@ use tokio::sync::mpsc::Sender;
 use tokio::sync::oneshot;
 use tokio_util::sync::CancellationToken;
 use tracing::error;
+use tracing::subscriber::set_global_default;
 use tracing_subscriber::prelude::*;
-use tracing_subscriber::{fmt, Registry};
+use tracing_subscriber::{fmt, EnvFilter, Registry};
 use zbus::connection::{Builder, Connection};
 
 use crate::daemon::{channel, Daemon, DaemonCommand, DaemonContext};
@@ -23,6 +24,7 @@ use crate::manager::root::SteamOSManager;
 use crate::path;
 use crate::power::SysfsWriterService;
 use crate::sls::ftrace::Ftrace;
+use crate::sls::{LogLayer, LogReceiver};
 
 #[derive(Copy, Clone, Default, Deserialize, Debug)]
 #[serde(default)]
@@ -184,7 +186,9 @@ pub async fn daemon() -> Result<()> {
     // level things. It implements com.steampowered.SteamOSManager1.RootManager interface
 
     let stdout_log = fmt::layer();
-    let subscriber = Registry::default().with(stdout_log);
+    let subscriber = Registry::default()
+        .with(stdout_log)
+        .with(EnvFilter::from_default_env());
     let (tx, rx) = channel::<RootContext>();
 
     let connection = match create_connection(tx.clone()).await {
@@ -195,9 +199,14 @@ pub async fn daemon() -> Result<()> {
             bail!(e);
         }
     };
+    let log_receiver = LogReceiver::new(connection.clone()).await?;
+    let remote_logger = LogLayer::new(&log_receiver);
+    let subscriber = subscriber.with(remote_logger);
+    set_global_default(subscriber)?;
 
     let context = RootContext::new(tx);
-    let mut daemon = Daemon::new(subscriber, connection.clone(), rx).await?;
+    let mut daemon = Daemon::new(connection.clone(), rx).await?;
+    daemon.add_service(log_receiver);
 
     daemon.run(context).await
 }

src/daemon/user.rs

@@ -11,9 +11,10 @@ use anyhow::{bail, Result};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 use tokio::sync::mpsc::{unbounded_channel, Sender};
+use tracing::subscriber::set_global_default;
 use tracing::{error, info};
 use tracing_subscriber::prelude::*;
-use tracing_subscriber::{fmt, Registry};
+use tracing_subscriber::{fmt, EnvFilter, Registry};
 #[cfg(not(test))]
 use xdg::BaseDirectories;
 use zbus::connection::{Builder, Connection};
@@ -151,7 +152,9 @@ pub async fn daemon() -> Result<()> {
     // level things. It implements com.steampowered.SteamOSManager1.Manager interface
 
     let stdout_log = fmt::layer();
-    let subscriber = Registry::default().with(stdout_log);
+    let subscriber = Registry::default()
+        .with(stdout_log)
+        .with(EnvFilter::from_default_env());
     let (tx, rx) = channel::<UserContext>();
 
     let (session, system, mirror_service, tdp_service, signal_relay_service) =
@@ -163,11 +166,12 @@ pub async fn daemon() -> Result<()> {
                 bail!(e);
             }
         };
+    set_global_default(subscriber)?;
 
     let context = UserContext {
         session: session.clone(),
     };
-    let mut daemon = Daemon::new(subscriber, system, rx).await?;
+    let mut daemon = Daemon::new(system, rx).await?;
 
     daemon.add_service(signal_relay_service);
     daemon.add_service(mirror_service);