feat(aws-sdk-rust): add aws sdk request metadata groundwork

Add canonical aws.sdk span attribute keys for the current Rust-supported AWS services and introduce handler-owned request metadata extraction for SQS, SNS, and EventBridge.

Keep the extraction layer explicit by using per-service operation enums and typed service metadata before converting into generic RequestMetadata.

This does not create aws.sdk spans yet; it only prepares the metadata and tag vocabulary they will use.

Author: Dogbu-cyber

integrations/aws/aws-sdk-rust/src/attribute_keys.rs

@@ -1,6 +1,30 @@
 // Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
+// Trace propagation payload keys.
 pub(crate) const DATADOG_ATTRIBUTE_KEY: &str = "_datadog";
 pub(crate) const START_TIME_KEY: &str = "x-datadog-start-time";
-pub(crate) const RESOURCE_NAME_KEY: &str = "x-datadog-resource-name";
+pub(crate) const DATADOG_RESOURCE_NAME_KEY: &str = "x-datadog-resource-name";
+
+// Generic aws.sdk span attributes.
+pub(crate) const AWS_SERVICE: &str = "aws.service";
+pub(crate) const AWS_OPERATION: &str = "aws.operation";
+pub(crate) const AWS_REGION: &str = "region";
+pub(crate) const AWS_PARTITION: &str = "aws.partition";
+pub(crate) const AWS_AGENT: &str = "aws.agent";
+pub(crate) const AWS_REQUEST_ID: &str = "aws.request_id";
+pub(crate) const HTTP_METHOD: &str = "http.method";
+pub(crate) const HTTP_URL: &str = "http.url";
+pub(crate) const HTTP_STATUS_CODE: &str = "http.status_code";
+pub(crate) const COMPONENT: &str = "component";
+pub(crate) const SPAN_KIND: &str = "span.kind";
+pub(crate) const SERVICE_NAME: &str = "service.name";
+pub(crate) const RESOURCE_NAME: &str = "resource.name";
+
+// SQS aws.sdk span attributes.
+pub(crate) const CLOUD_RESOURCE_ID: &str = "cloud.resource_id";
+pub(crate) const QUEUE_NAME: &str = "queuename";
+
+// SNS aws.sdk span attributes.
+pub(crate) const TOPIC_NAME: &str = "topicname";
+pub(crate) const TARGET_NAME: &str = "targetname";

integrations/aws/aws-sdk-rust/src/services/eventbridge.rs

@@ -8,14 +8,38 @@ use aws_sdk_eventbridge::operation::put_events::PutEventsInput;
 use aws_smithy_runtime_api::box_error::BoxError;
 use aws_smithy_runtime_api::client::interceptors::context::Input;
 
-use crate::attribute_keys::{DATADOG_ATTRIBUTE_KEY, RESOURCE_NAME_KEY, START_TIME_KEY};
+use crate::attribute_keys::{DATADOG_ATTRIBUTE_KEY, DATADOG_RESOURCE_NAME_KEY, START_TIME_KEY};
 
-use super::{AwsServiceHandler, ONE_MB};
+use super::{base_request_metadata, AwsServiceHandler, RequestMetadata, ONE_MB};
 
 #[derive(Debug, Clone, Copy, Default)]
 pub(crate) struct EventBridgeService;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum EventBridgeOperation {
+    PutEvents,
+}
+
+impl EventBridgeOperation {
+    fn from_name(operation: &str) -> Option<Self> {
+        match operation {
+            "PutEvents" => Some(Self::PutEvents),
+            _ => None,
+        }
+    }
+
+    fn name(self) -> &'static str {
+        match self {
+            Self::PutEvents => "PutEvents",
+        }
+    }
+}
+
 impl AwsServiceHandler for EventBridgeService {
+    fn service_id(&self) -> &'static str {
+        "EventBridge"
+    }
+
     fn inject(
         &self,
         operation: &str,
@@ -24,14 +48,34 @@ impl AwsServiceHandler for EventBridgeService {
     ) -> Result<(), BoxError> {
         inject(operation, trace_headers, input)
     }
+
+    fn extract_request_metadata(
+        &self,
+        operation: &str,
+        input: &Input,
+        region: &str,
+        partition: &str,
+    ) -> Option<RequestMetadata> {
+        let operation = EventBridgeOperation::from_name(operation)?;
+        if input.downcast_ref::<PutEventsInput>().is_none() {
+            return None;
+        }
+
+        Some(base_request_metadata(
+            self.service_id(),
+            operation.name(),
+            region,
+            partition,
+        ))
+    }
 }
 
 pub(super) fn inject(
     operation: &str,
     trace_headers: HashMap<String, String>,
     input: &mut Input,
 ) -> Result<(), BoxError> {
-    if operation == "PutEvents" {
+    if let Some(EventBridgeOperation::PutEvents) = EventBridgeOperation::from_name(operation) {
         if let Some(put_input) = input.downcast_mut::<PutEventsInput>() {
             inject_into_put_events(put_input, trace_headers)?;
         }
@@ -62,13 +106,13 @@ fn inject_into_put_events(
     for entry in entries.iter_mut() {
         if let Some(name) = entry.event_bus_name.as_deref() {
             ctx.insert(
-                RESOURCE_NAME_KEY.into(),
+                DATADOG_RESOURCE_NAME_KEY.into(),
                 serde_json::Value::String(name.into()),
             );
         }
 
         let trace_ctx = serde_json::Value::Object(ctx.clone());
-        ctx.remove(RESOURCE_NAME_KEY);
+        ctx.remove(DATADOG_RESOURCE_NAME_KEY);
 
         let detail = entry.detail.as_deref().unwrap_or("{}");
         let mut detail_map: serde_json::Map<String, serde_json::Value> =
@@ -101,6 +145,7 @@ mod tests {
         DATADOG_TRACE_ID_KEY,
     };
     use aws_sdk_eventbridge::types::PutEventsRequestEntry;
+    use aws_smithy_runtime_api::client::interceptors::context::Input;
 
     fn parse_detail_datadog(detail: &str) -> HashMap<String, String> {
         let parsed: serde_json::Value = serde_json::from_str(detail).unwrap();
@@ -153,7 +198,7 @@ mod tests {
         let detail = entries[0].detail.as_ref().unwrap();
         let dd = parse_detail_datadog(detail);
         assert_eq!(dd[DATADOG_TRACE_ID_KEY], "123456789");
-        assert!(!dd.contains_key(RESOURCE_NAME_KEY));
+        assert!(!dd.contains_key(DATADOG_RESOURCE_NAME_KEY));
     }
 
     #[test]
@@ -172,7 +217,7 @@ mod tests {
         let entries = input.entries.as_ref().unwrap();
         let detail = entries[0].detail.as_ref().unwrap();
         let dd = parse_detail_datadog(detail);
-        assert_eq!(dd[RESOURCE_NAME_KEY], "my-bus");
+        assert_eq!(dd[DATADOG_RESOURCE_NAME_KEY], "my-bus");
     }
 
     #[test]
@@ -205,9 +250,9 @@ mod tests {
             assert!(dd.contains_key(START_TIME_KEY));
         }
         let dd0 = parse_detail_datadog(entries[0].detail.as_ref().unwrap());
-        assert_eq!(dd0[RESOURCE_NAME_KEY], "bus-1");
+        assert_eq!(dd0[DATADOG_RESOURCE_NAME_KEY], "bus-1");
         let dd1 = parse_detail_datadog(entries[1].detail.as_ref().unwrap());
-        assert!(!dd1.contains_key(RESOURCE_NAME_KEY));
+        assert!(!dd1.contains_key(DATADOG_RESOURCE_NAME_KEY));
     }
 
     #[test]
@@ -285,4 +330,22 @@ mod tests {
             .unwrap();
         assert!(!detail.contains(DATADOG_ATTRIBUTE_KEY));
     }
+
+    #[test]
+    fn extracts_put_events_request_metadata() {
+        let input = Input::erase(PutEventsInput::builder().build().unwrap());
+
+        let metadata = EventBridgeService
+            .extract_request_metadata("PutEvents", &input, "eu-west-1", "aws")
+            .unwrap();
+
+        assert_eq!(metadata.service_name, "aws.EventBridge");
+        assert_eq!(metadata.resource_name, "EventBridge.PutEvents");
+        assert_eq!(metadata.tags["aws.service"], "EventBridge");
+        assert_eq!(metadata.tags["aws.operation"], "PutEvents");
+        assert_eq!(metadata.tags["region"], "eu-west-1");
+        assert_eq!(metadata.tags["aws.partition"], "aws");
+        assert_eq!(metadata.tags["service.name"], "aws.EventBridge");
+        assert_eq!(metadata.tags["resource.name"], "EventBridge.PutEvents");
+    }
 }

integrations/aws/aws-sdk-rust/src/services/mod.rs

@@ -10,6 +10,10 @@ use std::collections::HashMap;
 use aws_smithy_runtime_api::box_error::BoxError;
 use aws_smithy_runtime_api::client::interceptors::context::Input;
 
+use crate::attribute_keys::{
+    AWS_OPERATION, AWS_PARTITION, AWS_REGION, AWS_SERVICE, RESOURCE_NAME, SERVICE_NAME,
+};
+
 pub(crate) use eventbridge::EventBridgeService;
 pub(crate) use sns::SnsService;
 pub(crate) use sqs::SqsService;
@@ -18,12 +22,53 @@ pub(crate) const MAX_MESSAGE_ATTRIBUTES: usize = 10;
 pub(crate) const ONE_MB: usize = 1024 * 1024;
 
 pub(crate) trait AwsServiceHandler {
+    fn service_id(&self) -> &'static str;
+
     fn inject(
         &self,
         operation: &str,
         trace_headers: HashMap<String, String>,
         input: &mut Input,
     ) -> Result<(), BoxError>;
+
+    fn extract_request_metadata(
+        &self,
+        operation: &str,
+        input: &Input,
+        region: &str,
+        partition: &str,
+    ) -> Option<RequestMetadata>;
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RequestMetadata {
+    pub(crate) service_name: String,
+    pub(crate) resource_name: String,
+    pub(crate) tags: HashMap<&'static str, String>,
+}
+
+pub(crate) fn base_request_metadata(
+    service_id: &'static str,
+    operation: &str,
+    region: &str,
+    partition: &str,
+) -> RequestMetadata {
+    let service_name = format!("aws.{service_id}");
+    let resource_name = format!("{service_id}.{operation}");
+    let tags = HashMap::from([
+        (AWS_SERVICE, service_id.to_string()),
+        (AWS_OPERATION, operation.to_string()),
+        (AWS_REGION, region.to_string()),
+        (AWS_PARTITION, partition.to_string()),
+        (SERVICE_NAME, service_name.clone()),
+        (RESOURCE_NAME, resource_name.clone()),
+    ]);
+
+    RequestMetadata {
+        service_name,
+        resource_name,
+        tags,
+    }
 }
 
 #[cfg(test)]