Struct AwsSpan

pub struct AwsSpan { /* private fields */ }

A wrapper around an OpenTelemetry span specifically designed for AWS operations.

This struct represents an active span for an AWS SDK operation. It provides convenient methods for setting span attributes and recording AWS operation status upon its completion, including AWS request ID and optional error.

Usage

AwsSpan can be used for manual instrumentation when you need fine-grained control over span lifecycle. But for most use cases, consider using the higher-level traits like AwsInstrument or AwsBuilderInstrument which provide automatic instrumentation.

Should be constructed using AwsSpanBuilder by calling AwsSpanBuilder::start.

Example

use aws_sdk_dynamodb::{Client as DynamoClient, types::AttributeValue};
use telemetry_rust::{KeyValue, middleware::aws::DynamodbSpanBuilder, semconv};

async fn query_table() -> Result<i32, Box<dyn std::error::Error>> {
    let config = aws_config::load_from_env().await;
    let dynamo_client = DynamoClient::new(&config);

    // Create and start a span manually
    let mut span = DynamodbSpanBuilder::query("table_name")
        .attribute(KeyValue::new(semconv::AWS_DYNAMODB_INDEX_NAME, "my_index"))
        .start();

    let response = dynamo_client
        .query()
        .table_name("table_name")
        .index_name("my_index")
        .key_condition_expression("PK = :pk")
        .expression_attribute_values(":pk", AttributeValue::S("Test".to_string()))
        .send()
        .await;

    // Add attributes from response
    if let Some(output) = response.as_ref().ok() {
        let count = output.count() as i64;
        let scanned_count = output.scanned_count() as i64;
        span.set_attributes([
            KeyValue::new(semconv::AWS_DYNAMODB_COUNT, count),
            KeyValue::new(semconv::AWS_DYNAMODB_SCANNED_COUNT, scanned_count),
        ]);
    }

    // The span automatically handles success/error and request ID extraction
    span.end(&response);

    let response = response?;
    println!("DynamoDB items: {:#?}", response.items());
    Ok(response.count())
}

Implementations

impl AwsSpan

pub fn end<T, E>(self, aws_response: &Result<T, E>)

where T: RequestId, E: RequestId + Error,

Ends the span with AWS response information.

This method finalizes the span by recording the outcome of an AWS operation. It automatically extracts request IDs and handles error reporting.

Arguments

• aws_response - The result of the AWS operation, which must implement RequestId for both success and error cases

Behavior

• On success: Sets span status to OK and records the request ID
• On error: Records the error, sets error status, and records the request ID if available

pub fn set_attribute(&mut self, attribute: KeyValue)

Sets a single attribute on the span.

This method allows you to add custom attributes to the span after it has been created. This is useful for adding dynamic attributes that become available during operation execution.

For more information see BoxedSpan::set_attribute

Arguments

• attribute - The KeyValue attribute to add to the span

Example

use telemetry_rust::{KeyValue, middleware::aws::AwsSpanBuilder};

let mut span = AwsSpanBuilder::client("DynamoDB", "GetItem", []).start();
span.set_attribute(KeyValue::new("custom.attribute", "value"));

pub fn set_attributes(&mut self, attributes: impl IntoIterator<Item = KeyValue>)

Sets multiple attributes on the span.

This method allows you to add multiple custom attributes to the span at once. This is more efficient than calling set_attribute multiple times.

For more information see BoxedSpan::set_attributes

Arguments

• attributes - An iterator of KeyValue attributes to add to the span

Example

use telemetry_rust::{KeyValue, middleware::aws::AwsSpanBuilder, semconv};

let mut span = AwsSpanBuilder::client("DynamoDB", "GetItem", []).start();
span.set_attributes([
    KeyValue::new(semconv::DB_NAMESPACE, "my_table"),
    KeyValue::new("custom.attribute", "value"),
]);

Trait Implementations

impl From<BoxedSpan> for AwsSpan

fn from(span: BoxedSpan) -> Self

Converts to this type from the input type.

impl<T, E> InstrumentedFutureContext<Result<T, E>> for AwsSpan

where T: RequestId, E: RequestId + Error,

fn on_result(self, result: &Result<T, E>)

Called when the instrumented future completes with a result.