Skip to content

Commit 5b780a6

Browse files
committed
fix(sandbox): disable OTLP compression in the relay env and cover exec children
The relay refuses compressed bodies, so an image or creation request that sets gzip compression without naming an endpoint received the relay default and lost every trace export to a 415. The relay default now also sets OTEL_EXPORTER_OTLP_COMPRESSION and OTEL_EXPORTER_OTLP_TRACES_COMPRESSION to none, as NVIDIA#4275 asks. Boundary exec children start from a cleared environment and never see the image ENV, yet the relay default was suppressed when the sandbox's own environment named an endpoint, which left exec children with no endpoint at all. apply_otlp_relay_env now takes a ChildEnvironment so only children that inherit the sandbox environment consult it. Add a probe test for both TLS environment modes together with the relay default, now that the mode-aware TLS layering lives in compose_canonical_process_environment, and describe the whole composition at its call sites. Signed-off-by: Roland Huß <[email protected]>
1 parent 2a6b604 commit 5b780a6

6 files changed

Lines changed: 232 additions & 30 deletions

File tree

‎crates/openshell-core/src/sandbox_env.rs‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -324,6 +324,20 @@ pub const OTEL_EXPORTER_OTLP_PROTOCOL: &str = "OTEL_EXPORTER_OTLP_PROTOCOL";
324324
/// has chosen where traces go, so the relay default is left out.
325325
pub const OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: &str = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT";
326326

327+
/// Standard OpenTelemetry environment variable for OTLP exporter compression.
328+
///
329+
/// Set to `none` alongside [`OTEL_EXPORTER_OTLP_ENDPOINT`], because the
330+
/// relay refuses compressed bodies.
331+
pub const OTEL_EXPORTER_OTLP_COMPRESSION: &str = "OTEL_EXPORTER_OTLP_COMPRESSION";
332+
333+
/// Signal-specific compression variable, also set to `none` with the relay
334+
/// default.
335+
///
336+
/// SDKs prefer it over [`OTEL_EXPORTER_OTLP_COMPRESSION`], so a `gzip` value
337+
/// from the image or the creation request would otherwise still compress
338+
/// every trace export.
339+
pub const OTEL_EXPORTER_OTLP_TRACES_COMPRESSION: &str = "OTEL_EXPORTER_OTLP_TRACES_COMPRESSION";
340+
327341
/// Reserved destination agent processes export OTLP to.
328342
///
329343
/// This address is never routed. A workload `connect()` to any non-loopback

‎crates/openshell-sandbox/README.md‎

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -50,12 +50,16 @@ dropped.
5050

5151
When `AgentSpec::otlp_relay_active` is set, `child_env::apply_otlp_relay_env`
5252
gives every workload process (main, exec, and SSH) `OTEL_EXPORTER_OTLP_ENDPOINT`
53-
pointing at the relay address and `OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf`,
54-
and removes any inherited `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`. These defaults
55-
apply after the provider variables. If the creation request, the image, or a
56-
per-exec environment names a generic or traces-specific OTLP endpoint, the
57-
runtime injects nothing, and the workload exports to that endpoint under the
58-
sandbox's network policy.
53+
pointing at the relay address, `OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf`, and
54+
`none` for `OTEL_EXPORTER_OTLP_COMPRESSION` and
55+
`OTEL_EXPORTER_OTLP_TRACES_COMPRESSION`, and removes any inherited
56+
`OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`. These defaults apply after the provider
57+
variables. If the creation request or a per-exec environment names a generic
58+
or traces-specific OTLP endpoint, the runtime injects nothing, and the
59+
workload exports to that endpoint under the sandbox's network policy. An
60+
endpoint in the image `ENV` does the same for the main process; exec children
61+
start from a cleared environment (`ChildEnvironment::Cleared`), never see the
62+
image's endpoint, and still get the relay default.
5963

6064
## Supervisor takeover
6165

‎crates/openshell-sandbox/src/boundary_exec.rs‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -188,12 +188,15 @@ impl LocalBoundaryExec {
188188
crate::process::strip_proxy_env_std(&mut command);
189189
// Point OTel SDKs at the supervisor's trace relay after the creation
190190
// request's environment and the provider variables, matching the main
191-
// process. An endpoint in the creation request, the image, or this
192-
// exec's `spec.env` suppresses it, and any other `spec.env` value
193-
// applied below still wins for this exec only.
191+
// process. An endpoint in the creation request or this exec's
192+
// `spec.env` suppresses it, and any other `spec.env` value applied
193+
// below still wins for this exec only. The environment was cleared
194+
// above, so an endpoint in the image `ENV` never reaches this child
195+
// and does not suppress the default.
194196
crate::child_env::apply_otlp_relay_env(
195197
&mut command,
196198
self.otlp_relay_active,
199+
crate::child_env::ChildEnvironment::Cleared,
197200
&self.user_environment,
198201
&spec.env,
199202
);

‎crates/openshell-sandbox/src/child_env.rs‎

Lines changed: 82 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -6,8 +6,8 @@ use std::hash::BuildHasher;
66
use std::path::Path;
77

88
use openshell_core::sandbox_env::{
9-
OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_PROTOCOL, OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
10-
OTLP_RELAY_ENDPOINT,
9+
OTEL_EXPORTER_OTLP_COMPRESSION, OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_PROTOCOL,
10+
OTEL_EXPORTER_OTLP_TRACES_COMPRESSION, OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, OTLP_RELAY_ENDPOINT,
1111
};
1212

1313
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -56,16 +56,33 @@ const OTLP_ENDPOINT_VARS: [&str; 2] = [
5656
/// OpenTelemetry exporter variables that point agent SDKs at the
5757
/// supervisor's OTLP relay.
5858
///
59-
/// Only the generic variables are set. Signal-specific variables take
60-
/// precedence over them in every SDK, so an endpoint the workload sets later
61-
/// at any layer, generic or traces-specific, wins over this default.
62-
pub fn otlp_relay_env_vars() -> [(&'static str, &'static str); 2] {
59+
/// Only the generic endpoint and protocol are set. Signal-specific variables
60+
/// take precedence over them in every SDK, so an endpoint the workload sets
61+
/// later at any layer, generic or traces-specific, wins over this default.
62+
/// Compression is disabled for both the generic and the traces-specific
63+
/// variable because the relay refuses compressed bodies, and a `gzip` value
64+
/// from the image or the creation request would otherwise make every export
65+
/// fail.
66+
pub fn otlp_relay_env_vars() -> [(&'static str, &'static str); 4] {
6367
[
6468
(OTEL_EXPORTER_OTLP_ENDPOINT, OTLP_RELAY_ENDPOINT),
6569
(OTEL_EXPORTER_OTLP_PROTOCOL, "http/protobuf"),
70+
(OTEL_EXPORTER_OTLP_COMPRESSION, "none"),
71+
(OTEL_EXPORTER_OTLP_TRACES_COMPRESSION, "none"),
6672
]
6773
}
6874

75+
/// Whether a child process starts from the sandbox's own environment, which
76+
/// carries the image `ENV`.
77+
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
78+
pub enum ChildEnvironment {
79+
/// The child inherits the sandbox environment, like the main process.
80+
Inherited,
81+
/// The child starts from a cleared environment, like a boundary exec, so
82+
/// an endpoint in the image `ENV` never reaches it.
83+
Cleared,
84+
}
85+
6986
/// Whether one layer of the workload environment names an OTLP endpoint,
7087
/// generic or traces-specific.
7188
pub fn names_otlp_endpoint<S: BuildHasher>(environment: &HashMap<String, String, S>) -> bool {
@@ -97,17 +114,21 @@ fn relay_default_applies<S: BuildHasher>(
97114
/// Nothing is injected while the relay is inactive, or when the creation
98115
/// request (`user_environment`), the image, or `exec_environment` names an
99116
/// endpoint: the agent then exports where it was told to, subject to the
100-
/// sandbox's network policy and outside relay attribution. When the default
101-
/// is injected, a traces-specific endpoint can only have come from a
102-
/// provider, and is removed so a provider cannot redirect traces.
117+
/// sandbox's network policy and outside relay attribution. The image only
118+
/// counts for a child that inherits the sandbox environment; a child started
119+
/// from a cleared environment never sees the image's endpoint, so the relay
120+
/// default still applies to it. When the default is injected, a
121+
/// traces-specific endpoint can only have come from a provider, and is
122+
/// removed so a provider cannot redirect traces.
103123
pub fn apply_otlp_relay_env<S: BuildHasher>(
104124
cmd: &mut impl EnvTarget,
105125
relay_active: bool,
126+
child_environment: ChildEnvironment,
106127
user_environment: &HashMap<String, String, S>,
107128
exec_environment: &[(String, String)],
108129
) {
109130
if !relay_default_applies(relay_active, user_environment, exec_environment, |key| {
110-
std::env::var_os(key).is_some()
131+
child_environment == ChildEnvironment::Inherited && std::env::var_os(key).is_some()
111132
}) {
112133
return;
113134
}
@@ -208,10 +229,61 @@ mod tests {
208229
[
209230
("OTEL_EXPORTER_OTLP_ENDPOINT", "http://192.0.0.8:4318"),
210231
("OTEL_EXPORTER_OTLP_PROTOCOL", "http/protobuf"),
232+
("OTEL_EXPORTER_OTLP_COMPRESSION", "none"),
233+
("OTEL_EXPORTER_OTLP_TRACES_COMPRESSION", "none"),
211234
]
212235
);
213236
}
214237

238+
#[derive(Default)]
239+
struct RecordedEnv {
240+
set: HashMap<String, String>,
241+
removed: Vec<String>,
242+
}
243+
244+
impl EnvTarget for RecordedEnv {
245+
fn set_var(&mut self, key: &str, value: &str) {
246+
self.set.insert(key.to_string(), value.to_string());
247+
}
248+
249+
fn remove_var(&mut self, key: &str) {
250+
self.removed.push(key.to_string());
251+
}
252+
}
253+
254+
/// A child started from a cleared environment never sees the image
255+
/// `ENV`, so only the creation request and the exec environment can
256+
/// suppress the default, independent of the harness environment.
257+
#[test]
258+
fn cleared_child_ignores_the_inherited_environment() {
259+
let none: HashMap<String, String> = HashMap::new();
260+
let mut env = RecordedEnv::default();
261+
apply_otlp_relay_env(&mut env, true, ChildEnvironment::Cleared, &none, &[]);
262+
assert_eq!(
263+
env.set
264+
.get("OTEL_EXPORTER_OTLP_ENDPOINT")
265+
.map(String::as_str),
266+
Some("http://192.0.0.8:4318")
267+
);
268+
assert_eq!(env.removed, ["OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"]);
269+
270+
let mut env = RecordedEnv::default();
271+
apply_otlp_relay_env(
272+
&mut env,
273+
true,
274+
ChildEnvironment::Cleared,
275+
&none,
276+
&[(
277+
"OTEL_EXPORTER_OTLP_ENDPOINT".to_string(),
278+
"http://collector.example:4318".to_string(),
279+
)],
280+
);
281+
assert!(
282+
env.set.is_empty() && env.removed.is_empty(),
283+
"an exec endpoint still suppresses the default"
284+
);
285+
}
286+
215287
#[test]
216288
fn relay_default_applies_only_while_active_and_unconfigured() {
217289
let none: HashMap<String, String> = HashMap::new();

‎crates/openshell-sandbox/src/process.rs‎

Lines changed: 119 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -318,7 +318,13 @@ fn compose_canonical_process_environment(
318318
cmd.env(key, value);
319319
}
320320
}
321-
child_env::apply_otlp_relay_env(cmd, otlp_relay_active, user_environment, &[]);
321+
child_env::apply_otlp_relay_env(
322+
cmd,
323+
otlp_relay_active,
324+
child_env::ChildEnvironment::Inherited,
325+
user_environment,
326+
&[],
327+
);
322328
}
323329

324330
#[cfg(unix)]
@@ -569,9 +575,9 @@ impl ProcessHandle {
569575
.stderr(Stdio::piped());
570576
}
571577

572-
// Strip supervisor-only identity material from the entrypoint's
573-
// inherited environment. The entrypoint drops to the sandbox user
574-
// before `exec`; without this strip, sandbox code could recover
578+
// Build the entrypoint's environment. It also strips supervisor-only
579+
// identity material: the entrypoint drops to the sandbox user before
580+
// `exec`, and without the strip sandbox code could recover
575581
// supervisor credentials from its inherited environment.
576582
compose_canonical_process_environment(
577583
&mut cmd,
@@ -725,8 +731,8 @@ impl ProcessHandle {
725731
.stderr(Stdio::piped());
726732
}
727733

728-
// Strip supervisor-only identity material from the entrypoint's
729-
// inherited environment.
734+
// Build the entrypoint's environment, without supervisor-only
735+
// identity material.
730736
compose_canonical_process_environment(
731737
&mut cmd,
732738
policy,
@@ -1370,10 +1376,10 @@ mod tests {
13701376
#[test]
13711377
fn canonical_process_sees_relay_endpoint_and_never_the_collector() {
13721378
use openshell_core::sandbox_env::{
1373-
OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_PROTOCOL,
1379+
OTEL_EXPORTER_OTLP_COMPRESSION, OTEL_EXPORTER_OTLP_ENDPOINT,
1380+
OTEL_EXPORTER_OTLP_PROTOCOL, OTEL_EXPORTER_OTLP_TRACES_COMPRESSION,
13741381
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, OTLP_RELAY_ENDPOINT,
13751382
};
1376-
const OTEL_EXPORTER_OTLP_TRACES_COMPRESSION: &str = "OTEL_EXPORTER_OTLP_TRACES_COMPRESSION";
13771383
const COLLECTOR_HOST: &str = "collector.invalid";
13781384
if run_in_isolated_child(
13791385
"OPENSHELL_TEST_RELAY_ENV_CHILD",
@@ -1436,12 +1442,26 @@ mod tests {
14361442
};
14371443

14381444
// Relay active, no endpoint in the creation request: only the
1439-
// generic default is set, and a provider cannot redirect traces.
1445+
// generic default is set, compression is disabled, and a provider
1446+
// cannot redirect traces.
14401447
let variables = probe(
1441-
HashMap::from([(OTEL_EXPORTER_OTLP_PROTOCOL.into(), "grpc".into())]),
1448+
HashMap::from([
1449+
(OTEL_EXPORTER_OTLP_PROTOCOL.into(), "grpc".into()),
1450+
(OTEL_EXPORTER_OTLP_TRACES_COMPRESSION.into(), "gzip".into()),
1451+
]),
14421452
provider_redirect(),
14431453
true,
14441454
);
1455+
for key in [
1456+
OTEL_EXPORTER_OTLP_COMPRESSION,
1457+
OTEL_EXPORTER_OTLP_TRACES_COMPRESSION,
1458+
] {
1459+
assert_eq!(
1460+
get(&variables, key).as_deref(),
1461+
Some("none"),
1462+
"the relay refuses compressed bodies, so {key} is disabled: {variables:?}"
1463+
);
1464+
}
14451465
assert_eq!(
14461466
get(&variables, OTEL_EXPORTER_OTLP_ENDPOINT).as_deref(),
14471467
Some(OTLP_RELAY_ENDPOINT),
@@ -1511,6 +1531,95 @@ mod tests {
15111531
);
15121532
}
15131533

1534+
/// Both TLS environment modes keep their precedence in the composed
1535+
/// environment while the relay default is applied. In `Override`, the
1536+
/// `OpenShell` trust files win over the caller and the provider. In
1537+
/// `FillMissing`, a caller's TLS value wins over the provider and only the
1538+
/// variables the caller left unset point at `OpenShell` trust.
1539+
#[cfg(unix)]
1540+
#[test]
1541+
fn canonical_process_keeps_tls_mode_precedence_with_the_relay() {
1542+
use openshell_core::sandbox_env::{OTEL_EXPORTER_OTLP_ENDPOINT, OTLP_RELAY_ENDPOINT};
1543+
if run_in_isolated_child(
1544+
"OPENSHELL_TEST_TLS_MODE_ENV_CHILD",
1545+
"process::tests::canonical_process_keeps_tls_mode_precedence_with_the_relay",
1546+
&[],
1547+
) {
1548+
return;
1549+
}
1550+
let current_user = User::from_uid(nix::unistd::geteuid()).unwrap().unwrap();
1551+
let policy = policy_with_process(ProcessPolicy {
1552+
run_as_user: Some(current_user.name),
1553+
run_as_group: None,
1554+
});
1555+
let workspace = ResolvedWorkspace::default();
1556+
let ca_paths = (
1557+
PathBuf::from("/etc/openshell-tls/ca.pem"),
1558+
PathBuf::from("/etc/openshell-tls/ca-bundle.pem"),
1559+
);
1560+
let openshell_trust: HashMap<&str, String> =
1561+
child_env::tls_env_vars(&ca_paths.0, &ca_paths.1)
1562+
.into_iter()
1563+
.collect();
1564+
let declared = HashMap::from([("SSL_CERT_FILE".to_string(), "/caller.pem".to_string())]);
1565+
let provider_env = HashMap::from([
1566+
("SSL_CERT_FILE".to_string(), "/provider.pem".to_string()),
1567+
(
1568+
"REQUESTS_CA_BUNDLE".to_string(),
1569+
"/provider.pem".to_string(),
1570+
),
1571+
]);
1572+
let probe = |mode: child_env::TlsEnvironmentMode| {
1573+
let mut cmd = Command::new("/usr/bin/env");
1574+
cmd.stdout(StdStdio::piped());
1575+
compose_canonical_process_environment(
1576+
&mut cmd,
1577+
&policy,
1578+
&workspace,
1579+
false,
1580+
&declared,
1581+
&provider_env,
1582+
Some(&ca_paths),
1583+
mode,
1584+
true,
1585+
);
1586+
let variables = probe_environment(cmd);
1587+
assert_eq!(
1588+
variables
1589+
.get(OTEL_EXPORTER_OTLP_ENDPOINT)
1590+
.map(String::as_str),
1591+
Some(OTLP_RELAY_ENDPOINT),
1592+
"the relay default applies in {mode:?}: {variables:?}"
1593+
);
1594+
variables
1595+
};
1596+
1597+
let variables = probe(child_env::TlsEnvironmentMode::Override);
1598+
for (key, value) in &openshell_trust {
1599+
assert_eq!(
1600+
variables.get(*key),
1601+
Some(value),
1602+
"OpenShell trust wins for {key} in Override: {variables:?}"
1603+
);
1604+
}
1605+
1606+
let variables = probe(child_env::TlsEnvironmentMode::FillMissing);
1607+
assert_eq!(
1608+
variables.get("SSL_CERT_FILE").map(String::as_str),
1609+
Some("/caller.pem"),
1610+
"the caller's value wins over the provider in FillMissing: {variables:?}"
1611+
);
1612+
for (key, value) in &openshell_trust {
1613+
if *key != "SSL_CERT_FILE" {
1614+
assert_eq!(
1615+
variables.get(*key),
1616+
Some(value),
1617+
"OpenShell trust fills {key} in FillMissing: {variables:?}"
1618+
);
1619+
}
1620+
}
1621+
}
1622+
15141623
/// An endpoint in the image `ENV`, which reaches the canonical process
15151624
/// through the inherited sandbox environment, is left alone too.
15161625
#[cfg(unix)]

‎docs/how-it-works/gateways/configuration.mdx‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -657,7 +657,7 @@ enabled = true
657657
endpoint = "http://agent-collector.observability.svc:4317" # optional
658658
```
659659

660-
While the relay is active, the sandbox runtime sets `OTEL_EXPORTER_OTLP_ENDPOINT=http://192.0.0.8:4318` and `OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf` in every workload process, so a standard OpenTelemetry SDK exports without configuration. These are lowest-precedence defaults. They are not set when the sandbox creation request, the image `ENV`, or an environment passed to `openshell sandbox exec` names `OTEL_EXPORTER_OTLP_ENDPOINT` or `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, and an endpoint the workload sets itself, for example with a shell `export`, takes precedence over them. A workload that exports elsewhere does so subject to the sandbox's network policy, and its traces carry no relay attribution. Provider credentials cannot redirect traces. While the relay is off, nothing is injected. Because the generic endpoint is set, an SDK that also exports metrics or logs sends them to the relay, which answers with an empty OTLP success and discards them. To keep metrics and logs, point those exporters elsewhere with `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT` and `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT`. The address is a reserved label rather than a network destination: the supervisor serves it inside the sandbox boundary and forwards accepted batches to the collector over OTLP/gRPC. The collector's address is never visible inside the sandbox.
660+
While the relay is active, the sandbox runtime sets `OTEL_EXPORTER_OTLP_ENDPOINT=http://192.0.0.8:4318` and `OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf` in every workload process, and sets `OTEL_EXPORTER_OTLP_COMPRESSION` and `OTEL_EXPORTER_OTLP_TRACES_COMPRESSION` to `none`, so a standard OpenTelemetry SDK exports without configuration. These are lowest-precedence defaults. They are not set when the sandbox creation request or an environment passed to `openshell sandbox exec` names `OTEL_EXPORTER_OTLP_ENDPOINT` or `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, or when the image `ENV` names one for the main process, since `openshell sandbox exec` sessions do not inherit the image environment, and an endpoint the workload sets itself, for example with a shell `export`, takes precedence over them. A workload that exports elsewhere does so subject to the sandbox's network policy, and its traces carry no relay attribution. Provider credentials cannot redirect traces. While the relay is off, nothing is injected. Because the generic endpoint is set, an SDK that also exports metrics or logs sends them to the relay, which answers with an empty OTLP success and discards them. To keep metrics and logs, point those exporters elsewhere with `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT` and `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT`. The address is a reserved label rather than a network destination: the supervisor serves it inside the sandbox boundary and forwards accepted batches to the collector over OTLP/gRPC. The collector's address is never visible inside the sandbox.
661661

662662
Every forwarded resource carries `openshell.sandbox.id`, with the same value as the supervisor's own spans, and `openshell.telemetry.source=agent`. Values the agent supplies for those two keys are replaced at the resource level; span and scope attributes pass through unchanged, so filter and join on the resource attributes. Filter on `openshell.telemetry.source` to separate agent traces from infrastructure traces, and join on `openshell.sandbox.id` to correlate them.
663663

0 commit comments

Comments
 (0)