fix(telemetry): bound compute driver categories

Signed-off-by: Drew Newberry <anewberry@nvidia.com>

Author: drew

architecture/build.md

@@ -10,7 +10,7 @@ OpenShell builds these main artifacts:
 
 | Artifact | Source |
 |---|---|
-| Gateway binary | `crates/openshell-server` |
+| Gateway binary | `crates/openshell-gateway` |
 | CLI package and Python SDK | `python/openshell` plus Rust binaries where packaged |
 | TypeScript SDK package | `sdk/typescript` |
 | Gateway container image | `deploy/docker/Dockerfile.gateway` |

crates/openshell-core/src/telemetry.rs

@@ -159,20 +159,35 @@ impl SandboxTemplateSource {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct TelemetryComputeDriver(String);
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TelemetryComputeDriver(&'static str);
 
 impl TelemetryComputeDriver {
     #[must_use]
-    pub fn as_str(&self) -> &str {
-        &self.0
+    pub const fn as_str(self) -> &'static str {
+        self.0
     }
 
+    /// Classify an unregistered compute driver without exposing its configured
+    /// name.
     #[must_use]
-    pub fn from_raw(raw: &str) -> Self {
-        let name = crate::config::normalize_compute_driver_name(raw)
-            .unwrap_or_else(|_| "unknown".to_string());
-        Self(name)
+    pub const fn custom() -> Self {
+        Self("custom")
+    }
+
+    /// Define a bounded, anonymous category at a binary composition boundary.
+    ///
+    /// The category must be a static operational label. Never construct it
+    /// from user input, configuration, resource names, or other runtime data.
+    #[must_use]
+    pub const fn anonymous_category(category: &'static str) -> Self {
+        Self(category)
+    }
+}
+
+impl Default for TelemetryComputeDriver {
+    fn default() -> Self {
+        Self::custom()
     }
 }
 
@@ -657,21 +672,11 @@ mod tests {
     }
 
     #[test]
-    fn compute_driver_values_are_normalized_without_enumerating_backends() {
-        assert_eq!(TelemetryComputeDriver::from_raw("alpha").as_str(), "alpha");
-        assert_eq!(
-            TelemetryComputeDriver::from_raw(" Alpha ").as_str(),
-            "alpha"
-        );
-        assert_eq!(
-            TelemetryComputeDriver::from_raw("CUSTOM_BACKEND").as_str(),
-            "custom_backend"
-        );
-        assert_eq!(TelemetryComputeDriver::from_raw("beta").as_str(), "beta");
-        assert_eq!(TelemetryComputeDriver::from_raw("gamma").as_str(), "gamma");
+    fn compute_driver_values_are_bounded_by_the_composition_boundary() {
+        assert_eq!(TelemetryComputeDriver::custom().as_str(), "custom");
         assert_eq!(
-            TelemetryComputeDriver::from_raw("private-driver").as_str(),
-            "private-driver"
+            TelemetryComputeDriver::anonymous_category("first_party").as_str(),
+            "first_party"
         );
     }
 
@@ -760,7 +765,7 @@ mod disabled_tests {
             1,
             false,
             SandboxTemplateSource::Default,
-            TelemetryComputeDriver::from_raw("test-driver"),
+            TelemetryComputeDriver::custom(),
         );
         emit_policy_decision(
             PolicyDecisionOperation::Approve,

crates/openshell-gateway/BUILD.bazel

@@ -9,6 +9,8 @@
 #[cfg(all(not(target_os = "windows"), feature = "in-tree-compute-drivers"))]
 mod vm;
 
+#[cfg(all(not(target_os = "windows"), feature = "in-tree-compute-drivers"))]
+use openshell_core::telemetry::TelemetryComputeDriver;
 #[cfg(all(not(target_os = "windows"), feature = "in-tree-compute-drivers"))]
 use openshell_server::ComputeDriverRegistration;
 use openshell_server::ComputeDriverRegistry;
@@ -34,6 +36,7 @@ fn install_in_tree_compute_drivers(registry: &mut ComputeDriverRegistry) {
         )
         .map(|registration| {
             registration
+                .with_telemetry_category(TelemetryComputeDriver::anonymous_category("kubernetes"))
                 .without_mtls_user_auth()
                 .with_inherited_config_keys(&[
                     "namespace",
@@ -54,6 +57,7 @@ fn install_in_tree_compute_drivers(registry: &mut ComputeDriverRegistry) {
         )
         .map(|registration| {
             registration
+                .with_telemetry_category(TelemetryComputeDriver::anonymous_category("podman"))
                 .with_local_singleplayer()
                 .with_tracing_setup(podman_tracing_setup)
                 .with_inherited_config_keys(&[
@@ -73,6 +77,7 @@ fn install_in_tree_compute_drivers(registry: &mut ComputeDriverRegistry) {
         )
         .map(|registration| {
             registration
+                .with_telemetry_category(TelemetryComputeDriver::anonymous_category("docker"))
                 .with_local_singleplayer()
                 .with_inherited_config_keys(&[
                     "sandbox_namespace",
@@ -86,6 +91,7 @@ fn install_in_tree_compute_drivers(registry: &mut ComputeDriverRegistry) {
         }),
         ComputeDriverRegistration::new("vm", u16::MAX, None, VmFactory).map(|registration| {
             registration
+                .with_telemetry_category(TelemetryComputeDriver::anonymous_category("vm"))
                 .with_local_singleplayer()
                 .with_inherited_config_keys(&[
                     "default_image",
@@ -108,18 +114,13 @@ fn podman_tracing_setup(
     let (provider, error) = openshell_driver_podman::otel_tracing::provider_for(otlp_endpoint);
     let layer = provider.as_ref().map(|provider| {
         let layer: openshell_server::ComputeDriverTracingLayer = Box::new(
-            openshell_driver_podman::otel_tracing::in_process_layer(
-                provider,
-            ),
+            openshell_driver_podman::otel_tracing::in_process_layer(provider),
         );
         layer
     });
     let shutdown = provider.map(|provider| {
-        let shutdown: openshell_server::ComputeDriverTracingShutdown = Box::new(move || {
-            provider
-                .shutdown()
-                .map_err(|error| error.to_string())
-        });
+        let shutdown: openshell_server::ComputeDriverTracingShutdown =
+            Box::new(move || provider.shutdown().map_err(|error| error.to_string()));
         shutdown
     });
     openshell_server::ComputeDriverTracingSetup::new(

crates/openshell-gateway/src/lib.rs

@@ -36,6 +36,7 @@ use openshell_core::proto::{
     PlatformEvent, Sandbox, SandboxCondition, SandboxPhase, SandboxSpec, SandboxStatus,
     SandboxTemplate, ServiceEndpoint, SshSession,
 };
+use openshell_core::telemetry::TelemetryComputeDriver;
 use openshell_core::{ObjectLabels, ObjectWorkspace};
 use prost::Message;
 use std::collections::HashMap;
@@ -535,6 +536,7 @@ impl ComputeDriver for RemoteComputeDriver {
 pub struct ComputeRuntime {
     driver: TracedDriver,
     driver_info: ComputeDriverInfoSnapshot,
+    telemetry_compute_driver: TelemetryComputeDriver,
     driver_process: Option<Arc<ManagedDriverProcess>>,
     default_image: String,
     store: Arc<Store>,
@@ -651,6 +653,7 @@ impl ComputeRuntime {
         Ok(Self {
             driver: TracedDriver::new(driver, driver_name),
             driver_info,
+            telemetry_compute_driver: TelemetryComputeDriver::custom(),
             driver_process,
             default_image,
             store,
@@ -727,6 +730,20 @@ impl ComputeRuntime {
         &self.driver_info.name
     }
 
+    #[must_use]
+    pub(crate) fn telemetry_compute_driver(&self) -> TelemetryComputeDriver {
+        self.telemetry_compute_driver
+    }
+
+    #[must_use]
+    pub(crate) fn with_telemetry_compute_driver(
+        mut self,
+        telemetry_compute_driver: TelemetryComputeDriver,
+    ) -> Self {
+        self.telemetry_compute_driver = telemetry_compute_driver;
+        self
+    }
+
     #[must_use]
     pub(crate) fn gateway_listener_requirements(&self) -> &[GatewayListenerRequirement] {
         &self.gateway_listener_requirements
@@ -3995,6 +4012,7 @@ pub async fn new_test_runtime_with_driver(
             driver_version: "test".to_string(),
             gateway_manages_lifecycle: false,
         },
+        telemetry_compute_driver: TelemetryComputeDriver::custom(),
         driver_process: None,
         default_image: "openshell/sandbox:test".to_string(),
         store,
@@ -4679,6 +4697,7 @@ mod tests {
                 driver_version: "test".to_string(),
                 gateway_manages_lifecycle: false,
             },
+            telemetry_compute_driver: TelemetryComputeDriver::custom(),
             driver_process: None,
             default_image: "openshell/sandbox:test".to_string(),
             store,

crates/openshell-server/src/compute/mod.rs

@@ -29,8 +29,7 @@ use openshell_core::proto::{
 };
 use openshell_core::proto::{Sandbox, SandboxPhase, SandboxTemplate, SshSession};
 use openshell_core::telemetry::{
-    LifecycleOperation, LifecycleResource, SandboxTemplateSource, TelemetryComputeDriver,
-    TelemetryOutcome,
+    LifecycleOperation, LifecycleResource, SandboxTemplateSource, TelemetryOutcome,
 };
 use openshell_core::{ObjectId, ObjectName, ObjectWorkspace};
 use prost::Message;
@@ -171,7 +170,7 @@ fn emit_sandbox_create_telemetry(
     request: &CreateSandboxRequest,
     outcome: TelemetryOutcome,
 ) {
-    let compute_driver = telemetry_compute_driver(state.compute.configured_driver_name());
+    let compute_driver = state.compute.telemetry_compute_driver();
     let Some(spec) = request.spec.as_ref() else {
         openshell_core::telemetry::emit_sandbox_create(
             outcome,
@@ -204,10 +203,6 @@ fn emit_sandbox_create_telemetry(
     );
 }
 
-fn telemetry_compute_driver(driver_name: &str) -> TelemetryComputeDriver {
-    TelemetryComputeDriver::from_raw(driver_name)
-}
-
 async fn handle_create_sandbox_inner(
     state: &Arc<ServerState>,
     request: Request<CreateSandboxRequest>,
@@ -2407,30 +2402,6 @@ mod tests {
 
     // ---- shell_escape ----
 
-    #[test]
-    fn telemetry_compute_driver_uses_resolved_driver_kind() {
-        assert_eq!(
-            telemetry_compute_driver("docker"),
-            TelemetryComputeDriver::from_raw("docker")
-        );
-        assert_eq!(
-            telemetry_compute_driver("kubernetes"),
-            TelemetryComputeDriver::from_raw("kubernetes")
-        );
-        assert_eq!(
-            telemetry_compute_driver("podman"),
-            TelemetryComputeDriver::from_raw("podman")
-        );
-        assert_eq!(
-            telemetry_compute_driver("vm"),
-            TelemetryComputeDriver::from_raw("vm")
-        );
-        assert_eq!(
-            telemetry_compute_driver(""),
-            TelemetryComputeDriver::from_raw("")
-        );
-    }
-
     #[test]
     fn shell_escape_safe_chars_pass_through() {
         assert_eq!(shell_escape("ls").unwrap(), "ls");