Minor additions to internal logs

Author: cijothomas

examples/self-diagnostics/src/main.rs

@@ -26,7 +26,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     // OpenTelemetry uses `tracing` crate for its internal logging. Unless a
     // tracing subscriber is set, the logs will be discarded. In this example,
     // we configure a `tracing` subscriber to:
-    // 1. Print logs of level INFO or higher to stdout.
+    // 1. Print logs of level INFO or higher to stdout using tracing's fmt layer.
     // 2. Filter logs from OpenTelemetry's dependencies (like tonic, hyper,
     // reqwest etc. which are commonly used by the OTLP exporter) to only print
     // ERROR-level logs. This filtering helps reduce repetitive log messages
@@ -35,7 +35,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     // https://github.com/open-telemetry/opentelemetry-rust/issues/761 is
     // resolved.
 
-    // Target name used by OpenTelemetry always start with "opentelemetry".
+    // Target names used by all OpenTelemetry official crates always start with "opentelemetry".
     // Hence, one may use "add_directive("opentelemetry=off".parse().unwrap())"
     // to turn off all logs from OpenTelemetry.
 

opentelemetry-sdk/src/logs/log_emitter.rs

@@ -1,6 +1,7 @@
 use super::{BatchLogProcessor, LogProcessor, LogRecord, SimpleLogProcessor, TraceContext};
 use crate::{export::logs::LogExporter, runtime::RuntimeChannel, Resource};
 use crate::{logs::LogError, logs::LogResult};
+use opentelemetry::otel_info;
 use opentelemetry::{otel_debug, trace::TraceContextExt, Context, InstrumentationScope};
 
 #[cfg(feature = "spec_unstable_logs_enabled")]
@@ -154,10 +155,15 @@ impl LoggerProviderInner {
 impl Drop for LoggerProviderInner {
     fn drop(&mut self) {
         if !self.is_shutdown.load(Ordering::Relaxed) {
+            otel_info!(
+                name: "LoggerProvider.Drop",
+                message = "Last reference of LoggerProvider dropped, initiating shutdown."
+            );
             let _ = self.shutdown(); // errors are handled within shutdown
         } else {
             otel_debug!(
-                name: "LoggerProvider.Drop.AlreadyShutdown"
+                name: "LoggerProvider.Drop.AlreadyShutdown",
+                message = "LoggerProvider was already shut down; drop will not attempt shutdown again."
             );
         }
     }

opentelemetry-sdk/src/metrics/meter_provider.rs

@@ -9,7 +9,7 @@ use std::{
 
 use opentelemetry::{
     metrics::{Meter, MeterProvider},
-    otel_debug, otel_error, InstrumentationScope,
+    otel_debug, otel_error, otel_info, InstrumentationScope,
 };
 
 use crate::metrics::{MetricError, MetricResult};
@@ -109,6 +109,10 @@ impl SdkMeterProvider {
     /// There is no guaranteed that all telemetry be flushed or all resources have
     /// been released on error.
     pub fn shutdown(&self) -> MetricResult<()> {
+        otel_info!(
+            name: "MeterProvider.Shutdown",
+            message = "User initiated shutdown of MeterProvider."
+        );
         self.inner.shutdown()
     }
 }
@@ -139,15 +143,25 @@ impl Drop for SdkMeterProviderInner {
         // shutdown(), then we don't need to call shutdown again.
         if self.is_shutdown.load(Ordering::Relaxed) {
             otel_debug!(
-                name: "MeterProvider.AlreadyShutdown",
-                message = "Meter provider was already shut down; drop will not attempt shutdown again."
+                name: "MeterProvider.Drop.AlreadyShutdown",
+                message = "MeterProvider was already shut down; drop will not attempt shutdown again."
             );
-        } else if let Err(err) = self.shutdown() {
-            otel_error!(
-                name: "MeterProvider.ShutdownFailed",
-                message = "Shutdown attempt failed during drop of MeterProvider.",
-                reason = format!("{}", err)
+        } else {
+            otel_info!(
+                name: "MeterProvider.Drop",
+                message = "Last reference of MeterProvider dropped, initiating shutdown."
             );
+            if let Err(err) = self.shutdown() {
+                otel_error!(
+                    name: "MeterProvider.Drop.ShutdownFailed",
+                    message = "Shutdown attempt failed during drop of MeterProvider.",
+                    reason = format!("{}", err)
+                );
+            } else {
+                otel_info!(
+                    name: "MeterProvider.Drop.ShutdownCompleted",
+                );
+            }
         }
     }
 }
@@ -231,7 +245,7 @@ impl MeterProviderBuilder {
     /// Construct a new [MeterProvider] with this configuration.
 
     pub fn build(self) -> SdkMeterProvider {
-        SdkMeterProvider {
+        let meter_provider = SdkMeterProvider {
             inner: Arc::new(SdkMeterProviderInner {
                 pipes: Arc::new(Pipelines::new(
                     self.resource.unwrap_or_default(),
@@ -241,7 +255,12 @@ impl MeterProviderBuilder {
                 meters: Default::default(),
                 is_shutdown: AtomicBool::new(false),
             }),
-        }
+        };
+
+        otel_info!(
+            name: "MeterProvider.Built",
+        );
+        meter_provider
     }
 }
 

opentelemetry-sdk/src/metrics/periodic_reader.rs

@@ -11,7 +11,7 @@ use futures_util::{
     stream::{self, FusedStream},
     StreamExt,
 };
-use opentelemetry::{otel_debug, otel_error};
+use opentelemetry::{otel_debug, otel_error, otel_info};
 
 use crate::runtime::Runtime;
 use crate::{
@@ -234,10 +234,18 @@ impl<RT: Runtime> PeriodicReaderWorker<RT> {
     async fn collect_and_export(&mut self) -> MetricResult<()> {
         self.reader.collect(&mut self.rm)?;
         if self.rm.scope_metrics.is_empty() {
+            otel_debug!(
+                name: "PeriodicReaderWorker.NoMetricsToExport",
+            );
             // No metrics to export.
             return Ok(());
         }
 
+        otel_debug!(
+            name: "PeriodicReaderWorker.InvokeExporter",
+            message = "Calling exporter's export method with collected metrics.",
+            count = self.rm.scope_metrics.len(),
+        );
         let export = self.reader.exporter.export(&mut self.rm);
         let timeout = self.runtime.delay(self.timeout);
         pin_mut!(export);