refactor(coprocessor): decouple tracer from OTEL guard

Author: Eikix

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

@@ -23,17 +23,12 @@ pub const TXN_ID_ATTR_KEY: &str = "txn_id";
 /// Calls provider shutdown exactly once when dropped.
 pub struct OtelGuard {
     tracer_provider: Option<SdkTracerProvider>,
-    tracer: Option<opentelemetry_sdk::trace::Tracer>,
 }
 
 impl OtelGuard {
-    fn new(
-        trace_provider: SdkTracerProvider,
-        tracer: Option<opentelemetry_sdk::trace::Tracer>,
-    ) -> Self {
+    fn new(trace_provider: SdkTracerProvider) -> Self {
         Self {
             tracer_provider: Some(trace_provider),
-            tracer,
         }
     }
 
@@ -44,10 +39,6 @@ impl OtelGuard {
             }
         }
     }
-
-    pub fn tracer(&self) -> Option<opentelemetry_sdk::trace::Tracer> {
-        self.tracer.clone()
-    }
 }
 
 impl Drop for OtelGuard {
@@ -83,20 +74,23 @@ pub fn init_otel(
 
     let (_tracer, trace_provider) = build_tracer_provider(service_name, "otlp-layer")?;
     install_global_tracer_provider(trace_provider.clone());
-    Ok(Some(OtelGuard::new(trace_provider, None)))
+    Ok(Some(OtelGuard::new(trace_provider)))
 }
 
 pub fn init_otel_tracing(
     service_name: &str,
     tracer_name: &'static str,
-) -> Result<Option<OtelGuard>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+) -> Result<
+    Option<(opentelemetry_sdk::trace::Tracer, OtelGuard)>,
+    Box<dyn std::error::Error + Send + Sync + 'static>,
+> {
     if service_name.is_empty() {
         return Ok(None);
     }
 
     let (tracer, trace_provider) = build_tracer_provider(service_name, tracer_name)?;
     install_global_tracer_provider(trace_provider.clone());
-    Ok(Some(OtelGuard::new(trace_provider, Some(tracer))))
+    Ok(Some((tracer, OtelGuard::new(trace_provider))))
 }
 
 fn build_tracer_provider(
@@ -594,7 +588,7 @@ mod tests {
     #[test]
     fn otel_guard_shutdown_once_disarms_provider() {
         let provider = SdkTracerProvider::builder().build();
-        let mut guard = OtelGuard::new(provider, None);
+        let mut guard = OtelGuard::new(provider);
         assert!(guard.tracer_provider.is_some());
 
         guard.shutdown_once();
@@ -606,19 +600,8 @@ mod tests {
     }
 
     #[test]
-    fn otel_guard_keeps_tracer_when_present() {
-        let provider = SdkTracerProvider::builder().build();
-        let tracer = provider.tracer("test-tracer");
-        let runtime = OtelGuard::new(provider, Some(tracer));
-
-        assert!(runtime.tracer().is_some());
-    }
-
-    #[test]
-    fn otel_guard_handles_absent_tracer() {
-        let provider = SdkTracerProvider::builder().build();
-        let runtime = OtelGuard::new(provider, None);
-
-        assert!(runtime.tracer().is_none());
+    fn init_otel_tracing_empty_service_name_returns_none() {
+        let runtime = init_otel_tracing("", "otlp-layer").unwrap();
+        assert!(runtime.is_none());
     }
 }

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

@@ -69,13 +69,15 @@ async fn main() {
 
     let mut otlp_setup_error: Option<String> = None;
 
-    let otel_guard = match telemetry::init_otel_tracing(&config.service_name, "otlp-layer") {
-        Ok(runtime) => runtime,
-        Err(err) => {
-            otlp_setup_error = Some(err.to_string());
-            None
-        }
-    };
+    let (otel_tracer, _otel_guard) =
+        match telemetry::init_otel_tracing(&config.service_name, "otlp-layer") {
+            Ok(Some((tracer, guard))) => (Some(tracer), Some(guard)),
+            Ok(None) => (None, None),
+            Err(err) => {
+                otlp_setup_error = Some(err.to_string());
+                (None, None)
+            }
+        };
 
     let level_filter = tracing_subscriber::filter::LevelFilter::from_level(config.log_level);
 
@@ -93,7 +95,7 @@ async fn main() {
         .with(level_filter)
         .with(fmt_layer);
 
-    if let Some(tracer) = otel_guard.as_ref().and_then(|runtime| runtime.tracer()) {
+    if let Some(tracer) = otel_tracer {
         let otel_layer = tracing_opentelemetry::layer().with_tracer(tracer);
         base.with(otel_layer).init();
     } else {