From 7da284e2f40fd489e9df9645338a13da910949aa Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Wed, 18 Sep 2024 02:37:02 -0700 Subject: [PATCH 01/31] initial commit --- opentelemetry-appender-tracing/Cargo.toml | 6 +- .../examples/basic.rs | 31 ++++++- opentelemetry-appender-tracing/src/layer.rs | 3 + opentelemetry-sdk/Cargo.toml | 2 + opentelemetry-sdk/src/logs/log_emitter.rs | 2 + opentelemetry/Cargo.toml | 2 + opentelemetry/src/global/internal_logging.rs | 92 +++++++++++++++++++ opentelemetry/src/global/mod.rs | 1 + 8 files changed, 132 insertions(+), 7 deletions(-) create mode 100644 opentelemetry/src/global/internal_logging.rs diff --git a/opentelemetry-appender-tracing/Cargo.toml b/opentelemetry-appender-tracing/Cargo.toml index 322e451f32..11020ad4ed 100644 --- a/opentelemetry-appender-tracing/Cargo.toml +++ b/opentelemetry-appender-tracing/Cargo.toml @@ -12,16 +12,16 @@ rust-version = "1.65" [dependencies] log = { workspace = true, optional = true } -opentelemetry = { version = "0.25", path = "../opentelemetry", features = ["logs"] } +opentelemetry = { version = "0.25", path = "../opentelemetry", features = ["logs","experimental-internal-debugging"] } tracing = { workspace = true, features = ["std"]} tracing-core = { workspace = true } tracing-log = { version = "0.2", optional = true } -tracing-subscriber = { workspace = true, features = ["registry", "std"] } +tracing-subscriber = { workspace = true, features = ["registry", "std", "fmt"] } [dev-dependencies] log = { workspace = true } opentelemetry-stdout = { path = "../opentelemetry-stdout", features = ["logs"] } -opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["logs", "testing"] } +opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["logs", "testing", "experimental-internal-debugging"] } tracing-log = "0.2" async-trait = { workspace = true } criterion = { workspace = true } diff --git a/opentelemetry-appender-tracing/examples/basic.rs b/opentelemetry-appender-tracing/examples/basic.rs index 0f36d8a930..df4aba7185 100644 --- a/opentelemetry-appender-tracing/examples/basic.rs +++ b/opentelemetry-appender-tracing/examples/basic.rs @@ -3,8 +3,28 @@ use opentelemetry::KeyValue; use opentelemetry_appender_tracing::layer; use opentelemetry_sdk::{logs::LoggerProvider, Resource}; -use tracing::error; +use tracing::{error, Subscriber}; +use tracing_subscriber::layer::{Context, Layer}; use tracing_subscriber::prelude::*; +use tracing_subscriber::registry::LookupSpan; + +struct SimpleLogLayer; + +impl Layer for SimpleLogLayer +where + S: Subscriber + for<'a> LookupSpan<'a>, +{ + fn on_event(&self, event: &tracing::Event<'_>, _ctx: Context<'_, S>) { + // Extract the target of the event + let target = event.metadata().target(); + + // Check if the event is for the target "opentelemetry-internal" + if target == "opentelemetry-internal" { + // Print the event in a simple format + println!("OTEL_INTERNAL_LOG - {}: {:?}", target, event); + } + } +} fn main() { let exporter = opentelemetry_stdout::LogExporter::default(); @@ -15,9 +35,12 @@ fn main() { )])) .with_simple_exporter(exporter) .build(); - let layer = layer::OpenTelemetryTracingBridge::new(&provider); - tracing_subscriber::registry().with(layer).init(); - + let simple_log_layer = SimpleLogLayer; + let otel_layer = layer::OpenTelemetryTracingBridge::new(&provider); + tracing_subscriber::registry() + .with(simple_log_layer) + .with(otel_layer) + .init(); error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "otel@opentelemetry.io", message = "This is an example message"); let _ = provider.shutdown(); } diff --git a/opentelemetry-appender-tracing/src/layer.rs b/opentelemetry-appender-tracing/src/layer.rs index 8148f75069..e467a63d6f 100644 --- a/opentelemetry-appender-tracing/src/layer.rs +++ b/opentelemetry-appender-tracing/src/layer.rs @@ -157,6 +157,9 @@ where event: &tracing::Event<'_>, _ctx: tracing_subscriber::layer::Context<'_, S>, ) { + if event.metadata().target().starts_with("opentelemetry") { + return; + } #[cfg(feature = "experimental_metadata_attributes")] let normalized_meta = event.normalized_metadata(); diff --git a/opentelemetry-sdk/Cargo.toml b/opentelemetry-sdk/Cargo.toml index 8761a6a669..c086ce0dc5 100644 --- a/opentelemetry-sdk/Cargo.toml +++ b/opentelemetry-sdk/Cargo.toml @@ -28,6 +28,7 @@ url = { workspace = true, optional = true } tokio = { workspace = true, features = ["rt", "time"], optional = true } tokio-stream = { workspace = true, optional = true } http = { workspace = true, optional = true } +tracing = {workspace = true, optional = true} [package.metadata.docs.rs] all-features = true @@ -51,6 +52,7 @@ testing = ["opentelemetry/testing", "trace", "metrics", "logs", "rt-async-std", rt-tokio = ["tokio", "tokio-stream"] rt-tokio-current-thread = ["tokio", "tokio-stream"] rt-async-std = ["async-std"] +experimental-internal-debugging = ["opentelemetry/experimental-internal-debugging", "tracing"] [[bench]] name = "context" diff --git a/opentelemetry-sdk/src/logs/log_emitter.rs b/opentelemetry-sdk/src/logs/log_emitter.rs index 7463b19059..d77348c966 100644 --- a/opentelemetry-sdk/src/logs/log_emitter.rs +++ b/opentelemetry-sdk/src/logs/log_emitter.rs @@ -1,5 +1,6 @@ use super::{BatchLogProcessor, LogProcessor, LogRecord, SimpleLogProcessor, TraceContext}; use crate::{export::logs::LogExporter, runtime::RuntimeChannel, Resource}; +use opentelemetry::otel_info; use opentelemetry::{ global, logs::{LogError, LogResult}, @@ -247,6 +248,7 @@ impl opentelemetry::logs::Logger for Logger { /// Emit a `LogRecord`. fn emit(&self, mut record: Self::LogRecord) { + otel_info!(target: "opentelemetry-internal","emit log record"); let provider = self.provider(); let processors = provider.log_processors(); let trace_context = Context::map_current(|cx| { diff --git a/opentelemetry/Cargo.toml b/opentelemetry/Cargo.toml index 2cd03c778f..518e82ab7d 100644 --- a/opentelemetry/Cargo.toml +++ b/opentelemetry/Cargo.toml @@ -26,6 +26,7 @@ futures-sink = "0.3" once_cell = { workspace = true } pin-project-lite = { workspace = true, optional = true } thiserror = { workspace = true } +tracing = { version = "0.1", optional = true } [target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies] js-sys = "0.3.63" @@ -38,6 +39,7 @@ testing = ["trace", "metrics"] logs = [] logs_level_enabled = ["logs"] otel_unstable = [] +experimental-internal-debugging = ["tracing"] [dev-dependencies] opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["logs_level_enabled"]} # for documentation tests diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs new file mode 100644 index 0000000000..91ab3928a4 --- /dev/null +++ b/opentelemetry/src/global/internal_logging.rs @@ -0,0 +1,92 @@ +#![allow(unused_macros)] + +/// Macro for logging messages at the general log level in OpenTelemetry. +/// +/// This macro is used to emit log messages if the feature `experimental-internal-debugging` is enabled. +/// Under the hood, it calls the `tracing::log!` macro with the provided arguments. +/// +/// # Usage +/// ``` +/// otel_log!("This is a general log message"); +/// ``` +#[macro_export] +macro_rules! otel_log { + ($($arg:tt)*) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::log!($($arg)*); + } + } +} + +/// Macro for logging warning messages in OpenTelemetry. +/// +/// This macro emits warning messages using `tracing::warn!` if the feature `experimental-internal-debugging` is enabled. +/// +/// # Usage +/// ``` +/// otel_warn!("This is a warning message"); +/// ``` +#[macro_export] +macro_rules! otel_warn { + ($($arg:tt)*) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::warn!($($arg)*); + } + } +} + +/// Macro for logging debug messages in OpenTelemetry. +/// +/// This macro emits debug messages using `tracing::debug!` if the feature `experimental-internal-debugging` is enabled. +/// +/// # Usage +/// ``` +/// otel_debug!("This is a debug message"); +/// ``` +#[macro_export] +macro_rules! otel_debug { + ($($arg:tt)*) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::debug!($($arg)*); + } + } +} + +/// Macro for logging error messages in OpenTelemetry. +/// +/// This macro emits error messages using `tracing::error!` if the feature `experimental-internal-debugging` is enabled. +/// +/// # Usage +/// ``` +/// otel_error!("This is an error message"); +/// ``` +#[macro_export] +macro_rules! otel_error { + ($($arg:tt)*) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::error!($($arg)*); + } + } +} + +/// Macro for logging informational messages in OpenTelemetry. +/// +/// This macro emits informational messages using `tracing::info!` if the feature `experimental-internal-debugging` is enabled. +/// +/// # Usage +/// ``` +/// otel_info!("This is an info message"); +/// ``` +#[macro_export] +macro_rules! otel_info { + ($($arg:tt)*) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::info!($($arg)*); + } + } +} diff --git a/opentelemetry/src/global/mod.rs b/opentelemetry/src/global/mod.rs index a1e7b1da72..5a6d335431 100644 --- a/opentelemetry/src/global/mod.rs +++ b/opentelemetry/src/global/mod.rs @@ -126,6 +126,7 @@ //! [`set_meter_provider`]: crate::global::set_meter_provider mod error_handler; +mod internal_logging; #[cfg(feature = "metrics")] mod metrics; #[cfg(feature = "trace")] From 573994d2dd0cd8bbaee910c64f287da52c7b04e0 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Wed, 18 Sep 2024 23:49:35 -0700 Subject: [PATCH 02/31] instrument internal code --- opentelemetry-sdk/src/logs/log_emitter.rs | 19 +++- opentelemetry-sdk/src/logs/log_processor.rs | 19 ++++ opentelemetry/src/global/internal_logging.rs | 112 +++++++++++++------ 3 files changed, 111 insertions(+), 39 deletions(-) diff --git a/opentelemetry-sdk/src/logs/log_emitter.rs b/opentelemetry-sdk/src/logs/log_emitter.rs index d77348c966..463ed81e3c 100644 --- a/opentelemetry-sdk/src/logs/log_emitter.rs +++ b/opentelemetry-sdk/src/logs/log_emitter.rs @@ -1,12 +1,12 @@ use super::{BatchLogProcessor, LogProcessor, LogRecord, SimpleLogProcessor, TraceContext}; use crate::{export::logs::LogExporter, runtime::RuntimeChannel, Resource}; -use opentelemetry::otel_info; use opentelemetry::{ global, logs::{LogError, LogResult}, trace::TraceContextExt, Context, InstrumentationLibrary, }; +use opentelemetry::{otel_debug, otel_info, otel_warn}; #[cfg(feature = "logs_level_enabled")] use opentelemetry::logs::Severity; @@ -84,19 +84,23 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider { impl LoggerProvider { /// Create a new `LoggerProvider` builder. pub fn builder() -> Builder { + otel_info!(target: "opentelemetry-sdk", name: "logger_provider_builder", signal: "log", "Creating a new LoggerProvider builder."); Builder::default() } pub(crate) fn log_processors(&self) -> &[Box] { + otel_debug!(target: "opentelemetry-sdk", name: "logger_provider_log_processors", signal: "log", "Retrieving {} log processors.", self.inner.processors.len()); &self.inner.processors } pub(crate) fn resource(&self) -> &Resource { + otel_debug!(target: "opentelemetry-sdk", name: "logger_provider_resource", signal: "log", "Retrieving {} resource for LoggerProvider.", self.inner.resource.len()); &self.inner.resource } /// Force flush all remaining logs in log processors and return results. pub fn force_flush(&self) -> Vec> { + otel_info!(target: "opentelemetry-sdk", name: "logger_provider_force_flush", signal: "log", "Forcing flush for all log processors."); self.log_processors() .iter() .map(|processor| processor.force_flush()) @@ -105,6 +109,7 @@ impl LoggerProvider { /// Shuts down this `LoggerProvider` pub fn shutdown(&self) -> LogResult<()> { + otel_info!(target: "opentelemetry-sdk", name: "logger_provider_shutdown", signal: "log", "Shutting down LoggerProvider."); if self .is_shutdown .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst) @@ -115,6 +120,7 @@ impl LoggerProvider { let mut errs = vec![]; for processor in &self.inner.processors { if let Err(err) = processor.shutdown() { + otel_warn!(target: "opentelemetry-sdk", name: "logger_provider_shutdown_error", signal: "log", "Error while shutting down a log processor: {:?}", err); errs.push(err); } } @@ -125,6 +131,7 @@ impl LoggerProvider { Err(LogError::Other(format!("{errs:?}").into())) } } else { + otel_warn!(target: "opentelemetry-sdk", name: "logger_provider_already_shutdown", signal: "log", "LoggerProvider is already shut down."); Err(LogError::Other("logger provider already shut down".into())) } } @@ -222,6 +229,7 @@ impl Logger { instrumentation_lib: Arc, provider: LoggerProvider, ) -> Self { + otel_info!(target: "opentelemetry-sdk", name: "logger_new", signal: "log", "Creating a new Logger."); Logger { instrumentation_lib, provider, @@ -248,7 +256,12 @@ impl opentelemetry::logs::Logger for Logger { /// Emit a `LogRecord`. fn emit(&self, mut record: Self::LogRecord) { - otel_info!(target: "opentelemetry-internal","emit log record"); + otel_info!( + target: "opentelemetry-sdk", + name: "log_record_emit_start", + signal: "log", + "Starting the process of emitting a log record" + ); let provider = self.provider(); let processors = provider.log_processors(); let trace_context = Context::map_current(|cx| { @@ -282,6 +295,8 @@ impl opentelemetry::logs::Logger for Logger { self.instrumentation_library().name.as_ref(), ); } + otel_debug!(target: "opentelemetry-sdk", name: "log_record_event_enabled_check", signal: "log", "log event enabled status is {} for target: {} ", enabled, target); + enabled } } diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index b615acb9b8..ea07c282ae 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -16,6 +16,7 @@ use opentelemetry::{ logs::{LogError, LogResult}, InstrumentationLibrary, }; +use opentelemetry::{otel_debug, otel_error, otel_info, otel_warn}; use std::sync::atomic::AtomicBool; use std::{cmp::min, env, sync::Mutex}; use std::{ @@ -87,6 +88,7 @@ pub struct SimpleLogProcessor { impl SimpleLogProcessor { pub(crate) fn new(exporter: Box) -> Self { + otel_info!(target: "opentelemetry-sdk", name: "simple_log_processor_new", signal: "log", "Initializing SimpleLogProcessor."); SimpleLogProcessor { exporter: Mutex::new(exporter), is_shutdown: AtomicBool::new(false), @@ -98,9 +100,12 @@ impl LogProcessor for SimpleLogProcessor { fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationLibrary) { // noop after shutdown if self.is_shutdown.load(std::sync::atomic::Ordering::Relaxed) { + otel_warn!(target: "opentelemetry-sdk", name: "simple_log_processor_emit_after_shutdown", signal: "log", "Attempted to emit log after processor shutdown."); return; } + otel_info!(target: "opentelemetry-sdk", name: "simple_log_processor_emit", signal: "log", "Emitting log record."); + let result = self .exporter .lock() @@ -110,21 +115,25 @@ impl LogProcessor for SimpleLogProcessor { futures_executor::block_on(exporter.export(LogBatch::new(log_tuple))) }); if let Err(err) = result { + otel_error!(target: "opentelemetry-sdk", name: "simple_log_processor_emit_error", signal: "log", "Failed to emit log record: {:?}", err); global::handle_error(err); } } fn force_flush(&self) -> LogResult<()> { + otel_info!(target: "opentelemetry-sdk", name: "simple_log_processor_force_flush", signal: "log", "Forcing flush on log processor."); Ok(()) } fn shutdown(&self) -> LogResult<()> { + otel_info!(target: "opentelemetry-sdk", name: "simple_log_processor_shutdown", signal: "log", "Shutting down SimpleLogProcessor."); self.is_shutdown .store(true, std::sync::atomic::Ordering::Relaxed); if let Ok(mut exporter) = self.exporter.lock() { exporter.shutdown(); Ok(()) } else { + otel_error!(target: "opentelemetry-sdk", name: "simple_log_processor_shutdown_error", signal: "log", "Failed to shutdown SimpleLogProcessor."); Err(LogError::Other( "simple logprocessor mutex poison during shutdown".into(), )) @@ -132,6 +141,7 @@ impl LogProcessor for SimpleLogProcessor { } fn set_resource(&self, resource: &Resource) { + otel_info!(target: "opentelemetry-sdk", name: "simple_log_processor_set_resource", signal: "log", "Setting resource for SimpleLogProcessor."); if let Ok(mut exporter) = self.exporter.lock() { exporter.set_resource(resource); } @@ -154,17 +164,20 @@ impl Debug for BatchLogProcessor { impl LogProcessor for BatchLogProcessor { fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationLibrary) { + otel_info!(target: "opentelemetry-sdk", name: "batch_log_processor_emit", signal: "log", "Emitting log record in BatchLogProcessor."); let result = self.message_sender.try_send(BatchMessage::ExportLog(( record.clone(), instrumentation.clone(), ))); if let Err(err) = result { + otel_error!(target: "opentelemetry-sdk", name: "batch_log_processor_emit_error", signal: "log", "Failed to send log message to BatchLogProcessor: {:?}", err); global::handle_error(LogError::Other(err.into())); } } fn force_flush(&self) -> LogResult<()> { + otel_info!(target: "opentelemetry-sdk", name: "batch_log_processor_force_flush", signal: "log", "Forcing flush in BatchLogProcessor."); let (res_sender, res_receiver) = oneshot::channel(); self.message_sender .try_send(BatchMessage::Flush(Some(res_sender))) @@ -176,6 +189,7 @@ impl LogProcessor for BatchLogProcessor { } fn shutdown(&self) -> LogResult<()> { + otel_info!(target: "opentelemetry-sdk", name: "batch_log_processor_shutdown", signal: "log", "Shutting down BatchLogProcessor."); let (res_sender, res_receiver) = oneshot::channel(); self.message_sender .try_send(BatchMessage::Shutdown(res_sender)) @@ -187,6 +201,7 @@ impl LogProcessor for BatchLogProcessor { } fn set_resource(&self, resource: &Resource) { + otel_info!(target: "opentelemetry-sdk", name: "batch_log_processor_set_resource", signal: "log", "Setting resource for BatchLogProcessor."); let resource = Arc::new(resource.clone()); let _ = self .message_sender @@ -217,8 +232,11 @@ impl BatchLogProcessor { // Log has finished, add to buffer of pending logs. BatchMessage::ExportLog(log) => { logs.push(log); + otel_debug!(target: "opentelemetry-sdk", name: "batch_log_processor_record_count", signal: "log", "Batching log records. Current batch size: {}", logs.len()); + if logs.len() == config.max_export_batch_size { + otel_info!(target: "opentelemetry-sdk", name: "batch_log_processor_export", signal: "log", "Exporting log batch of size: {}", logs.len()); let result = export_with_timeout( config.max_export_timeout, exporter.as_mut(), @@ -228,6 +246,7 @@ impl BatchLogProcessor { .await; if let Err(err) = result { + otel_error!(target: "opentelemetry-sdk", name: "batch_log_processor_export_error", signal: "log", "Failed to export log batch: {:?}", err); global::handle_error(err); } } diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs index 91ab3928a4..771ee1c229 100644 --- a/opentelemetry/src/global/internal_logging.rs +++ b/opentelemetry/src/global/internal_logging.rs @@ -1,92 +1,130 @@ #![allow(unused_macros)] - /// Macro for logging messages at the general log level in OpenTelemetry. /// -/// This macro is used to emit log messages if the feature `experimental-internal-debugging` is enabled. -/// Under the hood, it calls the `tracing::log!` macro with the provided arguments. +/// # Fields: +/// - `target`: The component or module generating the log. This identifies which crate or system part is logging the message (e.g., "opentelemetry-sdk", "opentelemetry-otlp"). +/// - `name`: The operation or action being logged. This provides context on what the system is doing at the time the log is emitted (e.g., "sdk_initialization", "exporter_start"). +/// - `signal`: The type of telemetry data related to the log. This could be "trace", "metric", or "log", representing the OpenTelemetry signal. /// -/// # Usage -/// ``` -/// otel_log!("This is a general log message"); +/// # Example: +/// ```rust +/// otel_log!( +/// target: "opentelemetry-sdk", +/// name: "sdk_initialization", +/// signal: "trace", +/// "Initializing the OpenTelemetry SDK for traces" +/// ); /// ``` #[macro_export] macro_rules! otel_log { - ($($arg:tt)*) => { + (target: $target:expr, name: $name:expr, signal: $signal:expr, $($arg:tt)*) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::log!($($arg)*); + tracing::log!(target: $target, { name = $name, signal = $signal }, $($arg)*); } - } + }; } /// Macro for logging warning messages in OpenTelemetry. /// -/// This macro emits warning messages using `tracing::warn!` if the feature `experimental-internal-debugging` is enabled. +/// # Fields: +/// - `target`: The component or module generating the log (e.g., "opentelemetry-sdk"). +/// - `name`: The operation or action being logged (e.g., "export_warning"). +/// - `signal`: The type of telemetry data related to the log ("trace", "metric", "log"). /// -/// # Usage -/// ``` -/// otel_warn!("This is a warning message"); +/// # Example: +/// ```rust +/// otel_warn!( +/// target: "opentelemetry-otlp", +/// name: "export_warning", +/// signal: "metric", +/// "Potential issue detected during metric export" +/// ); /// ``` #[macro_export] macro_rules! otel_warn { - ($($arg:tt)*) => { + (target: $target:expr, name: $name:expr, signal: $signal:expr, $($arg:tt)*) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::warn!($($arg)*); + tracing::warn!(target: $target, { name = $name, signal = $signal }, $($arg)*); } - } + }; } /// Macro for logging debug messages in OpenTelemetry. /// -/// This macro emits debug messages using `tracing::debug!` if the feature `experimental-internal-debugging` is enabled. +/// # Fields: +/// - `target`: The component or module generating the log (e.g., "opentelemetry-otlp"). +/// - `name`: The operation or action being logged (e.g., "debug_operation"). +/// - `signal`: The type of telemetry data ("trace", "metric", "log"). /// -/// # Usage -/// ``` -/// otel_debug!("This is a debug message"); +/// # Example: +/// ```rust +/// otel_debug!( +/// target: "opentelemetry-metrics", +/// name: "metrics_debugging", +/// signal: "metric", +/// "Debugging metric exporter" +/// ); /// ``` #[macro_export] macro_rules! otel_debug { - ($($arg:tt)*) => { + (target: $target:expr, name: $name:expr, signal: $signal:expr, $($arg:tt)*) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::debug!($($arg)*); + tracing::debug!(target: $target, { name = $name, signal = $signal }, $($arg)*); } - } + }; } /// Macro for logging error messages in OpenTelemetry. /// -/// This macro emits error messages using `tracing::error!` if the feature `experimental-internal-debugging` is enabled. +/// # Fields: +/// - `target`: The component or module generating the log (e.g., "opentelemetry-otlp"). +/// - `name`: The operation or action being logged (e.g., "export_failure"). +/// - `signal`: The type of telemetry data related to the log ("trace", "metric", "log"). /// -/// # Usage -/// ``` -/// otel_error!("This is an error message"); +/// # Example: +/// ```rust +/// otel_error!( +/// target: "opentelemetry-otlp", +/// name: "export_failure", +/// signal: "metric", +/// "Failed to export metric data to collector" +/// ); /// ``` #[macro_export] macro_rules! otel_error { - ($($arg:tt)*) => { + (target: $target:expr, name: $name:expr, signal: $signal:expr, $($arg:tt)*) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::error!($($arg)*); + tracing::error!(target: $target, { name = $name, signal = $signal }, $($arg)*); } - } + }; } /// Macro for logging informational messages in OpenTelemetry. /// -/// This macro emits informational messages using `tracing::info!` if the feature `experimental-internal-debugging` is enabled. +/// # Fields: +/// - `target`: The component or module generating the log (e.g., "opentelemetry-sdk"). +/// - `name`: The operation or action being logged (e.g., "sdk_start"). +/// - `signal`: The type of telemetry data related to the log ("trace", "metric", "log"). /// -/// # Usage -/// ``` -/// otel_info!("This is an info message"); +/// # Example: +/// ```rust +/// otel_info!( +/// target: "opentelemetry-sdk", +/// name: "sdk_start", +/// signal: "trace", +/// "Starting SDK initialization" +/// ); /// ``` #[macro_export] macro_rules! otel_info { - ($($arg:tt)*) => { + (target: $target:expr, name: $name:expr, signal: $signal:expr, $($arg:tt)*) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::info!($($arg)*); + tracing::info!(target: $target, { name = $name, signal = $signal }, $($arg)*); } - } + }; } From 1bfd464d871428319ec6593249ce0295b241c23f Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Wed, 18 Sep 2024 23:54:58 -0700 Subject: [PATCH 03/31] instrument.. --- opentelemetry-sdk/src/logs/log_emitter.rs | 2 +- opentelemetry-sdk/src/logs/log_processor.rs | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/opentelemetry-sdk/src/logs/log_emitter.rs b/opentelemetry-sdk/src/logs/log_emitter.rs index 463ed81e3c..2c31260fa6 100644 --- a/opentelemetry-sdk/src/logs/log_emitter.rs +++ b/opentelemetry-sdk/src/logs/log_emitter.rs @@ -256,7 +256,7 @@ impl opentelemetry::logs::Logger for Logger { /// Emit a `LogRecord`. fn emit(&self, mut record: Self::LogRecord) { - otel_info!( + otel_debug!( target: "opentelemetry-sdk", name: "log_record_emit_start", signal: "log", diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index ea07c282ae..405c8e8e91 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -338,6 +338,7 @@ where .iter() .map(|log_data| (&log_data.0, &log_data.1)) .collect(); + otel_debug!(target: "opentelemetry-sdk", name: "export_with_timeout", signal: "log", "Exporting log batch of size: {}", log_vec.len()); let export = exporter.export(LogBatch::new(log_vec.as_slice())); let timeout = runtime.delay(time_out); pin_mut!(export); From 90470c3e6b784c89c4834b0e95868f57499273e0 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Wed, 18 Sep 2024 23:57:06 -0700 Subject: [PATCH 04/31] instrument.. --- opentelemetry-sdk/src/logs/log_processor.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index 405c8e8e91..953948bfa4 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -104,7 +104,7 @@ impl LogProcessor for SimpleLogProcessor { return; } - otel_info!(target: "opentelemetry-sdk", name: "simple_log_processor_emit", signal: "log", "Emitting log record."); + otel_debug!(target: "opentelemetry-sdk", name: "simple_log_processor_emit", signal: "log", "Emitting log record."); let result = self .exporter From 5f1b990f6c2f1ee81b264064d8080b6036c1cd86 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 19 Sep 2024 00:08:05 -0700 Subject: [PATCH 05/31] update example --- opentelemetry-appender-tracing/Cargo.toml | 2 +- .../examples/basic.rs | 32 ++++++------------- 2 files changed, 10 insertions(+), 24 deletions(-) diff --git a/opentelemetry-appender-tracing/Cargo.toml b/opentelemetry-appender-tracing/Cargo.toml index 11020ad4ed..1470580a2b 100644 --- a/opentelemetry-appender-tracing/Cargo.toml +++ b/opentelemetry-appender-tracing/Cargo.toml @@ -16,7 +16,7 @@ opentelemetry = { version = "0.25", path = "../opentelemetry", features = ["logs tracing = { workspace = true, features = ["std"]} tracing-core = { workspace = true } tracing-log = { version = "0.2", optional = true } -tracing-subscriber = { workspace = true, features = ["registry", "std", "fmt"] } +tracing-subscriber = { workspace = true, features = ["registry", "std", "fmt", "ansi"] } [dev-dependencies] log = { workspace = true } diff --git a/opentelemetry-appender-tracing/examples/basic.rs b/opentelemetry-appender-tracing/examples/basic.rs index df4aba7185..6bed9109f3 100644 --- a/opentelemetry-appender-tracing/examples/basic.rs +++ b/opentelemetry-appender-tracing/examples/basic.rs @@ -3,28 +3,11 @@ use opentelemetry::KeyValue; use opentelemetry_appender_tracing::layer; use opentelemetry_sdk::{logs::LoggerProvider, Resource}; -use tracing::{error, Subscriber}; -use tracing_subscriber::layer::{Context, Layer}; +use tracing::error; +use tracing_subscriber::filter::filter_fn; +use tracing_subscriber::fmt; +use tracing_subscriber::layer::Layer; use tracing_subscriber::prelude::*; -use tracing_subscriber::registry::LookupSpan; - -struct SimpleLogLayer; - -impl Layer for SimpleLogLayer -where - S: Subscriber + for<'a> LookupSpan<'a>, -{ - fn on_event(&self, event: &tracing::Event<'_>, _ctx: Context<'_, S>) { - // Extract the target of the event - let target = event.metadata().target(); - - // Check if the event is for the target "opentelemetry-internal" - if target == "opentelemetry-internal" { - // Print the event in a simple format - println!("OTEL_INTERNAL_LOG - {}: {:?}", target, event); - } - } -} fn main() { let exporter = opentelemetry_stdout::LogExporter::default(); @@ -35,10 +18,13 @@ fn main() { )])) .with_simple_exporter(exporter) .build(); - let simple_log_layer = SimpleLogLayer; let otel_layer = layer::OpenTelemetryTracingBridge::new(&provider); + let internal_log_layer = fmt::Layer::default() + .with_writer(std::io::stdout) // Writes to stdout + .pretty() + .with_filter(filter_fn(|meta| meta.target().starts_with("opentelemetry"))); // Custom filter function tracing_subscriber::registry() - .with(simple_log_layer) + .with(internal_log_layer) .with(otel_layer) .init(); error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "otel@opentelemetry.io", message = "This is an example message"); From 46ce8af8f7eaaec870e057aebff34a0c76523dd6 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 19 Sep 2024 00:43:53 -0700 Subject: [PATCH 06/31] update example --- opentelemetry-appender-tracing/examples/basic.rs | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/opentelemetry-appender-tracing/examples/basic.rs b/opentelemetry-appender-tracing/examples/basic.rs index 6bed9109f3..4b6bd6278e 100644 --- a/opentelemetry-appender-tracing/examples/basic.rs +++ b/opentelemetry-appender-tracing/examples/basic.rs @@ -4,7 +4,7 @@ use opentelemetry::KeyValue; use opentelemetry_appender_tracing::layer; use opentelemetry_sdk::{logs::LoggerProvider, Resource}; use tracing::error; -use tracing_subscriber::filter::filter_fn; +use tracing_subscriber::filter::{filter_fn, EnvFilter}; use tracing_subscriber::fmt; use tracing_subscriber::layer::Layer; use tracing_subscriber::prelude::*; @@ -18,15 +18,19 @@ fn main() { )])) .with_simple_exporter(exporter) .build(); + let env_filter = EnvFilter::from_default_env(); let otel_layer = layer::OpenTelemetryTracingBridge::new(&provider); let internal_log_layer = fmt::Layer::default() .with_writer(std::io::stdout) // Writes to stdout .pretty() - .with_filter(filter_fn(|meta| meta.target().starts_with("opentelemetry"))); // Custom filter function + .with_filter(filter_fn(|meta| meta.target().starts_with("opentelemetry"))) // Custom filter function + .with_filter(env_filter); tracing_subscriber::registry() .with(internal_log_layer) .with(otel_layer) .init(); - error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "otel@opentelemetry.io", message = "This is an example message"); + for i in 0..3 { + error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "otel@opentelemetry.io", message = "This is an example message", iteration = i); + } let _ = provider.shutdown(); } From e5260d9ad11c17691874f7f73cb259fd30e483f8 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 19 Sep 2024 01:17:44 -0700 Subject: [PATCH 07/31] changes for filtering --- opentelemetry-appender-tracing/Cargo.toml | 2 +- opentelemetry-sdk/src/logs/log_emitter.rs | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/opentelemetry-appender-tracing/Cargo.toml b/opentelemetry-appender-tracing/Cargo.toml index 1470580a2b..fdaac31b16 100644 --- a/opentelemetry-appender-tracing/Cargo.toml +++ b/opentelemetry-appender-tracing/Cargo.toml @@ -16,7 +16,7 @@ opentelemetry = { version = "0.25", path = "../opentelemetry", features = ["logs tracing = { workspace = true, features = ["std"]} tracing-core = { workspace = true } tracing-log = { version = "0.2", optional = true } -tracing-subscriber = { workspace = true, features = ["registry", "std", "fmt", "ansi"] } +tracing-subscriber = { workspace = true, features = ["registry", "std", "fmt", "ansi", "env-filter"] } [dev-dependencies] log = { workspace = true } diff --git a/opentelemetry-sdk/src/logs/log_emitter.rs b/opentelemetry-sdk/src/logs/log_emitter.rs index 2c31260fa6..5c7b95ddfe 100644 --- a/opentelemetry-sdk/src/logs/log_emitter.rs +++ b/opentelemetry-sdk/src/logs/log_emitter.rs @@ -50,6 +50,9 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider { attributes: Option>, ) -> Logger { let name = name.into(); + otel_info!(target: "opentelemetry-sdk", name: "logger_versioned_creation", signal: "log", + "Creating a new versioned logger with name: {:?}, version: {:?}, schema_url: {:?}, attributes: {:?}", + name, version, schema_url, attributes); let component_name = if name.is_empty() { Cow::Borrowed(DEFAULT_COMPONENT_NAME) @@ -73,6 +76,8 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider { } fn library_logger(&self, library: Arc) -> Self::Logger { + otel_info!(target: "opentelemetry-sdk", name: "logger_library_logger", signal: "log", + "Creating a library logger for library: {:?}", library); // If the provider is shutdown, new logger will refer a no-op logger provider. if self.is_shutdown.load(Ordering::Relaxed) { return Logger::new(library, NOOP_LOGGER_PROVIDER.clone()); @@ -208,6 +213,8 @@ impl Builder { }; // invoke set_resource on all the processors + otel_debug!(target: "opentelemetry-sdk", name: "logger_provider_build", signal: "log", + "Setting resource for logger provider and applying it to processors."); for processor in logger_provider.log_processors() { processor.set_resource(logger_provider.resource()); } From 197b12a5cf61ae752e9d5b493b56042038bb134c Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Mon, 23 Sep 2024 09:33:19 -0700 Subject: [PATCH 08/31] use structured logging --- opentelemetry-sdk/src/logs/log_emitter.rs | 85 +++++++--- opentelemetry-sdk/src/logs/log_processor.rs | 164 +++++++++++++++--- opentelemetry/src/global/internal_logging.rs | 170 +++++++++++++------ 3 files changed, 327 insertions(+), 92 deletions(-) diff --git a/opentelemetry-sdk/src/logs/log_emitter.rs b/opentelemetry-sdk/src/logs/log_emitter.rs index 5c7b95ddfe..1ba4a8ee7e 100644 --- a/opentelemetry-sdk/src/logs/log_emitter.rs +++ b/opentelemetry-sdk/src/logs/log_emitter.rs @@ -6,7 +6,7 @@ use opentelemetry::{ trace::TraceContextExt, Context, InstrumentationLibrary, }; -use opentelemetry::{otel_debug, otel_info, otel_warn}; +use opentelemetry::{otel_debug, otel_info, otel_target, otel_warn}; #[cfg(feature = "logs_level_enabled")] use opentelemetry::logs::Severity; @@ -50,9 +50,14 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider { attributes: Option>, ) -> Logger { let name = name.into(); - otel_info!(target: "opentelemetry-sdk", name: "logger_versioned_creation", signal: "log", - "Creating a new versioned logger with name: {:?}, version: {:?}, schema_url: {:?}, attributes: {:?}", - name, version, schema_url, attributes); + otel_info!( + target: otel_target!("logs"), + name: "logger_versioned_creation", + instr_lib_name= name, + version = version.as_deref(), + schema_url = schema_url.as_deref(), + attributes = attributes + ); let component_name = if name.is_empty() { Cow::Borrowed(DEFAULT_COMPONENT_NAME) @@ -76,8 +81,11 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider { } fn library_logger(&self, library: Arc) -> Self::Logger { - otel_info!(target: "opentelemetry-sdk", name: "logger_library_logger", signal: "log", - "Creating a library logger for library: {:?}", library); + otel_info!( + target: otel_target!("logs"), + name: "logger_library_logger_creation", + library= library + ); // If the provider is shutdown, new logger will refer a no-op logger provider. if self.is_shutdown.load(Ordering::Relaxed) { return Logger::new(library, NOOP_LOGGER_PROVIDER.clone()); @@ -89,23 +97,37 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider { impl LoggerProvider { /// Create a new `LoggerProvider` builder. pub fn builder() -> Builder { - otel_info!(target: "opentelemetry-sdk", name: "logger_provider_builder", signal: "log", "Creating a new LoggerProvider builder."); + otel_info!( + target: otel_target!("logs"), + name: "logger_provider_builder" + ); Builder::default() } pub(crate) fn log_processors(&self) -> &[Box] { - otel_debug!(target: "opentelemetry-sdk", name: "logger_provider_log_processors", signal: "log", "Retrieving {} log processors.", self.inner.processors.len()); + otel_debug!( + target: otel_target!("logs"), + name: "logger_provider_log_processors", + processor_count= self.inner.processors.len() + ); &self.inner.processors } pub(crate) fn resource(&self) -> &Resource { - otel_debug!(target: "opentelemetry-sdk", name: "logger_provider_resource", signal: "log", "Retrieving {} resource for LoggerProvider.", self.inner.resource.len()); + otel_debug!( + target: otel_target!("logs"), + name: "logger_provider_resource", + resource_count= self.inner.resource.len() + ); &self.inner.resource } /// Force flush all remaining logs in log processors and return results. pub fn force_flush(&self) -> Vec> { - otel_info!(target: "opentelemetry-sdk", name: "logger_provider_force_flush", signal: "log", "Forcing flush for all log processors."); + otel_info!( + target: otel_target!("logs"), + name: "logger_provider_force_flush" + ); self.log_processors() .iter() .map(|processor| processor.force_flush()) @@ -114,7 +136,10 @@ impl LoggerProvider { /// Shuts down this `LoggerProvider` pub fn shutdown(&self) -> LogResult<()> { - otel_info!(target: "opentelemetry-sdk", name: "logger_provider_shutdown", signal: "log", "Shutting down LoggerProvider."); + otel_info!( + target: otel_target!("logs"), + name: "logger_provider_shutdown" + ); if self .is_shutdown .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst) @@ -125,7 +150,11 @@ impl LoggerProvider { let mut errs = vec![]; for processor in &self.inner.processors { if let Err(err) = processor.shutdown() { - otel_warn!(target: "opentelemetry-sdk", name: "logger_provider_shutdown_error", signal: "log", "Error while shutting down a log processor: {:?}", err); + otel_warn!( + target: otel_target!("logs"), + name: "logger_provider_shutdown_error", + error= err + ); errs.push(err); } } @@ -136,7 +165,10 @@ impl LoggerProvider { Err(LogError::Other(format!("{errs:?}").into())) } } else { - otel_warn!(target: "opentelemetry-sdk", name: "logger_provider_already_shutdown", signal: "log", "LoggerProvider is already shut down."); + otel_warn!( + target: otel_target!("logs"), + name: "logger_provider_already_shutdown" + ); Err(LogError::Other("logger provider already shut down".into())) } } @@ -213,11 +245,15 @@ impl Builder { }; // invoke set_resource on all the processors - otel_debug!(target: "opentelemetry-sdk", name: "logger_provider_build", signal: "log", - "Setting resource for logger provider and applying it to processors."); for processor in logger_provider.log_processors() { processor.set_resource(logger_provider.resource()); } + otel_debug!( + target: otel_target!("logs"), + name: "logger_provider_build", + resource_count = logger_provider.resource().len(), + processor_count = logger_provider.log_processors().len() + ); logger_provider } } @@ -236,7 +272,10 @@ impl Logger { instrumentation_lib: Arc, provider: LoggerProvider, ) -> Self { - otel_info!(target: "opentelemetry-sdk", name: "logger_new", signal: "log", "Creating a new Logger."); + otel_info!( + target: otel_target!("logs"), + name: "logger_new" + ); Logger { instrumentation_lib, provider, @@ -264,10 +303,9 @@ impl opentelemetry::logs::Logger for Logger { /// Emit a `LogRecord`. fn emit(&self, mut record: Self::LogRecord) { otel_debug!( - target: "opentelemetry-sdk", + target: otel_target!("logs"), name: "log_record_emit_start", - signal: "log", - "Starting the process of emitting a log record" + record = record ); let provider = self.provider(); let processors = provider.log_processors(); @@ -302,8 +340,13 @@ impl opentelemetry::logs::Logger for Logger { self.instrumentation_library().name.as_ref(), ); } - otel_debug!(target: "opentelemetry-sdk", name: "log_record_event_enabled_check", signal: "log", "log event enabled status is {} for target: {} ", enabled, target); - + otel_debug!( + target: otel_target!("logs"), + name: "log_record_event_enabled_check", + enabled_status = enabled, + level = level, + log_target = target + ); enabled } } diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index 953948bfa4..a3fa4afd03 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -16,7 +16,7 @@ use opentelemetry::{ logs::{LogError, LogResult}, InstrumentationLibrary, }; -use opentelemetry::{otel_debug, otel_error, otel_info, otel_warn}; +use opentelemetry::{otel_debug, otel_error, otel_info, otel_target, otel_warn}; use std::sync::atomic::AtomicBool; use std::{cmp::min, env, sync::Mutex}; use std::{ @@ -88,7 +88,10 @@ pub struct SimpleLogProcessor { impl SimpleLogProcessor { pub(crate) fn new(exporter: Box) -> Self { - otel_info!(target: "opentelemetry-sdk", name: "simple_log_processor_new", signal: "log", "Initializing SimpleLogProcessor."); + otel_info!( + target: otel_target!("logs"), + name: "simple_log_processor_new" + ); SimpleLogProcessor { exporter: Mutex::new(exporter), is_shutdown: AtomicBool::new(false), @@ -100,12 +103,17 @@ impl LogProcessor for SimpleLogProcessor { fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationLibrary) { // noop after shutdown if self.is_shutdown.load(std::sync::atomic::Ordering::Relaxed) { - otel_warn!(target: "opentelemetry-sdk", name: "simple_log_processor_emit_after_shutdown", signal: "log", "Attempted to emit log after processor shutdown."); + otel_warn!( + target: "opentelemetry-sdk", + name: "simple_log_processor_emit_after_shutdown" + ); return; } - otel_debug!(target: "opentelemetry-sdk", name: "simple_log_processor_emit", signal: "log", "Emitting log record."); - + otel_debug!( + target: otel_target!("logs"), + name: "simple_log_processor_emit" + ); let result = self .exporter .lock() @@ -115,25 +123,38 @@ impl LogProcessor for SimpleLogProcessor { futures_executor::block_on(exporter.export(LogBatch::new(log_tuple))) }); if let Err(err) = result { - otel_error!(target: "opentelemetry-sdk", name: "simple_log_processor_emit_error", signal: "log", "Failed to emit log record: {:?}", err); + otel_error!( + target: otel_target!("logs"), + name: "simple_log_processor_emit_error", + error = format!("{:?}", err) + ); global::handle_error(err); } } fn force_flush(&self) -> LogResult<()> { - otel_info!(target: "opentelemetry-sdk", name: "simple_log_processor_force_flush", signal: "log", "Forcing flush on log processor."); + otel_info!( + target: otel_target!("logs"), + name: "simple_log_processor_force_flush" + ); Ok(()) } fn shutdown(&self) -> LogResult<()> { - otel_info!(target: "opentelemetry-sdk", name: "simple_log_processor_shutdown", signal: "log", "Shutting down SimpleLogProcessor."); + otel_info!( + target: otel_target!("logs"), + name: "simple_log_processor_shutdown" + ); self.is_shutdown .store(true, std::sync::atomic::Ordering::Relaxed); if let Ok(mut exporter) = self.exporter.lock() { exporter.shutdown(); Ok(()) } else { - otel_error!(target: "opentelemetry-sdk", name: "simple_log_processor_shutdown_error", signal: "log", "Failed to shutdown SimpleLogProcessor."); + otel_error!( + target: otel_target!("logs"), + name: "simple_log_processor_shutdown_error" + ); Err(LogError::Other( "simple logprocessor mutex poison during shutdown".into(), )) @@ -141,7 +162,10 @@ impl LogProcessor for SimpleLogProcessor { } fn set_resource(&self, resource: &Resource) { - otel_info!(target: "opentelemetry-sdk", name: "simple_log_processor_set_resource", signal: "log", "Setting resource for SimpleLogProcessor."); + otel_info!( + target: otel_target!("logs"), + name: "simple_log_processor_set_resource" + ); if let Ok(mut exporter) = self.exporter.lock() { exporter.set_resource(resource); } @@ -164,20 +188,31 @@ impl Debug for BatchLogProcessor { impl LogProcessor for BatchLogProcessor { fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationLibrary) { - otel_info!(target: "opentelemetry-sdk", name: "batch_log_processor_emit", signal: "log", "Emitting log record in BatchLogProcessor."); + otel_info!( + target: otel_target!("logs"), + name: "batch_log_processor_emit" + ); let result = self.message_sender.try_send(BatchMessage::ExportLog(( record.clone(), instrumentation.clone(), ))); if let Err(err) = result { - otel_error!(target: "opentelemetry-sdk", name: "batch_log_processor_emit_error", signal: "log", "Failed to send log message to BatchLogProcessor: {:?}", err); + otel_error!( + target: otel_target!("logs"), + name: "batch_log_processor_emit_error", + error = format!("{:?}", err) + ); global::handle_error(LogError::Other(err.into())); } } fn force_flush(&self) -> LogResult<()> { - otel_info!(target: "opentelemetry-sdk", name: "batch_log_processor_force_flush", signal: "log", "Forcing flush in BatchLogProcessor."); + otel_error!( + target: otel_target!("logs"), + name: "batch_log_processor_emit_error", + error = format!("{:?}", err) + ); let (res_sender, res_receiver) = oneshot::channel(); self.message_sender .try_send(BatchMessage::Flush(Some(res_sender))) @@ -189,7 +224,10 @@ impl LogProcessor for BatchLogProcessor { } fn shutdown(&self) -> LogResult<()> { - otel_info!(target: "opentelemetry-sdk", name: "batch_log_processor_shutdown", signal: "log", "Shutting down BatchLogProcessor."); + otel_info!( + target: otel_target!("logs"), + name: "batch_log_processor_shutdown" + ); let (res_sender, res_receiver) = oneshot::channel(); self.message_sender .try_send(BatchMessage::Shutdown(res_sender)) @@ -201,7 +239,10 @@ impl LogProcessor for BatchLogProcessor { } fn set_resource(&self, resource: &Resource) { - otel_info!(target: "opentelemetry-sdk", name: "batch_log_processor_set_resource", signal: "log", "Setting resource for BatchLogProcessor."); + otel_info!( + target: otel_target!("logs"), + name: "batch_log_processor_set_resource" + ); let resource = Arc::new(resource.clone()); let _ = self .message_sender @@ -227,16 +268,32 @@ impl BatchLogProcessor { let mut logs = Vec::new(); let mut messages = Box::pin(stream::select(message_receiver, ticker)); + otel_info!( + target: otel_target!("logs"), + name: "batch_log_processor_started", + max_queue_size = config.max_queue_size, + max_export_batch_size = config.max_export_batch_size, + scheduled_delay = config.scheduled_delay, + max_export_timeout = config.max_export_timeout + ); + while let Some(message) = messages.next().await { match message { // Log has finished, add to buffer of pending logs. BatchMessage::ExportLog(log) => { logs.push(log); - otel_debug!(target: "opentelemetry-sdk", name: "batch_log_processor_record_count", signal: "log", "Batching log records. Current batch size: {}", logs.len()); - + otel_debug!( + target: otel_target!("logs"), + name: "batch_log_processor_record_count", + current_batch_size = logs.len() + ); if logs.len() == config.max_export_batch_size { - otel_info!(target: "opentelemetry-sdk", name: "batch_log_processor_export", signal: "log", "Exporting log batch of size: {}", logs.len()); + otel_info!( + target: otel_target!("logs"), + name: "batch_log_processor_export", + batch_size = logs.len() + ); let result = export_with_timeout( config.max_export_timeout, exporter.as_mut(), @@ -246,7 +303,11 @@ impl BatchLogProcessor { .await; if let Err(err) = result { - otel_error!(target: "opentelemetry-sdk", name: "batch_log_processor_export_error", signal: "log", "Failed to export log batch: {:?}", err); + otel_error!( + target: otel_target!("logs"), + name: "batch_log_processor_export_error", + error = err + ); global::handle_error(err); } } @@ -267,13 +328,30 @@ impl BatchLogProcessor { "failed to send flush result: {:?}", result ))); + otel_error!( + target: otel_target!("logs"), + name: "batch_log_processor_flush_error", + error = result, + message = "Failed to send flush result" + ); } } else if let Err(err) = result { global::handle_error(err); + otel_error!( + target: otel_target!("logs"), + name: "batch_log_processor_flush_error", + error = err, + message = "Flush failed" + ); } } // Stream has terminated or processor is shutdown, return to finish execution. BatchMessage::Shutdown(ch) => { + otel_info!( + target: otel_target!("logs"), + name: "batch_log_processor_shutdown", + remaining_batch_size = logs.len() + ); let result = export_with_timeout( config.max_export_timeout, exporter.as_mut(), @@ -285,23 +363,51 @@ impl BatchLogProcessor { exporter.shutdown(); if let Err(result) = ch.send(result) { + otel_error!( + target: otel_target!("logs"), + name: "batch_log_processor_shutdown_error", + error = result, + message = "Failed to send shutdown result" + ); global::handle_error(LogError::from(format!( "failed to send batch processor shutdown result: {:?}", result ))); + } else if let Err(err) = result { + otel_error!( + target: otel_target!("logs"), + name: "batch_log_processor_shutdown_error", + error = err, + message = "Shutdown failed" + ); + global::handle_error(err); } + otel_info!( + target: otel_target!("logs"), + name: "batch_log_processor_shutdown_complete" + ); break; } // propagate the resource BatchMessage::SetResource(resource) => { + otel_info!( + target: otel_target!("logs"), + name: "batch_log_processor_set_resource", + resource_keys_count = resource.len(), + resource = resource + ); exporter.set_resource(&resource); } } } })); + otel_info!( + target: otel_target!("logs"), + name: "batch_log_processor_initialized" + ); // Return batch processor with link to worker BatchLogProcessor { message_sender } } @@ -330,6 +436,10 @@ where E: LogExporter + ?Sized, { if batch.is_empty() { + otel_debug!( + target: otel_target!("logs"), + name: "batch_log_processor_empty_batch" + ); return Ok(()); } @@ -338,14 +448,26 @@ where .iter() .map(|log_data| (&log_data.0, &log_data.1)) .collect(); - otel_debug!(target: "opentelemetry-sdk", name: "export_with_timeout", signal: "log", "Exporting log batch of size: {}", log_vec.len()); + otel_debug!( + target: otel_target!("logs"), + name: "export_with_timeout", + batch_size = log_vec.len(), + timeout = time_out + ); let export = exporter.export(LogBatch::new(log_vec.as_slice())); let timeout = runtime.delay(time_out); pin_mut!(export); pin_mut!(timeout); match future::select(export, timeout).await { Either::Left((export_res, _)) => export_res, - Either::Right((_, _)) => ExportResult::Err(LogError::ExportTimedOut(time_out)), + Either::Right((_, _)) => { + otel_error!( + target: otel_target!("logs"), + name: "export_with_timeout_timeout", + timeout_duration = time_out + ); + ExportResult::Err(LogError::ExportTimedOut(time_out)) + } } } diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs index 771ee1c229..5f47275390 100644 --- a/opentelemetry/src/global/internal_logging.rs +++ b/opentelemetry/src/global/internal_logging.rs @@ -1,26 +1,74 @@ #![allow(unused_macros)] -/// Macro for logging messages at the general log level in OpenTelemetry. + +/// Macro to dynamically generate the logging `target` string with the format `crate:signal:module`. +/// The `signal` is optional. +/// +/// This macro constructs a fully-qualified target string for `otel_*` logging macros by +/// concatenating the current crate name, the provided `signal`, and the module name (via `module_path!()`). +/// +/// # Example: +/// ```rust +/// // If `signal` is passed +/// otel_target!("log") +/// ``` +/// +/// If used inside a module called `my_module::sub_module`, the resulting target string would be: +/// ``` +/// "crate_name:log:my_module::sub_module" +/// ``` +/// +/// If no `signal` is passed: +/// ``` +/// "crate_name:my_module::sub_module" +/// ``` +#[macro_export] +macro_rules! otel_target { + ($signal:expr) => { + concat!(env!("CARGO_PKG_NAME"), ".", $signal, ".", module_path!()) + }; + () => { + concat!(env!("CARGO_PKG_NAME"), ".", module_path!()) + }; +} + +/// Macro for logging informational messages in OpenTelemetry. /// /// # Fields: -/// - `target`: The component or module generating the log. This identifies which crate or system part is logging the message (e.g., "opentelemetry-sdk", "opentelemetry-otlp"). -/// - `name`: The operation or action being logged. This provides context on what the system is doing at the time the log is emitted (e.g., "sdk_initialization", "exporter_start"). -/// - `signal`: The type of telemetry data related to the log. This could be "trace", "metric", or "log", representing the OpenTelemetry signal. +/// - `target`: The component or module generating the log (e.g., "opentelemetry-sdk"). +/// - `name`: The operation or action being logged (e.g., "sdk_start"). +/// - Additional optional key-value pairs can be passed as attributes (e.g., `version`, `schema_url`). /// /// # Example: /// ```rust -/// otel_log!( +/// // Without extra attributes +/// otel_info!( /// target: "opentelemetry-sdk", -/// name: "sdk_initialization", -/// signal: "trace", -/// "Initializing the OpenTelemetry SDK for traces" +/// name: "sdk_start" +/// ); +/// +/// // With extra attributes +/// otel_info!( +/// target: "opentelemetry-sdk", +/// name: "sdk_start", +/// version = "1.0.0", +/// schema_url = "http://example.com" /// ); /// ``` #[macro_export] -macro_rules! otel_log { - (target: $target:expr, name: $name:expr, signal: $signal:expr, $($arg:tt)*) => { +macro_rules! otel_info { + // Without extra attributes + (target: $target:expr, name: $name:expr) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::info!(target: $target, name: $name); + } + }; + + // With additional attributes + (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::log!(target: $target, { name = $name, signal = $signal }, $($arg)*); + tracing::info!(target: $target, name: $name, $($key: $value),+); } }; } @@ -28,25 +76,41 @@ macro_rules! otel_log { /// Macro for logging warning messages in OpenTelemetry. /// /// # Fields: -/// - `target`: The component or module generating the log (e.g., "opentelemetry-sdk"). +/// - `target`: The component or module generating the log (e.g., "opentelemetry-otlp"). /// - `name`: The operation or action being logged (e.g., "export_warning"). -/// - `signal`: The type of telemetry data related to the log ("trace", "metric", "log"). +/// - Additional optional key-value pairs can be passed as attributes (e.g., `version`, `error_code`). /// /// # Example: /// ```rust +/// // Without extra attributes +/// otel_warn!( +/// target: "opentelemetry-otlp", +/// name: "export_warning" +/// ); +/// +/// // With extra attributes /// otel_warn!( /// target: "opentelemetry-otlp", /// name: "export_warning", -/// signal: "metric", -/// "Potential issue detected during metric export" +/// error_code = 404, +/// version = "1.0.0" /// ); /// ``` #[macro_export] macro_rules! otel_warn { - (target: $target:expr, name: $name:expr, signal: $signal:expr, $($arg:tt)*) => { + // Without extra attributes + (target: $target:expr, name: $name:expr) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::warn!(target: $target, { name = $name, signal = $signal }, $($arg)*); + tracing::warn!(target: $target, name: $name ); + } + }; + + // With additional attributes + (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::warn!(target: $target, name: $name, $($key = $value),+ ); } }; } @@ -56,23 +120,39 @@ macro_rules! otel_warn { /// # Fields: /// - `target`: The component or module generating the log (e.g., "opentelemetry-otlp"). /// - `name`: The operation or action being logged (e.g., "debug_operation"). -/// - `signal`: The type of telemetry data ("trace", "metric", "log"). +/// - Additional optional key-value pairs can be passed as attributes (e.g., `version`, `debug_level`). /// /// # Example: /// ```rust +/// // Without extra attributes +/// otel_debug!( +/// target: "opentelemetry-otlp", +/// name: "debug_operation" +/// ); +/// +/// // With extra attributes /// otel_debug!( -/// target: "opentelemetry-metrics", -/// name: "metrics_debugging", -/// signal: "metric", -/// "Debugging metric exporter" +/// target: "opentelemetry-otlp", +/// name: "debug_operation", +/// debug_level = "high", +/// version = "1.0.0" /// ); /// ``` #[macro_export] macro_rules! otel_debug { - (target: $target:expr, name: $name:expr, signal: $signal:expr, $($arg:tt)*) => { + // Without extra attributes + (target: $target:expr, name: $name:expr) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::debug!(target: $target, { name = $name, signal = $signal }, $($arg)*); + tracing::debug!(target: $target, name: $name); + } + }; + + // With additional attributes + (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::debug!(target: $target, name = $name, $($key = $value),+ ); } }; } @@ -82,49 +162,39 @@ macro_rules! otel_debug { /// # Fields: /// - `target`: The component or module generating the log (e.g., "opentelemetry-otlp"). /// - `name`: The operation or action being logged (e.g., "export_failure"). -/// - `signal`: The type of telemetry data related to the log ("trace", "metric", "log"). +/// - Additional optional key-value pairs can be passed as attributes (e.g., `error_code`, `version`). /// /// # Example: /// ```rust +/// // Without extra attributes +/// otel_error!( +/// target: "opentelemetry-otlp", +/// name: "export_failure" +/// ); +/// +/// // With extra attributes /// otel_error!( /// target: "opentelemetry-otlp", /// name: "export_failure", -/// signal: "metric", -/// "Failed to export metric data to collector" +/// error_code = 500, +/// version = "1.0.0" /// ); /// ``` #[macro_export] macro_rules! otel_error { - (target: $target:expr, name: $name:expr, signal: $signal:expr, $($arg:tt)*) => { + // Without extra attributes + (target: $target:expr, name: $name:expr) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::error!(target: $target, { name = $name, signal = $signal }, $($arg)*); + tracing::error!(target: $target, name: $name); } }; -} -/// Macro for logging informational messages in OpenTelemetry. -/// -/// # Fields: -/// - `target`: The component or module generating the log (e.g., "opentelemetry-sdk"). -/// - `name`: The operation or action being logged (e.g., "sdk_start"). -/// - `signal`: The type of telemetry data related to the log ("trace", "metric", "log"). -/// -/// # Example: -/// ```rust -/// otel_info!( -/// target: "opentelemetry-sdk", -/// name: "sdk_start", -/// signal: "trace", -/// "Starting SDK initialization" -/// ); -/// ``` -#[macro_export] -macro_rules! otel_info { - (target: $target:expr, name: $name:expr, signal: $signal:expr, $($arg:tt)*) => { + // With additional attributes + (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::info!(target: $target, { name = $name, signal = $signal }, $($arg)*); + tracing::error!(target: $target, name: $name, $($key = $value),+ ); } }; } From 91e56ea5357e383cfd6b1a7e192a02b1f001dc04 Mon Sep 17 00:00:00 2001 From: Lalit Date: Fri, 27 Sep 2024 13:27:18 -0700 Subject: [PATCH 09/31] review comments --- opentelemetry-sdk/src/logs/log_emitter.rs | 27 +--- opentelemetry-sdk/src/logs/log_processor.rs | 64 ++------ opentelemetry/src/global/internal_logging.rs | 147 +++++++++++-------- 3 files changed, 103 insertions(+), 135 deletions(-) diff --git a/opentelemetry-sdk/src/logs/log_emitter.rs b/opentelemetry-sdk/src/logs/log_emitter.rs index 1ba4a8ee7e..f5fd060f29 100644 --- a/opentelemetry-sdk/src/logs/log_emitter.rs +++ b/opentelemetry-sdk/src/logs/log_emitter.rs @@ -6,7 +6,7 @@ use opentelemetry::{ trace::TraceContextExt, Context, InstrumentationLibrary, }; -use opentelemetry::{otel_debug, otel_info, otel_target, otel_warn}; +use opentelemetry::{otel_debug, otel_info, otel_warn}; #[cfg(feature = "logs_level_enabled")] use opentelemetry::logs::Severity; @@ -51,12 +51,10 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider { ) -> Logger { let name = name.into(); otel_info!( - target: otel_target!("logs"), name: "logger_versioned_creation", - instr_lib_name= name, + instr_lib_name= &*name, version = version.as_deref(), schema_url = schema_url.as_deref(), - attributes = attributes ); let component_name = if name.is_empty() { @@ -82,9 +80,7 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider { fn library_logger(&self, library: Arc) -> Self::Logger { otel_info!( - target: otel_target!("logs"), - name: "logger_library_logger_creation", - library= library + name: "logger_library_logger_creation" ); // If the provider is shutdown, new logger will refer a no-op logger provider. if self.is_shutdown.load(Ordering::Relaxed) { @@ -98,7 +94,6 @@ impl LoggerProvider { /// Create a new `LoggerProvider` builder. pub fn builder() -> Builder { otel_info!( - target: otel_target!("logs"), name: "logger_provider_builder" ); Builder::default() @@ -106,7 +101,6 @@ impl LoggerProvider { pub(crate) fn log_processors(&self) -> &[Box] { otel_debug!( - target: otel_target!("logs"), name: "logger_provider_log_processors", processor_count= self.inner.processors.len() ); @@ -115,7 +109,6 @@ impl LoggerProvider { pub(crate) fn resource(&self) -> &Resource { otel_debug!( - target: otel_target!("logs"), name: "logger_provider_resource", resource_count= self.inner.resource.len() ); @@ -125,7 +118,6 @@ impl LoggerProvider { /// Force flush all remaining logs in log processors and return results. pub fn force_flush(&self) -> Vec> { otel_info!( - target: otel_target!("logs"), name: "logger_provider_force_flush" ); self.log_processors() @@ -137,7 +129,6 @@ impl LoggerProvider { /// Shuts down this `LoggerProvider` pub fn shutdown(&self) -> LogResult<()> { otel_info!( - target: otel_target!("logs"), name: "logger_provider_shutdown" ); if self @@ -151,9 +142,8 @@ impl LoggerProvider { for processor in &self.inner.processors { if let Err(err) = processor.shutdown() { otel_warn!( - target: otel_target!("logs"), name: "logger_provider_shutdown_error", - error= err + error = format!("{:?}", err) ); errs.push(err); } @@ -166,7 +156,6 @@ impl LoggerProvider { } } else { otel_warn!( - target: otel_target!("logs"), name: "logger_provider_already_shutdown" ); Err(LogError::Other("logger provider already shut down".into())) @@ -249,7 +238,6 @@ impl Builder { processor.set_resource(logger_provider.resource()); } otel_debug!( - target: otel_target!("logs"), name: "logger_provider_build", resource_count = logger_provider.resource().len(), processor_count = logger_provider.log_processors().len() @@ -273,7 +261,6 @@ impl Logger { provider: LoggerProvider, ) -> Self { otel_info!( - target: otel_target!("logs"), name: "logger_new" ); Logger { @@ -303,9 +290,8 @@ impl opentelemetry::logs::Logger for Logger { /// Emit a `LogRecord`. fn emit(&self, mut record: Self::LogRecord) { otel_debug!( - target: otel_target!("logs"), name: "log_record_emit_start", - record = record + record = format!("{:?}", record) ); let provider = self.provider(); let processors = provider.log_processors(); @@ -341,10 +327,9 @@ impl opentelemetry::logs::Logger for Logger { ); } otel_debug!( - target: otel_target!("logs"), name: "log_record_event_enabled_check", enabled_status = enabled, - level = level, + level = level.name(), log_target = target ); enabled diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index a3fa4afd03..e1f40f10c7 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -16,7 +16,7 @@ use opentelemetry::{ logs::{LogError, LogResult}, InstrumentationLibrary, }; -use opentelemetry::{otel_debug, otel_error, otel_info, otel_target, otel_warn}; +use opentelemetry::{otel_debug, otel_error, otel_info, otel_warn}; use std::sync::atomic::AtomicBool; use std::{cmp::min, env, sync::Mutex}; use std::{ @@ -89,7 +89,6 @@ pub struct SimpleLogProcessor { impl SimpleLogProcessor { pub(crate) fn new(exporter: Box) -> Self { otel_info!( - target: otel_target!("logs"), name: "simple_log_processor_new" ); SimpleLogProcessor { @@ -111,7 +110,6 @@ impl LogProcessor for SimpleLogProcessor { } otel_debug!( - target: otel_target!("logs"), name: "simple_log_processor_emit" ); let result = self @@ -124,7 +122,6 @@ impl LogProcessor for SimpleLogProcessor { }); if let Err(err) = result { otel_error!( - target: otel_target!("logs"), name: "simple_log_processor_emit_error", error = format!("{:?}", err) ); @@ -134,7 +131,6 @@ impl LogProcessor for SimpleLogProcessor { fn force_flush(&self) -> LogResult<()> { otel_info!( - target: otel_target!("logs"), name: "simple_log_processor_force_flush" ); Ok(()) @@ -142,7 +138,6 @@ impl LogProcessor for SimpleLogProcessor { fn shutdown(&self) -> LogResult<()> { otel_info!( - target: otel_target!("logs"), name: "simple_log_processor_shutdown" ); self.is_shutdown @@ -152,7 +147,6 @@ impl LogProcessor for SimpleLogProcessor { Ok(()) } else { otel_error!( - target: otel_target!("logs"), name: "simple_log_processor_shutdown_error" ); Err(LogError::Other( @@ -163,7 +157,6 @@ impl LogProcessor for SimpleLogProcessor { fn set_resource(&self, resource: &Resource) { otel_info!( - target: otel_target!("logs"), name: "simple_log_processor_set_resource" ); if let Ok(mut exporter) = self.exporter.lock() { @@ -189,7 +182,6 @@ impl Debug for BatchLogProcessor { impl LogProcessor for BatchLogProcessor { fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationLibrary) { otel_info!( - target: otel_target!("logs"), name: "batch_log_processor_emit" ); let result = self.message_sender.try_send(BatchMessage::ExportLog(( @@ -199,7 +191,6 @@ impl LogProcessor for BatchLogProcessor { if let Err(err) = result { otel_error!( - target: otel_target!("logs"), name: "batch_log_processor_emit_error", error = format!("{:?}", err) ); @@ -208,10 +199,8 @@ impl LogProcessor for BatchLogProcessor { } fn force_flush(&self) -> LogResult<()> { - otel_error!( - target: otel_target!("logs"), - name: "batch_log_processor_emit_error", - error = format!("{:?}", err) + otel_info!( + name: "batch_log_processor_force_flush" ); let (res_sender, res_receiver) = oneshot::channel(); self.message_sender @@ -225,7 +214,6 @@ impl LogProcessor for BatchLogProcessor { fn shutdown(&self) -> LogResult<()> { otel_info!( - target: otel_target!("logs"), name: "batch_log_processor_shutdown" ); let (res_sender, res_receiver) = oneshot::channel(); @@ -240,7 +228,6 @@ impl LogProcessor for BatchLogProcessor { fn set_resource(&self, resource: &Resource) { otel_info!( - target: otel_target!("logs"), name: "batch_log_processor_set_resource" ); let resource = Arc::new(resource.clone()); @@ -269,12 +256,11 @@ impl BatchLogProcessor { let mut messages = Box::pin(stream::select(message_receiver, ticker)); otel_info!( - target: otel_target!("logs"), name: "batch_log_processor_started", max_queue_size = config.max_queue_size, max_export_batch_size = config.max_export_batch_size, - scheduled_delay = config.scheduled_delay, - max_export_timeout = config.max_export_timeout + scheduled_delay = config.scheduled_delay.as_millis(), + max_export_timeout = config.max_export_timeout.as_millis() ); while let Some(message) = messages.next().await { @@ -283,14 +269,12 @@ impl BatchLogProcessor { BatchMessage::ExportLog(log) => { logs.push(log); otel_debug!( - target: otel_target!("logs"), name: "batch_log_processor_record_count", current_batch_size = logs.len() ); if logs.len() == config.max_export_batch_size { otel_info!( - target: otel_target!("logs"), name: "batch_log_processor_export", batch_size = logs.len() ); @@ -304,9 +288,8 @@ impl BatchLogProcessor { if let Err(err) = result { otel_error!( - target: otel_target!("logs"), name: "batch_log_processor_export_error", - error = err + error = format!("{:?}", err) ); global::handle_error(err); } @@ -329,26 +312,23 @@ impl BatchLogProcessor { result ))); otel_error!( - target: otel_target!("logs"), name: "batch_log_processor_flush_error", - error = result, + error = format!("{:?}", result), message = "Failed to send flush result" ); } } else if let Err(err) = result { - global::handle_error(err); otel_error!( - target: otel_target!("logs"), name: "batch_log_processor_flush_error", - error = err, + error = format!("{:?}", err), message = "Flush failed" ); + global::handle_error(err); } } // Stream has terminated or processor is shutdown, return to finish execution. BatchMessage::Shutdown(ch) => { otel_info!( - target: otel_target!("logs"), name: "batch_log_processor_shutdown", remaining_batch_size = logs.len() ); @@ -364,28 +344,15 @@ impl BatchLogProcessor { if let Err(result) = ch.send(result) { otel_error!( - target: otel_target!("logs"), name: "batch_log_processor_shutdown_error", - error = result, + error = format!("{:?}", result), message = "Failed to send shutdown result" ); global::handle_error(LogError::from(format!( "failed to send batch processor shutdown result: {:?}", result ))); - } else if let Err(err) = result { - otel_error!( - target: otel_target!("logs"), - name: "batch_log_processor_shutdown_error", - error = err, - message = "Shutdown failed" - ); - global::handle_error(err); } - otel_info!( - target: otel_target!("logs"), - name: "batch_log_processor_shutdown_complete" - ); break; } @@ -393,10 +360,9 @@ impl BatchLogProcessor { // propagate the resource BatchMessage::SetResource(resource) => { otel_info!( - target: otel_target!("logs"), name: "batch_log_processor_set_resource", resource_keys_count = resource.len(), - resource = resource + resource = format!("{:?}", resource) ); exporter.set_resource(&resource); } @@ -405,7 +371,6 @@ impl BatchLogProcessor { })); otel_info!( - target: otel_target!("logs"), name: "batch_log_processor_initialized" ); // Return batch processor with link to worker @@ -437,7 +402,6 @@ where { if batch.is_empty() { otel_debug!( - target: otel_target!("logs"), name: "batch_log_processor_empty_batch" ); return Ok(()); @@ -449,10 +413,9 @@ where .map(|log_data| (&log_data.0, &log_data.1)) .collect(); otel_debug!( - target: otel_target!("logs"), name: "export_with_timeout", batch_size = log_vec.len(), - timeout = time_out + timeout = time_out.as_millis() ); let export = exporter.export(LogBatch::new(log_vec.as_slice())); let timeout = runtime.delay(time_out); @@ -462,9 +425,8 @@ where Either::Left((export_res, _)) => export_res, Either::Right((_, _)) => { otel_error!( - target: otel_target!("logs"), name: "export_with_timeout_timeout", - timeout_duration = time_out + timeout_duration = time_out.as_millis() ); ExportResult::Err(LogError::ExportTimedOut(time_out)) } diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs index 5f47275390..115193efb5 100644 --- a/opentelemetry/src/global/internal_logging.rs +++ b/opentelemetry/src/global/internal_logging.rs @@ -1,40 +1,10 @@ #![allow(unused_macros)] -/// Macro to dynamically generate the logging `target` string with the format `crate:signal:module`. -/// The `signal` is optional. -/// -/// This macro constructs a fully-qualified target string for `otel_*` logging macros by -/// concatenating the current crate name, the provided `signal`, and the module name (via `module_path!()`). -/// -/// # Example: -/// ```rust -/// // If `signal` is passed -/// otel_target!("log") -/// ``` -/// -/// If used inside a module called `my_module::sub_module`, the resulting target string would be: -/// ``` -/// "crate_name:log:my_module::sub_module" -/// ``` -/// -/// If no `signal` is passed: -/// ``` -/// "crate_name:my_module::sub_module" -/// ``` -#[macro_export] -macro_rules! otel_target { - ($signal:expr) => { - concat!(env!("CARGO_PKG_NAME"), ".", $signal, ".", module_path!()) - }; - () => { - concat!(env!("CARGO_PKG_NAME"), ".", module_path!()) - }; -} - /// Macro for logging informational messages in OpenTelemetry. +/// The `target` is optional and defaults to `"opentelemetry"` if not provided. /// /// # Fields: -/// - `target`: The component or module generating the log (e.g., "opentelemetry-sdk"). +/// - `target`: The component or module generating the log (optional, default: "opentelemetry"). /// - `name`: The operation or action being logged (e.g., "sdk_start"). /// - Additional optional key-value pairs can be passed as attributes (e.g., `version`, `schema_url`). /// @@ -42,11 +12,10 @@ macro_rules! otel_target { /// ```rust /// // Without extra attributes /// otel_info!( -/// target: "opentelemetry-sdk", /// name: "sdk_start" /// ); /// -/// // With extra attributes +/// // With explicit target and extra attributes /// otel_info!( /// target: "opentelemetry-sdk", /// name: "sdk_start", @@ -56,27 +25,41 @@ macro_rules! otel_target { /// ``` #[macro_export] macro_rules! otel_info { - // Without extra attributes + // Without extra attributes, default target + (name: $name:expr) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::info!(target: "opentelemetry", name = $name); + } + }; + // With explicit target (target: $target:expr, name: $name:expr) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::info!(target: $target, name: $name); + tracing::info!(target: $target, name = $name); } }; - - // With additional attributes + // With additional attributes, default target + (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::info!(target: "opentelemetry", name = $name, $($key= $value),+); + } + }; + // With explicit target and additional attributes (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::info!(target: $target, name: $name, $($key: $value),+); + tracing::info!(target: $target, name = $name, $($key= $value),+); } }; } /// Macro for logging warning messages in OpenTelemetry. +/// The `target` is optional and defaults to `"opentelemetry"` if not provided. /// /// # Fields: -/// - `target`: The component or module generating the log (e.g., "opentelemetry-otlp"). +/// - `target`: The component or module generating the log (optional, default: "opentelemetry"). /// - `name`: The operation or action being logged (e.g., "export_warning"). /// - Additional optional key-value pairs can be passed as attributes (e.g., `version`, `error_code`). /// @@ -84,11 +67,10 @@ macro_rules! otel_info { /// ```rust /// // Without extra attributes /// otel_warn!( -/// target: "opentelemetry-otlp", /// name: "export_warning" /// ); /// -/// // With extra attributes +/// // With explicit target and extra attributes /// otel_warn!( /// target: "opentelemetry-otlp", /// name: "export_warning", @@ -98,27 +80,41 @@ macro_rules! otel_info { /// ``` #[macro_export] macro_rules! otel_warn { - // Without extra attributes + // Without extra attributes, default target + (name: $name:expr) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::warn!(target: "opentelemetry", name = $name ); + } + }; + // With explicit target (target: $target:expr, name: $name:expr) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::warn!(target: $target, name: $name ); + tracing::warn!(target: $target, name = $name ); } }; - - // With additional attributes + // With additional attributes, default target + (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::warn!(target: "opentelemetry", name = $name , $($key= $value),+ ); + } + }; + // With explicit target and additional attributes (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::warn!(target: $target, name: $name, $($key = $value),+ ); + tracing::warn!(target: $target, name = $name , $($key= $value),+ ); } }; } /// Macro for logging debug messages in OpenTelemetry. +/// The `target` is optional and defaults to `"opentelemetry"` if not provided. /// /// # Fields: -/// - `target`: The component or module generating the log (e.g., "opentelemetry-otlp"). +/// - `target`: The component or module generating the log (optional, default: "opentelemetry"). /// - `name`: The operation or action being logged (e.g., "debug_operation"). /// - Additional optional key-value pairs can be passed as attributes (e.g., `version`, `debug_level`). /// @@ -126,11 +122,10 @@ macro_rules! otel_warn { /// ```rust /// // Without extra attributes /// otel_debug!( -/// target: "opentelemetry-otlp", /// name: "debug_operation" /// ); /// -/// // With extra attributes +/// // With explicit target and extra attributes /// otel_debug!( /// target: "opentelemetry-otlp", /// name: "debug_operation", @@ -140,27 +135,41 @@ macro_rules! otel_warn { /// ``` #[macro_export] macro_rules! otel_debug { - // Without extra attributes + // Without extra attributes, default target + (name: $name:expr) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::debug!(target: "opentelemetry", name = $name ); + } + }; + // With explicit target (target: $target:expr, name: $name:expr) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::debug!(target: $target, name: $name); + tracing::debug!(target: $target, name = $name ); } }; - - // With additional attributes + // With additional attributes, default target + (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::debug!(target: "opentelemetry", name = $name , $($key = $value),+ ); + } + }; + // With explicit target and additional attributes (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::debug!(target: $target, name = $name, $($key = $value),+ ); + tracing::debug!(target: $target, name = $name , $($key = $value),+ ); } }; } /// Macro for logging error messages in OpenTelemetry. +/// The `target` is optional and defaults to `"opentelemetry"` if not provided. /// /// # Fields: -/// - `target`: The component or module generating the log (e.g., "opentelemetry-otlp"). +/// - `target`: The component or module generating the log (optional, default: "opentelemetry"). /// - `name`: The operation or action being logged (e.g., "export_failure"). /// - Additional optional key-value pairs can be passed as attributes (e.g., `error_code`, `version`). /// @@ -168,11 +177,10 @@ macro_rules! otel_debug { /// ```rust /// // Without extra attributes /// otel_error!( -/// target: "opentelemetry-otlp", /// name: "export_failure" /// ); /// -/// // With extra attributes +/// // With explicit target and extra attributes /// otel_error!( /// target: "opentelemetry-otlp", /// name: "export_failure", @@ -182,19 +190,32 @@ macro_rules! otel_debug { /// ``` #[macro_export] macro_rules! otel_error { - // Without extra attributes + // Without extra attributes, default target + (name: $name:expr) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::error!(target: "opentelemetry", name = $name ); + } + }; + // With explicit target (target: $target:expr, name: $name:expr) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::error!(target: $target, name: $name); + tracing::error!(target: $target, name = $name); } }; - - // With additional attributes + // With additional attributes, default target + (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { + #[cfg(all(feature = "experimental-internal-debugging"))] + { + tracing::error!(target: "opentelemetry", name = $name , $($key= $value),+ ); + } + }; + // With explicit target and additional attributes (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::error!(target: $target, name: $name, $($key = $value),+ ); + tracing::error!(target: $target, name = $name, $($key= $value),+ ); } }; } From fa7148e76c90b14857012e6fa5d25fddd1ae2de4 Mon Sep 17 00:00:00 2001 From: Lalit Date: Fri, 27 Sep 2024 15:05:54 -0700 Subject: [PATCH 10/31] update self diagnostic --- examples/self-diagnostics/Cargo.toml | 2 +- examples/self-diagnostics/src/main.rs | 22 +++++++++++++++++++++- 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/examples/self-diagnostics/Cargo.toml b/examples/self-diagnostics/Cargo.toml index 8e8b1cd394..74b1cd40f1 100644 --- a/examples/self-diagnostics/Cargo.toml +++ b/examples/self-diagnostics/Cargo.toml @@ -13,7 +13,7 @@ opentelemetry-appender-tracing = { path = "../../opentelemetry-appender-tracing" tokio = { workspace = true, features = ["full"] } tracing = { workspace = true, features = ["std"]} tracing-core = { workspace = true } -tracing-subscriber = { version = "0.3.18", features = ["env-filter","registry", "std"]} +tracing-subscriber = { version = "0.3.18", features = ["env-filter","registry", "std", "fmt", "env-filter"]} opentelemetry-otlp = { path = "../../opentelemetry-otlp", features = ["http-proto", "reqwest-client", "logs"] } once_cell ={ version = "1.19.0"} ctrlc = "3.4" diff --git a/examples/self-diagnostics/src/main.rs b/examples/self-diagnostics/src/main.rs index b9e6ebd490..1e3077bf9e 100644 --- a/examples/self-diagnostics/src/main.rs +++ b/examples/self-diagnostics/src/main.rs @@ -2,8 +2,8 @@ use opentelemetry::global::{self, set_error_handler, Error as OtelError}; use opentelemetry::KeyValue; use opentelemetry_appender_tracing::layer; use opentelemetry_otlp::WithExportConfig; +use tracing_subscriber::filter::{filter_fn, EnvFilter}; use tracing_subscriber::prelude::*; -use tracing_subscriber::EnvFilter; use std::error::Error; use tracing::error; @@ -32,6 +32,7 @@ impl ErrorState { } static GLOBAL_ERROR_STATE: Lazy> = Lazy::new(|| Arc::new(ErrorState::new())); +static SEEN_EVENT_NAMES: Lazy>> = Lazy::new(|| Mutex::new(HashSet::new())); fn custom_error_handler(err: OtelError) { if GLOBAL_ERROR_STATE.mark_as_seen(&err) { @@ -72,10 +73,29 @@ fn init_logger_provider() -> opentelemetry_sdk::logs::LoggerProvider { .add_directive("hyper=error".parse().unwrap()) .add_directive("tonic=error".parse().unwrap()) .add_directive("reqwest=error".parse().unwrap()); + let unique_event_name_filter = filter_fn(|meta| { + if let Some(name) = meta.fields().iter().find(|field| field.name() == "name") { + let event_name = name.to_string(); + let mut seen_events = SEEN_EVENT_NAMES.lock().unwrap(); + + if seen_events.contains(&event_name) { + // Drop subsequent events with the same name + false + } else { + // Allow the first event with this name and mark it as seen + seen_events.insert(event_name); + true + } + } else { + true // Allow events without a "name" field + } + }); + let cloned_provider = provider.clone(); let layer = layer::OpenTelemetryTracingBridge::new(&cloned_provider); tracing_subscriber::registry() .with(filter) + .with(unique_event_name_filter) .with(layer) .init(); provider From a78357c681b7a3889c52bd87aaf4d5af41506995 Mon Sep 17 00:00:00 2001 From: Lalit Date: Fri, 27 Sep 2024 15:10:18 -0700 Subject: [PATCH 11/31] allow internal events in pipeline --- opentelemetry-appender-tracing/src/layer.rs | 3 --- 1 file changed, 3 deletions(-) diff --git a/opentelemetry-appender-tracing/src/layer.rs b/opentelemetry-appender-tracing/src/layer.rs index e467a63d6f..8148f75069 100644 --- a/opentelemetry-appender-tracing/src/layer.rs +++ b/opentelemetry-appender-tracing/src/layer.rs @@ -157,9 +157,6 @@ where event: &tracing::Event<'_>, _ctx: tracing_subscriber::layer::Context<'_, S>, ) { - if event.metadata().target().starts_with("opentelemetry") { - return; - } #[cfg(feature = "experimental_metadata_attributes")] let normalized_meta = event.normalized_metadata(); From 54e075526492c05ae110dc12fd2409084e9c6b43 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Tue, 1 Oct 2024 16:20:27 -0700 Subject: [PATCH 12/31] fix macros --- opentelemetry-sdk/src/logs/log_processor.rs | 1 - opentelemetry/src/global/internal_logging.rs | 167 +++---------------- 2 files changed, 24 insertions(+), 144 deletions(-) diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index a9b41d7a50..dd4e2d4e4c 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -103,7 +103,6 @@ impl LogProcessor for SimpleLogProcessor { // noop after shutdown if self.is_shutdown.load(std::sync::atomic::Ordering::Relaxed) { otel_warn!( - target: "opentelemetry-sdk", name: "simple_log_processor_emit_after_shutdown" ); return; diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs index 115193efb5..b7e7e15534 100644 --- a/opentelemetry/src/global/internal_logging.rs +++ b/opentelemetry/src/global/internal_logging.rs @@ -1,221 +1,102 @@ #![allow(unused_macros)] - /// Macro for logging informational messages in OpenTelemetry. -/// The `target` is optional and defaults to `"opentelemetry"` if not provided. /// /// # Fields: -/// - `target`: The component or module generating the log (optional, default: "opentelemetry"). -/// - `name`: The operation or action being logged (e.g., "sdk_start"). -/// - Additional optional key-value pairs can be passed as attributes (e.g., `version`, `schema_url`). +/// - `name`: The operation or action being logged. +/// - Additional optional key-value pairs can be passed as attributes. /// /// # Example: /// ```rust -/// // Without extra attributes -/// otel_info!( -/// name: "sdk_start" -/// ); -/// -/// // With explicit target and extra attributes -/// otel_info!( -/// target: "opentelemetry-sdk", -/// name: "sdk_start", -/// version = "1.0.0", -/// schema_url = "http://example.com" -/// ); +/// otel_info!("sdk_start", version = "1.0.0", schema_url = "http://example.com"); /// ``` #[macro_export] macro_rules! otel_info { - // Without extra attributes, default target - (name: $name:expr) => { - #[cfg(all(feature = "experimental-internal-debugging"))] - { - tracing::info!(target: "opentelemetry", name = $name); - } - }; - // With explicit target - (target: $target:expr, name: $name:expr) => { + (name: $name:expr $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::info!(target: $target, name = $name); + tracing::info!(name: $name, target: env!("CARGO_PKG_NAME"),""); } }; - // With additional attributes, default target (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::info!(target: "opentelemetry", name = $name, $($key= $value),+); - } - }; - // With explicit target and additional attributes - (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { - #[cfg(all(feature = "experimental-internal-debugging"))] - { - tracing::info!(target: $target, name = $name, $($key= $value),+); + tracing::info!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); } }; } /// Macro for logging warning messages in OpenTelemetry. -/// The `target` is optional and defaults to `"opentelemetry"` if not provided. /// /// # Fields: -/// - `target`: The component or module generating the log (optional, default: "opentelemetry"). -/// - `name`: The operation or action being logged (e.g., "export_warning"). -/// - Additional optional key-value pairs can be passed as attributes (e.g., `version`, `error_code`). +/// - `name`: The operation or action being logged. +/// - Additional optional key-value pairs can be passed as attributes. /// /// # Example: /// ```rust -/// // Without extra attributes -/// otel_warn!( -/// name: "export_warning" -/// ); -/// -/// // With explicit target and extra attributes -/// otel_warn!( -/// target: "opentelemetry-otlp", -/// name: "export_warning", -/// error_code = 404, -/// version = "1.0.0" -/// ); +/// otel_warn!("export_warning", error_code = 404, version = "1.0.0"); /// ``` #[macro_export] macro_rules! otel_warn { - // Without extra attributes, default target - (name: $name:expr) => { - #[cfg(all(feature = "experimental-internal-debugging"))] - { - tracing::warn!(target: "opentelemetry", name = $name ); - } - }; - // With explicit target - (target: $target:expr, name: $name:expr) => { + (name: $name:expr $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::warn!(target: $target, name = $name ); + tracing::warn!(name: $name, target: env!("CARGO_PKG_NAME"), ""); } }; - // With additional attributes, default target (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::warn!(target: "opentelemetry", name = $name , $($key= $value),+ ); - } - }; - // With explicit target and additional attributes - (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { - #[cfg(all(feature = "experimental-internal-debugging"))] - { - tracing::warn!(target: $target, name = $name , $($key= $value),+ ); + tracing::warn!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); } }; } /// Macro for logging debug messages in OpenTelemetry. -/// The `target` is optional and defaults to `"opentelemetry"` if not provided. /// /// # Fields: -/// - `target`: The component or module generating the log (optional, default: "opentelemetry"). -/// - `name`: The operation or action being logged (e.g., "debug_operation"). -/// - Additional optional key-value pairs can be passed as attributes (e.g., `version`, `debug_level`). +/// - `name`: The operation or action being logged. +/// - Additional optional key-value pairs can be passed as attributes. /// /// # Example: /// ```rust -/// // Without extra attributes -/// otel_debug!( -/// name: "debug_operation" -/// ); -/// -/// // With explicit target and extra attributes -/// otel_debug!( -/// target: "opentelemetry-otlp", -/// name: "debug_operation", -/// debug_level = "high", -/// version = "1.0.0" -/// ); +/// otel_debug!("debug_operation", debug_level = "high", version = "1.0.0"); /// ``` #[macro_export] macro_rules! otel_debug { - // Without extra attributes, default target - (name: $name:expr) => { + (name: $name:expr $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::debug!(target: "opentelemetry", name = $name ); + tracing::debug!(name: $name, target: env!("CARGO_PKG_NAME"), ""); } }; - // With explicit target - (target: $target:expr, name: $name:expr) => { - #[cfg(all(feature = "experimental-internal-debugging"))] - { - tracing::debug!(target: $target, name = $name ); - } - }; - // With additional attributes, default target (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::debug!(target: "opentelemetry", name = $name , $($key = $value),+ ); - } - }; - // With explicit target and additional attributes - (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { - #[cfg(all(feature = "experimental-internal-debugging"))] - { - tracing::debug!(target: $target, name = $name , $($key = $value),+ ); + tracing::debug!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); } }; } /// Macro for logging error messages in OpenTelemetry. -/// The `target` is optional and defaults to `"opentelemetry"` if not provided. /// /// # Fields: -/// - `target`: The component or module generating the log (optional, default: "opentelemetry"). -/// - `name`: The operation or action being logged (e.g., "export_failure"). -/// - Additional optional key-value pairs can be passed as attributes (e.g., `error_code`, `version`). +/// - `name`: The operation or action being logged. +/// - Additional optional key-value pairs can be passed as attributes. /// /// # Example: /// ```rust -/// // Without extra attributes -/// otel_error!( -/// name: "export_failure" -/// ); -/// -/// // With explicit target and extra attributes -/// otel_error!( -/// target: "opentelemetry-otlp", -/// name: "export_failure", -/// error_code = 500, -/// version = "1.0.0" -/// ); +/// otel_error!("export_failure", error_code = 500, version = "1.0.0"); /// ``` #[macro_export] macro_rules! otel_error { - // Without extra attributes, default target - (name: $name:expr) => { - #[cfg(all(feature = "experimental-internal-debugging"))] + (name: $name:expr $(,)?) => { { - tracing::error!(target: "opentelemetry", name = $name ); + tracing::error!(name: $name, target: env!("CARGO_PKG_NAME"), ""); } }; - // With explicit target - (target: $target:expr, name: $name:expr) => { - #[cfg(all(feature = "experimental-internal-debugging"))] - { - tracing::error!(target: $target, name = $name); - } - }; - // With additional attributes, default target (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { - #[cfg(all(feature = "experimental-internal-debugging"))] - { - tracing::error!(target: "opentelemetry", name = $name , $($key= $value),+ ); - } - }; - // With explicit target and additional attributes - (target: $target:expr, name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { - #[cfg(all(feature = "experimental-internal-debugging"))] { - tracing::error!(target: $target, name = $name, $($key= $value),+ ); + tracing::error!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); } }; } From 4c8cb42903de7ba98137103158ab31caf7c4d8af Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Tue, 1 Oct 2024 16:44:57 -0700 Subject: [PATCH 13/31] revert appender-tracing example --- opentelemetry-appender-tracing/Cargo.toml | 6 +++--- .../examples/basic.rs | 21 ++++--------------- 2 files changed, 7 insertions(+), 20 deletions(-) diff --git a/opentelemetry-appender-tracing/Cargo.toml b/opentelemetry-appender-tracing/Cargo.toml index fdaac31b16..322e451f32 100644 --- a/opentelemetry-appender-tracing/Cargo.toml +++ b/opentelemetry-appender-tracing/Cargo.toml @@ -12,16 +12,16 @@ rust-version = "1.65" [dependencies] log = { workspace = true, optional = true } -opentelemetry = { version = "0.25", path = "../opentelemetry", features = ["logs","experimental-internal-debugging"] } +opentelemetry = { version = "0.25", path = "../opentelemetry", features = ["logs"] } tracing = { workspace = true, features = ["std"]} tracing-core = { workspace = true } tracing-log = { version = "0.2", optional = true } -tracing-subscriber = { workspace = true, features = ["registry", "std", "fmt", "ansi", "env-filter"] } +tracing-subscriber = { workspace = true, features = ["registry", "std"] } [dev-dependencies] log = { workspace = true } opentelemetry-stdout = { path = "../opentelemetry-stdout", features = ["logs"] } -opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["logs", "testing", "experimental-internal-debugging"] } +opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["logs", "testing"] } tracing-log = "0.2" async-trait = { workspace = true } criterion = { workspace = true } diff --git a/opentelemetry-appender-tracing/examples/basic.rs b/opentelemetry-appender-tracing/examples/basic.rs index 4b6bd6278e..0f36d8a930 100644 --- a/opentelemetry-appender-tracing/examples/basic.rs +++ b/opentelemetry-appender-tracing/examples/basic.rs @@ -4,9 +4,6 @@ use opentelemetry::KeyValue; use opentelemetry_appender_tracing::layer; use opentelemetry_sdk::{logs::LoggerProvider, Resource}; use tracing::error; -use tracing_subscriber::filter::{filter_fn, EnvFilter}; -use tracing_subscriber::fmt; -use tracing_subscriber::layer::Layer; use tracing_subscriber::prelude::*; fn main() { @@ -18,19 +15,9 @@ fn main() { )])) .with_simple_exporter(exporter) .build(); - let env_filter = EnvFilter::from_default_env(); - let otel_layer = layer::OpenTelemetryTracingBridge::new(&provider); - let internal_log_layer = fmt::Layer::default() - .with_writer(std::io::stdout) // Writes to stdout - .pretty() - .with_filter(filter_fn(|meta| meta.target().starts_with("opentelemetry"))) // Custom filter function - .with_filter(env_filter); - tracing_subscriber::registry() - .with(internal_log_layer) - .with(otel_layer) - .init(); - for i in 0..3 { - error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "otel@opentelemetry.io", message = "This is an example message", iteration = i); - } + let layer = layer::OpenTelemetryTracingBridge::new(&provider); + tracing_subscriber::registry().with(layer).init(); + + error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "otel@opentelemetry.io", message = "This is an example message"); let _ = provider.shutdown(); } From 5e95e00bcb1dc61d07aab428d25c731a1cc941d7 Mon Sep 17 00:00:00 2001 From: Lalit Date: Tue, 1 Oct 2024 21:28:41 -0700 Subject: [PATCH 14/31] update instrument --- opentelemetry-sdk/src/logs/log_processor.rs | 13 ++--------- .../src/metrics/periodic_reader.rs | 22 ++++++++----------- opentelemetry/Cargo.toml | 3 +-- opentelemetry/src/global/internal_logging.rs | 6 ----- opentelemetry/src/global/mod.rs | 1 + 5 files changed, 13 insertions(+), 32 deletions(-) diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index 9708abaf65..2040ff0122 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -14,9 +14,9 @@ use opentelemetry::logs::Severity; use opentelemetry::{ global, logs::{LogError, LogResult}, - InstrumentationLibrary, + otel_debug, otel_error, otel_info, otel_warn, InstrumentationLibrary, }; -use opentelemetry::{otel_debug, otel_error, otel_info, otel_warn}; + use std::sync::atomic::AtomicBool; use std::{cmp::min, env, sync::Mutex}; use std::{ @@ -108,10 +108,8 @@ impl LogProcessor for SimpleLogProcessor { return; } - #[cfg(feature = "experimental-internal-logs")] tracing::debug!( name: "simple_log_processor_emit", - target: "opentelemetry-sdk", event_name = record.event_name ); @@ -271,10 +269,8 @@ impl BatchLogProcessor { // Log has finished, add to buffer of pending logs. BatchMessage::ExportLog(log) => { logs.push(log); - #[cfg(feature = "experimental-internal-logs")] tracing::debug!( name: "batch_log_processor_record_count", - target: "opentelemetry-sdk", current_batch_size = logs.len() ); @@ -312,10 +308,6 @@ impl BatchLogProcessor { if let Some(channel) = res_channel { if let Err(result) = channel.send(result) { - global::handle_error(LogError::from(format!( - "failed to send flush result: {:?}", - result - ))); otel_error!( name: "batch_log_processor_flush_error", error = format!("{:?}", result), @@ -328,7 +320,6 @@ impl BatchLogProcessor { error = format!("{:?}", err), message = "Flush failed" ); - global::handle_error(err); } } // Stream has terminated or processor is shutdown, return to finish execution. diff --git a/opentelemetry-sdk/src/metrics/periodic_reader.rs b/opentelemetry-sdk/src/metrics/periodic_reader.rs index 721b979078..fef639489c 100644 --- a/opentelemetry-sdk/src/metrics/periodic_reader.rs +++ b/opentelemetry-sdk/src/metrics/periodic_reader.rs @@ -14,6 +14,7 @@ use futures_util::{ use opentelemetry::{ global, metrics::{MetricsError, Result}, + otel_debug, otel_error, otel_info, }; use crate::runtime::Runtime; @@ -235,7 +236,7 @@ struct PeriodicReaderWorker { impl PeriodicReaderWorker { async fn collect_and_export(&mut self) -> Result<()> { #[cfg(feature = "experimental-internal-logs")] - tracing::debug!(name: "metrics_collect_and_export", target: "opentelemetry-sdk", status = "started"); + otel_debug!(name: "metrics_collect_and_export", status = "started"); self.reader.collect(&mut self.rm)?; if self.rm.scope_metrics.is_empty() { // No metrics to export. @@ -250,19 +251,17 @@ impl PeriodicReaderWorker { match future::select(export, timeout).await { Either::Left((res, _)) => { #[cfg(feature = "experimental-internal-logs")] - tracing::debug!( + otel_debug!( name: "collect_and_export", - target: "opentelemetry-sdk", status = "completed", - result = ?res + result = format!("{:?}", res), ); res // return the status of export. } Either::Right(_) => { #[cfg(feature = "experimental-internal-logs")] - tracing::error!( - name = "collect_and_export", - target = "opentelemetry-sdk", + otel_error!( + name: "collect_and_export", status = "timed_out" ); Err(MetricsError::Other("export timed out".into())) @@ -273,23 +272,20 @@ impl PeriodicReaderWorker { async fn process_message(&mut self, message: Message) -> bool { match message { Message::Export => { - #[cfg(feature = "experimental-internal-logs")] - tracing::debug!(name: "process_message", target: "opentelemetry-sdk", message_type = "export"); + otel_debug!(name: "process_message", message_type = "export"); if let Err(err) = self.collect_and_export().await { global::handle_error(err) } } Message::Flush(ch) => { - #[cfg(feature = "experimental-internal-logs")] - tracing::debug!(name: "process_message", target: "opentelemetry-sdk", message_type = "flush"); + otel_info!(name: "process_message", message_type = "flush"); let res = self.collect_and_export().await; if ch.send(res).is_err() { global::handle_error(MetricsError::Other("flush channel closed".into())) } } Message::Shutdown(ch) => { - #[cfg(feature = "experimental-internal-logs")] - tracing::debug!(name: "process_message", target: "opentelemetry-sdk", message_type = "shutdown"); + otel_info!(name: "process_message", message_type = "shutdown"); let res = self.collect_and_export().await; let _ = self.reader.exporter.shutdown(); if ch.send(res).is_err() { diff --git a/opentelemetry/Cargo.toml b/opentelemetry/Cargo.toml index 13a7ffa0fe..eebd083ad9 100644 --- a/opentelemetry/Cargo.toml +++ b/opentelemetry/Cargo.toml @@ -26,7 +26,7 @@ futures-sink = "0.3" once_cell = { workspace = true } pin-project-lite = { workspace = true, optional = true } thiserror = { workspace = true } -tracing = { version = "0.1", optional = true } +tracing = { version = "0.1"} [target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies] js-sys = "0.3.63" @@ -39,7 +39,6 @@ testing = ["trace", "metrics"] logs = [] logs_level_enabled = ["logs"] otel_unstable = [] -experimental-internal-debugging = ["tracing"] [dev-dependencies] opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["logs_level_enabled"]} # for documentation tests diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs index b7e7e15534..ec85aaba94 100644 --- a/opentelemetry/src/global/internal_logging.rs +++ b/opentelemetry/src/global/internal_logging.rs @@ -12,13 +12,11 @@ #[macro_export] macro_rules! otel_info { (name: $name:expr $(,)?) => { - #[cfg(all(feature = "experimental-internal-debugging"))] { tracing::info!(name: $name, target: env!("CARGO_PKG_NAME"),""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { - #[cfg(all(feature = "experimental-internal-debugging"))] { tracing::info!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); } @@ -38,13 +36,11 @@ macro_rules! otel_info { #[macro_export] macro_rules! otel_warn { (name: $name:expr $(,)?) => { - #[cfg(all(feature = "experimental-internal-debugging"))] { tracing::warn!(name: $name, target: env!("CARGO_PKG_NAME"), ""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { - #[cfg(all(feature = "experimental-internal-debugging"))] { tracing::warn!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); } @@ -64,13 +60,11 @@ macro_rules! otel_warn { #[macro_export] macro_rules! otel_debug { (name: $name:expr $(,)?) => { - #[cfg(all(feature = "experimental-internal-debugging"))] { tracing::debug!(name: $name, target: env!("CARGO_PKG_NAME"), ""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { - #[cfg(all(feature = "experimental-internal-debugging"))] { tracing::debug!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); } diff --git a/opentelemetry/src/global/mod.rs b/opentelemetry/src/global/mod.rs index 5a6d335431..66d699b8ba 100644 --- a/opentelemetry/src/global/mod.rs +++ b/opentelemetry/src/global/mod.rs @@ -134,6 +134,7 @@ mod propagation; #[cfg(feature = "trace")] mod trace; +pub use crate::{otel_debug, otel_error, otel_info, otel_warn}; pub use error_handler::{handle_error, set_error_handler, Error}; #[cfg(feature = "metrics")] #[cfg_attr(docsrs, doc(cfg(feature = "metrics")))] From da3716d64e554da318e6dd3f32b812b28f658510 Mon Sep 17 00:00:00 2001 From: Lalit Date: Tue, 1 Oct 2024 21:34:45 -0700 Subject: [PATCH 15/31] cont.. --- opentelemetry/src/global/mod.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/opentelemetry/src/global/mod.rs b/opentelemetry/src/global/mod.rs index 66d699b8ba..5a6d335431 100644 --- a/opentelemetry/src/global/mod.rs +++ b/opentelemetry/src/global/mod.rs @@ -134,7 +134,6 @@ mod propagation; #[cfg(feature = "trace")] mod trace; -pub use crate::{otel_debug, otel_error, otel_info, otel_warn}; pub use error_handler::{handle_error, set_error_handler, Error}; #[cfg(feature = "metrics")] #[cfg_attr(docsrs, doc(cfg(feature = "metrics")))] From 62b9f83bae3f524c4516a5d34c7107f44920c531 Mon Sep 17 00:00:00 2001 From: Lalit Date: Tue, 1 Oct 2024 21:40:57 -0700 Subject: [PATCH 16/31] lint fix --- examples/self-diagnostics/Cargo.toml | 4 ++-- opentelemetry-sdk/Cargo.toml | 3 +-- opentelemetry-sdk/src/metrics/periodic_reader.rs | 2 +- opentelemetry/Cargo.toml | 2 +- 4 files changed, 5 insertions(+), 6 deletions(-) diff --git a/examples/self-diagnostics/Cargo.toml b/examples/self-diagnostics/Cargo.toml index 40e574a7e5..8e8b1cd394 100644 --- a/examples/self-diagnostics/Cargo.toml +++ b/examples/self-diagnostics/Cargo.toml @@ -7,13 +7,13 @@ publish = false [dependencies] opentelemetry = { path = "../../opentelemetry" } -opentelemetry_sdk = { path = "../../opentelemetry-sdk", features = ["rt-tokio", "experimental-internal-logs"]} +opentelemetry_sdk = { path = "../../opentelemetry-sdk", features = ["rt-tokio"]} opentelemetry-stdout = { path = "../../opentelemetry-stdout"} opentelemetry-appender-tracing = { path = "../../opentelemetry-appender-tracing"} tokio = { workspace = true, features = ["full"] } tracing = { workspace = true, features = ["std"]} tracing-core = { workspace = true } tracing-subscriber = { version = "0.3.18", features = ["env-filter","registry", "std"]} -opentelemetry-otlp = { path = "../../opentelemetry-otlp", features = ["http-proto", "reqwest-client", "logs", "experimental-internal-logs"] } +opentelemetry-otlp = { path = "../../opentelemetry-otlp", features = ["http-proto", "reqwest-client", "logs"] } once_cell ={ version = "1.19.0"} ctrlc = "3.4" diff --git a/opentelemetry-sdk/Cargo.toml b/opentelemetry-sdk/Cargo.toml index 86380d45ca..e7c0b62bfc 100644 --- a/opentelemetry-sdk/Cargo.toml +++ b/opentelemetry-sdk/Cargo.toml @@ -28,7 +28,7 @@ url = { workspace = true, optional = true } tokio = { workspace = true, features = ["rt", "time"], optional = true } tokio-stream = { workspace = true, optional = true } http = { workspace = true, optional = true } -tracing = {workspace = true, optional = true} +tracing = {workspace = true} [package.metadata.docs.rs] all-features = true @@ -52,7 +52,6 @@ testing = ["opentelemetry/testing", "trace", "metrics", "logs", "rt-async-std", rt-tokio = ["tokio", "tokio-stream"] rt-tokio-current-thread = ["tokio", "tokio-stream"] rt-async-std = ["async-std"] -experimental-internal-logs = ["tracing"] [[bench]] name = "context" diff --git a/opentelemetry-sdk/src/metrics/periodic_reader.rs b/opentelemetry-sdk/src/metrics/periodic_reader.rs index fef639489c..45db5c6aec 100644 --- a/opentelemetry-sdk/src/metrics/periodic_reader.rs +++ b/opentelemetry-sdk/src/metrics/periodic_reader.rs @@ -14,7 +14,7 @@ use futures_util::{ use opentelemetry::{ global, metrics::{MetricsError, Result}, - otel_debug, otel_error, otel_info, + otel_debug, otel_info, }; use crate::runtime::Runtime; diff --git a/opentelemetry/Cargo.toml b/opentelemetry/Cargo.toml index eebd083ad9..edbeed1c38 100644 --- a/opentelemetry/Cargo.toml +++ b/opentelemetry/Cargo.toml @@ -26,7 +26,7 @@ futures-sink = "0.3" once_cell = { workspace = true } pin-project-lite = { workspace = true, optional = true } thiserror = { workspace = true } -tracing = { version = "0.1"} +tracing = { version = "0.1", optional = true } [target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies] js-sys = "0.3.63" From 591c45ae2d35db83b9a7d901f5686781ed2c22a9 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Wed, 2 Oct 2024 15:41:28 -0700 Subject: [PATCH 17/31] fix macro to dump operation name as name keyt --- examples/self-diagnostics/src/main.rs | 1 - opentelemetry-sdk/src/logs/log_processor.rs | 7 +++--- .../src/metrics/periodic_reader.rs | 5 +---- opentelemetry/src/global/internal_logging.rs | 22 ++++++++++++------- 4 files changed, 19 insertions(+), 16 deletions(-) diff --git a/examples/self-diagnostics/src/main.rs b/examples/self-diagnostics/src/main.rs index da9ebf82cc..68716794aa 100644 --- a/examples/self-diagnostics/src/main.rs +++ b/examples/self-diagnostics/src/main.rs @@ -33,7 +33,6 @@ impl ErrorState { } static GLOBAL_ERROR_STATE: Lazy> = Lazy::new(|| Arc::new(ErrorState::new())); -static SEEN_EVENT_NAMES: Lazy>> = Lazy::new(|| Mutex::new(HashSet::new())); fn custom_error_handler(err: OtelError) { if GLOBAL_ERROR_STATE.mark_as_seen(&err) { diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index 2040ff0122..80e7c617d3 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -182,8 +182,9 @@ impl Debug for BatchLogProcessor { impl LogProcessor for BatchLogProcessor { fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationLibrary) { - otel_info!( - name: "batch_log_processor_emit" + otel_debug!( + name: "batch_log_processor_emit", + record_count = record.attributes.len() ); let result = self.message_sender.try_send(BatchMessage::ExportLog(( record.clone(), @@ -269,7 +270,7 @@ impl BatchLogProcessor { // Log has finished, add to buffer of pending logs. BatchMessage::ExportLog(log) => { logs.push(log); - tracing::debug!( + otel_debug!( name: "batch_log_processor_record_count", current_batch_size = logs.len() ); diff --git a/opentelemetry-sdk/src/metrics/periodic_reader.rs b/opentelemetry-sdk/src/metrics/periodic_reader.rs index 45db5c6aec..7a6544fa94 100644 --- a/opentelemetry-sdk/src/metrics/periodic_reader.rs +++ b/opentelemetry-sdk/src/metrics/periodic_reader.rs @@ -14,7 +14,7 @@ use futures_util::{ use opentelemetry::{ global, metrics::{MetricsError, Result}, - otel_debug, otel_info, + otel_debug, otel_error, otel_info, }; use crate::runtime::Runtime; @@ -235,7 +235,6 @@ struct PeriodicReaderWorker { impl PeriodicReaderWorker { async fn collect_and_export(&mut self) -> Result<()> { - #[cfg(feature = "experimental-internal-logs")] otel_debug!(name: "metrics_collect_and_export", status = "started"); self.reader.collect(&mut self.rm)?; if self.rm.scope_metrics.is_empty() { @@ -250,7 +249,6 @@ impl PeriodicReaderWorker { match future::select(export, timeout).await { Either::Left((res, _)) => { - #[cfg(feature = "experimental-internal-logs")] otel_debug!( name: "collect_and_export", status = "completed", @@ -259,7 +257,6 @@ impl PeriodicReaderWorker { res // return the status of export. } Either::Right(_) => { - #[cfg(feature = "experimental-internal-logs")] otel_error!( name: "collect_and_export", status = "timed_out" diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs index ec85aaba94..2ecac700b1 100644 --- a/opentelemetry/src/global/internal_logging.rs +++ b/opentelemetry/src/global/internal_logging.rs @@ -1,4 +1,10 @@ #![allow(unused_macros)] +/// +/// **Note**: These macros (`otel_info!`, `otel_warn!`, `otel_debug!`, and `otel_error!`) are intended to be used +/// **internally within OpenTelemetry code** or for **custom exporters and processors**. They are not designed +/// for general application logging and should not be used for that purpose. +/// + /// Macro for logging informational messages in OpenTelemetry. /// /// # Fields: @@ -13,12 +19,12 @@ macro_rules! otel_info { (name: $name:expr $(,)?) => { { - tracing::info!(name: $name, target: env!("CARGO_PKG_NAME"),""); + tracing::info!( target: env!("CARGO_PKG_NAME"), name= $name,""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { { - tracing::info!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); + tracing::info!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } }; } @@ -37,12 +43,12 @@ macro_rules! otel_info { macro_rules! otel_warn { (name: $name:expr $(,)?) => { { - tracing::warn!(name: $name, target: env!("CARGO_PKG_NAME"), ""); + tracing::warn!(target: env!("CARGO_PKG_NAME"), name= $name, ""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { { - tracing::warn!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); + tracing::warn!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } }; } @@ -61,12 +67,12 @@ macro_rules! otel_warn { macro_rules! otel_debug { (name: $name:expr $(,)?) => { { - tracing::debug!(name: $name, target: env!("CARGO_PKG_NAME"), ""); + tracing::debug!(target: env!("CARGO_PKG_NAME"), name= $name,""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { { - tracing::debug!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); + tracing::debug!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } }; } @@ -85,12 +91,12 @@ macro_rules! otel_debug { macro_rules! otel_error { (name: $name:expr $(,)?) => { { - tracing::error!(name: $name, target: env!("CARGO_PKG_NAME"), ""); + tracing::error!(target: env!("CARGO_PKG_NAME"), name= $name, ""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { { - tracing::error!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); + tracing::error!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } }; } From 27145085a3968cf7c994e746fb2b1bea5b33b087 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Wed, 2 Oct 2024 17:05:58 -0700 Subject: [PATCH 18/31] fix unit test for appender-tracing --- opentelemetry-appender-tracing/Cargo.toml | 1 + opentelemetry-appender-tracing/src/layer.rs | 31 ++++++++++++++++----- 2 files changed, 25 insertions(+), 7 deletions(-) diff --git a/opentelemetry-appender-tracing/Cargo.toml b/opentelemetry-appender-tracing/Cargo.toml index eb52a7c02a..5fffd11900 100644 --- a/opentelemetry-appender-tracing/Cargo.toml +++ b/opentelemetry-appender-tracing/Cargo.toml @@ -22,6 +22,7 @@ tracing-subscriber = { workspace = true, features = ["registry", "std"] } log = { workspace = true } opentelemetry-stdout = { path = "../opentelemetry-stdout", features = ["logs"] } opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["logs", "testing"] } +tracing-subscriber = { workspace = true, features = ["registry", "std", "env-filter"] } tracing-log = "0.2" async-trait = { workspace = true } criterion = { workspace = true } diff --git a/opentelemetry-appender-tracing/src/layer.rs b/opentelemetry-appender-tracing/src/layer.rs index 8148f75069..7a30f325d4 100644 --- a/opentelemetry-appender-tracing/src/layer.rs +++ b/opentelemetry-appender-tracing/src/layer.rs @@ -217,7 +217,8 @@ mod tests { use opentelemetry_sdk::trace; use opentelemetry_sdk::trace::{Sampler, TracerProvider}; use tracing::error; - use tracing_subscriber::layer::SubscriberExt; + use tracing_subscriber::prelude::__tracing_subscriber_SubscriberExt; + use tracing_subscriber::Layer; pub fn attributes_contains(log_record: &LogRecord, key: &Key, value: &AnyValue) -> bool { log_record @@ -234,7 +235,11 @@ mod tests { .with_simple_exporter(exporter.clone()) .build(); - let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider); + let non_opentelemetry_filter = tracing_subscriber::filter::filter_fn(|metadata| { + !metadata.target().starts_with("opentelemetry") + }); // filter internal logs + let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider) + .with_filter(non_opentelemetry_filter); let subscriber = tracing_subscriber::registry().with(layer); // avoiding setting tracing subscriber as global as that does not @@ -315,7 +320,11 @@ mod tests { .with_simple_exporter(exporter.clone()) .build(); - let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider); + let non_opentelemetry_filter = tracing_subscriber::filter::filter_fn(|metadata| { + !metadata.target().starts_with("opentelemetry") + }); // filter internal logs + let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider) + .with_filter(non_opentelemetry_filter); let subscriber = tracing_subscriber::registry().with(layer); // avoiding setting tracing subscriber as global as that does not @@ -427,7 +436,11 @@ mod tests { .with_simple_exporter(exporter.clone()) .build(); - let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider); + let non_opentelemetry_filter = tracing_subscriber::filter::filter_fn(|metadata| { + !metadata.target().starts_with("opentelemetry") + }); // filter internal logs + let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider) + .with_filter(non_opentelemetry_filter); let subscriber = tracing_subscriber::registry().with(layer); // avoiding setting tracing subscriber as global as that does not @@ -436,7 +449,7 @@ mod tests { drop(tracing_log::LogTracer::init()); // Act - log::error!("log from log crate"); + log::error!(target: "my-system", "log from log crate"); logger_provider.force_flush(); // Assert TODO: move to helper methods @@ -493,7 +506,11 @@ mod tests { .with_simple_exporter(exporter.clone()) .build(); - let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider); + let non_opentelemetry_filter = tracing_subscriber::filter::filter_fn(|metadata| { + !metadata.target().starts_with("opentelemetry") + }); // filter internal logs + let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider) + .with_filter(non_opentelemetry_filter); let subscriber = tracing_subscriber::registry().with(layer); // avoiding setting tracing subscriber as global as that does not @@ -513,7 +530,7 @@ mod tests { let span_id = cx.span().span_context().span_id(); // logging is done inside span context. - log::error!("log from log crate"); + log::error!(target: "my-system", "log from log crate"); (trace_id, span_id) }); From 83763b11fc7389a7e88c15965b3f1cea39710954 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Wed, 2 Oct 2024 17:19:14 -0700 Subject: [PATCH 19/31] fix unit tests, and doc test --- opentelemetry/Cargo.toml | 1 + opentelemetry/src/global/internal_logging.rs | 12 ++++++++---- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/opentelemetry/Cargo.toml b/opentelemetry/Cargo.toml index edbeed1c38..3016e485f8 100644 --- a/opentelemetry/Cargo.toml +++ b/opentelemetry/Cargo.toml @@ -44,6 +44,7 @@ otel_unstable = [] opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["logs_level_enabled"]} # for documentation tests criterion = { workspace = true } rand = { workspace = true } +tracing = { version = "0.1"} [[bench]] name = "metrics" diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs index 2ecac700b1..c4263b0581 100644 --- a/opentelemetry/src/global/internal_logging.rs +++ b/opentelemetry/src/global/internal_logging.rs @@ -13,7 +13,8 @@ /// /// # Example: /// ```rust -/// otel_info!("sdk_start", version = "1.0.0", schema_url = "http://example.com"); +/// use opentelemetry::otel_info; +/// otel_info!(name: "sdk_start", version = "1.0.0", schema_url = "http://example.com"); /// ``` #[macro_export] macro_rules! otel_info { @@ -37,7 +38,8 @@ macro_rules! otel_info { /// /// # Example: /// ```rust -/// otel_warn!("export_warning", error_code = 404, version = "1.0.0"); +/// use opentelemetry::otel_warn; +/// otel_warn!(name: "export_warning", error_code = 404, version = "1.0.0"); /// ``` #[macro_export] macro_rules! otel_warn { @@ -61,7 +63,8 @@ macro_rules! otel_warn { /// /// # Example: /// ```rust -/// otel_debug!("debug_operation", debug_level = "high", version = "1.0.0"); +/// use opentelemetry::otel_debug; +/// otel_debug!(name: "debug_operation", debug_level = "high", version = "1.0.0"); /// ``` #[macro_export] macro_rules! otel_debug { @@ -85,7 +88,8 @@ macro_rules! otel_debug { /// /// # Example: /// ```rust -/// otel_error!("export_failure", error_code = 500, version = "1.0.0"); +/// use opentelemetry::otel_error; +/// otel_error!(name: "export_failure", error_code = 500, version = "1.0.0"); /// ``` #[macro_export] macro_rules! otel_error { From e325316fcedbe867f5deaec26dbc401d7ae91e8a Mon Sep 17 00:00:00 2001 From: Lalit Date: Wed, 2 Oct 2024 21:34:56 -0700 Subject: [PATCH 20/31] add macros under feature flag --- opentelemetry-otlp/Cargo.toml | 2 +- opentelemetry-otlp/src/metric.rs | 13 +++++-------- opentelemetry-sdk/Cargo.toml | 5 +++-- opentelemetry/src/global/internal_logging.rs | 8 ++++++++ 4 files changed, 17 insertions(+), 11 deletions(-) diff --git a/opentelemetry-otlp/Cargo.toml b/opentelemetry-otlp/Cargo.toml index 07ad6127df..9f2f9ef1f4 100644 --- a/opentelemetry-otlp/Cargo.toml +++ b/opentelemetry-otlp/Cargo.toml @@ -58,7 +58,7 @@ trace = ["opentelemetry/trace", "opentelemetry_sdk/trace", "opentelemetry-proto/ metrics = ["opentelemetry/metrics", "opentelemetry_sdk/metrics", "opentelemetry-proto/metrics"] logs = ["opentelemetry/logs", "opentelemetry_sdk/logs", "opentelemetry-proto/logs"] populate-logs-event-name = ["opentelemetry-proto/populate-logs-event-name"] -experimental-internal-logs = ["tracing"] +internal-logs = ["tracing"] # add ons serialize = ["serde", "serde_json"] diff --git a/opentelemetry-otlp/src/metric.rs b/opentelemetry-otlp/src/metric.rs index 55124f5355..d1f53565b0 100644 --- a/opentelemetry-otlp/src/metric.rs +++ b/opentelemetry-otlp/src/metric.rs @@ -7,6 +7,7 @@ use crate::{NoExporterConfig, OtlpPipeline}; use async_trait::async_trait; use core::fmt; use opentelemetry::metrics::Result; +use opentelemetry::otel_debug; #[cfg(feature = "grpc-tonic")] use crate::exporter::tonic::TonicExporterBuilder; @@ -294,10 +295,8 @@ impl TemporalitySelector for MetricsExporter { #[async_trait] impl PushMetricsExporter for MetricsExporter { async fn export(&self, metrics: &mut ResourceMetrics) -> Result<()> { - #[cfg(feature = "experimental-internal-logs")] - tracing::debug!( - name = "export_metrics", - target = "opentelemetry-otlp", + otel_debug!( + name: "export_metrics", metrics_count = metrics .scope_metrics .iter() @@ -306,10 +305,8 @@ impl PushMetricsExporter for MetricsExporter { status = "started" ); let result = self.client.export(metrics).await; - #[cfg(feature = "experimental-internal-logs")] - tracing::debug!( - name = "export_metrics", - target = "opentelemetry-otlp", + otel_debug!( + name: "export_metrics", status = if result.is_ok() { "completed" } else { diff --git a/opentelemetry-sdk/Cargo.toml b/opentelemetry-sdk/Cargo.toml index e7c0b62bfc..5fc542a943 100644 --- a/opentelemetry-sdk/Cargo.toml +++ b/opentelemetry-sdk/Cargo.toml @@ -28,7 +28,7 @@ url = { workspace = true, optional = true } tokio = { workspace = true, features = ["rt", "time"], optional = true } tokio-stream = { workspace = true, optional = true } http = { workspace = true, optional = true } -tracing = {workspace = true} +tracing = {workspace = true, optional = true} [package.metadata.docs.rs] all-features = true @@ -42,7 +42,7 @@ temp-env = { workspace = true } pprof = { version = "0.13", features = ["flamegraph", "criterion"] } [features] -default = ["trace", "metrics", "logs"] +default = ["trace", "metrics", "logs", "internal-logs"] trace = ["opentelemetry/trace", "rand", "async-trait", "percent-encoding"] jaeger_remote_sampler = ["trace", "opentelemetry-http", "http", "serde", "serde_json", "url"] logs = ["opentelemetry/logs", "async-trait", "serde_json"] @@ -52,6 +52,7 @@ testing = ["opentelemetry/testing", "trace", "metrics", "logs", "rt-async-std", rt-tokio = ["tokio", "tokio-stream"] rt-tokio-current-thread = ["tokio", "tokio-stream"] rt-async-std = ["async-std"] +internal-logs = ["tracing"] [[bench]] name = "context" diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs index c4263b0581..bc0b9ff786 100644 --- a/opentelemetry/src/global/internal_logging.rs +++ b/opentelemetry/src/global/internal_logging.rs @@ -19,11 +19,13 @@ #[macro_export] macro_rules! otel_info { (name: $name:expr $(,)?) => { + #[cfg(feature = "internal-logs")] { tracing::info!( target: env!("CARGO_PKG_NAME"), name= $name,""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { + #[cfg(feature = "internal-logs")] { tracing::info!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } @@ -44,11 +46,13 @@ macro_rules! otel_info { #[macro_export] macro_rules! otel_warn { (name: $name:expr $(,)?) => { + #[cfg(feature = "internal-logs")] { tracing::warn!(target: env!("CARGO_PKG_NAME"), name= $name, ""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { + #[cfg(feature = "internal-logs")] { tracing::warn!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } @@ -69,11 +73,13 @@ macro_rules! otel_warn { #[macro_export] macro_rules! otel_debug { (name: $name:expr $(,)?) => { + #[cfg(feature = "internal-logs")] { tracing::debug!(target: env!("CARGO_PKG_NAME"), name= $name,""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { + #[cfg(feature = "internal-logs")] { tracing::debug!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } @@ -94,11 +100,13 @@ macro_rules! otel_debug { #[macro_export] macro_rules! otel_error { (name: $name:expr $(,)?) => { + #[cfg(feature = "internal-logs")] { tracing::error!(target: env!("CARGO_PKG_NAME"), name= $name, ""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { + #[cfg(feature = "internal-logs")] { tracing::error!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } From 19822b1fc7fb0e98309a2804aac53688402337a8 Mon Sep 17 00:00:00 2001 From: Lalit Date: Wed, 2 Oct 2024 21:40:40 -0700 Subject: [PATCH 21/31] make feature default --- opentelemetry-otlp/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/opentelemetry-otlp/Cargo.toml b/opentelemetry-otlp/Cargo.toml index 9f2f9ef1f4..272481053e 100644 --- a/opentelemetry-otlp/Cargo.toml +++ b/opentelemetry-otlp/Cargo.toml @@ -63,7 +63,7 @@ internal-logs = ["tracing"] # add ons serialize = ["serde", "serde_json"] -default = ["grpc-tonic", "trace", "metrics", "logs"] +default = ["grpc-tonic", "trace", "metrics", "logs", "internal-logs"] # grpc using tonic grpc-tonic = ["tonic", "prost", "http", "tokio", "opentelemetry-proto/gen-tonic"] From 6b98c165e8e7749cfa1c02604aa66e0faa2ff8dd Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 3 Oct 2024 10:36:27 -0700 Subject: [PATCH 22/31] fix build --- opentelemetry-sdk/src/logs/log_processor.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index 80e7c617d3..b688d28190 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -108,7 +108,7 @@ impl LogProcessor for SimpleLogProcessor { return; } - tracing::debug!( + otel_debug!( name: "simple_log_processor_emit", event_name = record.event_name ); From d24875007e7b927d7efcc43bffe9cc1b14795cdf Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 3 Oct 2024 10:42:22 -0700 Subject: [PATCH 23/31] fix lint --- opentelemetry-sdk/src/logs/log_processor.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index b688d28190..f8621b5231 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -308,17 +308,17 @@ impl BatchLogProcessor { .await; if let Some(channel) = res_channel { - if let Err(result) = channel.send(result) { + if let Err(_result) = channel.send(result) { otel_error!( name: "batch_log_processor_flush_error", - error = format!("{:?}", result), + error = format!("{:?}", _result), message = "Failed to send flush result" ); } - } else if let Err(err) = result { + } else if let Err(_err) = result { otel_error!( name: "batch_log_processor_flush_error", - error = format!("{:?}", err), + error = format!("{:?}", _err), message = "Flush failed" ); } From f9e3d2da681da33862f09fdfb5998c9bb06e55a2 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 3 Oct 2024 11:01:44 -0700 Subject: [PATCH 24/31] lint --- opentelemetry-otlp/src/metric.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/opentelemetry-otlp/src/metric.rs b/opentelemetry-otlp/src/metric.rs index d1f53565b0..375384278e 100644 --- a/opentelemetry-otlp/src/metric.rs +++ b/opentelemetry-otlp/src/metric.rs @@ -304,6 +304,7 @@ impl PushMetricsExporter for MetricsExporter { .sum::(), status = "started" ); + #[allow(clippy::let_and_return)] // for scenario where internal logs is disabled let result = self.client.export(metrics).await; otel_debug!( name: "export_metrics", From d4c1eb7bf0cc12463351ea5aaf736a0486e75021 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 3 Oct 2024 11:31:31 -0700 Subject: [PATCH 25/31] use eprintln for warn and error if internal-logs flag is disabled --- opentelemetry/src/global/internal_logging.rs | 28 ++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs index bc0b9ff786..e7327f364b 100644 --- a/opentelemetry/src/global/internal_logging.rs +++ b/opentelemetry/src/global/internal_logging.rs @@ -50,12 +50,26 @@ macro_rules! otel_warn { { tracing::warn!(target: env!("CARGO_PKG_NAME"), name= $name, ""); } + #[cfg(not(feature = "internal-logs"))] + { + eprintln!("[WARN] {}: {}", env!("CARGO_PKG_NAME"), $name); + } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(feature = "internal-logs")] { tracing::warn!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } + #[cfg(not(feature = "internal-logs"))] + { + let msg = format!( + "[WARN] {}: {} ({})", + env!("CARGO_PKG_NAME"), + $name, + format!(concat!($(stringify!($key), "={}, "),+), $($value),+).trim_end_matches(", ") + ); + eprintln!("{}", msg); + } }; } @@ -104,11 +118,25 @@ macro_rules! otel_error { { tracing::error!(target: env!("CARGO_PKG_NAME"), name= $name, ""); } + #[cfg(not(feature = "internal-logs"))] + { + eprintln!("[ERROR] {}: {}", env!("CARGO_PKG_NAME"), $name); + } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(feature = "internal-logs")] { tracing::error!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } + #[cfg(not(feature = "internal-logs"))] + { + let msg = format!( + "[ERROR] {}: {} ({})", + env!("CARGO_PKG_NAME"), + $name, + format!(concat!($(stringify!($key), "={}, "),+), $($value),+).trim_end_matches(", ") + ); + eprintln!("{}", msg); + } }; } From d5120a27c7f305085e51b7c77503e70c7eea23fd Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 3 Oct 2024 13:24:31 -0700 Subject: [PATCH 26/31] review comments --- opentelemetry-appender-tracing/src/layer.rs | 39 ++++++++------------ opentelemetry-sdk/src/logs/log_processor.rs | 13 +++++-- opentelemetry/src/global/internal_logging.rs | 28 -------------- 3 files changed, 24 insertions(+), 56 deletions(-) diff --git a/opentelemetry-appender-tracing/src/layer.rs b/opentelemetry-appender-tracing/src/layer.rs index 7a30f325d4..1bfbef0fcf 100644 --- a/opentelemetry-appender-tracing/src/layer.rs +++ b/opentelemetry-appender-tracing/src/layer.rs @@ -226,6 +226,17 @@ mod tests { .any(|(k, v)| k == key && v == value) } + fn create_tracing_subscriber( + _exporter: InMemoryLogsExporter, + logger_provider: &LoggerProvider, + ) -> impl tracing::Subscriber { + let level_filter = tracing_subscriber::filter::LevelFilter::WARN; // Capture WARN and ERROR levels + let layer = + layer::OpenTelemetryTracingBridge::new(logger_provider).with_filter(level_filter); // No filter based on target, only based on log level + + tracing_subscriber::registry().with(layer) + } + // cargo test --features=testing #[test] fn tracing_appender_standalone() { @@ -235,12 +246,7 @@ mod tests { .with_simple_exporter(exporter.clone()) .build(); - let non_opentelemetry_filter = tracing_subscriber::filter::filter_fn(|metadata| { - !metadata.target().starts_with("opentelemetry") - }); // filter internal logs - let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider) - .with_filter(non_opentelemetry_filter); - let subscriber = tracing_subscriber::registry().with(layer); + let subscriber = create_tracing_subscriber(exporter.clone(), &logger_provider); // avoiding setting tracing subscriber as global as that does not // play well with unit tests. @@ -320,12 +326,7 @@ mod tests { .with_simple_exporter(exporter.clone()) .build(); - let non_opentelemetry_filter = tracing_subscriber::filter::filter_fn(|metadata| { - !metadata.target().starts_with("opentelemetry") - }); // filter internal logs - let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider) - .with_filter(non_opentelemetry_filter); - let subscriber = tracing_subscriber::registry().with(layer); + let subscriber = create_tracing_subscriber(exporter.clone(), &logger_provider); // avoiding setting tracing subscriber as global as that does not // play well with unit tests. @@ -436,12 +437,7 @@ mod tests { .with_simple_exporter(exporter.clone()) .build(); - let non_opentelemetry_filter = tracing_subscriber::filter::filter_fn(|metadata| { - !metadata.target().starts_with("opentelemetry") - }); // filter internal logs - let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider) - .with_filter(non_opentelemetry_filter); - let subscriber = tracing_subscriber::registry().with(layer); + let subscriber = create_tracing_subscriber(exporter.clone(), &logger_provider); // avoiding setting tracing subscriber as global as that does not // play well with unit tests. @@ -506,12 +502,7 @@ mod tests { .with_simple_exporter(exporter.clone()) .build(); - let non_opentelemetry_filter = tracing_subscriber::filter::filter_fn(|metadata| { - !metadata.target().starts_with("opentelemetry") - }); // filter internal logs - let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider) - .with_filter(non_opentelemetry_filter); - let subscriber = tracing_subscriber::registry().with(layer); + let subscriber = create_tracing_subscriber(exporter.clone(), &logger_provider); // avoiding setting tracing subscriber as global as that does not // play well with unit tests. diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index f8621b5231..92f70f927c 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -308,19 +308,24 @@ impl BatchLogProcessor { .await; if let Some(channel) = res_channel { - if let Err(_result) = channel.send(result) { + if let Err(result) = channel.send(result) { + global::handle_error(LogError::from(format!( + "failed to send flush result: {:?}", + result + ))); otel_error!( name: "batch_log_processor_flush_error", - error = format!("{:?}", _result), + error = format!("{:?}", result), message = "Failed to send flush result" ); } - } else if let Err(_err) = result { + } else if let Err(err) = result { otel_error!( name: "batch_log_processor_flush_error", - error = format!("{:?}", _err), + error = format!("{:?}", err), message = "Flush failed" ); + global::handle_error(err); } } // Stream has terminated or processor is shutdown, return to finish execution. diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs index e7327f364b..bc0b9ff786 100644 --- a/opentelemetry/src/global/internal_logging.rs +++ b/opentelemetry/src/global/internal_logging.rs @@ -50,26 +50,12 @@ macro_rules! otel_warn { { tracing::warn!(target: env!("CARGO_PKG_NAME"), name= $name, ""); } - #[cfg(not(feature = "internal-logs"))] - { - eprintln!("[WARN] {}: {}", env!("CARGO_PKG_NAME"), $name); - } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(feature = "internal-logs")] { tracing::warn!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } - #[cfg(not(feature = "internal-logs"))] - { - let msg = format!( - "[WARN] {}: {} ({})", - env!("CARGO_PKG_NAME"), - $name, - format!(concat!($(stringify!($key), "={}, "),+), $($value),+).trim_end_matches(", ") - ); - eprintln!("{}", msg); - } }; } @@ -118,25 +104,11 @@ macro_rules! otel_error { { tracing::error!(target: env!("CARGO_PKG_NAME"), name= $name, ""); } - #[cfg(not(feature = "internal-logs"))] - { - eprintln!("[ERROR] {}: {}", env!("CARGO_PKG_NAME"), $name); - } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(feature = "internal-logs")] { tracing::error!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); } - #[cfg(not(feature = "internal-logs"))] - { - let msg = format!( - "[ERROR] {}: {} ({})", - env!("CARGO_PKG_NAME"), - $name, - format!(concat!($(stringify!($key), "={}, "),+), $($value),+).trim_end_matches(", ") - ); - eprintln!("{}", msg); - } }; } From c103467ac5aed0ad7aa002c32f79954511f58827 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 3 Oct 2024 15:32:25 -0700 Subject: [PATCH 27/31] remove tracing from opentelemetry crate, and use name as metadata --- opentelemetry/Cargo.toml | 1 - opentelemetry/src/global/internal_logging.rs | 16 ++++++++-------- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/opentelemetry/Cargo.toml b/opentelemetry/Cargo.toml index 3016e485f8..8805905e3f 100644 --- a/opentelemetry/Cargo.toml +++ b/opentelemetry/Cargo.toml @@ -26,7 +26,6 @@ futures-sink = "0.3" once_cell = { workspace = true } pin-project-lite = { workspace = true, optional = true } thiserror = { workspace = true } -tracing = { version = "0.1", optional = true } [target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies] js-sys = "0.3.63" diff --git a/opentelemetry/src/global/internal_logging.rs b/opentelemetry/src/global/internal_logging.rs index bc0b9ff786..3a5c24ba69 100644 --- a/opentelemetry/src/global/internal_logging.rs +++ b/opentelemetry/src/global/internal_logging.rs @@ -21,13 +21,13 @@ macro_rules! otel_info { (name: $name:expr $(,)?) => { #[cfg(feature = "internal-logs")] { - tracing::info!( target: env!("CARGO_PKG_NAME"), name= $name,""); + tracing::info!( name: $name, target: env!("CARGO_PKG_NAME"), ""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(feature = "internal-logs")] { - tracing::info!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); + tracing::info!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); } }; } @@ -48,13 +48,13 @@ macro_rules! otel_warn { (name: $name:expr $(,)?) => { #[cfg(feature = "internal-logs")] { - tracing::warn!(target: env!("CARGO_PKG_NAME"), name= $name, ""); + tracing::warn!(name: $name, target: env!("CARGO_PKG_NAME"), ""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(feature = "internal-logs")] { - tracing::warn!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); + tracing::warn!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); } }; } @@ -75,13 +75,13 @@ macro_rules! otel_debug { (name: $name:expr $(,)?) => { #[cfg(feature = "internal-logs")] { - tracing::debug!(target: env!("CARGO_PKG_NAME"), name= $name,""); + tracing::debug!(name: $name, target: env!("CARGO_PKG_NAME"),""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(feature = "internal-logs")] { - tracing::debug!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); + tracing::debug!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); } }; } @@ -102,13 +102,13 @@ macro_rules! otel_error { (name: $name:expr $(,)?) => { #[cfg(feature = "internal-logs")] { - tracing::error!(target: env!("CARGO_PKG_NAME"), name= $name, ""); + tracing::error!(name: $name, target: env!("CARGO_PKG_NAME"), ""); } }; (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => { #[cfg(feature = "internal-logs")] { - tracing::error!(target: env!("CARGO_PKG_NAME"), name= $name, $($key = $value),+, ""); + tracing::error!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, ""); } }; } From b7470b199111a8af3258166a4dc0da0521c084d0 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 3 Oct 2024 16:20:27 -0700 Subject: [PATCH 28/31] fix --- opentelemetry-sdk/src/logs/log_emitter.rs | 47 +------------ opentelemetry-sdk/src/logs/log_processor.rs | 70 +------------------ opentelemetry-sdk/src/metrics/internal/mod.rs | 5 +- .../src/metrics/periodic_reader.rs | 11 +-- 4 files changed, 7 insertions(+), 126 deletions(-) diff --git a/opentelemetry-sdk/src/logs/log_emitter.rs b/opentelemetry-sdk/src/logs/log_emitter.rs index f5fd060f29..1b4e1b8c2c 100644 --- a/opentelemetry-sdk/src/logs/log_emitter.rs +++ b/opentelemetry-sdk/src/logs/log_emitter.rs @@ -1,12 +1,12 @@ use super::{BatchLogProcessor, LogProcessor, LogRecord, SimpleLogProcessor, TraceContext}; use crate::{export::logs::LogExporter, runtime::RuntimeChannel, Resource}; +use opentelemetry::otel_warn; use opentelemetry::{ global, logs::{LogError, LogResult}, trace::TraceContextExt, Context, InstrumentationLibrary, }; -use opentelemetry::{otel_debug, otel_info, otel_warn}; #[cfg(feature = "logs_level_enabled")] use opentelemetry::logs::Severity; @@ -50,13 +50,6 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider { attributes: Option>, ) -> Logger { let name = name.into(); - otel_info!( - name: "logger_versioned_creation", - instr_lib_name= &*name, - version = version.as_deref(), - schema_url = schema_url.as_deref(), - ); - let component_name = if name.is_empty() { Cow::Borrowed(DEFAULT_COMPONENT_NAME) } else { @@ -79,9 +72,6 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider { } fn library_logger(&self, library: Arc) -> Self::Logger { - otel_info!( - name: "logger_library_logger_creation" - ); // If the provider is shutdown, new logger will refer a no-op logger provider. if self.is_shutdown.load(Ordering::Relaxed) { return Logger::new(library, NOOP_LOGGER_PROVIDER.clone()); @@ -93,33 +83,19 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider { impl LoggerProvider { /// Create a new `LoggerProvider` builder. pub fn builder() -> Builder { - otel_info!( - name: "logger_provider_builder" - ); Builder::default() } pub(crate) fn log_processors(&self) -> &[Box] { - otel_debug!( - name: "logger_provider_log_processors", - processor_count= self.inner.processors.len() - ); &self.inner.processors } pub(crate) fn resource(&self) -> &Resource { - otel_debug!( - name: "logger_provider_resource", - resource_count= self.inner.resource.len() - ); &self.inner.resource } /// Force flush all remaining logs in log processors and return results. pub fn force_flush(&self) -> Vec> { - otel_info!( - name: "logger_provider_force_flush" - ); self.log_processors() .iter() .map(|processor| processor.force_flush()) @@ -128,9 +104,6 @@ impl LoggerProvider { /// Shuts down this `LoggerProvider` pub fn shutdown(&self) -> LogResult<()> { - otel_info!( - name: "logger_provider_shutdown" - ); if self .is_shutdown .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst) @@ -237,11 +210,6 @@ impl Builder { for processor in logger_provider.log_processors() { processor.set_resource(logger_provider.resource()); } - otel_debug!( - name: "logger_provider_build", - resource_count = logger_provider.resource().len(), - processor_count = logger_provider.log_processors().len() - ); logger_provider } } @@ -260,9 +228,6 @@ impl Logger { instrumentation_lib: Arc, provider: LoggerProvider, ) -> Self { - otel_info!( - name: "logger_new" - ); Logger { instrumentation_lib, provider, @@ -289,10 +254,6 @@ impl opentelemetry::logs::Logger for Logger { /// Emit a `LogRecord`. fn emit(&self, mut record: Self::LogRecord) { - otel_debug!( - name: "log_record_emit_start", - record = format!("{:?}", record) - ); let provider = self.provider(); let processors = provider.log_processors(); let trace_context = Context::map_current(|cx| { @@ -326,12 +287,6 @@ impl opentelemetry::logs::Logger for Logger { self.instrumentation_library().name.as_ref(), ); } - otel_debug!( - name: "log_record_event_enabled_check", - enabled_status = enabled, - level = level.name(), - log_target = target - ); enabled } } diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index 92f70f927c..e6578c7f7e 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -14,7 +14,7 @@ use opentelemetry::logs::Severity; use opentelemetry::{ global, logs::{LogError, LogResult}, - otel_debug, otel_error, otel_info, otel_warn, InstrumentationLibrary, + otel_error, otel_warn, InstrumentationLibrary, }; use std::sync::atomic::AtomicBool; @@ -88,9 +88,6 @@ pub struct SimpleLogProcessor { impl SimpleLogProcessor { pub(crate) fn new(exporter: Box) -> Self { - otel_info!( - name: "simple_log_processor_new" - ); SimpleLogProcessor { exporter: Mutex::new(exporter), is_shutdown: AtomicBool::new(false), @@ -108,11 +105,6 @@ impl LogProcessor for SimpleLogProcessor { return; } - otel_debug!( - name: "simple_log_processor_emit", - event_name = record.event_name - ); - let result = self .exporter .lock() @@ -131,16 +123,10 @@ impl LogProcessor for SimpleLogProcessor { } fn force_flush(&self) -> LogResult<()> { - otel_info!( - name: "simple_log_processor_force_flush" - ); Ok(()) } fn shutdown(&self) -> LogResult<()> { - otel_info!( - name: "simple_log_processor_shutdown" - ); self.is_shutdown .store(true, std::sync::atomic::Ordering::Relaxed); if let Ok(mut exporter) = self.exporter.lock() { @@ -157,9 +143,6 @@ impl LogProcessor for SimpleLogProcessor { } fn set_resource(&self, resource: &Resource) { - otel_info!( - name: "simple_log_processor_set_resource" - ); if let Ok(mut exporter) = self.exporter.lock() { exporter.set_resource(resource); } @@ -182,10 +165,6 @@ impl Debug for BatchLogProcessor { impl LogProcessor for BatchLogProcessor { fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationLibrary) { - otel_debug!( - name: "batch_log_processor_emit", - record_count = record.attributes.len() - ); let result = self.message_sender.try_send(BatchMessage::ExportLog(( record.clone(), instrumentation.clone(), @@ -201,9 +180,6 @@ impl LogProcessor for BatchLogProcessor { } fn force_flush(&self) -> LogResult<()> { - otel_info!( - name: "batch_log_processor_force_flush" - ); let (res_sender, res_receiver) = oneshot::channel(); self.message_sender .try_send(BatchMessage::Flush(Some(res_sender))) @@ -215,9 +191,6 @@ impl LogProcessor for BatchLogProcessor { } fn shutdown(&self) -> LogResult<()> { - otel_info!( - name: "batch_log_processor_shutdown" - ); let (res_sender, res_receiver) = oneshot::channel(); self.message_sender .try_send(BatchMessage::Shutdown(res_sender)) @@ -229,9 +202,6 @@ impl LogProcessor for BatchLogProcessor { } fn set_resource(&self, resource: &Resource) { - otel_info!( - name: "batch_log_processor_set_resource" - ); let resource = Arc::new(resource.clone()); let _ = self .message_sender @@ -257,29 +227,12 @@ impl BatchLogProcessor { let mut logs = Vec::new(); let mut messages = Box::pin(stream::select(message_receiver, ticker)); - otel_info!( - name: "batch_log_processor_started", - max_queue_size = config.max_queue_size, - max_export_batch_size = config.max_export_batch_size, - scheduled_delay = config.scheduled_delay.as_millis(), - max_export_timeout = config.max_export_timeout.as_millis() - ); - while let Some(message) = messages.next().await { match message { // Log has finished, add to buffer of pending logs. BatchMessage::ExportLog(log) => { logs.push(log); - otel_debug!( - name: "batch_log_processor_record_count", - current_batch_size = logs.len() - ); - if logs.len() == config.max_export_batch_size { - otel_info!( - name: "batch_log_processor_export", - batch_size = logs.len() - ); let result = export_with_timeout( config.max_export_timeout, exporter.as_mut(), @@ -330,10 +283,6 @@ impl BatchLogProcessor { } // Stream has terminated or processor is shutdown, return to finish execution. BatchMessage::Shutdown(ch) => { - otel_info!( - name: "batch_log_processor_shutdown", - remaining_batch_size = logs.len() - ); let result = export_with_timeout( config.max_export_timeout, exporter.as_mut(), @@ -361,20 +310,11 @@ impl BatchLogProcessor { // propagate the resource BatchMessage::SetResource(resource) => { - otel_info!( - name: "batch_log_processor_set_resource", - resource_keys_count = resource.len(), - resource = format!("{:?}", resource) - ); exporter.set_resource(&resource); } } } })); - - otel_info!( - name: "batch_log_processor_initialized" - ); // Return batch processor with link to worker BatchLogProcessor { message_sender } } @@ -403,9 +343,6 @@ where E: LogExporter + ?Sized, { if batch.is_empty() { - otel_debug!( - name: "batch_log_processor_empty_batch" - ); return Ok(()); } @@ -414,11 +351,6 @@ where .iter() .map(|log_data| (&log_data.0, &log_data.1)) .collect(); - otel_debug!( - name: "export_with_timeout", - batch_size = log_vec.len(), - timeout = time_out.as_millis() - ); let export = exporter.export(LogBatch::new(log_vec.as_slice())); let timeout = runtime.delay(time_out); pin_mut!(export); diff --git a/opentelemetry-sdk/src/metrics/internal/mod.rs b/opentelemetry-sdk/src/metrics/internal/mod.rs index abc691b2fc..a3a324a15b 100644 --- a/opentelemetry-sdk/src/metrics/internal/mod.rs +++ b/opentelemetry-sdk/src/metrics/internal/mod.rs @@ -17,7 +17,7 @@ pub(crate) use aggregate::{AggregateBuilder, ComputeAggregation, Measure}; pub(crate) use exponential_histogram::{EXPO_MAX_SCALE, EXPO_MIN_SCALE}; use once_cell::sync::Lazy; use opentelemetry::metrics::MetricsError; -use opentelemetry::{global, KeyValue}; +use opentelemetry::{global, otel_warn, KeyValue}; use crate::metrics::AttributeSet; @@ -147,6 +147,9 @@ impl, T: Number, O: Operation> ValueMap { O::update_tracker(&new_tracker, measurement, index); trackers.insert(STREAM_OVERFLOW_ATTRIBUTES.clone(), Arc::new(new_tracker)); global::handle_error(MetricsError::Other("Warning: Maximum data points for metric stream exceeded. Entry added to overflow. Subsequent overflows to same metric until next collect will not be logged.".into())); + otel_warn!( name: "ValueMap.measure", + message = "Warning: Maximum data points for metric stream exceeded. Entry added to overflow. Subsequent overflows to same metric until next collect will not be logged." + ); } } } diff --git a/opentelemetry-sdk/src/metrics/periodic_reader.rs b/opentelemetry-sdk/src/metrics/periodic_reader.rs index 7a6544fa94..30604acc48 100644 --- a/opentelemetry-sdk/src/metrics/periodic_reader.rs +++ b/opentelemetry-sdk/src/metrics/periodic_reader.rs @@ -14,7 +14,7 @@ use futures_util::{ use opentelemetry::{ global, metrics::{MetricsError, Result}, - otel_debug, otel_error, otel_info, + otel_error, }; use crate::runtime::Runtime; @@ -235,7 +235,6 @@ struct PeriodicReaderWorker { impl PeriodicReaderWorker { async fn collect_and_export(&mut self) -> Result<()> { - otel_debug!(name: "metrics_collect_and_export", status = "started"); self.reader.collect(&mut self.rm)?; if self.rm.scope_metrics.is_empty() { // No metrics to export. @@ -249,11 +248,6 @@ impl PeriodicReaderWorker { match future::select(export, timeout).await { Either::Left((res, _)) => { - otel_debug!( - name: "collect_and_export", - status = "completed", - result = format!("{:?}", res), - ); res // return the status of export. } Either::Right(_) => { @@ -269,20 +263,17 @@ impl PeriodicReaderWorker { async fn process_message(&mut self, message: Message) -> bool { match message { Message::Export => { - otel_debug!(name: "process_message", message_type = "export"); if let Err(err) = self.collect_and_export().await { global::handle_error(err) } } Message::Flush(ch) => { - otel_info!(name: "process_message", message_type = "flush"); let res = self.collect_and_export().await; if ch.send(res).is_err() { global::handle_error(MetricsError::Other("flush channel closed".into())) } } Message::Shutdown(ch) => { - otel_info!(name: "process_message", message_type = "shutdown"); let res = self.collect_and_export().await; let _ = self.reader.exporter.shutdown(); if ch.send(res).is_err() { From 30f7a4cec19591e086021cbbd3ec40ab4d0382c1 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 3 Oct 2024 16:23:29 -0700 Subject: [PATCH 29/31] remove tracing from otel dev dep --- opentelemetry/Cargo.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/opentelemetry/Cargo.toml b/opentelemetry/Cargo.toml index 8805905e3f..c553731715 100644 --- a/opentelemetry/Cargo.toml +++ b/opentelemetry/Cargo.toml @@ -43,7 +43,6 @@ otel_unstable = [] opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["logs_level_enabled"]} # for documentation tests criterion = { workspace = true } rand = { workspace = true } -tracing = { version = "0.1"} [[bench]] name = "metrics" From adc3fd26093cddc3ca59300a6e6e60d5cf462973 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 3 Oct 2024 16:26:28 -0700 Subject: [PATCH 30/31] remove debug --- opentelemetry-otlp/src/metric.rs | 22 +--------------------- 1 file changed, 1 insertion(+), 21 deletions(-) diff --git a/opentelemetry-otlp/src/metric.rs b/opentelemetry-otlp/src/metric.rs index 375384278e..83474e94ff 100644 --- a/opentelemetry-otlp/src/metric.rs +++ b/opentelemetry-otlp/src/metric.rs @@ -7,7 +7,6 @@ use crate::{NoExporterConfig, OtlpPipeline}; use async_trait::async_trait; use core::fmt; use opentelemetry::metrics::Result; -use opentelemetry::otel_debug; #[cfg(feature = "grpc-tonic")] use crate::exporter::tonic::TonicExporterBuilder; @@ -295,26 +294,7 @@ impl TemporalitySelector for MetricsExporter { #[async_trait] impl PushMetricsExporter for MetricsExporter { async fn export(&self, metrics: &mut ResourceMetrics) -> Result<()> { - otel_debug!( - name: "export_metrics", - metrics_count = metrics - .scope_metrics - .iter() - .map(|scope| scope.metrics.len()) - .sum::(), - status = "started" - ); - #[allow(clippy::let_and_return)] // for scenario where internal logs is disabled - let result = self.client.export(metrics).await; - otel_debug!( - name: "export_metrics", - status = if result.is_ok() { - "completed" - } else { - "failed" - } - ); - result + self.client.export(metrics).await } async fn force_flush(&self) -> Result<()> { From 3c4d20cca8c8d7ea56ea758cd4e0de0742d0b04c Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 3 Oct 2024 16:53:37 -0700 Subject: [PATCH 31/31] Update opentelemetry-sdk/src/metrics/internal/mod.rs Co-authored-by: Utkarsh Umesan Pillai <66651184+utpilla@users.noreply.github.com> --- opentelemetry-sdk/src/metrics/internal/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/opentelemetry-sdk/src/metrics/internal/mod.rs b/opentelemetry-sdk/src/metrics/internal/mod.rs index a3a324a15b..7a79fe4653 100644 --- a/opentelemetry-sdk/src/metrics/internal/mod.rs +++ b/opentelemetry-sdk/src/metrics/internal/mod.rs @@ -148,7 +148,7 @@ impl, T: Number, O: Operation> ValueMap { trackers.insert(STREAM_OVERFLOW_ATTRIBUTES.clone(), Arc::new(new_tracker)); global::handle_error(MetricsError::Other("Warning: Maximum data points for metric stream exceeded. Entry added to overflow. Subsequent overflows to same metric until next collect will not be logged.".into())); otel_warn!( name: "ValueMap.measure", - message = "Warning: Maximum data points for metric stream exceeded. Entry added to overflow. Subsequent overflows to same metric until next collect will not be logged." + message = "Maximum data points for metric stream exceeded. Entry added to overflow. Subsequent overflows to same metric until next collect will not be logged." ); } }