@@ -713,10 +713,12 @@ between a trace and its log lines. Store and compute-driver spans become
 children of the request span. Reconciliation, provider refresh, and
 driver-watch loops create their own operation spans because they have no
 inbound request to provide a parent. gRPC status is recorded when response
-trailers arrive.
+trailers arrive. Gateway spans carry resource attributes for the gateway
+identity and configured compute driver.
 
-The gateway forwards OTLP configuration and W3C trace context to managed
-external drivers. Each driver exports under its own service name.
+The gateway forwards OTLP configuration, its configured gateway name, and W3C
+trace context to managed external drivers. Each driver exports under its own
+service name and carries the gateway name as a resource attribute.
 
 Two invariants shape the failure behavior. Telemetry is diagnostic, so no OTLP
 failure stops the gateway from serving: a malformed endpoint is logged at
 
@@ -91,6 +91,9 @@ struct Args {
     #[arg(long, env = "OPENSHELL_OTLP_ENDPOINT")]
     otlp_endpoint: Option<String>,
 
+    #[arg(long, env = "OPENSHELL_GATEWAY_NAME")]
+    gateway_name: Option<String>,
+
     #[arg(long, env = "OPENSHELL_GRPC_ENDPOINT")]
     openshell_endpoint: Option<String>,
 
@@ -186,8 +189,10 @@ async fn main() -> Result<()> {
         return Ok(());
     }
 
-    let (tracer_provider, setup_error) =
-        openshell_driver_vm::otel_tracing::provider_for(args.otlp_endpoint.as_deref());
+    let (tracer_provider, setup_error) = openshell_driver_vm::otel_tracing::provider_for(
+        args.otlp_endpoint.as_deref(),
+        args.gateway_name.as_deref(),
+    );
     tracing_subscriber::registry()
         .with(EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(&args.log_level)))
         .with(tracing_subscriber::fmt::layer())
@@ -691,11 +696,13 @@ mod tests {
     }
 
     #[test]
-    fn accepts_gateway_otlp_endpoint() {
+    fn accepts_gateway_otlp_configuration() {
         let args = Args::try_parse_from([
             "openshell-driver-vm",
             "--otlp-endpoint",
             "http://127.0.0.1:4317",
+            "--gateway-name",
+            "production-us-west",
         ]);
         assert!(
             args.is_ok(),
 
@@ -88,14 +88,28 @@ fn compute_driver_rpc_operation(path: &str) -> (&'static str, &'static str) {
     }
 }
 
-/// Build a tracer provider for the configured OTLP/gRPC endpoint.
+/// Build a tracer provider for the configured OTLP/gRPC endpoint and gateway.
 #[must_use]
-pub fn provider_for(endpoint: Option<&str>) -> (Option<SdkTracerProvider>, Option<SetupError>) {
-    openshell_otel::provider_for(endpoint.map(|endpoint| OtlpTraceConfig {
-        endpoint,
-        service_name: ServiceName::Fixed(SERVICE_NAME),
-        service_version: Some(openshell_core::VERSION),
-        resource_attributes: Vec::new(),
+pub fn provider_for(
+    endpoint: Option<&str>,
+    gateway_name: Option<&str>,
+) -> (Option<SdkTracerProvider>, Option<SetupError>) {
+    openshell_otel::provider_for(endpoint.map(|endpoint| {
+        OtlpTraceConfig {
+            endpoint,
+            service_name: ServiceName::Fixed(SERVICE_NAME),
+            service_version: Some(openshell_core::VERSION),
+            resource_attributes: gateway_name
+                .map(str::trim)
+                .filter(|name| !name.is_empty())
+                .map(|name| {
+                    vec![opentelemetry::KeyValue::new(
+                        "openshell.gateway.name",
+                        name.to_string(),
+                    )]
+                })
+                .unwrap_or_default(),
+        }
     }))
 }
 
@@ -122,6 +136,7 @@ mod tests {
     struct Received {
         spans: Vec<Span>,
         service_names: Vec<String>,
+        gateway_names: Vec<String>,
     }
 
     #[derive(Clone)]
@@ -140,18 +155,19 @@ mod tests {
                 let mut received = self.received.lock().unwrap();
                 for resource_span in request.into_inner().resource_spans {
                     if let Some(resource) = resource_span.resource {
-                        received.service_names.extend(
-                            resource
-                                .attributes
-                                .into_iter()
-                                .filter(|attribute| attribute.key == "service.name")
-                                .filter_map(|attribute| attribute.value)
-                                .filter_map(|value| value.value)
-                                .filter_map(|value| match value {
-                                    opentelemetry_proto::tonic::common::v1::any_value::Value::StringValue(value) => Some(value),
-                                    _ => None,
-                                }),
-                        );
+                        for attribute in resource.attributes {
+                            let Some(value) = attribute.value.and_then(|value| value.value) else {
+                                continue;
+                            };
+                            let opentelemetry_proto::tonic::common::v1::any_value::Value::StringValue(value) = value else {
+                                continue;
+                            };
+                            match attribute.key.as_str() {
+                                "service.name" => received.service_names.push(value),
+                                "openshell.gateway.name" => received.gateway_names.push(value),
+                                _ => {}
+                            }
+                        }
                     }
                     for scope_span in resource_span.scope_spans {
                         received.spans.extend(scope_span.spans);
@@ -211,7 +227,7 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn vm_driver_spans_reach_otlp_collector_with_distinct_service_name() {
+    async fn vm_driver_spans_reach_otlp_collector_with_resource_identity() {
         let received = Arc::new(Mutex::new(Received::default()));
         let exported = Arc::new(tokio::sync::Notify::new());
         let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
@@ -233,7 +249,10 @@ mod tests {
                 .await
         });
 
-        let (provider, error) = super::provider_for(Some(&format!("http://{address}")));
+        let (provider, error) = super::provider_for(
+            Some(&format!("http://{address}")),
+            Some("production-us-west"),
+        );
         assert!(error.is_none(), "valid OTLP endpoint should configure");
         let provider = provider.expect("provider");
         let subscriber = tracing_subscriber::registry().with(super::layer(&provider));
@@ -272,5 +291,6 @@ mod tests {
             "VM spans should use a distinct service name, got {:?}",
             received.service_names
         );
+        assert_eq!(received.gateway_names, ["production-us-west"]);
     }
 }
@@ -509,12 +509,17 @@ async fn run_from_args(
         .config_file
         .as_ref()
         .and_then(|f| f.openshell.gateway.otlp.as_ref());
+    let gateway_resource = crate::otel_tracing::GatewayResourceAttributes::new(
+        Some(prepared.config.name.as_str()),
+        Some(compute_driver.name()),
+    );
     let (tracing_handle, setup_error) = crate::tracing_setup::install(
         EnvFilter::try_from_default_env()
             .unwrap_or_else(|_| EnvFilter::new(&prepared.config.log_level)),
         &tracing_log_bus,
         otlp_config,
         crate::tracing_setup::podman_export_enabled(&compute_driver),
+        gateway_resource,
     );
 
     let has_client_ca = prepared
 
@@ -478,7 +478,7 @@ pub async fn spawn(
         .arg("--expected-peer-pid")
         .arg(std::process::id().to_string());
     command.arg("--log-level").arg(&config.log_level);
-    append_otlp_args(&mut command, otlp_config);
+    append_otlp_args(&mut command, otlp_config, &config.name);
     command
         .arg("--openshell-endpoint")
         .arg(&vm_config.grpc_endpoint);
@@ -521,9 +521,10 @@ pub async fn spawn(
 }
 
 #[cfg(unix)]
-fn append_otlp_args(command: &mut Command, otlp_config: Option<&OtlpConfig>) {
+fn append_otlp_args(command: &mut Command, otlp_config: Option<&OtlpConfig>, gateway_name: &str) {
     if let Some(config) = otlp_config {
         command.arg("--otlp-endpoint").arg(&config.endpoint);
+        command.arg("--gateway-name").arg(gateway_name);
     }
 }
 
@@ -621,22 +622,31 @@ mod tests {
     use tempfile::tempdir;
 
     #[test]
-    fn vm_driver_command_includes_gateway_otlp_endpoint() {
+    fn vm_driver_command_includes_gateway_otlp_configuration() {
         let mut command = tokio::process::Command::new("openshell-driver-vm");
         append_otlp_args(
             &mut command,
             Some(&OtlpConfig {
                 endpoint: "http://collector.internal:4317".to_string(),
                 service_name: Some("custom-gateway".to_string()),
             }),
+            "production-us-west",
         );
 
         let args = command
             .as_std()
             .get_args()
             .map(|arg| arg.to_string_lossy().into_owned())
             .collect::<Vec<_>>();
-        assert_eq!(args, ["--otlp-endpoint", "http://collector.internal:4317"]);
+        assert_eq!(
+            args,
+            [
+                "--otlp-endpoint",
+                "http://collector.internal:4317",
+                "--gateway-name",
+                "production-us-west"
+            ]
+        );
     }
 
     #[tokio::test]
 
@@ -579,13 +579,8 @@ pub(crate) async fn run_server(
     let sandbox_index = SandboxIndex::new();
     let sandbox_watch_bus = SandboxWatchBus::new();
     let supervisor_sessions = Arc::new(supervisor_session::SupervisorSessionRegistry::new());
-    let driver_startup = compute::driver_config::DriverStartupContext {
-        file: config_file.as_ref(),
-        guest_tls: guest_tls.as_ref(),
-        gateway_port: config.bind_address.port(),
-        gateway_tls_enabled: config.tls.is_some(),
-        endpoint_overrides: &config.compute_driver_endpoints,
-    };
+    let driver_startup =
+        compute_driver_startup_context(&config, config_file.as_ref(), guest_tls.as_ref());
     let (compute, operator_allowlist) = build_compute_runtime(
         &config,
         driver_startup,
@@ -1596,14 +1591,28 @@ async fn build_compute_runtime(
     Ok((runtime, operator_allowlist))
 }
 
+fn compute_driver_startup_context<'a>(
+    config: &'a Config,
+    config_file: Option<&'a config_file::ConfigFile>,
+    guest_tls: Option<&'a compute::driver_config::GuestTlsPaths>,
+) -> compute::driver_config::DriverStartupContext<'a> {
+    compute::driver_config::DriverStartupContext {
+        file: config_file,
+        guest_tls,
+        gateway_port: config.bind_address.port(),
+        gateway_tls_enabled: config.tls.is_some(),
+        endpoint_overrides: &config.compute_driver_endpoints,
+    }
+}
+
 #[derive(Debug, Clone)]
 pub(crate) enum ConfiguredComputeDriver {
     Registered(ComputeDriverRegistration),
     Remote { name: String },
 }
 
 impl ConfiguredComputeDriver {
-    fn name(&self) -> &str {
+    pub(crate) fn name(&self) -> &str {
         match self {
             Self::Registered(registration) => &registration.name,
             Self::Remote { name } => name,