1use crate::otlp::Resource;
4use crate::span::AttrValue;
5
6pub const DEFAULT_ENDPOINT: &str = "http://localhost:4318";
8
9#[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#[derive(Clone, Debug, PartialEq)]
19pub struct OtelConfig {
20 pub disabled: bool,
22 pub endpoint_configured: bool,
24 pub traces_endpoint: String,
26 pub metrics_endpoint: String,
28 pub headers: Vec<(String, String)>,
30 pub resource: Resource,
31 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 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 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 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 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
116pub 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}