Skip to main content

graphrt_otel/
config.rs

1//! Configuration from the standard `OTEL_*` environment variables.
2
3use crate::otlp::Resource;
4use crate::span::AttrValue;
5
6/// Default OTLP/HTTP endpoint (a local collector).
7pub const DEFAULT_ENDPOINT: &str = "http://localhost:4318";
8
9/// Configuration error.
10#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
11#[non_exhaustive]
12pub enum ConfigError {
13    #[error("invalid {var}: {message}")]
14    Invalid { var: String, message: String },
15}
16
17/// Exporter settings resolved from environment variables.
18#[derive(Clone, Debug, PartialEq)]
19pub struct OtelConfig {
20    /// `OTEL_SDK_DISABLED=true`.
21    pub disabled: bool,
22    /// Whether any OTLP endpoint variable was set explicitly.
23    pub endpoint_configured: bool,
24    /// Full URL for trace export (`.../v1/traces`).
25    pub traces_endpoint: String,
26    /// Full URL for metric export (`.../v1/metrics`).
27    pub metrics_endpoint: String,
28    /// Extra request headers (e.g. vendor API keys). Values are secrets: never logged.
29    pub headers: Vec<(String, String)>,
30    pub resource: Resource,
31    /// Attach truncated node outputs to spans (`GRAPHRT_OTEL_CAPTURE_CONTENT=true`).
32    pub capture_content: bool,
33}
34
35impl Default for OtelConfig {
36    fn default() -> Self {
37        Self {
38            disabled: false,
39            endpoint_configured: false,
40            traces_endpoint: format!("{DEFAULT_ENDPOINT}/v1/traces"),
41            metrics_endpoint: format!("{DEFAULT_ENDPOINT}/v1/metrics"),
42            headers: Vec::new(),
43            resource: Resource::default(),
44            capture_content: false,
45        }
46    }
47}
48
49impl OtelConfig {
50    /// Read the process environment.
51    pub fn from_env() -> Result<Self, ConfigError> {
52        let vars: Vec<(String, String)> = std::env::vars().collect();
53        Self::from_vars(&vars)
54    }
55
56    /// Resolve from explicit variables. Supported: `OTEL_SDK_DISABLED`,
57    /// `OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`,
58    /// `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT`, `OTEL_EXPORTER_OTLP_HEADERS`,
59    /// `OTEL_EXPORTER_OTLP_TRACES_HEADERS`, `OTEL_SERVICE_NAME`,
60    /// `OTEL_RESOURCE_ATTRIBUTES`, and `GRAPHRT_OTEL_CAPTURE_CONTENT`.
61    pub fn from_vars(vars: &[(String, String)]) -> Result<Self, ConfigError> {
62        let get = |k: &str| vars.iter().rev().find(|(n, v)| n == k && !v.trim().is_empty()).map(|(_, v)| v.trim());
63        let mut cfg = Self { disabled: get("OTEL_SDK_DISABLED").is_some_and(is_true), ..Self::default() };
64
65        let base = get("OTEL_EXPORTER_OTLP_ENDPOINT");
66        if let Some(base) = base {
67            let base = base.trim_end_matches('/');
68            cfg.traces_endpoint = format!("{base}/v1/traces");
69            cfg.metrics_endpoint = format!("{base}/v1/metrics");
70            cfg.endpoint_configured = true;
71        }
72        // Signal-specific endpoints are used as-is (the spec appends no path to them).
73        if let Some(url) = get("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT") {
74            cfg.traces_endpoint = url.to_owned();
75            cfg.endpoint_configured = true;
76        }
77        if let Some(url) = get("OTEL_EXPORTER_OTLP_METRICS_ENDPOINT") {
78            cfg.metrics_endpoint = url.to_owned();
79        }
80        for (var, url) in [("traces endpoint", &cfg.traces_endpoint), ("metrics endpoint", &cfg.metrics_endpoint)] {
81            if !(url.starts_with("http://") || url.starts_with("https://")) {
82                return Err(ConfigError::Invalid { var: var.into(), message: "must be an http(s) URL".into() });
83            }
84        }
85
86        if let Some(raw) = get("OTEL_EXPORTER_OTLP_HEADERS") {
87            cfg.headers = parse_pairs("OTEL_EXPORTER_OTLP_HEADERS", raw)?;
88        }
89        if let Some(raw) = get("OTEL_EXPORTER_OTLP_TRACES_HEADERS") {
90            for (k, v) in parse_pairs("OTEL_EXPORTER_OTLP_TRACES_HEADERS", raw)? {
91                cfg.headers.retain(|(name, _)| !name.eq_ignore_ascii_case(&k));
92                cfg.headers.push((k, v));
93            }
94        }
95
96        let mut resource = Resource::default();
97        if let Some(raw) = get("OTEL_RESOURCE_ATTRIBUTES") {
98            for (k, v) in parse_pairs("OTEL_RESOURCE_ATTRIBUTES", raw)? {
99                resource = resource.with(&k, AttrValue::Str(v));
100            }
101        }
102        // OTEL_SERVICE_NAME wins over a service.name in OTEL_RESOURCE_ATTRIBUTES.
103        if let Some(name) = get("OTEL_SERVICE_NAME") {
104            resource = resource.with("service.name", name);
105        }
106        cfg.resource = resource;
107        cfg.capture_content = get("GRAPHRT_OTEL_CAPTURE_CONTENT").is_some_and(is_true);
108        Ok(cfg)
109    }
110}
111
112fn is_true(v: &str) -> bool {
113    v.eq_ignore_ascii_case("true") || v == "1"
114}
115
116/// Parse `k1=v1,k2=v2` (W3C baggage-like; values are percent-decoded).
117pub fn parse_pairs(var: &str, raw: &str) -> Result<Vec<(String, String)>, ConfigError> {
118    let mut out = Vec::new();
119    for item in raw.split(',') {
120        let item = item.trim();
121        if item.is_empty() {
122            continue;
123        }
124        let Some((k, v)) = item.split_once('=') else {
125            return Err(ConfigError::Invalid {
126                var: var.to_owned(),
127                message: "expected comma-separated key=value pairs".into(),
128            });
129        };
130        let k = percent_decode(k.trim());
131        if k.is_empty() {
132            return Err(ConfigError::Invalid { var: var.to_owned(), message: "empty key".into() });
133        }
134        out.push((k, percent_decode(v.trim())));
135    }
136    Ok(out)
137}
138
139fn percent_decode(s: &str) -> String {
140    let bytes = s.as_bytes();
141    let mut out = Vec::with_capacity(bytes.len());
142    let mut i = 0;
143    while let Some(&b) = bytes.get(i) {
144        if b == b'%' {
145            let hex = bytes.get(i + 1..i + 3).and_then(|h| std::str::from_utf8(h).ok());
146            if let Some(v) = hex.and_then(|h| u8::from_str_radix(h, 16).ok()) {
147                out.push(v);
148                i += 3;
149                continue;
150            }
151        }
152        out.push(b);
153        i += 1;
154    }
155    String::from_utf8_lossy(&out).into_owned()
156}
157
158#[cfg(test)]
159mod tests {
160    use super::*;
161
162    fn vars(pairs: &[(&str, &str)]) -> Vec<(String, String)> {
163        pairs.iter().map(|(k, v)| ((*k).to_owned(), (*v).to_owned())).collect()
164    }
165
166    #[test]
167    fn defaults_point_at_local_collector() {
168        let cfg = OtelConfig::from_vars(&[]).unwrap();
169        assert!(!cfg.disabled && !cfg.endpoint_configured);
170        assert_eq!(cfg.traces_endpoint, "http://localhost:4318/v1/traces");
171    }
172
173    #[test]
174    fn env_variables_are_honored() {
175        let cfg = OtelConfig::from_vars(&vars(&[
176            ("OTEL_EXPORTER_OTLP_ENDPOINT", "https://otel.example.com/"),
177            ("OTEL_EXPORTER_OTLP_HEADERS", "x-api-key=abc%20def, x-team = core"),
178            ("OTEL_SERVICE_NAME", "agents"),
179            ("OTEL_RESOURCE_ATTRIBUTES", "service.name=ignored,deployment.environment=prod"),
180            ("GRAPHRT_OTEL_CAPTURE_CONTENT", "true"),
181        ]))
182        .unwrap();
183        assert!(cfg.endpoint_configured && cfg.capture_content);
184        assert_eq!(cfg.traces_endpoint, "https://otel.example.com/v1/traces");
185        assert_eq!(cfg.metrics_endpoint, "https://otel.example.com/v1/metrics");
186        assert_eq!(cfg.headers, vec![("x-api-key".into(), "abc def".into()), ("x-team".into(), "core".into())]);
187        let attrs = &cfg.resource.attributes;
188        assert!(attrs.contains(&("service.name".into(), AttrValue::from("agents"))));
189        assert!(attrs.contains(&("deployment.environment".into(), AttrValue::from("prod"))));
190
191        let cfg = OtelConfig::from_vars(&vars(&[
192            ("OTEL_EXPORTER_OTLP_ENDPOINT", "http://a:4318"),
193            ("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", "http://b:9999/custom"),
194            ("OTEL_SDK_DISABLED", "TRUE"),
195        ]))
196        .unwrap();
197        assert_eq!(cfg.traces_endpoint, "http://b:9999/custom");
198        assert!(cfg.disabled);
199    }
200
201    #[test]
202    fn bad_values_are_errors() {
203        assert!(OtelConfig::from_vars(&vars(&[("OTEL_EXPORTER_OTLP_HEADERS", "novalue")])).is_err());
204        assert!(OtelConfig::from_vars(&vars(&[("OTEL_EXPORTER_OTLP_ENDPOINT", "ftp://x")])).is_err());
205    }
206}