refactor(coprocessor): simplify OTLP subscriber init fallback

Author: Eikix

coprocessor/fhevm-engine/fhevm-engine-common/src/telemetry.rs

@@ -12,7 +12,7 @@ use std::{
     sync::{Arc, LazyLock, OnceLock},
 };
 use tokio::sync::RwLock;
-use tracing::{debug, info, warn, Span};
+use tracing::{debug, error, info, warn, Span};
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
@@ -109,6 +109,20 @@ pub fn init_json_subscriber(
     Ok(Some(TracerProviderGuard::new(trace_provider)))
 }
 
+pub fn init_json_subscriber_with_otlp_fallback(
+    log_level: tracing::Level,
+    service_name: &str,
+    tracer_name: &'static str,
+) -> Option<TracerProviderGuard> {
+    match init_json_subscriber(log_level, service_name, tracer_name) {
+        Ok(guard) => guard,
+        Err(err) => {
+            error!(error = %err, "Failed to setup OTLP");
+            None
+        }
+    }
+}
+
 fn setup_otel_with_tracer(
     service_name: &str,
     tracer_name: &'static str,

coprocessor/fhevm-engine/gw-listener/src/bin/gw_listener.rs

@@ -103,18 +103,11 @@ async fn main() -> anyhow::Result<()> {
 
     let conf = Conf::parse();
 
-    let mut otlp_setup_error: Option<String> = None;
-    let _otel_guard =
-        match telemetry::init_json_subscriber(conf.log_level, &conf.service_name, "otlp-layer") {
-            Ok(guard) => guard,
-            Err(err) => {
-                otlp_setup_error = Some(err.to_string());
-                None
-            }
-        };
-    if let Some(err) = otlp_setup_error {
-        error!(error = %err, "Failed to setup OTLP");
-    }
+    let _otel_guard = telemetry::init_json_subscriber_with_otlp_fallback(
+        conf.log_level,
+        &conf.service_name,
+        "otlp-layer",
+    );
 
     info!(gateway_url = %conf.gw_url, max_retries = %conf.provider_max_retries,
          retry_interval = ?conf.provider_retry_interval, "Connecting to Gateway");

coprocessor/fhevm-engine/host-listener/src/bin/main.rs

@@ -1,26 +1,15 @@
 use clap::Parser;
 use fhevm_engine_common::telemetry;
-use tracing::error;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     let args = host_listener::cmd::Args::parse();
 
-    let mut otlp_setup_error: Option<String> = None;
-    let _otel_guard = match telemetry::init_json_subscriber(
+    let _otel_guard = telemetry::init_json_subscriber_with_otlp_fallback(
         args.log_level,
         &args.service_name,
         "otlp-layer",
-    ) {
-        Ok(guard) => guard,
-        Err(err) => {
-            otlp_setup_error = Some(err.to_string());
-            None
-        }
-    };
-    if let Some(err) = otlp_setup_error {
-        error!(error = %err, "Failed to setup OTLP");
-    }
+    );
 
     host_listener::cmd::main(args).await
 }

coprocessor/fhevm-engine/host-listener/src/bin/poller.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 use alloy::primitives::Address;
 use clap::Parser;
 use tokio_util::sync::CancellationToken;
-use tracing::{error, Level};
+use tracing::Level;
 
 use fhevm_engine_common::utils::DatabaseURL;
 use fhevm_engine_common::{metrics_server, telemetry};
@@ -126,21 +126,11 @@ struct Args {
 async fn main() -> anyhow::Result<()> {
     let args = Args::parse();
 
-    let mut otlp_setup_error: Option<String> = None;
-    let _otel_guard = match telemetry::init_json_subscriber(
+    let _otel_guard = telemetry::init_json_subscriber_with_otlp_fallback(
         args.log_level,
         &args.service_name,
         "otlp-layer",
-    ) {
-        Ok(guard) => guard,
-        Err(err) => {
-            otlp_setup_error = Some(err.to_string());
-            None
-        }
-    };
-    if let Some(err) = otlp_setup_error {
-        error!(error = %err, "Failed to setup OTLP");
-    }
+    );
 
     let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
 

coprocessor/fhevm-engine/sns-worker/src/bin/sns_worker.rs

@@ -65,21 +65,11 @@ async fn main() {
     let config: Config = construct_config();
     let parent = CancellationToken::new();
 
-    let mut otlp_setup_error: Option<String> = None;
-
-    let _otel_guard =
-        match telemetry::init_json_subscriber(config.log_level, &config.service_name, "otlp-layer")
-        {
-            Ok(guard) => guard,
-            Err(err) => {
-                otlp_setup_error = Some(err.to_string());
-                None
-            }
-        };
-
-    if let Some(err) = otlp_setup_error {
-        error!(error = %err, "Failed to setup OTLP");
-    }
+    let _otel_guard = telemetry::init_json_subscriber_with_otlp_fallback(
+        config.log_level,
+        &config.service_name,
+        "otlp-layer",
+    );
 
     // Handle SIGINIT signals
     handle_sigint(parent.clone());

coprocessor/fhevm-engine/tfhe-worker/src/lib.rs

@@ -49,27 +49,19 @@ pub fn start_runtime(
 
 // Used for testing as we would call `async_main()` multiple times.
 static TRACING_INIT: Once = Once::new();
-static OTLP_SETUP_ERROR: OnceLock<String> = OnceLock::new();
 static OTEL_GUARD: OnceLock<Option<telemetry::TracerProviderGuard>> = OnceLock::new();
 
 pub async fn async_main(
     args: daemon_cli::Args,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     TRACING_INIT.call_once(|| {
-        let otel_guard =
-            match telemetry::init_json_subscriber(args.log_level, &args.service_name, "otlp-layer")
-            {
-                Ok(guard) => guard,
-                Err(err) => {
-                    let _ = OTLP_SETUP_ERROR.set(err.to_string());
-                    None
-                }
-            };
+        let otel_guard = telemetry::init_json_subscriber_with_otlp_fallback(
+            args.log_level,
+            &args.service_name,
+            "otlp-layer",
+        );
         let _ = OTEL_GUARD.set(otel_guard);
     });
-    if let Some(err) = OTLP_SETUP_ERROR.get() {
-        error!(error = %err, "Failed to setup OTLP");
-    }
 
     let cancel_token = CancellationToken::new();
     info!(target: "async_main", args = ?args, "Starting runtime with args");

coprocessor/fhevm-engine/transaction-sender/src/bin/transaction_sender.rs

@@ -286,18 +286,11 @@ async fn main() -> anyhow::Result<()> {
 
     let conf = parse_args();
 
-    let mut otlp_setup_error: Option<String> = None;
-    let _otel_guard =
-        match telemetry::init_json_subscriber(conf.log_level, &conf.service_name, "otlp-layer") {
-            Ok(guard) => guard,
-            Err(err) => {
-                otlp_setup_error = Some(err.to_string());
-                None
-            }
-        };
-    if let Some(err) = otlp_setup_error {
-        error!(error = %err, "Failed to setup OTLP");
-    }
+    let _otel_guard = telemetry::init_json_subscriber_with_otlp_fallback(
+        conf.log_level,
+        &conf.service_name,
+        "otlp-layer",
+    );
 
     let cancel_token = CancellationToken::new();
     install_signal_handlers(cancel_token.clone())?;

coprocessor/fhevm-engine/zkproof-worker/src/bin/zkproof_worker.rs

@@ -82,18 +82,11 @@ pub fn parse_args() -> Args {
 async fn main() {
     let args = parse_args();
 
-    let mut otlp_setup_error: Option<String> = None;
-    let _otel_guard =
-        match telemetry::init_json_subscriber(args.log_level, &args.service_name, "otlp-layer") {
-            Ok(guard) => guard,
-            Err(err) => {
-                otlp_setup_error = Some(err.to_string());
-                None
-            }
-        };
-    if let Some(err) = otlp_setup_error {
-        error!(error = %err, "Failed to setup OTLP");
-    }
+    let _otel_guard = telemetry::init_json_subscriber_with_otlp_fallback(
+        args.log_level,
+        &args.service_name,
+        "otlp-layer",
+    );
 
     let database_url = args.database_url.clone().unwrap_or_default();