simplify the otel logging

Author: KSDaemon

rust/cubestore/cubestore/src/bin/cubestored.rs

@@ -1,5 +1,6 @@
 use cubestore::config::{validate_config, Config, CubeServices};
 use cubestore::http::status::serve_status_probes;
+use cubestore::telemetry::otel_tracing::init_tracing_telemetry;
 use cubestore::telemetry::{init_agent_sender, track_event};
 use cubestore::util::logger::init_cube_logger;
 use cubestore::util::metrics::init_metrics;
@@ -12,7 +13,7 @@ use std::collections::HashMap;
 use std::time::Duration;
 use tokio::runtime::Builder;
 
-const PACKAGE_JSON: &'static str = std::include_str!("../../../package.json");
+const PACKAGE_JSON: &'static str = include_str!("../../../package.json");
 
 fn main() {
     let package_json: Value = serde_json::from_str(PACKAGE_JSON).unwrap();
@@ -54,6 +55,9 @@ fn main() {
             ))
         })
         .unwrap();
+    if enable_telemetry {
+        init_tracing_telemetry();
+    }
     init_cube_logger(enable_telemetry);
 
     log::info!("Cube Store version {}", version);

rust/cubestore/cubestore/src/telemetry/otel_tracing.rs

@@ -1,54 +1,28 @@
-use lazy_static::lazy_static;
 use log::{Level, Log, Metadata, Record};
-use opentelemetry::global::ObjectSafeSpan;
-use opentelemetry::logs::AnyValue::String;
-use opentelemetry::logs::{LogRecord, Logger, LoggerProvider};
-use opentelemetry::trace::{SpanKind, Tracer, TracerProvider};
-use opentelemetry::{KeyValue, StringValue};
-use opentelemetry_sdk::logs::{LogRecord as LogRecordSDK, Logger as LoggerSDK};
-use opentelemetry_sdk::trace::Tracer as TracerSDK;
+use opentelemetry::trace::TracerProvider;
+use tracing::{event, Level as TracingLevel};
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::Registry;
 
 const OTEL_SERVICE_NAME: &str = "cubestore";
 
-lazy_static! {
-    pub static ref OT_TRACER: TracerSDK = init_tracing().unwrap();
-    pub static ref OT_LOGGER: LoggerSDK = init_logging().unwrap();
-}
-
 pub fn init_tracing_telemetry() {
-    let telemetry = tracing_opentelemetry::layer().with_tracer(OT_TRACER.clone());
-    let subscriber = Registry::default().with(telemetry);
-
-    tracing::subscriber::set_global_default(subscriber)
-        .expect("setting default tracing subscriber failed");
-}
-
-pub fn init_tracing() -> Result<TracerSDK, Box<dyn std::error::Error>> {
     let otlp_exporter = opentelemetry_otlp::new_exporter()
         .http()
         .with_http_client(reqwest::Client::new());
     let tracer_provider = opentelemetry_otlp::new_pipeline()
         .tracing()
         .with_exporter(otlp_exporter)
-        .install_batch(opentelemetry_sdk::runtime::Tokio)?;
+        .install_batch(opentelemetry_sdk::runtime::Tokio)
+        .expect("Should be able to initialise the tracer_provider");
 
     let tracer = tracer_provider.tracer_builder(OTEL_SERVICE_NAME).build();
-    Ok(tracer)
-}
 
-pub fn init_logging() -> Result<LoggerSDK, Box<dyn std::error::Error>> {
-    let otlp_exporter = opentelemetry_otlp::new_exporter()
-        .http()
-        .with_http_client(reqwest::Client::new());
-    let logger_provider = opentelemetry_otlp::new_pipeline()
-        .logging()
-        .with_exporter(otlp_exporter)
-        .install_batch(opentelemetry_sdk::runtime::Tokio)?;
+    let telemetry = tracing_opentelemetry::layer().with_tracer(tracer);
+    let subscriber = Registry::default().with(telemetry);
 
-    let logger = logger_provider.logger_builder(OTEL_SERVICE_NAME).build();
-    Ok(logger)
+    tracing::subscriber::set_global_default(subscriber)
+        .expect("setting default tracing subscriber failed");
 }
 
 pub struct OpenTelemetryLogger {
@@ -74,25 +48,19 @@ impl Log for OpenTelemetryLogger {
 
         match record.metadata().level() {
             Level::Error => {
-                // Log error messages using OpenTelemetry logger
-                let logger = &*OT_LOGGER;
-                emit_log(record, logger);
+                event!(TracingLevel::ERROR, "{}", record.args().to_string());
             }
             Level::Warn => {
-                // Log warning messages using OpenTelemetry logger
-                let logger = &*OT_LOGGER;
-                emit_log(record, logger);
+                event!(TracingLevel::WARN, "{}", record.args().to_string());
+            }
+            Level::Info => {
+                event!(TracingLevel::INFO, "{}", record.args().to_string());
             }
-            Level::Info => {}
             Level::Debug => {
-                // Create an OpenTelemetry trace for Debug level
-                let tracer = &*OT_TRACER;
-                create_log_trace(record, tracer);
+                event!(TracingLevel::DEBUG, "{}", record.args().to_string());
             }
             Level::Trace => {
-                // Create an OpenTelemetry trace for Trace level
-                let tracer = &*OT_TRACER;
-                create_log_trace(record, tracer);
+                event!(TracingLevel::TRACE, "{}", record.args().to_string());
             }
         }
     }
@@ -101,30 +69,3 @@ impl Log for OpenTelemetryLogger {
         self.logger.flush()
     }
 }
-
-fn emit_log(record: &Record, logger: &LoggerSDK) {
-    let mut rec = LogRecordSDK::default();
-
-    rec.set_target(record.target().to_string());
-    rec.set_severity_text(record.level().as_str());
-    rec.set_body(String(StringValue::from(record.args().to_string())));
-
-    logger.emit(rec);
-}
-
-fn create_log_trace(record: &Record, tracer: &TracerSDK) {
-    let mut span = tracer
-        .span_builder(format!(
-            "{} ({})",
-            record.module_path().unwrap_or(record.target()),
-            record.file().unwrap_or("-")
-        ))
-        .with_kind(SpanKind::Server)
-        .with_attributes([
-            KeyValue::new("level", record.level().as_str()),
-            KeyValue::new("target", record.target().to_string()),
-            KeyValue::new("message", record.args().to_string()),
-        ])
-        .start(tracer);
-    span.end();
-}

rust/cubestore/cubestore/src/util/logger.rs

@@ -1,4 +1,3 @@
-use crate::telemetry::otel_tracing::init_tracing_telemetry;
 use crate::telemetry::{OpenTelemetryLogger, ReportingLogger};
 use log::{Level, Log, Metadata, Record};
 use simple_logger::SimpleLogger;
@@ -34,7 +33,6 @@ pub fn init_cube_logger(enable_telemetry: bool) {
         // No need to introduce special env vars, let's use the de facto standard ones
         if let Ok(_) = env::var("OTEL_EXPORTER_OTLP_ENDPOINT") {
             logger = Box::new(OpenTelemetryLogger::new(logger));
-            init_tracing_telemetry();
         } else {
             logger = Box::new(ReportingLogger::new(logger));
         }