aws_runtime/

observability_detection.rs

/*
 * 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;
        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
            }
        }

        // Set up a 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 rc = RuntimeComponentsBuilder::for_tests().build().unwrap();

        // Invoke interceptor multiple times with the same provider
        for i in 0..3 {
            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 mut cfg = ConfigBag::base();

            interceptor
                .read_before_signing(&Into::into(&context), &rc, &mut cfg)
                .unwrap();

            // Each invocation should detect the provider consistently
            let smithy_features: Vec<_> = cfg
                .interceptor_state()
                .load::<SmithySdkFeature>()
                .cloned()
                .collect();
            assert!(
                smithy_features.contains(&SmithySdkFeature::ObservabilityMetrics),
                "Invocation {} should detect custom provider",
                i
            );
            let aws_features: Vec<_> = cfg
                .interceptor_state()
                .load::<AwsSdkFeature>()
                .cloned()
                .collect();
            assert_eq!(
                aws_features.len(),
                0,
                "Invocation {} should not have OTel features for custom provider",
                i
            );
        }
    }

    #[cfg(all(not(target_arch = "powerpc"), not(target_family = "wasm")))]
    #[test]
    #[serial_test::serial]
    fn test_interceptor_handles_errors_gracefully() {
        // This test verifies that the interceptor doesn't panic or fail
        // when the global provider is in various states

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

        // Test with noop provider (should succeed without tracking)
        let _ = aws_smithy_observability::global::set_telemetry_provider(TelemetryProvider::noop());

        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 mut cfg = ConfigBag::base();

        // Should not return an error
        let result = interceptor.read_before_signing(&Into::into(&context), &rc, &mut cfg);
        assert!(
            result.is_ok(),
            "Interceptor should handle noop provider gracefully"
        );

        // Verify no features were tracked
        let smithy_features: Vec<_> = cfg
            .interceptor_state()
            .load::<SmithySdkFeature>()
            .cloned()
            .collect();
        assert_eq!(
            smithy_features.len(),
            0,
            "Should not track features for noop provider"
        );
    }

    #[cfg(all(not(target_arch = "powerpc"), not(target_family = "wasm")))]
    #[test]
    #[serial_test::serial]
    fn test_interceptor_with_default_constructor() {
        use aws_smithy_observability::meter::{Meter, ProvideMeter};
        use aws_smithy_observability::noop::NoopMeterProvider;
        use aws_smithy_observability::Attributes;
        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
            }
        }

        // Set up a 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);

        // Test both constructors produce equivalent behavior
        let interceptor_new = ObservabilityDetectionInterceptor::new();
        let interceptor_default = ObservabilityDetectionInterceptor::default();

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

        // Test with new()
        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_new
            .read_before_signing(&Into::into(&context1), &rc, &mut cfg1)
            .unwrap();

        // Test with default()
        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_default
            .read_before_signing(&Into::into(&context2), &rc, &mut cfg2)
            .unwrap();

        // Both should produce the same results
        let smithy_features1: Vec<_> = cfg1
            .interceptor_state()
            .load::<SmithySdkFeature>()
            .cloned()
            .collect();
        let smithy_features2: Vec<_> = cfg2
            .interceptor_state()
            .load::<SmithySdkFeature>()
            .cloned()
            .collect();
        assert_eq!(
            smithy_features1, smithy_features2,
            "Both constructors should produce identical behavior"
        );
    }
}