refactor(coprocessor): align OTEL runtime naming

Author: Eikix

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

@@ -21,11 +21,11 @@ use tracing::{debug, info, warn};
 pub const TXN_ID_ATTR_KEY: &str = "txn_id";
 
 /// Calls provider shutdown exactly once when dropped.
-pub struct OtlpShutdownGuard {
+pub struct TracerProviderGuard {
     provider: Option<SdkTracerProvider>,
 }
 
-impl OtlpShutdownGuard {
+impl TracerProviderGuard {
     fn new(provider: SdkTracerProvider) -> Self {
         Self {
             provider: Some(provider),
@@ -41,22 +41,22 @@ impl OtlpShutdownGuard {
     }
 }
 
-impl Drop for OtlpShutdownGuard {
+impl Drop for TracerProviderGuard {
     fn drop(&mut self) {
         self.shutdown_once();
     }
 }
 
 /// Runtime OTLP handles that must stay alive for the process lifetime.
-pub struct OtlpRuntime {
+pub struct OtelGuard {
     tracer: Option<opentelemetry_sdk::trace::Tracer>,
-    _shutdown_guard: OtlpShutdownGuard,
+    _shutdown_guard: TracerProviderGuard,
 }
 
-impl OtlpRuntime {
+impl OtelGuard {
     fn new(
         tracer: Option<opentelemetry_sdk::trace::Tracer>,
-        shutdown_guard: OtlpShutdownGuard,
+        shutdown_guard: TracerProviderGuard,
     ) -> Self {
         Self {
             tracer,
@@ -87,38 +87,38 @@ pub(crate) static ZKPROOF_TXN_LATENCY_HISTOGRAM: LazyLock<Histogram> = LazyLock:
     )
 });
 
-pub fn init_otlp(
+pub fn init_otel(
     service_name: &str,
-) -> Result<Option<OtlpRuntime>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+) -> Result<Option<OtelGuard>, Box<dyn std::error::Error + Send + Sync + 'static>> {
     if service_name.is_empty() {
         return Ok(None);
     }
 
-    let (_tracer, trace_provider) = build_otlp_tracer_and_provider(service_name, "otlp-layer")?;
-    install_global_otel(trace_provider.clone());
-    Ok(Some(OtlpRuntime::new(
+    let (_tracer, trace_provider) = build_tracer_provider(service_name, "otlp-layer")?;
+    install_global_tracer_provider(trace_provider.clone());
+    Ok(Some(OtelGuard::new(
         None,
-        OtlpShutdownGuard::new(trace_provider),
+        TracerProviderGuard::new(trace_provider),
     )))
 }
 
-pub fn init_otlp_tracing(
+pub fn init_otel_tracing(
     service_name: &str,
     tracer_name: &'static str,
-) -> Result<Option<OtlpRuntime>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+) -> Result<Option<OtelGuard>, Box<dyn std::error::Error + Send + Sync + 'static>> {
     if service_name.is_empty() {
         return Ok(None);
     }
 
-    let (tracer, trace_provider) = build_otlp_tracer_and_provider(service_name, tracer_name)?;
-    install_global_otel(trace_provider.clone());
-    Ok(Some(OtlpRuntime::new(
+    let (tracer, trace_provider) = build_tracer_provider(service_name, tracer_name)?;
+    install_global_tracer_provider(trace_provider.clone());
+    Ok(Some(OtelGuard::new(
         Some(tracer),
-        OtlpShutdownGuard::new(trace_provider),
+        TracerProviderGuard::new(trace_provider),
     )))
 }
 
-fn build_otlp_tracer_and_provider(
+fn build_tracer_provider(
     service_name: &str,
     tracer_name: &'static str,
 ) -> Result<
@@ -146,7 +146,7 @@ fn build_otlp_tracer_and_provider(
     Ok((tracer, trace_provider))
 }
 
-fn install_global_otel(trace_provider: SdkTracerProvider) {
+fn install_global_tracer_provider(trace_provider: SdkTracerProvider) {
     opentelemetry::global::set_tracer_provider(trace_provider);
 }
 
@@ -611,9 +611,9 @@ mod tests {
     use super::*;
 
     #[test]
-    fn otlp_shutdown_guard_shutdown_once_disarms_provider() {
+    fn tracer_provider_guard_shutdown_once_disarms_provider() {
         let provider = SdkTracerProvider::builder().build();
-        let mut guard = OtlpShutdownGuard::new(provider);
+        let mut guard = TracerProviderGuard::new(provider);
         assert!(guard.provider.is_some());
 
         guard.shutdown_once();
@@ -625,18 +625,18 @@ mod tests {
     }
 
     #[test]
-    fn otlp_runtime_keeps_tracer_when_present() {
+    fn otel_guard_keeps_tracer_when_present() {
         let provider = SdkTracerProvider::builder().build();
         let tracer = provider.tracer("test-tracer");
-        let runtime = OtlpRuntime::new(Some(tracer), OtlpShutdownGuard::new(provider));
+        let runtime = OtelGuard::new(Some(tracer), TracerProviderGuard::new(provider));
 
         assert!(runtime.tracer().is_some());
     }
 
     #[test]
-    fn otlp_runtime_handles_absent_tracer() {
+    fn otel_guard_handles_absent_tracer() {
         let provider = SdkTracerProvider::builder().build();
-        let runtime = OtlpRuntime::new(None, OtlpShutdownGuard::new(provider));
+        let runtime = OtelGuard::new(None, TracerProviderGuard::new(provider));
 
         assert!(runtime.tracer().is_none());
     }

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

@@ -108,7 +108,7 @@ async fn main() -> anyhow::Result<()> {
         .with_max_level(conf.log_level)
         .init();
 
-    let _otlp_runtime = match telemetry::init_otlp(&conf.service_name) {
+    let _otel_guard = match telemetry::init_otel(&conf.service_name) {
         Ok(runtime) => runtime,
         Err(err) => {
             error!(error = %err, "Failed to setup OTLP");

coprocessor/fhevm-engine/host-listener/src/cmd/mod.rs

@@ -1024,7 +1024,7 @@ pub async fn main(args: Args) -> anyhow::Result<()> {
         )
     };
 
-    let _otlp_runtime = match telemetry::init_otlp(&args.service_name) {
+    let _otel_guard = match telemetry::init_otel(&args.service_name) {
         Ok(runtime) => runtime,
         Err(err) => {
             error!(error = %err, "Failed to setup OTLP");

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

@@ -90,7 +90,7 @@ pub struct PollerConfig {
 }
 
 pub async fn run_poller(config: PollerConfig) -> Result<()> {
-    let _otlp_runtime = match telemetry::init_otlp(&config.service_name) {
+    let _otel_guard = match telemetry::init_otel(&config.service_name) {
         Ok(runtime) => runtime,
         Err(err) => {
             warn!(error = %err, "Failed to setup OTLP");

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

@@ -69,7 +69,7 @@ async fn main() {
 
     let mut otlp_setup_error: Option<String> = None;
 
-    let otlp_runtime = match telemetry::init_otlp_tracing(&config.service_name, "otlp-layer") {
+    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());
@@ -93,7 +93,7 @@ async fn main() {
         .with(level_filter)
         .with(fmt_layer);
 
-    if let Some(tracer) = otlp_runtime.as_ref().and_then(|runtime| runtime.tracer()) {
+    if let Some(tracer) = otel_guard.as_ref().and_then(|runtime| runtime.tracer()) {
         let otel_layer = tracing_opentelemetry::layer().with_tracer(tracer);
         base.with(otel_layer).init();
     } else {

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

@@ -65,7 +65,7 @@ pub async fn async_main(
     let cancel_token = CancellationToken::new();
     info!(target: "async_main", args = ?args, "Starting runtime with args");
 
-    let _otlp_runtime = match telemetry::init_otlp(&args.service_name) {
+    let _otel_guard = match telemetry::init_otel(&args.service_name) {
         Ok(runtime) => runtime,
         Err(err) => {
             error!(error = %err, "Failed to setup OTLP");

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

@@ -308,7 +308,7 @@ async fn main() -> anyhow::Result<()> {
         }
     };
 
-    let _otlp_runtime = match telemetry::init_otlp(&conf.service_name) {
+    let _otel_guard = match telemetry::init_otel(&conf.service_name) {
         Ok(runtime) => runtime,
         Err(err) => {
             error!(error = %err, "Failed to setup OTLP");

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

@@ -103,7 +103,7 @@ async fn main() {
         pg_auto_explain_with_min_duration: args.pg_auto_explain_with_min_duration,
     };
 
-    let _otlp_runtime = match telemetry::init_otlp(&args.service_name) {
+    let _otel_guard = match telemetry::init_otel(&args.service_name) {
         Ok(runtime) => runtime,
         Err(err) => {
             error!(error = %err, "Failed to setup OTLP");