Add more unit tests and improve documentation

Author: andborja

opentelemetry-declarative-config/Cargo.toml

@@ -25,7 +25,6 @@ opentelemetry-stdout = { version = "0.31.0" }
 opentelemetry-otlp = { version = "0.31.0" }
 serde = { workspace = true, features = ["derive"] }
 serde_yaml = "0.9.34"
-tokio = { workspace = true, features = ["sync", "rt"], optional = true }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

opentelemetry-declarative-config/README.md

@@ -23,6 +23,7 @@ of telemetry is intentionally left to other tools.
 
 [`Prometheus`]: https://prometheus.io
 [`OpenTelemetry`]: https://crates.io/crates/opentelemetry
+[`Jaeger`]: https://www.jaegertracing.io
 
 ## Release Notes
 

opentelemetry-declarative-config/examples/declarative_basic.rs

@@ -29,7 +29,7 @@ pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
     "#;
     let result = configurator.configure_telemetry_from_yaml(config_yaml.into());
     if let Err(ref e) = result {
-        panic!("Failed to configure telemetry from YAML file: {}", e);
+        panic!("Failed to configure telemetry from YAML string: {}", e);
     }
     assert!(result.is_ok());
     let telemetry_providers = result.unwrap();

opentelemetry-declarative-config/src/lib.rs

@@ -62,7 +62,7 @@ impl Configurator {
                 .with_logs_provider(sdk_logger_provider_option);
         }
 
-        //TODO: Add similar configuration for traces and logs when implemented
+        //TODO: Add similar configuration for traces when implemented
         Ok(configured_telemetry_providers)
     }
 

opentelemetry-declarative-config/src/logs.rs

@@ -44,9 +44,25 @@ impl BatchExporterFactory {
     // Get factory by name (useful for configuration-driven creation)
     pub fn from_name(name: &str) -> Result<Self, Box<dyn std::error::Error>> {
         match name {
-            "stdout" => Ok(BatchExporterFactory::Stdout(StdoutLogsBatchExporterFactory::new())),
+            "stdout" => Ok(Self::stdout()),
             "otlp" => Ok(Self::otlp()),
             _ => Err(format!("Unknown logs exporter factory: {}", name).into()),
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_logs_batch_exporter_factory_from_name() {
+        let stdout_factory = BatchExporterFactory::from_name("stdout").unwrap();
+        let otlp_factory = BatchExporterFactory::from_name("otlp").unwrap();
+        let unknown_factory = BatchExporterFactory::from_name("unknown");
+
+        assert!(matches!(stdout_factory, BatchExporterFactory::Stdout(_)));
+        assert!(matches!(otlp_factory, BatchExporterFactory::Otlp(_)));
+        assert!(unknown_factory.is_err());
+    }
+}

opentelemetry-declarative-config/src/logs/exporters/otlp_batch_exporter.rs

@@ -1,8 +1,8 @@
-//! # Stdout log exporter module.
+//! # OTLP log exporter module.
 //!
-//! This module contains the definitions and common implementations for the stdout logs exporter
+//! This module contains the definitions and common implementations for the OTLP logs exporter
 //! that can be used with OpenTelemetry SDKs. Exporters are responsible for sending
-//! collected logs data to different backends or systems.
+//! collected logs data to OTLP-compatible backends or systems.
 
 use opentelemetry_sdk::logs::LogExporter;
 use serde::{Deserialize, Deserializer};
@@ -30,7 +30,7 @@ impl Default for OtlpLogsBatchExporterFactory {
 impl LogsBatchExporterFactory for OtlpLogsBatchExporterFactory {
 
     /// Creates a LogExporter based on the provided configuration
-    fn create_logs_batch_exporter(&self, config: &Value) -> Result<impl LogExporter + 'static, Box<dyn std::error::Error>> {
+    fn create_logs_batch_exporter(&self, _config: &Value) -> Result<impl LogExporter + 'static, Box<dyn std::error::Error>> {
         let exporter_builder = opentelemetry_otlp::LogExporter::builder();
 
         #[cfg(feature = "tonic-client")]
@@ -41,11 +41,13 @@ impl LogsBatchExporterFactory for OtlpLogsBatchExporterFactory {
             feature = "reqwest-client",
             feature = "reqwest-blocking-client"
         ))]
-        let mut exporter_builder = exporter_builder.with_http();
+        let exporter_builder = exporter_builder.with_http();
 
-        let _config_parsed = serde_yaml::from_value::<OtlpConfig>(config.clone())?;
+        /*
+        let config_parsed = serde_yaml::from_value::<OtlpConfig>(config.clone())?;
+        */
 
-        // TODO: Configure the exporter based on config_parsed fields. There are no methods in trhe builder to pass its parameters yet..
+        // TODO: Configure the exporter based on config_parsed fields. There are no methods in the builder to pass its parameters yet..
 
         let exporter = exporter_builder
             .build()?;
@@ -77,3 +79,55 @@ where
         _ => Err(serde::de::Error::custom(format!("Invalid protocol: {}", s))),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_yaml::from_str;
+
+    #[tokio::test]
+    async fn test_default_otlp_logs_batch_exporter_factory() {
+        let factory = OtlpLogsBatchExporterFactory::default();
+        assert!(factory.create_logs_batch_exporter(&Value::Null).is_ok());
+    }
+
+    #[test]
+    fn test_deserialize_otlp_config() {
+        let yaml_data = r#"
+            protocol: "grpc"
+            endpoint: "http://localhost:4317"
+        "#;
+        let config: OtlpConfig = from_str(yaml_data).unwrap();
+        assert_eq!(config.protocol, Some(opentelemetry_otlp::Protocol::Grpc));
+        assert_eq!(config.endpoint, Some("http://localhost:4317".into()));
+    }
+
+    #[test]
+    fn test_deserialize_protocol() {
+        let yaml_grpc = r#"
+            protocol: "grpc"
+        "#;
+        let config: OtlpConfig = from_str(yaml_grpc).unwrap();
+        assert_eq!(config.protocol, Some(opentelemetry_otlp::Protocol::Grpc));
+
+        let yaml_http_binary = r#"
+            protocol: "http/protobuf"
+        "#;
+        let config: OtlpConfig = from_str(yaml_http_binary).unwrap();
+        assert_eq!(config.protocol, Some(opentelemetry_otlp::Protocol::HttpBinary));
+
+        let yaml_http_json = r#"
+            protocol: "http/json"
+        "#;
+        let config: OtlpConfig = from_str(yaml_http_json).unwrap();
+        assert_eq!(config.protocol, Some(opentelemetry_otlp::Protocol::HttpJson));
+
+        let yaml_unknown = r#"
+            protocol: "http/unknown"
+        "#;
+        let config: Result<OtlpConfig, _> = from_str(yaml_unknown);
+        assert!(config.is_err());
+
+    }
+    
+}

opentelemetry-declarative-config/src/logs/exporters/stdout_batch_exporter.rs

@@ -33,3 +33,14 @@ impl LogsBatchExporterFactory for StdoutLogsBatchExporterFactory {
         Ok(exporter)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_default_stdout_logs_batch_exporter_factory() {
+        let factory = StdoutLogsBatchExporterFactory::default();
+        assert!(factory.create_logs_batch_exporter(&Value::Null).is_ok());
+    }
+}

opentelemetry-declarative-config/src/metrics.rs

@@ -79,3 +79,25 @@ impl PullExporterFactory {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_periodic_exporter_factory_from_name() {
+        let stdout_factory = PeriodicExporterFactory::from_name("stdout").unwrap();
+        let otlp_factory = PeriodicExporterFactory::from_name("otlp").unwrap();
+        let unknown_factory = PeriodicExporterFactory::from_name("unknown");
+        assert!(matches!(stdout_factory, PeriodicExporterFactory::Stdout(_)));
+        assert!(matches!(otlp_factory, PeriodicExporterFactory::Otlp(_)));
+        assert!(unknown_factory.is_err());
+    }
+
+    #[test]
+    fn test_pull_exporter_factory_from_name() {
+        let prometheus_factory = PullExporterFactory::from_name("prometheus").unwrap();
+        let unknown_factory = PullExporterFactory::from_name("unknown");
+        assert!(matches!(prometheus_factory, PullExporterFactory::Prometheus(_)));
+        assert!(unknown_factory.is_err());
+    }
+}

opentelemetry-declarative-config/src/metrics/exporters.rs

@@ -25,3 +25,46 @@ where
         None => Ok(None),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(Debug, Deserialize)]
+    struct MockTemporalityHolder {
+        #[serde(default, deserialize_with = "deserialize_temporality")]
+        pub temporality: Option<opentelemetry_sdk::metrics::Temporality>,
+    }
+
+    #[test]
+    fn test_deserialize_cumulative_temporality() {
+        let yaml_cumulative = r#"
+            temporality: cumulative
+        "#;
+        let temporality_holder: MockTemporalityHolder = serde_yaml::from_str(yaml_cumulative).unwrap();
+        assert_eq!(temporality_holder.temporality, Some(opentelemetry_sdk::metrics::Temporality::Cumulative));
+    }
+
+    #[test]
+    fn test_deserialize_delta_temporality() {
+        let yaml_cumulative = r#"
+            temporality: delta
+        "#;
+        let temporality_holder: MockTemporalityHolder = serde_yaml::from_str(yaml_cumulative).unwrap();
+        assert_eq!(temporality_holder.temporality, Some(opentelemetry_sdk::metrics::Temporality::Delta));
+    }
+
+    #[test]
+    fn test_deserialize_unknown_temporality() {
+        let yaml_cumulative = r#"
+            temporality: unknown
+        "#;
+        let temporality_holder_result = serde_yaml::from_str::<MockTemporalityHolder>(yaml_cumulative);
+        if let Err(e) = temporality_holder_result {
+            let err_msg = e.to_string();
+            assert!(err_msg.contains("Invalid temporality"));
+        } else {
+            panic!("Expected error for unknown temporality");
+        }
+    }
+}

opentelemetry-declarative-config/src/metrics/exporters/otlp_periodic_exporter.rs

@@ -97,6 +97,12 @@ where
 mod tests {
     use super::*;
 
+    #[tokio::test]
+    async fn test_default_otlp_metrics_periodic_exporter_factory() {
+        let factory = OtlpMetricsPeriodicExporterFactory::default();
+        assert!(factory.create_metrics_periodic_exporter(&Value::Null).is_ok());
+    }
+
     #[test]
     fn test_deserialize_config_all_fields_in() {
         let yaml_grpc = r#"        
@@ -130,7 +136,7 @@ mod tests {
             unknown: field
         "#;
 
-        let config_result: Result<OtlpConfig, _>  = serde_yaml::from_str(yaml_grpc);
+        let config_result = serde_yaml::from_str::<OtlpConfig>(yaml_grpc);
         assert!(config_result.is_err());
         if let Err(e) = config_result {
             let err_msg = e.to_string();