Fix lint

Author: andborja

opentelemetry-declarative-config/src/lib.rs

@@ -2,91 +2,102 @@
 //!
 //! This crate provides a declarative way to configure OpenTelemetry SDKs using YAML files.
 
-pub mod telemetry_config;
-pub mod metrics;
 pub mod logs;
+pub mod metrics;
+pub mod telemetry_config;
 
 use opentelemetry::global;
-use opentelemetry_sdk::{error::OTelSdkResult, logs::SdkLoggerProvider, metrics::SdkMeterProvider, trace::SdkTracerProvider};
+use opentelemetry_sdk::{
+    error::OTelSdkResult, logs::SdkLoggerProvider, metrics::SdkMeterProvider,
+    trace::SdkTracerProvider,
+};
 
 use crate::{
-    logs::{
-        BatchExporterFactory,
-        LogsConfig,
-        LogsBatchExporterFactory,
-    },
+    logs::{BatchExporterFactory, LogsBatchExporterFactory, LogsConfig},
     metrics::{
-        MetricsConfig,
-        MetricsPeriodicExporterFactory,
-        MetricsPullExporterFactory,
-        PeriodicExporterFactory,
-        PullExporterFactory,
+        MetricsConfig, MetricsPeriodicExporterFactory, MetricsPullExporterFactory,
+        PeriodicExporterFactory, PullExporterFactory,
     },
     telemetry_config::TelemetryConfig,
 };
 
-pub struct Configurator {
-}
+pub struct Configurator {}
 
 impl Configurator {
     pub fn new() -> Self {
-        Self {
-        }
+        Self {}
     }
 
-    pub fn configure_telemetry_from_yaml(&self, telemetry_config_str: String) -> Result<TelemetryProviders, Box<dyn std::error::Error>> {
+    pub fn configure_telemetry_from_yaml(
+        &self,
+        telemetry_config_str: String,
+    ) -> Result<TelemetryProviders, Box<dyn std::error::Error>> {
         let config = TelemetryConfig::from_yaml(&telemetry_config_str)?;
         self.configure_telemetry(config)
     }
 
-    pub fn configure_telemetry_from_yaml_file(&self, file_path: &str) -> Result<TelemetryProviders, Box<dyn std::error::Error>> {
+    pub fn configure_telemetry_from_yaml_file(
+        &self,
+        file_path: &str,
+    ) -> Result<TelemetryProviders, Box<dyn std::error::Error>> {
         let config = TelemetryConfig::from_yaml_file(file_path)?;
         self.configure_telemetry(config)
     }
 
-    pub fn configure_telemetry(&self, telemetry_config: TelemetryConfig) -> Result<TelemetryProviders, Box<dyn std::error::Error>> {
-
+    pub fn configure_telemetry(
+        &self,
+        telemetry_config: TelemetryConfig,
+    ) -> Result<TelemetryProviders, Box<dyn std::error::Error>> {
         let mut configured_telemetry_providers = TelemetryProviders::new();
 
         let resource = Self::as_resource(telemetry_config.resource);
         if let Some(metrics_config) = telemetry_config.metrics {
-            let sdk_meter_provider_option = self.build_metrics_sdk_provider(metrics_config, resource.clone())?;
-            configured_telemetry_providers = configured_telemetry_providers
-                .with_meter_provider(sdk_meter_provider_option);
+            let sdk_meter_provider_option =
+                self.build_metrics_sdk_provider(metrics_config, resource.clone())?;
+            configured_telemetry_providers =
+                configured_telemetry_providers.with_meter_provider(sdk_meter_provider_option);
         }
 
         if let Some(logs_config) = telemetry_config.logs {
-            let sdk_logger_provider_option = self.build_logs_sdk_provider(logs_config, resource.clone())?;
-            configured_telemetry_providers = configured_telemetry_providers
-                .with_logs_provider(sdk_logger_provider_option);
+            let sdk_logger_provider_option =
+                self.build_logs_sdk_provider(logs_config, resource.clone())?;
+            configured_telemetry_providers =
+                configured_telemetry_providers.with_logs_provider(sdk_logger_provider_option);
         }
 
         //TODO: Add similar configuration for traces when implemented
         Ok(configured_telemetry_providers)
     }
 
-    fn build_metrics_sdk_provider(&self, metrics_config: MetricsConfig, resource: opentelemetry_sdk::Resource) -> Result<SdkMeterProvider, Box<dyn std::error::Error>> {
-
-        let mut provider_builder = SdkMeterProvider::builder()
-            .with_resource(resource);
+    fn build_metrics_sdk_provider(
+        &self,
+        metrics_config: MetricsConfig,
+        resource: opentelemetry_sdk::Resource,
+    ) -> Result<SdkMeterProvider, Box<dyn std::error::Error>> {
+        let mut provider_builder = SdkMeterProvider::builder().with_resource(resource);
 
         for reader_config in metrics_config.readers {
             if let Some(periodic_reader) = reader_config.periodic {
                 let periodic_exporter_config = periodic_reader.exporter;
                 if let Some(periodic_exporter_mapping) = periodic_exporter_config.as_mapping() {
                     for (key, value) in periodic_exporter_mapping {
                         if let Some(periodic_exporter_factory_name) = key.as_str() {
-                            let exporter_factory = PeriodicExporterFactory::from_name(periodic_exporter_factory_name)?;
+                            let exporter_factory =
+                                PeriodicExporterFactory::from_name(periodic_exporter_factory_name)?;
                             let config = value;
                             match exporter_factory {
                                 PeriodicExporterFactory::Stdout(factory) => {
-                                    let periodic_exporter = factory.create_metrics_periodic_exporter(config)?;
-                                    provider_builder = provider_builder.with_periodic_exporter(periodic_exporter);
-                                },
+                                    let periodic_exporter =
+                                        factory.create_metrics_periodic_exporter(config)?;
+                                    provider_builder =
+                                        provider_builder.with_periodic_exporter(periodic_exporter);
+                                }
                                 PeriodicExporterFactory::Otlp(factory) => {
-                                    let periodic_exporter = factory.create_metrics_periodic_exporter(config)?;
-                                    provider_builder = provider_builder.with_periodic_exporter(periodic_exporter);
-                                },
+                                    let periodic_exporter =
+                                        factory.create_metrics_periodic_exporter(config)?;
+                                    provider_builder =
+                                        provider_builder.with_periodic_exporter(periodic_exporter);
+                                }
                             }
                         } else {
                             return Err("Invalid periodic exporter factory configuration".into());
@@ -101,13 +112,15 @@ impl Configurator {
                 if let Some(pull_exporter_mapping) = pull_exporter_config.as_mapping() {
                     for (key, value) in pull_exporter_mapping {
                         if let Some(pull_exporter_factory_name) = key.as_str() {
-                            let exporter_factory = PullExporterFactory::from_name(pull_exporter_factory_name)?;
+                            let exporter_factory =
+                                PullExporterFactory::from_name(pull_exporter_factory_name)?;
                             let config = value;
                             match exporter_factory {
                                 PullExporterFactory::Prometheus(factory) => {
-                                    let pull_exporter = factory.create_metrics_pull_exporter(config)?;
+                                    let pull_exporter =
+                                        factory.create_metrics_pull_exporter(config)?;
                                     provider_builder = provider_builder.with_reader(pull_exporter);
-                                },
+                                }
                             }
                         } else {
                             return Err("Invalid pull exporter factory configuration".into());
@@ -124,28 +137,35 @@ impl Configurator {
         Ok(provider)
     }
 
-    fn build_logs_sdk_provider(&self, logs_config: LogsConfig, resource: opentelemetry_sdk::Resource) -> Result<SdkLoggerProvider, Box<dyn std::error::Error>> {
-
-        let mut provider_builder = SdkLoggerProvider::builder()
-            .with_resource(resource);
+    fn build_logs_sdk_provider(
+        &self,
+        logs_config: LogsConfig,
+        resource: opentelemetry_sdk::Resource,
+    ) -> Result<SdkLoggerProvider, Box<dyn std::error::Error>> {
+        let mut provider_builder = SdkLoggerProvider::builder().with_resource(resource);
 
         for processor_config in logs_config.processors {
             if let Some(batch_processor) = processor_config.batch {
                 let batch_exporter_config = batch_processor.exporter;
                 if let Some(batch_exporter_mapping) = batch_exporter_config.as_mapping() {
                     for (key, value) in batch_exporter_mapping {
                         if let Some(batch_exporter_factory_name) = key.as_str() {
-                            let exporter_factory = BatchExporterFactory::from_name(batch_exporter_factory_name)?;
+                            let exporter_factory =
+                                BatchExporterFactory::from_name(batch_exporter_factory_name)?;
                             let config = value;
                             match exporter_factory {
                                 BatchExporterFactory::Stdout(factory) => {
-                                    let batch_exporter = factory.create_logs_batch_exporter(config)?;
-                                    provider_builder = provider_builder.with_batch_exporter(batch_exporter);
-                                },
+                                    let batch_exporter =
+                                        factory.create_logs_batch_exporter(config)?;
+                                    provider_builder =
+                                        provider_builder.with_batch_exporter(batch_exporter);
+                                }
                                 BatchExporterFactory::Otlp(factory) => {
-                                    let batch_exporter = factory.create_logs_batch_exporter(config)?;
-                                    provider_builder = provider_builder.with_batch_exporter(batch_exporter);
-                                },
+                                    let batch_exporter =
+                                        factory.create_logs_batch_exporter(config)?;
+                                    provider_builder =
+                                        provider_builder.with_batch_exporter(batch_exporter);
+                                }
                             }
                         } else {
                             return Err("Invalid batch exporter factory configuration".into());
@@ -161,10 +181,13 @@ impl Configurator {
         Ok(provider)
     }
 
-    fn as_resource(resource_attributes: std::collections::HashMap<String, String>) -> opentelemetry_sdk::Resource {
+    fn as_resource(
+        resource_attributes: std::collections::HashMap<String, String>,
+    ) -> opentelemetry_sdk::Resource {
         let mut resource_builder = opentelemetry_sdk::Resource::builder();
         for (key, value) in resource_attributes {
-            resource_builder = resource_builder.with_attribute(opentelemetry::KeyValue::new(key, value));
+            resource_builder =
+                resource_builder.with_attribute(opentelemetry::KeyValue::new(key, value));
         }
         resource_builder.build()
     }

opentelemetry-declarative-config/src/logs.rs

@@ -3,14 +3,20 @@
 //! This module defines the configuration structures for Logs telemetry
 //! used in OpenTelemetry SDKs.
 
-pub mod processor_config;
 pub mod exporters;
+pub mod processor_config;
 
 use opentelemetry_sdk::logs::LogExporter;
 use serde::Deserialize;
 use serde_yaml::Value;
 
-use crate::logs::{exporters::{otlp_batch_exporter::OtlpLogsBatchExporterFactory, stdout_batch_exporter::StdoutLogsBatchExporterFactory}, processor_config::ProcessorConfig};
+use crate::logs::{
+    exporters::{
+        otlp_batch_exporter::OtlpLogsBatchExporterFactory,
+        stdout_batch_exporter::StdoutLogsBatchExporterFactory,
+    },
+    processor_config::ProcessorConfig,
+};
 
 /// Configuration for Logs telemetry
 #[derive(Deserialize)]
@@ -20,9 +26,11 @@ pub struct LogsConfig {
 
 /// Factory trait implemented by the different logs exporters
 pub trait LogsBatchExporterFactory {
-
     /// Creates a LogsExporter 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>>;
 }
 
 /// Enum representing different Batch Exporter Factories

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

@@ -3,6 +3,6 @@
 //! This module contains the definitions and common implementations for various logs exporters
 //! that can be used with OpenTelemetry SDKs. Exporters are responsible for sending
 //! collected logs data to different backends or systems.
- 
-pub mod stdout_batch_exporter;
+
 pub mod otlp_batch_exporter;
+pub mod stdout_batch_exporter;

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

@@ -11,8 +11,7 @@ use serde_yaml::Value;
 use crate::logs::LogsBatchExporterFactory;
 
 /// Factory for creating OTLP Logs Batch Exporters
-pub struct OtlpLogsBatchExporterFactory {
-}
+pub struct OtlpLogsBatchExporterFactory {}
 
 impl OtlpLogsBatchExporterFactory {
     /// Creates a new OtlpLogsBatchExporterFactory
@@ -28,9 +27,11 @@ 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")]
@@ -48,9 +49,8 @@ impl LogsBatchExporterFactory for OtlpLogsBatchExporterFactory {
         */
 
         // 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()?;
+
+        let exporter = exporter_builder.build()?;
 
         Ok(exporter)
     }
@@ -67,7 +67,9 @@ pub struct OtlpConfig {
     pub endpoint: Option<String>,
 }
 
-fn deserialize_protocol<'de, D>(deserializer: D) -> Result<Option<opentelemetry_otlp::Protocol>, D::Error>
+fn deserialize_protocol<'de, D>(
+    deserializer: D,
+) -> Result<Option<opentelemetry_otlp::Protocol>, D::Error>
 where
     D: Deserializer<'de>,
 {
@@ -114,20 +116,24 @@ mod tests {
             protocol: "http/protobuf"
         "#;
         let config: OtlpConfig = from_str(yaml_http_binary).unwrap();
-        assert_eq!(config.protocol, Some(opentelemetry_otlp::Protocol::HttpBinary));
+        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));
+        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

@@ -10,8 +10,7 @@ use serde_yaml::Value;
 use crate::logs::LogsBatchExporterFactory;
 
 /// Factory for creating Stdout Logs Batch Exporters
-pub struct StdoutLogsBatchExporterFactory {
-}
+pub struct StdoutLogsBatchExporterFactory {}
 
 impl StdoutLogsBatchExporterFactory {
     /// Creates a new StdoutLogsBatchExporterFactory
@@ -28,7 +27,10 @@ impl Default for StdoutLogsBatchExporterFactory {
 
 impl LogsBatchExporterFactory for StdoutLogsBatchExporterFactory {
     /// 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 = opentelemetry_stdout::LogExporter::default();
         Ok(exporter)
     }