feat: Add structured internal logging for debugging for Geneva-uploader (#472)

L

Author: lalitb

opentelemetry-exporter-geneva/geneva-uploader/Cargo.toml

@@ -28,6 +28,7 @@ lz4_flex = { version = "0.11", features = ["safe-encode"], default-features = fa
 # Azure Identity dependencies - using public crates.io versions
 azure_identity = "0.27.0"
 azure_core = "0.27.0"
+tracing = "0.1"
 
 [features]
 self_signed_certs = [] # Empty by default for security

opentelemetry-exporter-geneva/geneva-uploader/src/client.rs

@@ -7,6 +7,7 @@ use crate::payload_encoder::otlp_encoder::OtlpEncoder;
 use opentelemetry_proto::tonic::logs::v1::ResourceLogs;
 use opentelemetry_proto::tonic::trace::v1::ResourceSpans;
 use std::sync::Arc;
+use tracing::{debug, info};
 
 /// Public batch type (already LZ4 chunked compressed).
 /// Produced by `OtlpEncoder::encode_log_batch` and returned to callers.
@@ -44,13 +45,27 @@ pub struct GenevaClient {
 
 impl GenevaClient {
     pub fn new(cfg: GenevaClientConfig) -> Result<Self, String> {
+        info!(
+            name: "client.new",
+            target: "geneva-uploader",
+            endpoint = %cfg.endpoint,
+            namespace = %cfg.namespace,
+            account = %cfg.account,
+            "Initializing GenevaClient"
+        );
+
         // Validate MSI resource presence for managed identity variants
         match cfg.auth_method {
             AuthMethod::SystemManagedIdentity
             | AuthMethod::UserManagedIdentity { .. }
             | AuthMethod::UserManagedIdentityByObjectId { .. }
             | AuthMethod::UserManagedIdentityByResourceId { .. } => {
                 if cfg.msi_resource.is_none() {
+                    debug!(
+                        name: "client.new.validate_msi_resource",
+                        target: "geneva-uploader",
+                        "Validation failed: msi_resource must be provided for managed identity auth"
+                    );
                     return Err(
                         "msi_resource must be provided for managed identity auth".to_string()
                     );
@@ -71,10 +86,16 @@ impl GenevaClient {
             auth_method: cfg.auth_method,
             msi_resource: cfg.msi_resource,
         };
-        let config_client = Arc::new(
-            GenevaConfigClient::new(config_client_config)
-                .map_err(|e| format!("GenevaConfigClient init failed: {e}"))?,
-        );
+        let config_client =
+            Arc::new(GenevaConfigClient::new(config_client_config).map_err(|e| {
+                debug!(
+                    name: "client.new.config_client_init",
+                    target: "geneva-uploader",
+                    error = %e,
+                    "GenevaConfigClient init failed"
+                );
+                format!("GenevaConfigClient init failed: {e}")
+            })?);
 
         let source_identity = format!(
             "Tenant={}/Role={}/RoleInstance={}",
@@ -95,8 +116,22 @@ impl GenevaClient {
             config_version: config_version.clone(),
         };
 
-        let uploader = GenevaUploader::from_config_client(config_client, uploader_config)
-            .map_err(|e| format!("GenevaUploader init failed: {e}"))?;
+        let uploader =
+            GenevaUploader::from_config_client(config_client, uploader_config).map_err(|e| {
+                debug!(
+                    name: "client.new.uploader_init",
+                    target: "geneva-uploader",
+                    error = %e,
+                    "GenevaUploader init failed"
+                );
+                format!("GenevaUploader init failed: {e}")
+            })?;
+
+        info!(
+            name: "client.new.complete",
+            target: "geneva-uploader",
+            "GenevaClient initialized successfully"
+        );
 
         Ok(Self {
             uploader: Arc::new(uploader),
@@ -110,38 +145,92 @@ impl GenevaClient {
         &self,
         logs: &[ResourceLogs],
     ) -> Result<Vec<EncodedBatch>, String> {
+        debug!(
+            name: "client.encode_and_compress_logs",
+            target: "geneva-uploader",
+            resource_logs_count = logs.len(),
+            "Encoding and compressing resource logs"
+        );
+
         let log_iter = logs
             .iter()
             .flat_map(|resource_log| resource_log.scope_logs.iter())
             .flat_map(|scope_log| scope_log.log_records.iter());
 
         self.encoder
             .encode_log_batch(log_iter, &self.metadata)
-            .map_err(|e| format!("Compression failed: {e}"))
+            .map_err(|e| {
+                debug!(
+                    name: "client.encode_and_compress_logs.error",
+                    target: "geneva-uploader",
+                    error = %e,
+                    "Log compression failed"
+                );
+                format!("Compression failed: {e}")
+            })
     }
 
     /// Encode OTLP spans into LZ4 chunked compressed batches.
     pub fn encode_and_compress_spans(
         &self,
         spans: &[ResourceSpans],
     ) -> Result<Vec<EncodedBatch>, String> {
+        debug!(
+            name: "client.encode_and_compress_spans",
+            target: "geneva-uploader",
+            resource_spans_count = spans.len(),
+            "Encoding and compressing resource spans"
+        );
+
         let span_iter = spans
             .iter()
             .flat_map(|resource_span| resource_span.scope_spans.iter())
             .flat_map(|scope_span| scope_span.spans.iter());
 
         self.encoder
             .encode_span_batch(span_iter, &self.metadata)
-            .map_err(|e| format!("Compression failed: {e}"))
+            .map_err(|e| {
+                debug!(
+                    name: "client.encode_and_compress_spans.error",
+                    target: "geneva-uploader",
+                    error = %e,
+                    "Span compression failed"
+                );
+                format!("Compression failed: {e}")
+            })
     }
 
     /// Upload a single compressed batch.
     /// This allows for granular control over uploads, including custom retry logic for individual batches.
     pub async fn upload_batch(&self, batch: &EncodedBatch) -> Result<(), String> {
+        debug!(
+            name: "client.upload_batch",
+            target: "geneva-uploader",
+            event_name = %batch.event_name,
+            size = batch.data.len(),
+            "Uploading batch"
+        );
+
         self.uploader
             .upload(batch.data.clone(), &batch.event_name, &batch.metadata)
             .await
-            .map(|_| ())
-            .map_err(|e| format!("Geneva upload failed: {e} Event: {}", batch.event_name))
+            .map(|_| {
+                debug!(
+                    name: "client.upload_batch.success",
+                    target: "geneva-uploader",
+                    event_name = %batch.event_name,
+                    "Successfully uploaded batch"
+                );
+            })
+            .map_err(|e| {
+                debug!(
+                    name: "client.upload_batch.error",
+                    target: "geneva-uploader",
+                    event_name = %batch.event_name,
+                    error = %e,
+                    "Geneva upload failed"
+                );
+                format!("Geneva upload failed: {e} Event: {}", batch.event_name)
+            })
     }
 }