AWS SDK

version = "1.2.10"

version = "1.9.5"

version = "1.3.11"

version = "1.1.5"

version = "1.9.5"

version = "1.3.11"

version = "1.2.10"

            format!("{creds:?}"),

            format!("{creds:?}"),

version = "1.2.10"

version = "1.3.8"

[dependencies.aws-smithy-observability]

path = "../aws-smithy-observability"

version = "0.2.0"

version = "1.9.5"

version = "1.3.11"

[target."cfg(all(not(target_arch = \"powerpc\"), not(target_family = \"wasm\")))".dependencies.aws-smithy-observability-otel]

version = "0.1.3"

path = "../aws-smithy-observability-otel"

[target."cfg(all(not(target_arch = \"powerpc\"), not(target_family = \"wasm\")))".dev-dependencies.opentelemetry_sdk]

version = "0.27.1"

features = ["metrics"]

serial_test = "3"

version = "1.2.10"

/*

 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

 * SPDX-License-Identifier: Apache-2.0

 */

//! Endpoint override detection for business metrics tracking

use aws_smithy_runtime_api::box_error::BoxError;

use aws_smithy_runtime_api::client::interceptors::context::BeforeTransmitInterceptorContextRef;

use aws_smithy_runtime_api::client::interceptors::Intercept;

use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;

use aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

use aws_smithy_types::config_bag::{ConfigBag, FrozenLayer, Layer};

use crate::sdk_feature::AwsSdkFeature;

/// Interceptor that detects custom endpoint URLs for business metrics

///

/// This interceptor checks at runtime if a `StaticUriEndpointResolver` is configured,

/// which indicates that `.endpoint_url()` was called. When detected, it stores the

/// `AwsSdkFeature::EndpointOverride` feature flag for business metrics tracking.

#[derive(Debug, Default)]

#[non_exhaustive]

pub struct EndpointOverrideInterceptor;

impl EndpointOverrideInterceptor {

    /// Creates a new EndpointOverrideInterceptor

    pub fn new() -> Self {

        Self

    }

}

impl Intercept for EndpointOverrideInterceptor {

    fn name(&self) -> &'static str {

        "EndpointOverrideInterceptor"

    }

    fn read_after_serialization(

        &self,

        _context: &BeforeTransmitInterceptorContextRef<'_>,

        runtime_components: &RuntimeComponents,

        cfg: &mut ConfigBag,

    ) -> Result<(), BoxError> {

        // Check if the endpoint resolver is a StaticUriEndpointResolver

        // This indicates that .endpoint_url() was called

        let resolver = runtime_components.endpoint_resolver();

        // Check the resolver's debug string to see if it's StaticUriEndpointResolver

        let debug_str = format!("{:?}", resolver);

        if debug_str.contains("StaticUriEndpointResolver") {

            // Store in interceptor_state

            cfg.interceptor_state()

                .store_append(AwsSdkFeature::EndpointOverride);

        }

        Ok(())

    }

}

/// Runtime plugin that detects when a custom endpoint URL has been configured

/// and tracks it for business metrics.

///

/// This plugin is created by the codegen decorator when a user explicitly

/// sets an endpoint URL via `.endpoint_url()`. It stores the

/// `AwsSdkFeature::EndpointOverride` feature flag in the ConfigBag for

/// business metrics tracking.

#[derive(Debug, Default)]

#[non_exhaustive]

pub struct EndpointOverrideRuntimePlugin {

    config: Option<FrozenLayer>,

}

impl EndpointOverrideRuntimePlugin {

    /// Creates a new `EndpointOverrideRuntimePlugin` with the given config layer

    pub fn new(config: Option<FrozenLayer>) -> Self {

        Self { config }

    }

    /// Creates a new `EndpointOverrideRuntimePlugin` and marks that endpoint override is enabled

    pub fn new_with_feature_flag() -> Self {

        let mut layer = Layer::new("endpoint_override");

        layer.store_append(AwsSdkFeature::EndpointOverride);

        Self {

            config: Some(layer.freeze()),

        }

    }

}

impl RuntimePlugin for EndpointOverrideRuntimePlugin {

    fn config(&self) -> Option<FrozenLayer> {

        self.config.clone()

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::sdk_feature::AwsSdkFeature;

    #[test]

    fn test_plugin_with_no_config() {

        let plugin = EndpointOverrideRuntimePlugin::default();

        assert!(plugin.config().is_none());

    }

    #[test]

    fn test_plugin_with_feature_flag() {

        let plugin = EndpointOverrideRuntimePlugin::new_with_feature_flag();

        let config = plugin.config().expect("config should be set");

        // Verify the feature flag is present in the config

        let features: Vec<_> = config.load::<AwsSdkFeature>().cloned().collect();

        assert_eq!(features.len(), 1);

        assert_eq!(features[0], AwsSdkFeature::EndpointOverride);

    }

    #[test]

    fn test_interceptor_detects_static_uri_resolver() {

        use aws_smithy_runtime::client::orchestrator::endpoints::StaticUriEndpointResolver;

        use aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver;

        use aws_smithy_runtime_api::client::interceptors::context::{Input, InterceptorContext};

        use aws_smithy_runtime_api::client::orchestrator::HttpRequest;

        use aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder;

        use aws_smithy_types::config_bag::ConfigBag;

        // Create a StaticUriEndpointResolver

        let endpoint_resolver = SharedEndpointResolver::new(StaticUriEndpointResolver::uri(

            "https://custom.example.com",

        ));

        let mut context = InterceptorContext::new(Input::doesnt_matter());

        context.enter_serialization_phase();

        context.set_request(HttpRequest::empty());

        let _ = context.take_input();

        context.enter_before_transmit_phase();

        let rc = RuntimeComponentsBuilder::for_tests()

            .with_endpoint_resolver(Some(endpoint_resolver))

            .build()

            .unwrap();

        let mut cfg = ConfigBag::base();

        let interceptor = EndpointOverrideInterceptor::new();

        let ctx = Into::into(&context);

        interceptor

            .read_after_serialization(&ctx, &rc, &mut cfg)

            .unwrap();

        // Verify the feature flag was set

        let features: Vec<_> = cfg

            .interceptor_state()

            .load::<AwsSdkFeature>()

            .cloned()

            .collect();

        assert_eq!(features.len(), 1, "Expected 1 feature, got: {features:?}");

        assert_eq!(features[0], AwsSdkFeature::EndpointOverride);

    }

}

            eprintln!("test: {i}");

                if format!("{msg}").contains(substr) {

                    Err(format!("Expected {msg} to contain {substr}"))

                Err(format!("Expected to succeed but got: {err}"))

            eprintln!("Test case failed: {copy:#?}");

            eprintln!("failure: {e}");

            eprintln!("test: {i}");

/// Supporting code for endpoint override detection in the AWS SDK.

pub mod endpoint_override;

/// Supporting code for observability feature detection in the AWS SDK.

pub mod observability_detection;

/*

 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

 * SPDX-License-Identifier: Apache-2.0

 */

//! Observability feature detection for business metrics tracking

//!

//! This module provides an interceptor for detecting observability features in the AWS SDK:

//!

//! - [`ObservabilityDetectionInterceptor`]: Detects observability features during

//!   request processing and tracks them for business metrics in the User-Agent header.

#[cfg(all(not(target_arch = "powerpc"), not(target_family = "wasm")))]

use crate::sdk_feature::AwsSdkFeature;

#[cfg(all(not(target_arch = "powerpc"), not(target_family = "wasm")))]

use aws_smithy_observability_otel::meter::OtelMeterProvider;

#[cfg(all(not(target_arch = "powerpc"), not(target_family = "wasm")))]

use aws_smithy_runtime::client::sdk_feature::SmithySdkFeature;

use aws_smithy_runtime_api::box_error::BoxError;

use aws_smithy_runtime_api::client::interceptors::context::BeforeTransmitInterceptorContextRef;

use aws_smithy_runtime_api::client::interceptors::Intercept;

use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;

use aws_smithy_types::config_bag::ConfigBag;

/// Interceptor that detects when observability features are being used

/// and tracks them for business metrics.

#[derive(Debug, Default)]

#[non_exhaustive]

pub struct ObservabilityDetectionInterceptor;

impl ObservabilityDetectionInterceptor {

    /// Creates a new `ObservabilityDetectionInterceptor`

    pub fn new() -> Self {

        Self

    }

}

impl Intercept for ObservabilityDetectionInterceptor {

    fn name(&self) -> &'static str {

        "ObservabilityDetectionInterceptor"

    }

    fn read_before_signing(

        &self,

        _context: &BeforeTransmitInterceptorContextRef<'_>,

        _runtime_components: &RuntimeComponents,

        _cfg: &mut ConfigBag,

    ) -> Result<(), BoxError> {

        #[cfg(all(not(target_arch = "powerpc"), not(target_family = "wasm")))]

        {

            // Try to get the global telemetry provider

            if let Ok(provider) = aws_smithy_observability::global::get_telemetry_provider() {

                let meter_provider = provider.meter_provider();

                // Check if this is an OpenTelemetry meter provider

                let is_otel = meter_provider

                    .as_any()

                    .downcast_ref::<OtelMeterProvider>()

                    .is_some();

                // Check if this is a noop provider (we don't want to track noop)

                let is_noop = meter_provider

                    .as_any()

                    .downcast_ref::<aws_smithy_observability::noop::NoopMeterProvider>()

                    .is_some();

                if !is_noop {

                    // Track generic observability metrics (for any non-noop provider)

                    _cfg.interceptor_state()

                        .store_append(SmithySdkFeature::ObservabilityMetrics);

                    // If it's specifically OpenTelemetry, track that too

                    if is_otel {

                        _cfg.interceptor_state()

                            .store_append(AwsSdkFeature::ObservabilityOtelMetrics);

                    }

                }

            }

        }

        Ok(())

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::sdk_feature::AwsSdkFeature;

    use aws_smithy_observability::TelemetryProvider;

    use aws_smithy_runtime_api::client::interceptors::context::{Input, InterceptorContext};

    use aws_smithy_runtime_api::client::orchestrator::HttpRequest;

    use aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder;

    use aws_smithy_types::config_bag::ConfigBag;

    #[cfg(all(not(target_arch = "powerpc"), not(target_family = "wasm")))]

    #[test]

    #[serial_test::serial]

    fn test_detects_noop_provider() {

        let mut context = InterceptorContext::new(Input::doesnt_matter());

        context.enter_serialization_phase();

        context.set_request(HttpRequest::empty());

        let _ = context.take_input();

        context.enter_before_transmit_phase();

        let rc = RuntimeComponentsBuilder::for_tests().build().unwrap();

        let mut cfg = ConfigBag::base();

        // Set a noop provider (ignore error if already set by another test)

        let _ = aws_smithy_observability::global::set_telemetry_provider(TelemetryProvider::noop());

        let interceptor = ObservabilityDetectionInterceptor::new();

        let ctx = Into::into(&context);

        interceptor

            .read_before_signing(&ctx, &rc, &mut cfg)

            .unwrap();

        // Should not track any features for noop provider

        let smithy_features: Vec<_> = cfg

            .interceptor_state()

            .load::<SmithySdkFeature>()

            .cloned()

            .collect();

        assert_eq!(

            smithy_features.len(),

            0,

            "Should not track Smithy features for noop provider"

        );

        let aws_features: Vec<_> = cfg

            .interceptor_state()

            .load::<AwsSdkFeature>()

            .cloned()

            .collect();

        assert_eq!(

            aws_features.len(),

            0,

            "Should not track AWS features for noop provider"

        );

    }

    #[cfg(all(not(target_arch = "powerpc"), not(target_family = "wasm")))]

    #[test]

    #[serial_test::serial]

    fn test_custom_provider_not_detected_as_otel() {

        use aws_smithy_observability::meter::{Meter, ProvideMeter};

        use aws_smithy_observability::noop::NoopMeterProvider;

        use aws_smithy_observability::Attributes;

        use std::sync::Arc;

        // Create a custom (non-OTel, non-noop) meter provider

        // This simulates a user implementing their own metrics provider

        #[derive(Debug)]

        struct CustomMeterProvider {

            inner: NoopMeterProvider,

        }

        impl ProvideMeter for CustomMeterProvider {

            fn get_meter(&self, scope: &'static str, attributes: Option<&Attributes>) -> Meter {

                // Delegate to noop for simplicity, but this is a distinct type

                self.inner.get_meter(scope, attributes)

            }

            fn as_any(&self) -> &dyn std::any::Any {

                self

            }

        }

        let mut context = InterceptorContext::new(Input::doesnt_matter());

        context.enter_serialization_phase();

        context.set_request(HttpRequest::empty());

        let _ = context.take_input();

        context.enter_before_transmit_phase();

        let rc = RuntimeComponentsBuilder::for_tests().build().unwrap();

        let mut cfg = ConfigBag::base();

        // Set the custom provider

        let custom_provider = Arc::new(CustomMeterProvider {

            inner: NoopMeterProvider,

        });

        let telemetry_provider = TelemetryProvider::builder()

            .meter_provider(custom_provider)

            .build();

        let _ = aws_smithy_observability::global::set_telemetry_provider(telemetry_provider);

        let interceptor = ObservabilityDetectionInterceptor::new();

        let ctx = Into::into(&context);

        interceptor

            .read_before_signing(&ctx, &rc, &mut cfg)

            .unwrap();

        // Should track generic observability metrics for custom provider

        let smithy_features: Vec<_> = cfg

            .interceptor_state()

            .load::<SmithySdkFeature>()

            .cloned()

            .collect();

        assert!(

            smithy_features.contains(&SmithySdkFeature::ObservabilityMetrics),

            "Should detect custom provider as having observability metrics"

        );

        // Should NOT track AWS-specific observability metrics for custom provider

        let aws_features: Vec<_> = cfg

            .interceptor_state()

            .load::<AwsSdkFeature>()

            .cloned()

            .collect();

        assert!(

            !aws_features.contains(&AwsSdkFeature::ObservabilityOtelMetrics),

            "Should NOT track OTel-specific metrics for custom provider"

        );

        assert_eq!(

            aws_features.len(),

            0,

            "Should not track any AWS-specific features for custom provider"

        );

    }

    #[cfg(all(not(target_arch = "powerpc"), not(target_family = "wasm")))]

    #[test]

    #[serial_test::serial]

    fn test_detects_otel_provider() {

        use aws_smithy_observability_otel::meter::OtelMeterProvider;

        use opentelemetry_sdk::metrics::SdkMeterProvider;

        use std::sync::Arc;

        let mut context = InterceptorContext::new(Input::doesnt_matter());

        context.enter_serialization_phase();

        context.set_request(HttpRequest::empty());

        let _ = context.take_input();

        context.enter_before_transmit_phase();

        let rc = RuntimeComponentsBuilder::for_tests().build().unwrap();

        let mut cfg = ConfigBag::base();

        // Create an actual OpenTelemetry meter provider

        let otel_sdk_provider = SdkMeterProvider::builder().build();

        let otel_provider = Arc::new(OtelMeterProvider::new(otel_sdk_provider));

        let telemetry_provider = TelemetryProvider::builder()

            .meter_provider(otel_provider)

            .build();

        let _ = aws_smithy_observability::global::set_telemetry_provider(telemetry_provider);

        let interceptor = ObservabilityDetectionInterceptor::new();

        let ctx = Into::into(&context);

        interceptor

            .read_before_signing(&ctx, &rc, &mut cfg)

            .unwrap();

        // Should track generic observability metrics for OTel provider

        let smithy_features: Vec<_> = cfg

            .interceptor_state()

            .load::<SmithySdkFeature>()

            .cloned()

            .collect();

        assert!(

            smithy_features.contains(&SmithySdkFeature::ObservabilityMetrics),

            "Should detect OTel provider as having observability metrics"

        );

        // Should ALSO track AWS-specific OTel observability metrics

        let aws_features: Vec<_> = cfg

            .interceptor_state()

            .load::<AwsSdkFeature>()

            .cloned()

            .collect();

        assert!(

            aws_features.contains(&AwsSdkFeature::ObservabilityOtelMetrics),

            "Should track OTel-specific metrics for OTel provider"

        );

    }

    // Edge case tests

    #[cfg(all(not(target_arch = "powerpc"), not(target_family = "wasm")))]

    #[test]

    #[serial_test::serial]

    fn test_multiple_provider_changes() {

        use aws_smithy_observability::meter::{Meter, ProvideMeter};

        use aws_smithy_observability::noop::NoopMeterProvider;

        use aws_smithy_observability::Attributes;

        use aws_smithy_observability_otel::meter::OtelMeterProvider;

        use opentelemetry_sdk::metrics::SdkMeterProvider;

        use std::sync::Arc;

        #[derive(Debug)]

        struct CustomMeterProvider {

            inner: NoopMeterProvider,

        }

        impl ProvideMeter for CustomMeterProvider {

            fn get_meter(&self, scope: &'static str, attributes: Option<&Attributes>) -> Meter {

                self.inner.get_meter(scope, attributes)

            }

            fn as_any(&self) -> &dyn std::any::Any {

                self

            }

        }

        let interceptor = ObservabilityDetectionInterceptor::new();

        let rc = RuntimeComponentsBuilder::for_tests().build().unwrap();

        // Test 1: Start with noop provider

        let _ = aws_smithy_observability::global::set_telemetry_provider(TelemetryProvider::noop());

        let mut context1 = InterceptorContext::new(Input::doesnt_matter());

        context1.enter_serialization_phase();

        context1.set_request(HttpRequest::empty());

        let _ = context1.take_input();

        context1.enter_before_transmit_phase();

        let mut cfg1 = ConfigBag::base();

        interceptor

            .read_before_signing(&Into::into(&context1), &rc, &mut cfg1)

            .unwrap();

        let smithy_features: Vec<_> = cfg1

            .interceptor_state()

            .load::<SmithySdkFeature>()

            .cloned()

            .collect();

        assert_eq!(

            smithy_features.len(),

            0,

            "Noop provider should not be tracked"

        );

        // Test 2: Switch to custom provider

        let custom_provider = Arc::new(CustomMeterProvider {

            inner: NoopMeterProvider,

        });

        let telemetry_provider = TelemetryProvider::builder()

            .meter_provider(custom_provider)

            .build();

        let _ = aws_smithy_observability::global::set_telemetry_provider(telemetry_provider);

        let mut context2 = InterceptorContext::new(Input::doesnt_matter());

        context2.enter_serialization_phase();

        context2.set_request(HttpRequest::empty());

        let _ = context2.take_input();

        context2.enter_before_transmit_phase();

        let mut cfg2 = ConfigBag::base();

        interceptor

            .read_before_signing(&Into::into(&context2), &rc, &mut cfg2)

            .unwrap();

        let smithy_features: Vec<_> = cfg2

            .interceptor_state()

            .load::<SmithySdkFeature>()

            .cloned()

            .collect();

        assert!(

            smithy_features.contains(&SmithySdkFeature::ObservabilityMetrics),

            "Custom provider should be tracked"

        );

        let aws_features: Vec<_> = cfg2

            .interceptor_state()

            .load::<AwsSdkFeature>()

            .cloned()

            .collect();

        assert_eq!(

            aws_features.len(),

            0,

            "Custom provider should not have OTel features"

        );

        // Test 3: Switch to OTel provider

        let otel_sdk_provider = SdkMeterProvider::builder().build();

        let otel_provider = Arc::new(OtelMeterProvider::new(otel_sdk_provider));

        let telemetry_provider = TelemetryProvider::builder()

            .meter_provider(otel_provider)

            .build();

        let _ = aws_smithy_observability::global::set_telemetry_provider(telemetry_provider);

        let mut context3 = InterceptorContext::new(Input::doesnt_matter());

        context3.enter_serialization_phase();

        context3.set_request(HttpRequest::empty());

        let _ = context3.take_input();

        context3.enter_before_transmit_phase();

        let mut cfg3 = ConfigBag::base();

        interceptor

            .read_before_signing(&Into::into(&context3), &rc, &mut cfg3)

            .unwrap();

        let smithy_features: Vec<_> = cfg3

            .interceptor_state()

            .load::<SmithySdkFeature>()

            .cloned()

            .collect();

        assert!(

            smithy_features.contains(&SmithySdkFeature::ObservabilityMetrics),

            "OTel provider should be tracked"

        );

        let aws_features: Vec<_> = cfg3

            .interceptor_state()

            .load::<AwsSdkFeature>()

            .cloned()

            .collect();

        assert!(

            aws_features.contains(&AwsSdkFeature::ObservabilityOtelMetrics),

            "OTel provider should have OTel features"

        );

    }

    #[cfg(all(not(target_arch = "powerpc"), not(target_family = "wasm")))]

    #[test]

    #[serial_test::serial]

    fn test_multiple_invocations_same_provider() {

        use aws_smithy_observability::meter::{Meter, ProvideMeter};

        use aws_smithy_observability::noop::NoopMeterProvider;

        use aws_smithy_observability::Attributes;