otel-rs 0.1.0

Modern OpenTelemetry observability helpers for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! Standard OTel environment variable parsing.
//!
//! Reads the following variables (all optional, builder values take
//! precedence):
//!
//! | Variable | Maps to |
//! |---|---|
//! | `OTEL_SERVICE_NAME` | service name |
//! | `OTEL_EXPORTER_OTLP_ENDPOINT` | collector endpoint |
//! | `OTEL_EXPORTER_OTLP_PROTOCOL` | `grpc` or `http/protobuf` |
//! | `OTEL_EXPORTER_OTLP_HEADERS` | comma-separated `key=value` pairs |
//! | `OTEL_EXPORTER_OTLP_TIMEOUT` | export timeout in milliseconds |
//! | `OTEL_TRACES_SAMPLER` | sampling strategy name |
//! | `OTEL_TRACES_SAMPLER_ARG` | sampler argument (e.g., ratio) |

use std::{collections::HashMap, time::Duration};

use crate::config::{OtlpProtocol, SamplingStrategy};

/// Parsed OTel environment variables (all optional).
#[derive(Debug, Default)]
pub(crate) struct EnvConfig {
    pub service_name: Option<String>,
    pub endpoint: Option<String>,
    pub protocol: Option<OtlpProtocol>,
    pub headers: Option<HashMap<String, String>>,
    pub timeout: Option<Duration>,
    pub sampler: Option<SamplingStrategy>,
}

/// Read standard OTel environment variables.
pub(crate) fn read_env() -> EnvConfig {
    EnvConfig {
        service_name: std::env::var("OTEL_SERVICE_NAME").ok(),
        endpoint: std::env::var("OTEL_EXPORTER_OTLP_ENDPOINT").ok(),
        protocol: std::env::var("OTEL_EXPORTER_OTLP_PROTOCOL")
            .ok()
            .and_then(|s| s.parse().ok()),
        headers: parse_headers(),
        timeout: std::env::var("OTEL_EXPORTER_OTLP_TIMEOUT")
            .ok()
            .and_then(|s| s.parse::<u64>().ok())
            .map(Duration::from_millis),
        sampler: parse_sampler(),
    }
}

/// Parse `OTEL_EXPORTER_OTLP_HEADERS` as comma-separated `key=value` pairs.
fn parse_headers() -> Option<HashMap<String, String>> {
    let raw = std::env::var("OTEL_EXPORTER_OTLP_HEADERS").ok()?;
    let mut headers = HashMap::new();
    for pair in raw.split(',') {
        if let Some((k, v)) = pair.split_once('=') {
            headers.insert(k.trim().to_string(), v.trim().to_string());
        }
    }
    if headers.is_empty() {
        None
    } else {
        Some(headers)
    }
}

/// Parse `OTEL_TRACES_SAMPLER` and `OTEL_TRACES_SAMPLER_ARG`.
fn parse_sampler() -> Option<SamplingStrategy> {
    let sampler = std::env::var("OTEL_TRACES_SAMPLER").ok()?;
    match sampler.to_lowercase().as_str() {
        "always_on" => Some(SamplingStrategy::AlwaysOn),
        "always_off" => Some(SamplingStrategy::AlwaysOff),
        "traceidratio" => {
            let ratio = std::env::var("OTEL_TRACES_SAMPLER_ARG")
                .ok()
                .and_then(|s| s.parse::<f64>().ok())
                .unwrap_or(1.0);
            Some(SamplingStrategy::TraceIdRatio(ratio))
        }
        "parentbased_always_on" | "parentbased" => Some(SamplingStrategy::ParentBased),
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn read_env_without_vars() {
        // In test environment, OTEL_* vars are typically unset.
        let env = read_env();
        // If they happen to be set in CI, just verify the struct is valid.
        let _ = env;
    }

    #[test]
    fn parse_headers_when_unset() {
        // OTEL_EXPORTER_OTLP_HEADERS is not set → None.
        // (This test only works if the var is genuinely unset.)
        if std::env::var("OTEL_EXPORTER_OTLP_HEADERS").is_err() {
            assert!(parse_headers().is_none());
        }
    }
}