telemetry-rust 6.10.0

/// AWS DynamoDB fluent builder instrumentation implementations
/// Generated by GitHub Copilot with human guidance
use super::{utils::*, *};
use crate::semconv;

/// Utility trait to deduplicate elements in an iterator and convert them to owned values.
///
/// This trait is used to extract unique table names from batch operations.
trait ToUniqOwned<'a, T: ToOwned + ?Sized + 'a>: Iterator<Item = &'a T> {
    /// Consumes the iterator, returning a new iterator over unique owned elements.
    fn uniq_owned(self) -> impl Iterator<Item = T::Owned>;
}

impl<'a, T, I> ToUniqOwned<'a, T> for I
where
    T: Ord + ToOwned + ?Sized + 'a,
    I: Iterator<Item = &'a T>,
{
    /// An implementation that collects items into a temporary vector,
    /// which is then sorted and deduped.
    ///
    /// This implementation has an `O(n * log(n))` complexity due to [`core::slice::sort::unstable`] being used,
    /// but for small collections it should be more efficient than using a [`std::collections::HashSet`].
    fn uniq_owned(self) -> impl Iterator<Item = T::Owned> {
        let mut input = self.collect::<Vec<_>>();
        input.sort_unstable();
        input.dedup();
        input.into_iter().map(ToOwned::to_owned)
    }
}

impl<'a> AwsBuilderInstrument<'a> for GetItemFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        let attributes = attributes![
            self.get_consistent_read()
                .as_attribute(semconv::AWS_DYNAMODB_CONSISTENT_READ),
            self.get_projection_expression()
                .as_attribute(semconv::AWS_DYNAMODB_PROJECTION),
        ];
        DynamodbSpanBuilder::get_item(table_name).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for GetItemOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::get_item);

impl<'a> AwsBuilderInstrument<'a> for GetResourcePolicyFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_resource_arn().clone().unwrap_or_default();
        DynamodbSpanBuilder::get_resource_policy(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for GetResourcePolicyOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::get_resource_policy);

impl<'a> AwsBuilderInstrument<'a> for PutItemFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::put_item(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for PutItemOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::put_item);

impl<'a> AwsBuilderInstrument<'a> for PutResourcePolicyFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_resource_arn().clone().unwrap_or_default();
        DynamodbSpanBuilder::put_resource_policy(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for PutResourcePolicyOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::put_resource_policy);

impl<'a> AwsBuilderInstrument<'a> for UpdateItemFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::update_item(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for UpdateItemOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::update_item);

impl<'a> AwsBuilderInstrument<'a> for DeleteItemFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::delete_item(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for DeleteItemOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::delete_item);

impl<'a> AwsBuilderInstrument<'a> for DeleteResourcePolicyFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_resource_arn().clone().unwrap_or_default();
        DynamodbSpanBuilder::delete_resource_policy(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for DeleteResourcePolicyOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::delete_resource_policy);

impl<'a> AwsBuilderInstrument<'a> for QueryFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        let attributes = attributes![
            self.get_attributes_to_get()
                .as_attribute(semconv::AWS_DYNAMODB_ATTRIBUTES_TO_GET),
            self.get_consistent_read()
                .as_attribute(semconv::AWS_DYNAMODB_CONSISTENT_READ),
            self.get_index_name()
                .as_attribute(semconv::AWS_DYNAMODB_INDEX_NAME),
            self.get_limit().as_attribute(semconv::AWS_DYNAMODB_LIMIT),
            self.get_projection_expression()
                .as_attribute(semconv::AWS_DYNAMODB_PROJECTION),
            self.get_scan_index_forward()
                .as_attribute(semconv::AWS_DYNAMODB_SCAN_FORWARD),
            self.get_select().as_attribute(semconv::AWS_DYNAMODB_SELECT),
        ];
        DynamodbSpanBuilder::query(table_name).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for QueryOutput {
    fn extract_attributes(&self) -> impl IntoIterator<Item = KeyValue> {
        [
            KeyValue::new(semconv::AWS_DYNAMODB_COUNT, self.count() as i64),
            KeyValue::new(
                semconv::AWS_DYNAMODB_SCANNED_COUNT,
                self.scanned_count() as i64,
            ),
        ]
    }
}
instrument_aws_operation!(aws_sdk_dynamodb::operation::query);

impl<'a> AwsBuilderInstrument<'a> for ScanFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        let attributes = attributes![
            self.get_attributes_to_get()
                .as_attribute(semconv::AWS_DYNAMODB_ATTRIBUTES_TO_GET),
            self.get_consistent_read()
                .as_attribute(semconv::AWS_DYNAMODB_CONSISTENT_READ),
            self.get_index_name()
                .as_attribute(semconv::AWS_DYNAMODB_INDEX_NAME),
            self.get_limit().as_attribute(semconv::AWS_DYNAMODB_LIMIT),
            self.get_projection_expression()
                .as_attribute(semconv::AWS_DYNAMODB_PROJECTION),
            self.get_select().as_attribute(semconv::AWS_DYNAMODB_SELECT),
            self.get_segment()
                .as_attribute(semconv::AWS_DYNAMODB_SEGMENT),
            self.get_total_segments()
                .as_attribute(semconv::AWS_DYNAMODB_TOTAL_SEGMENTS),
        ];
        DynamodbSpanBuilder::scan(table_name).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for ScanOutput {
    fn extract_attributes(&self) -> impl IntoIterator<Item = KeyValue> {
        [
            KeyValue::new(semconv::AWS_DYNAMODB_COUNT, self.count() as i64),
            KeyValue::new(
                semconv::AWS_DYNAMODB_SCANNED_COUNT,
                self.scanned_count() as i64,
            ),
        ]
    }
}
instrument_aws_operation!(aws_sdk_dynamodb::operation::scan);

impl<'a> AwsBuilderInstrument<'a> for BatchGetItemFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_names = self
            .get_request_items()
            .iter()
            .flat_map(|items| items.keys())
            .map(ToOwned::to_owned);
        let attributes = attributes![
            self.get_request_items()
                .as_ref()
                .map(|items| items.len())
                .as_attribute(semconv::DB_OPERATION_BATCH_SIZE)
        ];
        DynamodbSpanBuilder::batch_get_item(table_names).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for BatchGetItemOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::batch_get_item);

impl<'a> AwsBuilderInstrument<'a> for BatchWriteItemFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_names = self
            .get_request_items()
            .iter()
            .flat_map(|items| items.keys())
            .map(ToOwned::to_owned);
        let attributes = attributes![
            self.get_request_items()
                .as_ref()
                .map(|items| items.len())
                .as_attribute(semconv::DB_OPERATION_BATCH_SIZE)
        ];
        DynamodbSpanBuilder::batch_write_item(table_names).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for BatchWriteItemOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::batch_write_item);

impl<'a> AwsBuilderInstrument<'a> for TransactGetItemsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_names = self
            .get_transact_items()
            .iter()
            .flatten()
            .flat_map(|item| item.get().map(|op| op.table_name()))
            .uniq_owned();
        DynamodbSpanBuilder::transact_get_items(table_names)
    }
}
impl InstrumentedFluentBuilderOutput for TransactGetItemsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::transact_get_items);

impl<'a> AwsBuilderInstrument<'a> for TransactWriteItemsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_names = self
            .get_transact_items()
            .iter()
            .flatten()
            .flat_map(|item| {
                [
                    item.condition_check().map(|op| op.table_name()),
                    item.put().map(|op| op.table_name()),
                    item.delete().map(|op| op.table_name()),
                    item.update().map(|op| op.table_name()),
                ]
            })
            .flatten()
            .uniq_owned();
        DynamodbSpanBuilder::transact_write_items(table_names)
    }
}
impl InstrumentedFluentBuilderOutput for TransactWriteItemsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::transact_write_items);

// Table management operations
impl<'a> AwsBuilderInstrument<'a> for CreateTableFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        let throughput = self.get_provisioned_throughput().as_ref();
        let attributes = attributes![
            throughput
                .map(|pt| pt.read_capacity_units())
                .as_attribute(semconv::AWS_DYNAMODB_PROVISIONED_READ_CAPACITY),
            throughput
                .map(|pt| pt.write_capacity_units())
                .as_attribute(semconv::AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY),
        ];
        DynamodbSpanBuilder::create_table(table_name).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for CreateTableOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::create_table);

impl<'a> AwsBuilderInstrument<'a> for DeleteTableFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::delete_table(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for DeleteTableOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::delete_table);

impl<'a> AwsBuilderInstrument<'a> for DescribeTableFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::describe_table(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for DescribeTableOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::describe_table);

impl<'a> AwsBuilderInstrument<'a> for UpdateTableFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        let throughput = self.get_provisioned_throughput().as_ref();
        let attributes = attributes![
            throughput
                .map(|pt| pt.read_capacity_units())
                .as_attribute(semconv::AWS_DYNAMODB_PROVISIONED_READ_CAPACITY),
            throughput
                .map(|pt| pt.write_capacity_units())
                .as_attribute(semconv::AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY),
        ];
        DynamodbSpanBuilder::update_table(table_name).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for UpdateTableOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::update_table);

impl<'a> AwsBuilderInstrument<'a> for ListTablesFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let attributes = attributes![
            self.get_exclusive_start_table_name()
                .as_attribute(semconv::AWS_DYNAMODB_EXCLUSIVE_START_TABLE),
            self.get_limit().as_attribute(semconv::AWS_DYNAMODB_LIMIT),
        ];
        DynamodbSpanBuilder::list_tables().attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for ListTablesOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::list_tables);

// Backup operations
impl<'a> AwsBuilderInstrument<'a> for CreateBackupFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::create_backup(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for CreateBackupOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::create_backup);

impl<'a> AwsBuilderInstrument<'a> for DeleteBackupFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        DynamodbSpanBuilder::delete_backup()
    }
}
impl InstrumentedFluentBuilderOutput for DeleteBackupOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::delete_backup);

impl<'a> AwsBuilderInstrument<'a> for DescribeBackupFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        DynamodbSpanBuilder::describe_backup()
    }
}
impl InstrumentedFluentBuilderOutput for DescribeBackupOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::describe_backup);

impl<'a> AwsBuilderInstrument<'a> for ListBackupsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::list_backups(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for ListBackupsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::list_backups);

impl<'a> AwsBuilderInstrument<'a> for RestoreTableFromBackupFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let target_table_name = self.get_target_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::restore_table_from_backup(target_table_name)
    }
}
impl InstrumentedFluentBuilderOutput for RestoreTableFromBackupOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::restore_table_from_backup);

impl<'a> AwsBuilderInstrument<'a> for RestoreTableToPointInTimeFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let target_table_name = self.get_target_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::restore_table_to_point_in_time(target_table_name)
    }
}
impl InstrumentedFluentBuilderOutput for RestoreTableToPointInTimeOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::restore_table_to_point_in_time);

// PartiQL operations
impl<'a> AwsBuilderInstrument<'a> for ExecuteStatementFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table = self
            .get_statement()
            .as_deref()
            .map(TableReference::from)
            .unwrap_or_default();

        let attributes = attributes![
            table.index_name(),
            self.get_consistent_read()
                .as_attribute(semconv::AWS_DYNAMODB_CONSISTENT_READ),
            self.get_limit().as_attribute(semconv::AWS_DYNAMODB_LIMIT),
        ];

        DynamodbSpanBuilder::execute_statement(table.name.to_owned())
            .attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for ExecuteStatementOutput {
    fn extract_attributes(&self) -> impl IntoIterator<Item = KeyValue> {
        attributes![self.items().len().as_attribute(semconv::AWS_DYNAMODB_COUNT)]
    }
}
instrument_aws_operation!(aws_sdk_dynamodb::operation::execute_statement);

impl<'a> AwsBuilderInstrument<'a> for BatchExecuteStatementFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_names = self
            .get_statements()
            .iter()
            .flatten()
            .map(|op| TableReference::from(op.statement()).name)
            .uniq_owned();

        let attributes = attributes![
            self.get_statements()
                .as_ref()
                .map(|statements| statements.len())
                .as_attribute(semconv::DB_OPERATION_BATCH_SIZE)
        ];

        DynamodbSpanBuilder::batch_execute_statement(table_names).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for BatchExecuteStatementOutput {
    fn extract_attributes(&self) -> impl IntoIterator<Item = KeyValue> {
        let errors = self
            .responses()
            .iter()
            .filter_map(|resp| resp.error())
            .count();
        attributes![errors.as_attribute("db.operation.batch.errors")]
    }
}
instrument_aws_operation!(aws_sdk_dynamodb::operation::batch_execute_statement);

impl<'a> AwsBuilderInstrument<'a> for ExecuteTransactionFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_names = self
            .get_transact_statements()
            .iter()
            .flatten()
            .map(|t| TableReference::from(t.statement()).name)
            .uniq_owned();

        let attributes = attributes![
            self.get_transact_statements()
                .as_ref()
                .map(|statements| statements.len())
                .as_attribute(semconv::DB_OPERATION_BATCH_SIZE)
        ];

        DynamodbSpanBuilder::execute_transaction(table_names).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for ExecuteTransactionOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::execute_transaction);

// Additional global operations
impl<'a> AwsBuilderInstrument<'a> for DescribeEndpointsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        DynamodbSpanBuilder::describe_endpoints()
    }
}
impl InstrumentedFluentBuilderOutput for DescribeEndpointsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::describe_endpoints);

impl<'a> AwsBuilderInstrument<'a> for DescribeLimitsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        DynamodbSpanBuilder::describe_limits()
    }
}
impl InstrumentedFluentBuilderOutput for DescribeLimitsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::describe_limits);

impl<'a> AwsBuilderInstrument<'a> for ListGlobalTablesFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let attributes = attributes![
            self.get_exclusive_start_global_table_name()
                .as_attribute(semconv::AWS_DYNAMODB_EXCLUSIVE_START_TABLE),
            self.get_limit().as_attribute(semconv::AWS_DYNAMODB_LIMIT),
            self.get_region_name().as_attribute(semconv::CLOUD_REGION),
        ];
        DynamodbSpanBuilder::list_global_tables().attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for ListGlobalTablesOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::list_global_tables);

// Import/Export operations
impl<'a> AwsBuilderInstrument<'a> for DescribeExportFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        DynamodbSpanBuilder::describe_export()
    }
}
impl InstrumentedFluentBuilderOutput for DescribeExportOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::describe_export);

impl<'a> AwsBuilderInstrument<'a> for DescribeImportFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        DynamodbSpanBuilder::describe_import()
    }
}
impl InstrumentedFluentBuilderOutput for DescribeImportOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::describe_import);

impl<'a> AwsBuilderInstrument<'a> for ImportTableFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self
            .get_table_creation_parameters()
            .as_ref()
            .map(|p| p.table_name())
            .map(ToOwned::to_owned)
            .unwrap_or_default();
        DynamodbSpanBuilder::import_table(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for ImportTableOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::import_table);

impl<'a> AwsBuilderInstrument<'a> for ExportTableToPointInTimeFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_arn = self.get_table_arn().clone().unwrap_or_default();
        DynamodbSpanBuilder::export_table_to_point_in_time(table_arn)
    }
}
impl InstrumentedFluentBuilderOutput for ExportTableToPointInTimeOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::export_table_to_point_in_time);

impl<'a> AwsBuilderInstrument<'a> for ListExportsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_arn = self.get_table_arn().clone().unwrap_or_default();
        let attributes = attributes![
            self.get_max_results()
                .as_attribute(semconv::AWS_DYNAMODB_LIMIT)
        ];
        DynamodbSpanBuilder::list_exports(table_arn).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for ListExportsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::list_exports);

impl<'a> AwsBuilderInstrument<'a> for ListImportsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_arn = self.get_table_arn().clone().unwrap_or_default();
        let attributes = attributes![
            self.get_page_size()
                .as_attribute(semconv::AWS_DYNAMODB_LIMIT)
        ];
        DynamodbSpanBuilder::list_imports(table_arn).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for ListImportsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::list_imports);

// Global table operations
impl<'a> AwsBuilderInstrument<'a> for CreateGlobalTableFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let global_table_name = self.get_global_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::create_global_table(global_table_name)
    }
}
impl InstrumentedFluentBuilderOutput for CreateGlobalTableOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::create_global_table);

impl<'a> AwsBuilderInstrument<'a> for DescribeGlobalTableFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let global_table_name = self.get_global_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::describe_global_table(global_table_name)
    }
}
impl InstrumentedFluentBuilderOutput for DescribeGlobalTableOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::describe_global_table);

impl<'a> AwsBuilderInstrument<'a> for DescribeGlobalTableSettingsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let global_table_name = self.get_global_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::describe_global_table_settings(global_table_name)
    }
}
impl InstrumentedFluentBuilderOutput for DescribeGlobalTableSettingsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::describe_global_table_settings);

impl<'a> AwsBuilderInstrument<'a> for UpdateGlobalTableFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let global_table_name = self.get_global_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::update_global_table(global_table_name)
    }
}
impl InstrumentedFluentBuilderOutput for UpdateGlobalTableOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::update_global_table);

impl<'a> AwsBuilderInstrument<'a> for UpdateGlobalTableSettingsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let global_table_name = self.get_global_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::update_global_table_settings(global_table_name)
    }
}
impl InstrumentedFluentBuilderOutput for UpdateGlobalTableSettingsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::update_global_table_settings);

// Additional table management operations
impl<'a> AwsBuilderInstrument<'a> for DescribeContinuousBackupsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::describe_continuous_backups(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for DescribeContinuousBackupsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::describe_continuous_backups);

impl<'a> AwsBuilderInstrument<'a> for UpdateContinuousBackupsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::update_continuous_backups(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for UpdateContinuousBackupsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::update_continuous_backups);

impl<'a> AwsBuilderInstrument<'a> for DescribeTimeToLiveFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::describe_time_to_live(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for DescribeTimeToLiveOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::describe_time_to_live);

impl<'a> AwsBuilderInstrument<'a> for UpdateTimeToLiveFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::update_time_to_live(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for UpdateTimeToLiveOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::update_time_to_live);

impl<'a> AwsBuilderInstrument<'a> for DescribeTableReplicaAutoScalingFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::describe_table_replica_auto_scaling(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for DescribeTableReplicaAutoScalingOutput {}
instrument_aws_operation!(
    aws_sdk_dynamodb::operation::describe_table_replica_auto_scaling
);

impl<'a> AwsBuilderInstrument<'a> for UpdateTableReplicaAutoScalingFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::update_table_replica_auto_scaling(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for UpdateTableReplicaAutoScalingOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::update_table_replica_auto_scaling);

// Kinesis streaming operations
impl<'a> AwsBuilderInstrument<'a> for DescribeKinesisStreamingDestinationFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::describe_kinesis_streaming_destination(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for DescribeKinesisStreamingDestinationOutput {}
instrument_aws_operation!(
    aws_sdk_dynamodb::operation::describe_kinesis_streaming_destination
);

impl<'a> AwsBuilderInstrument<'a> for EnableKinesisStreamingDestinationFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::enable_kinesis_streaming_destination(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for EnableKinesisStreamingDestinationOutput {}
instrument_aws_operation!(
    aws_sdk_dynamodb::operation::enable_kinesis_streaming_destination
);

impl<'a> AwsBuilderInstrument<'a> for DisableKinesisStreamingDestinationFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::disable_kinesis_streaming_destination(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for DisableKinesisStreamingDestinationOutput {}
instrument_aws_operation!(
    aws_sdk_dynamodb::operation::disable_kinesis_streaming_destination
);

impl<'a> AwsBuilderInstrument<'a> for UpdateKinesisStreamingDestinationFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        DynamodbSpanBuilder::update_kinesis_streaming_destination(table_name)
    }
}
impl InstrumentedFluentBuilderOutput for UpdateKinesisStreamingDestinationOutput {}
instrument_aws_operation!(
    aws_sdk_dynamodb::operation::update_kinesis_streaming_destination
);

// Contributor insights operations
impl<'a> AwsBuilderInstrument<'a> for DescribeContributorInsightsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        let attributes = attributes![
            self.get_index_name()
                .as_attribute(semconv::AWS_DYNAMODB_INDEX_NAME)
        ];
        DynamodbSpanBuilder::describe_contributor_insights(table_name)
            .attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for DescribeContributorInsightsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::describe_contributor_insights);

impl<'a> AwsBuilderInstrument<'a> for ListContributorInsightsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        let attributes = attributes![
            self.get_max_results()
                .as_attribute(semconv::AWS_DYNAMODB_LIMIT)
        ];
        DynamodbSpanBuilder::list_contributor_insights(table_name).attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for ListContributorInsightsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::list_contributor_insights);

impl<'a> AwsBuilderInstrument<'a> for UpdateContributorInsightsFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let table_name = self.get_table_name().clone().unwrap_or_default();
        let attributes = attributes![
            self.get_index_name()
                .as_attribute(semconv::AWS_DYNAMODB_INDEX_NAME)
        ];
        DynamodbSpanBuilder::update_contributor_insights(table_name)
            .attributes(attributes)
    }
}
impl InstrumentedFluentBuilderOutput for UpdateContributorInsightsOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::update_contributor_insights);

// Resource tagging operations
impl<'a> AwsBuilderInstrument<'a> for ListTagsOfResourceFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let resource_arn = self.get_resource_arn().clone().unwrap_or_default();
        DynamodbSpanBuilder::list_tags_of_resource(resource_arn)
    }
}
impl InstrumentedFluentBuilderOutput for ListTagsOfResourceOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::list_tags_of_resource);

impl<'a> AwsBuilderInstrument<'a> for TagResourceFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let resource_arn = self.get_resource_arn().clone().unwrap_or_default();
        DynamodbSpanBuilder::tag_resource(resource_arn)
    }
}
impl InstrumentedFluentBuilderOutput for TagResourceOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::tag_resource);

impl<'a> AwsBuilderInstrument<'a> for UntagResourceFluentBuilder {
    fn build_aws_span(&self) -> AwsSpanBuilder<'a> {
        let resource_arn = self.get_resource_arn().clone().unwrap_or_default();
        DynamodbSpanBuilder::untag_resource(resource_arn)
    }
}
impl InstrumentedFluentBuilderOutput for UntagResourceOutput {}
instrument_aws_operation!(aws_sdk_dynamodb::operation::untag_resource);