Updated env var to disable telemetry

Author: kirit93

Cargo.lock

@@ -247,7 +247,7 @@ OpenShell is built agent-first — your agent is your first collaborator. Before
 
 OpenShell collects anonymous telemetry to help improve the project for developers. This data is not used to track individual user behavior. It helps us understand aggregate usage of sandbox, provider, and policy workflows so we can prioritize product improvements and share usage trends with the community.
 
-Disable telemetry with `OPENSHELL_TELEMETRY_ENABLED=false`. See the [telemetry schema](openshell_telemetry_schema.json) for details.
+Disable telemetry by setting `OPENSHELL_TELEMETRY_ENABLED=false` on the gateway deployment. OpenShell propagates this deployment setting into sandbox supervisor environments so sandbox-side telemetry collection is disabled as well. See the [telemetry schema](openshell_telemetry_schema.json) for details.
 
 Telemetry events are limited to anonymous operational categories and counts, such as sandbox lifecycle outcomes, provider profile buckets, policy decision counts, and aggregate network activity denial categories. OpenShell telemetry does not collect sandbox names or IDs, hostnames, file paths, binary paths, prompts, credentials, provider names, model names, or user content.
 

README.md

@@ -26,6 +26,9 @@ pub const LOG_LEVEL: &str = "OPENSHELL_LOG_LEVEL";
 /// Shell command to run inside the sandbox.
 pub const SANDBOX_COMMAND: &str = "OPENSHELL_SANDBOX_COMMAND";
 
+/// Deployment-controlled telemetry toggle propagated to the sandbox supervisor.
+pub const TELEMETRY_ENABLED: &str = "OPENSHELL_TELEMETRY_ENABLED";
+
 /// Path to the CA certificate for mTLS communication with the gateway.
 pub const TLS_CA: &str = "OPENSHELL_TLS_CA";
 

crates/openshell-core/src/sandbox_env.rs

@@ -34,6 +34,18 @@ pub fn enabled() -> bool {
     telemetry_enabled_from(std::env::var("OPENSHELL_TELEMETRY_ENABLED").ok().as_deref())
 }
 
+pub fn enabled_env_value() -> &'static str {
+    enabled_env_value_from(std::env::var("OPENSHELL_TELEMETRY_ENABLED").ok().as_deref())
+}
+
+fn enabled_env_value_from(value: Option<&str>) -> &'static str {
+    if telemetry_enabled_from(value) {
+        "true"
+    } else {
+        "false"
+    }
+}
+
 fn telemetry_enabled_from(value: Option<&str>) -> bool {
     let value = value.unwrap_or("true");
     !matches!(
@@ -405,6 +417,14 @@ mod tests {
         assert!(telemetry_enabled_from(Some("yes")));
     }
 
+    #[test]
+    fn telemetry_enabled_env_value_is_normalized() {
+        assert_eq!(enabled_env_value_from(Some("false")), "false");
+        assert_eq!(enabled_env_value_from(Some("0")), "false");
+        assert_eq!(enabled_env_value_from(None), "true");
+        assert_eq!(enabled_env_value_from(Some("yes")), "true");
+    }
+
     #[test]
     fn telemetry_endpoint_empty_disables_publish() {
         assert_eq!(telemetry_endpoint_from(Some("  ")), None);

crates/openshell-core/src/telemetry.rs

@@ -25,5 +25,8 @@ tar = "0.4"
 tempfile = "3"
 url = { workspace = true }
 
+[dev-dependencies]
+temp-env = "0.3"
+
 [lints]
 workspace = true

crates/openshell-driver-docker/Cargo.toml

@@ -970,6 +970,10 @@ fn build_environment(sandbox: &DriverSandbox, config: &DockerDriverRuntimeConfig
         openshell_core::sandbox_env::SANDBOX_COMMAND.to_string(),
         SANDBOX_COMMAND.to_string(),
     );
+    environment.insert(
+        openshell_core::sandbox_env::TELEMETRY_ENABLED.to_string(),
+        openshell_core::telemetry::enabled_env_value().to_string(),
+    );
     // The root supervisor executes namespace helpers during bootstrap; keep
     // their search path driver-owned even when the template/spec set PATH.
     environment.insert("PATH".to_string(), SUPERVISOR_PATH.to_string());

crates/openshell-driver-docker/src/lib.rs

@@ -8,9 +8,11 @@ use openshell_core::proto::compute::v1::{
 };
 use std::fs;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::sync::{LazyLock, Mutex};
 use tempfile::TempDir;
 
 const TLS_MOUNT_DIR: &str = "/etc/openshell/tls/client";
+static ENV_LOCK: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
 
 fn test_sandbox() -> DriverSandbox {
     // Mirrors the gateway-supplied request: the public `Sandbox` API no
@@ -420,6 +422,41 @@ fn build_environment_keeps_path_driver_controlled() {
     assert_eq!(path_entries[0], &expected_path);
 }
 
+#[test]
+fn build_environment_keeps_telemetry_toggle_driver_controlled() {
+    let _guard = ENV_LOCK.lock().unwrap();
+    temp_env::with_vars(
+        [(
+            openshell_core::sandbox_env::TELEMETRY_ENABLED,
+            Some("false"),
+        )],
+        || {
+            let mut sandbox = test_sandbox();
+            sandbox.spec.as_mut().unwrap().environment.insert(
+                openshell_core::sandbox_env::TELEMETRY_ENABLED.to_string(),
+                "true".to_string(),
+            );
+
+            let env = build_environment(&sandbox, &runtime_config());
+            let telemetry_entries = env
+                .iter()
+                .filter(|entry| {
+                    entry.starts_with(&format!(
+                        "{}=",
+                        openshell_core::sandbox_env::TELEMETRY_ENABLED
+                    ))
+                })
+                .collect::<Vec<_>>();
+
+            assert_eq!(telemetry_entries.len(), 1);
+            assert_eq!(
+                telemetry_entries[0],
+                &format!("{}=false", openshell_core::sandbox_env::TELEMETRY_ENABLED)
+            );
+        },
+    );
+}
+
 #[test]
 fn build_binds_uses_docker_tls_directory() {
     let binds = build_binds(&runtime_config());

crates/openshell-driver-docker/src/tests.rs

@@ -34,5 +34,8 @@ tracing-subscriber = { workspace = true }
 thiserror = { workspace = true }
 miette = { workspace = true }
 
+[dev-dependencies]
+temp-env = "0.3"
+
 [lints]
 workspace = true

crates/openshell-driver-kubernetes/Cargo.toml

@@ -1424,6 +1424,11 @@ fn apply_required_env(
         openshell_core::sandbox_env::SANDBOX_COMMAND,
         "sleep infinity",
     );
+    upsert_env(
+        env,
+        openshell_core::sandbox_env::TELEMETRY_ENABLED,
+        openshell_core::telemetry::enabled_env_value(),
+    );
     if !ssh_socket_path.is_empty() {
         upsert_env(
             env,
@@ -1592,6 +1597,9 @@ mod tests {
     };
     use prost_types::{Struct, Value, value::Kind};
 
+    static ENV_LOCK: std::sync::LazyLock<std::sync::Mutex<()>> =
+        std::sync::LazyLock::new(|| std::sync::Mutex::new(()));
+
     #[test]
     fn kube_pulling_event_adds_image_progress_metadata() {
         let mut metadata = std::collections::HashMap::new();
@@ -2475,6 +2483,37 @@ mod tests {
         assert!(cr["spec"].get("logLevel").is_none());
     }
 
+    #[test]
+    fn telemetry_toggle_propagates_from_driver_env_to_sandbox_pod() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        temp_env::with_vars(
+            [(
+                openshell_core::sandbox_env::TELEMETRY_ENABLED,
+                Some("false"),
+            )],
+            || {
+                let spec = SandboxSpec {
+                    environment: std::collections::HashMap::from([(
+                        openshell_core::sandbox_env::TELEMETRY_ENABLED.to_string(),
+                        "true".to_string(),
+                    )]),
+                    ..SandboxSpec::default()
+                };
+                let cr = sandbox_to_k8s_spec(Some(&spec), &SandboxPodParams::default());
+                let env = cr["spec"]["podTemplate"]["spec"]["containers"][0]["env"]
+                    .as_array()
+                    .unwrap();
+                let telemetry_entries = env
+                    .iter()
+                    .filter(|entry| entry["name"] == openshell_core::sandbox_env::TELEMETRY_ENABLED)
+                    .collect::<Vec<_>>();
+
+                assert_eq!(telemetry_entries.len(), 1);
+                assert_eq!(telemetry_entries[0]["value"], serde_json::json!("false"));
+            },
+        );
+    }
+
     #[test]
     fn node_selector_from_platform_config() {
         let template = SandboxTemplate {

crates/openshell-driver-kubernetes/src/driver.rs

@@ -280,6 +280,10 @@ fn build_env(
         openshell_core::sandbox_env::SANDBOX_COMMAND.into(),
         "sleep infinity".into(),
     );
+    env.insert(
+        openshell_core::sandbox_env::TELEMETRY_ENABLED.into(),
+        openshell_core::telemetry::enabled_env_value().into(),
+    );
 
     // 3. TLS client cert paths (when mTLS is enabled). These point to
     //    the container-side mount paths where the cert files are
@@ -636,6 +640,9 @@ fn parse_memory_to_bytes(quantity: &str) -> Option<u64> {
 mod tests {
     use super::*;
 
+    static ENV_LOCK: std::sync::LazyLock<std::sync::Mutex<()>> =
+        std::sync::LazyLock::new(|| std::sync::Mutex::new(()));
+
     #[test]
     fn parse_cpu_millicore() {
         assert_eq!(parse_cpu_to_microseconds("500m"), Some(50_000));
@@ -908,6 +915,41 @@ mod tests {
         );
     }
 
+    #[test]
+    fn container_spec_telemetry_toggle_comes_from_driver_env() {
+        use openshell_core::proto::compute::v1::{DriverSandboxSpec, DriverSandboxTemplate};
+
+        let _guard = ENV_LOCK.lock().unwrap();
+        temp_env::with_vars(
+            [(
+                openshell_core::sandbox_env::TELEMETRY_ENABLED,
+                Some("false"),
+            )],
+            || {
+                let mut sandbox = test_sandbox("test-id", "legit-name");
+                sandbox.spec = Some(DriverSandboxSpec {
+                    environment: std::collections::HashMap::from([(
+                        openshell_core::sandbox_env::TELEMETRY_ENABLED.to_string(),
+                        "true".to_string(),
+                    )]),
+                    template: Some(DriverSandboxTemplate::default()),
+                    ..Default::default()
+                });
+
+                let spec = build_container_spec(&sandbox, &test_config());
+                let env_map = spec["env"].as_object().expect("env should be an object");
+
+                assert_eq!(
+                    env_map
+                        .get(openshell_core::sandbox_env::TELEMETRY_ENABLED)
+                        .and_then(|v| v.as_str()),
+                    Some("false"),
+                    "telemetry toggle must come from the deployment environment"
+                );
+            },
+        );
+    }
+
     #[test]
     fn container_spec_required_labels_cannot_be_overridden() {
         use openshell_core::proto::compute::v1::{DriverSandboxSpec, DriverSandboxTemplate};