Route all Rocket internal logs through gem_tracing

apps/api/src/devices/guard.rs

@@ -1,3 +1,4 @@
+use gem_tracing::info_with_fields;
 use rocket::Request;
 use rocket::http::Status;
 use rocket::outcome::Outcome::{Error, Success};
@@ -31,6 +32,9 @@ fn auth_error_outcome<T>(req: &Request<'_>, error: DeviceError, device_id: Optio
         Some(id) => format!("{} device_id={}", error, id),
         None => error.to_string(),
     };
+    let uri = req.uri().to_string();
+    let user_agent = req.headers().get_one("User-Agent").unwrap_or("unknown");
+    info_with_fields!("Request guard failed", uri = uri, status = status.code, error = message, user_agent = user_agent);
     cache_error(req, &message);
     Error((status, message))
 }

apps/api/src/main.rs

@@ -320,6 +320,8 @@ async fn main() {
 
     println!("api start service: {}", service.as_ref());
 
+    gem_tracing::init();
+
     let rocket = match service {
         APIService::Api => rocket_api(settings).await,
         APIService::WebsocketPrices => rocket_ws_prices(settings).await,

apps/dynode/src/main.rs

@@ -130,6 +130,7 @@ fn resolve_chain(path: &str) -> Option<Chain> {
 
 #[rocket::main]
 async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    gem_tracing::init();
     let (config, chains) = load_config()?;
 
     let node_address = IpAddr::from_str(config.address.as_str())?;

crates/tracing/Cargo.toml

@@ -6,3 +6,4 @@ edition = { workspace = true }
 [dependencies]
 tracing = { version = "0.1.44" }
 tracing-subscriber = { version = "0.3.22" }
+log = { version = "log = "0.4.29"" }

crates/tracing/src/lib.rs

@@ -8,6 +8,46 @@ pub fn get_subscriber() -> Arc<FmtSubscriber> {
     TRACING_SUBSCRIBER.get_or_init(|| Arc::new(tracing_subscriber::fmt().with_target(false).finish())).clone()
 }
 
+struct GemLogger;
+
+impl log::Log for GemLogger {
+    fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
+        metadata.level() <= log::max_level()
+    }
+
+    fn log(&self, record: &log::Record<'_>) {
+        if !self.enabled(record.metadata()) {
+            return;
+        }
+        let subscriber = get_subscriber();
+        let message = record.args().to_string();
+        tracing::subscriber::with_default(subscriber, || match record.level() {
+            log::Level::Error => tracing::error!("{}", message),
+            log::Level::Warn => tracing::warn!("{}", message),
+            log::Level::Info => tracing::info!("{}", message),
+            log::Level::Debug => tracing::debug!("{}", message),
+            log::Level::Trace => tracing::trace!("{}", message),
+        });
+    }
+
+    fn flush(&self) {}
+}
+
+/// Initializes gem_tracing as the global `log` backend.
+/// Log level is read from the `ROCKET_LOG_LEVEL` environment variable
+/// (values: `off`, `critical`, `normal`, `debug`; default: `normal`).
+/// If a global logger is already registered the call is a no-op.
+pub fn init() {
+    let level_filter = match std::env::var("ROCKET_LOG_LEVEL").as_deref() {
+        Ok("off") => log::LevelFilter::Off,
+        Ok("critical") => log::LevelFilter::Warn,
+        Ok("debug") => log::LevelFilter::Trace,
+        _ => log::LevelFilter::Info,
+    };
+    let _ = log::set_boxed_logger(Box::new(GemLogger));
+    log::set_max_level(level_filter);
+}
+
 pub fn human_duration(duration: Duration) -> String {
     if duration.is_zero() {
         return "0s".to_string();