apollo-opentelemetry 0.8.0

//! Top-level OpenTelemetry configuration.

mod attribute_limits;
pub(crate) mod exporters;
pub(crate) mod logs;
pub(crate) mod metrics;
pub(crate) mod processor;
pub(crate) mod propagator;
mod resource;
pub(crate) mod traces;

pub(crate) use processor::BatchProcessorConfig;
pub(crate) use processor::RateLimitedProcessorConfig;

use attribute_limits::AttributeLimitsConfig;
pub(crate) use exporters::LogExporter;
pub(crate) use exporters::MetricExporter;
pub(crate) use exporters::SpanExporter;
pub(crate) use logs::LogRecordProcessor;
use logs::LoggerProviderConfig;
use metrics::MeterProviderConfig;
pub(crate) use metrics::MetricReader;
use propagator::PropagatorConfig;
use resource::ResourceConfig;
pub(crate) use traces::SpanProcessor;
use traces::TracerProviderConfig;

use apollo_configuration::configuration;

/// Top-level OpenTelemetry configuration.
///
/// This structure follows the OTel declarative configuration standard with
/// first-class enum variants for exporters.
#[configuration]
pub struct OpenTelemetryConfig {
    /// Schema version (e.g., "1.0-rc.1").
    pub(crate) file_format: Option<String>,

    /// When true, the SDK is disabled.
    pub(crate) disabled: Option<bool>,

    /// Internal SDK logger severity threshold.
    pub(crate) log_level: Option<LogLevel>,

    /// Global attribute constraints.
    pub(crate) attribute_limits: AttributeLimitsConfig,

    /// Service identity attributes.
    pub(crate) resource: ResourceConfig,

    /// Context propagation configuration.
    pub(crate) propagator: PropagatorConfig,

    /// Span collection and export.
    pub(crate) tracer_provider: TracerProviderConfig,

    /// Metric collection and export.
    pub(crate) meter_provider: MeterProviderConfig,

    /// Log collection and export.
    pub(crate) logger_provider: LoggerProviderConfig,
}

/// Log level for SDK internal logging.
#[configuration]
#[derive(Copy, PartialEq, Eq)]
pub(crate) enum LogLevel {
    Trace,
    Debug,
    Info,
    Warn,
    Error,
}

#[cfg(test)]
mod tests {
    use apollo_configuration::parse_yaml;

    use super::*;

    #[test]
    fn parse_minimal_config() {
        let config: OpenTelemetryConfig = parse_yaml("{}", &Default::default()).unwrap();
        assert!(config.disabled.is_none());
    }

    #[test]
    fn parse_disabled_config() {
        let config: OpenTelemetryConfig = parse_yaml(
            indoc::indoc! {"
                disabled: true
            "},
            &Default::default(),
        )
        .unwrap();
        assert_eq!(config.disabled, Some(true));
    }

    #[test]
    fn parse_full_config() {
        let config: OpenTelemetryConfig = parse_yaml(
            indoc::indoc! {"
                file_format: '1.0-rc.1'
                disabled: false
                log_level: info

                attribute_limits:
                  attribute_count_limit: 128
                  attribute_value_length_limit: 1024

                resource:
                  attributes:
                    - name: service.name
                      value: my-service

                propagator:
                  composite:
                    - tracecontext
                    - baggage

                tracer_provider:
                  processors:
                    - batch:
                        exporter:
                          console: {}
                  sampler: always_on
                  limits:
                    attribute_count_limit: 128

                meter_provider:
                  readers:
                    - periodic:
                        exporter:
                          console: {}

                logger_provider:
                  processors:
                    - batch:
                        exporter:
                          console: {}
            "},
            &Default::default(),
        )
        .unwrap();

        assert_eq!(config.file_format, Some("1.0-rc.1".to_string()));
        assert_eq!(config.disabled, Some(false));
        assert!(config.log_level.is_some());
    }

    #[test]
    fn json_schema() {
        insta::assert_json_snapshot!(apollo_configuration::export_json_schema::<
            OpenTelemetryConfig,
        >());
    }
}