AWS SDK

    #[test]

    fn test_double_url_encode_path() {

        let test = SigningSuiteTest::v4("double-encode-path");

        let req = test.request();

        let req = SignableRequest::from(&req);

        let identity = Credentials::for_tests().into();

        let signing_params = signing_params(&identity, SigningSettings::default());

        let creq = CanonicalRequest::from(&req, &signing_params).unwrap();

        let expected = test.canonical_request(SignatureLocation::Headers);

        assert_eq!(actual, expected);

    }

    #[test]

    fn test_double_url_encode() {

        let test = SigningSuiteTest::v4("double-url-encode");

        let req = test.request();

        let req = SignableRequest::from(&req);

        let identity = Credentials::for_tests().into();

        let signing_params = signing_params(&identity, SigningSettings::default());

        let creq = CanonicalRequest::from(&req, &signing_params).unwrap();

        let expected = test.canonical_request(SignatureLocation::Headers);

        assert_eq!(actual, expected);

    }

    #[test]

    fn test_tilde_in_uri() {

        let req = http0::Request::builder()

            .uri("https://s3.us-east-1.amazonaws.com/my-bucket?list-type=2&prefix=~objprefix&single&k=&unreserved=-_.~").body("").unwrap().into();

        let req = SignableRequest::from(&req);

        let identity = Credentials::for_tests().into();

        let signing_params = signing_params(&identity, SigningSettings::default());

    pub(crate) fn context(&self) -> TestContext {

        let context = read(&self.path("context.json"));

        let tc_builder: TestContextBuilder = serde_json::from_str(&context).unwrap();

        tc_builder.build()

    }

}

fn test_parsed_request(path: &str) -> TestRequest {

    match parse_request(read(path).as_bytes()) {

        Ok(parsed) => parsed,

    }

}

fn new_v4_signing_params_from_context(

    test_context: &'_ TestContext,

    signature_location: SignatureLocation,

) -> crate::http_request::SigningParams<'_> {

    let mut params = crate::sign::v4::SigningParams::from(test_context);

    params.settings.signature_location = signature_location;

    params.into()

    #[test]

    fn test_read_query_params() {

        let req = SigningSuiteTest::v4a("get-header-value-trim").request();

        assert_eq!(req.method, "GET");

        assert_eq!(req.uri, "https://example.amazonaws.com/");

        assert!(!req.headers.is_empty());

    }

}

fn read(path: &str) -> String {

    let v = {

        match std::fs::read_to_string(path) {

            // This replacement is necessary for tests to pass on Windows, as reading the

            // test snapshots from the file system results in CRLF line endings being inserted.

            Ok(value) => value.replace("\r\n", "\n"),

            Err(err) => {

            }

        }

    };

    v.trim().to_string()

}

pub(crate) struct TestRequest {

    pub(crate) uri: String,

    pub(crate) method: String,

    pub(crate) headers: Vec<(String, String)>,

    pub(crate) body: TestSignedBody,

}

pub(crate) enum TestSignedBody {

    Signable(SignableBody<'static>),

    Bytes(Vec<u8>),

}

impl TestSignedBody {

    fn as_signable_body(&self) -> SignableBody<'_> {

        match self {

            TestSignedBody::Signable(data) => data.clone(),

            TestSignedBody::Bytes(data) => SignableBody::Bytes(data.as_slice()),

        }

    }

}

impl TestRequest {

    pub(crate) fn set_body(&mut self, body: SignableBody<'static>) {

        self.body = TestSignedBody::Signable(body);

    }

    pub(crate) fn as_http_request(&self) -> http0::Request<&'static str> {

        let mut builder = http0::Request::builder()

            .uri(&self.uri)

            .method(Method::from_bytes(self.method.as_bytes()).unwrap());

        for (k, v) in &self.headers {

            builder = builder.header(k, v);

        }

        builder.body("body").unwrap()

    }

}

impl<B: AsRef<[u8]>> From<http0::Request<B>> for TestRequest {

    fn from(value: http0::Request<B>) -> Self {

        let invalid = value

            .headers()

            .values()

            .find(|h| std::str::from_utf8(h.as_bytes()).is_err());

        if let Some(invalid) = invalid {

        }

        Self {

            uri: value.uri().to_string(),

            method: value.method().to_string(),

            headers: value

                .headers()

                .iter()

                .map(|(k, v)| {

                    (

                        k.to_string(),

# Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

[package]

name = "aws-smithy-compression"

authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Zelda Hessler <zhessler@amazon.com>"]

description = "Request compression for smithy clients."

edition = "2021"

license = "Apache-2.0"

repository = "https://github.com/smithy-lang/smithy-rs"

[package.metadata.docs.rs]

all-features = true

targets = ["x86_64-unknown-linux-gnu"]

cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]

rustdoc-args = ["--cfg", "docsrs"]

            let compress_request =

                CompressionAlgorithm::Gzip.into_impl_http_body_1_x(&compression_options);

            let body = SdkBody::from(UNCOMPRESSED_INPUT);

            let mut compressed_body = CompressedBody::new(body, compress_request);

            let mut output = SegmentedBuf::new();

            loop {

                let data = match compressed_body.frame().await {

                    Some(Ok(frame)) => frame.into_data(),

                    // No more frames, break out of loop

                    None => break,

                }

                .expect("frame is OK");

                output.push(data);

            }

            let mut actual_output = Vec::new();

            output

                .reader()

[[example]]

name = "custom-dns"

required-features = ["rustls-ring"]

doc-scrape-examples = true

[package]

name = "aws-smithy-http-client"

authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]

description = "HTTP client abstractions for generated smithy clients"

license = "Apache-2.0"

edition = "2021"

repository = "https://github.com/smithy-lang/smithy-rs"

[package.metadata.smithy-rs-release-tooling]

stable = true

[package.metadata.docs.rs]

all-features = false

features = ["default-client ", "wire-mock", "test-util", "rustls-ring", "rustls-aws-lc"]

targets = ["x86_64-unknown-linux-gnu"]

cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use std::error::Error;

    use std::fs;

    #[tokio::test]

    async fn correctly_fixes_content_lengths() -> Result<(), Box<dyn Error>> {

        let network_traffic = fs::read_to_string("test-data/example.com.json")?;

        let mut network_traffic: NetworkTraffic = serde_json::from_str(&network_traffic)?;

        network_traffic.correct_content_lengths();

        let Action::Request {

            request: Request { headers, .. },

        } = &network_traffic.events[0].action

        else {

            panic!("unexpected event")

        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), Error>> {

            unreachable!()

        }

    }

}

#[cfg(test)]

mod test {

    #[cfg(feature = "hyper-014")]

    #[tokio::test]

    async fn never_tcp_connector_plugs_into_hyper_014() {

        use super::NeverTcpConnector;

        use crate::hyper_014::HyperClientBuilder;

        // it should compile

        let client = HyperClientBuilder::new().build(NeverTcpConnector::new());

        let components = RuntimeComponentsBuilder::for_tests()

            .with_sleep_impl(Some(TokioSleep::new()))

version = "1.3.4"

[dependencies.aws-smithy-runtime-api]

path = "../aws-smithy-runtime-api"

features = ["client", "http-1x", "test-util"]

version = "1.9.2"

[dependencies.aws-smithy-http-client]

path = "../aws-smithy-http-client"

features = ["test-util"]

[dev-dependencies.tokio]

version = "1"

features = ["full"]

[dev-dependencies.aws-smithy-async]

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

features = ["rt-tokio"]

version = "1.2.6"

[dev-dependencies.aws-smithy-runtime]

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

features = ["client"]

[[bench]]

name = "sync_instruments"

harness = false

[[bench]]

name = "async_instruments"

harness = false

[package]

name = "aws-smithy-observability-otel"

authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]

description = "Smithy OpenTelemetry observability implementation."

edition = "2021"

license = "Apache-2.0"

repository = "https://github.com/awslabs/smithy-rs"

[package.metadata.docs.rs]

all-features = true

targets = ["x86_64-unknown-linux-gnu"]

cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]

rustdoc-args = ["--cfg", "docsrs"]

[dependencies]

value-bag = "1.10.0"

async-global-executor = "2.4.1"

async-task = "=4.7.1"

[dependencies.aws-smithy-observability]

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

[dependencies.opentelemetry]

features = ["metrics"]

features = ["metrics", "testing"]

[dev-dependencies]

stats_alloc = "0.1.10"

[dev-dependencies.tokio]

version = "1.23.1"

[dev-dependencies.criterion]

version = "0.5.1"

 * SPDX-License-Identifier: Apache-2.0

 */

use aws_smithy_observability::instruments::AsyncMeasure;

use aws_smithy_observability::meter::Meter;

use aws_smithy_observability::{AttributeValue, Attributes, TelemetryProvider};

use aws_smithy_observability_otel::meter::OtelMeterProvider;

use criterion::{criterion_group, criterion_main, Criterion};

use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};

use opentelemetry_sdk::runtime::Tokio;

use stats_alloc::{Region, StatsAlloc, INSTRUMENTED_SYSTEM};

use std::alloc::System;

use std::sync::Arc;

async fn record_async_instruments(dyn_sdk_meter: Meter) {

    //Create all async instruments and record some data

    let gauge = dyn_sdk_meter

        .create_gauge(

            "TestGauge".to_string(),

fn async_instruments_benchmark(c: &mut Criterion) {

    #[global_allocator]

    static GLOBAL: &StatsAlloc<System> = &INSTRUMENTED_SYSTEM;

    let reg = Region::new(GLOBAL);

    // Setup the Otel MeterProvider (which needs to be done inside an async runtime)

    // The runtime is reused later for running the bench function

    let runtime = tokio::runtime::Runtime::new().unwrap();

    let otel_mp = runtime.block_on(async {

        let reader = PeriodicReader::builder(exporter.clone(), Tokio).build();

        SdkMeterProvider::builder().with_reader(reader).build()

    });

    // Create the SDK metrics types from the OTel objects

    let sdk_mp = Arc::new(OtelMeterProvider::new(otel_mp));

    let sdk_tp = TelemetryProvider::builder().meter_provider(sdk_mp).build();

    // Get the dyn versions of the SDK metrics objects

    let dyn_sdk_mp = sdk_tp.meter_provider();

    let dyn_sdk_meter = dyn_sdk_mp.get_meter("TestMeter", None);

    c.bench_function("async_instruments", |b| {

        b.to_async(&runtime)

    });

    println!("FINISHING");

    println!("Stats at end: {:#?}", reg.change());

}

criterion_group!(benches, async_instruments_benchmark);

criterion_main!(benches);

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

 * SPDX-License-Identifier: Apache-2.0

 */

use aws_smithy_observability::meter::Meter;

use aws_smithy_observability::TelemetryProvider;

use aws_smithy_observability_otel::meter::OtelMeterProvider;

use criterion::{criterion_group, criterion_main, Criterion};

use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};

use opentelemetry_sdk::runtime::Tokio;

use stats_alloc::{Region, StatsAlloc, INSTRUMENTED_SYSTEM};

use std::alloc::System;

use std::sync::Arc;

async fn record_sync_instruments(dyn_sdk_meter: Meter) {

    //Create all 3 sync instruments and record some data for each

    let mono_counter = dyn_sdk_meter

        .create_monotonic_counter("TestMonoCounter")

        .build();

    mono_counter.add(4, None, None);

    let ud_counter = dyn_sdk_meter

        .create_up_down_counter("TestUpDownCounter")

        .build();

    ud_counter.add(-6, None, None);

    let histogram = dyn_sdk_meter

        .create_histogram("TestHistogram".to_string())

        .build();

    histogram.record(1.234, None, None);

}

fn sync_instruments_benchmark(c: &mut Criterion) {

    #[global_allocator]

    static GLOBAL: &StatsAlloc<System> = &INSTRUMENTED_SYSTEM;

    let reg = Region::new(GLOBAL);

    // Setup the Otel MeterProvider (which needs to be done inside an async runtime)

    // The runtime is reused later for running the bench function

    let runtime = tokio::runtime::Runtime::new().unwrap();

    let otel_mp = runtime.block_on(async {

        let reader = PeriodicReader::builder(exporter.clone(), Tokio).build();

        SdkMeterProvider::builder().with_reader(reader).build()

    });

    // Create the SDK metrics types from the OTel objects

    let sdk_mp = Arc::new(OtelMeterProvider::new(otel_mp));

    let sdk_tp = TelemetryProvider::builder().meter_provider(sdk_mp).build();

    // Get the dyn versions of the SDK metrics objects

    let dyn_sdk_mp = sdk_tp.meter_provider();

    let dyn_sdk_meter = dyn_sdk_mp.get_meter("TestMeter", None);

    c.bench_function("sync_instruments", |b| {

        b.to_async(&runtime)

    });

    println!("FINISHING");

    println!("Stats at end: {:#?}", reg.change());

}

criterion_group!(benches, sync_instruments_benchmark);

criterion_main!(benches);

            attrs.set(

                kv.key.clone(),

                match &kv.value {

                    Value::Bool(val) => AttributeValue::Bool(*val),

                    Value::I64(val) => AttributeValue::I64(*val),

                    Value::F64(val) => AttributeValue::F64(*val),

                    Value::String(val) => AttributeValue::String(val.clone().into()),

                    Value::Array(_) => {

                        AttributeValue::String("UNSUPPORTED ATTRIBUTE VALUE TYPE".into())

                    }

                },

            )

        });

        AttributesWrap(attrs)

    }

}

#[cfg(test)]

mod tests {

/* Automatically managed default lints */

#![cfg_attr(docsrs, feature(doc_cfg))]

/* End of automatically managed default lints */

#![warn(

    missing_docs,

    rustdoc::missing_crate_level_docs,

    unreachable_pub,

    rust_2018_idioms

)]

// The `opentelemetry_sdk` crate uses std::sync::atomic::{AtomicI64, AtomicU64} which are not available on powerpc

//! Smithy Observability OpenTelemetry

//TODO(smithyobservability): once we have finalized everything and integrated metrics with our runtime

// libraries update this with detailed usage docs and examples

pub mod attributes;

pub mod meter;

#[cfg(test)]

mod tests {

    use std::sync::Arc;

    use crate::meter::OtelMeterProvider;

    use aws_smithy_observability::{

        global::{get_telemetry_provider, set_telemetry_provider},

        TelemetryProvider,

    };

    use opentelemetry_sdk::metrics::{data::Sum, PeriodicReader, SdkMeterProvider};

    use opentelemetry_sdk::runtime::Tokio;

    // Without these tokio settings this test just stalls forever on flushing the metrics pipeline

    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]

    async fn can_construct_set_and_use_otel_as_global_telemetry_provider() {

        // Create the OTel metrics objects

        let reader = PeriodicReader::builder(exporter.clone(), Tokio).build();

        let otel_mp = SdkMeterProvider::builder().with_reader(reader).build();

        // Create the SDK metrics types from the OTel objects

        let sdk_mp = Arc::new(OtelMeterProvider::new(otel_mp));

        let sdk_ref = sdk_mp.clone();

        let sdk_tp = TelemetryProvider::builder().meter_provider(sdk_mp).build();

        // Set the global TelemetryProvider and then get it back out

        let _ = set_telemetry_provider(sdk_tp);

    }

}

#[derive(Debug)]

struct GaugeWrap(OtelObservableGauge<f64>);

impl AsyncMeasure for GaugeWrap {

    type Value = f64;

    fn record(

        &self,

        _context: Option<&dyn Context>,

    ) {

    }

    // OTel rust does not currently support unregistering callbacks

    // https://github.com/open-telemetry/opentelemetry-rust/issues/2245

    fn stop(&self) {}

}

#[derive(Debug)]

struct AsyncUpDownCounterWrap(OtelObservableUpDownCounter<i64>);

impl AsyncMeasure for AsyncUpDownCounterWrap {

    type Value = i64;

    fn record(

        &self,

        _context: Option<&dyn Context>,

    ) {

    }

    // OTel rust does not currently support unregistering callbacks

    // https://github.com/open-telemetry/opentelemetry-rust/issues/2245

    fn stop(&self) {}

}

#[derive(Debug)]

struct AsyncMonotonicCounterWrap(OtelObservableCounter<u64>);

impl AsyncMeasure for AsyncMonotonicCounterWrap {

    type Value = u64;

    fn record(

        &self,

        _context: Option<&dyn Context>,

    ) {

    }

    // OTel rust does not currently support unregistering callbacks

    // https://github.com/open-telemetry/opentelemetry-rust/issues/2245

    fn stop(&self) {}

}

struct AsyncInstrumentWrap<'a, T>(&'a (dyn OtelAsyncInstrument<T> + Send + Sync));

impl<T> AsyncMeasure for AsyncInstrumentWrap<'_, T> {

    type Value = T;

        if let Some(u) = builder.get_units() {

            otel_builder = otel_builder.with_unit(u.clone());

        }

        otel_builder = otel_builder.with_callback(move |input: &dyn OtelAsyncInstrument<f64>| {

            let f = builder.callback.clone();

            f(&AsyncInstrumentWrap(input));

        });

    }

    fn create_up_down_counter(

        &self,

        builder: InstrumentBuilder<'_, Arc<dyn UpDownCounter>>,

    ) -> Arc<dyn UpDownCounter> {

        let mut otel_builder = self.i64_up_down_counter(builder.get_name().clone());

        if let Some(desc) = builder.get_description() {

            otel_builder = otel_builder.with_description(desc.clone());

        }

        if let Some(u) = builder.get_units() {

            otel_builder = otel_builder.with_unit(u.clone());

        }

    }

    fn create_async_up_down_counter(

        &self,

        builder: AsyncInstrumentBuilder<'_, Arc<dyn AsyncMeasure<Value = i64>>, i64>,

    ) -> Arc<dyn AsyncMeasure<Value = i64>> {

        let mut otel_builder = self.i64_observable_up_down_counter(builder.get_name().clone());

        if let Some(desc) = builder.get_description() {

            otel_builder = otel_builder.with_description(desc.clone());

        }

        if let Some(u) = builder.get_units() {

            otel_builder = otel_builder.with_unit(u.clone());

        }

        otel_builder = otel_builder.with_callback(move |input: &dyn OtelAsyncInstrument<i64>| {

            let f = builder.callback.clone();

            f(&AsyncInstrumentWrap(input));

        });

    }

    fn create_monotonic_counter(

        &self,

        builder: InstrumentBuilder<'_, Arc<dyn MonotonicCounter>>,

    ) -> Arc<dyn MonotonicCounter> {

        let mut otel_builder = self.u64_counter(builder.get_name().clone());

        if let Some(desc) = builder.get_description() {

            otel_builder = otel_builder.with_description(desc.clone());

        }

        if let Some(u) = builder.get_units() {

            otel_builder = otel_builder.with_unit(u.clone());

        }

    }

    fn create_async_monotonic_counter(

        &self,

        builder: AsyncInstrumentBuilder<'_, Arc<dyn AsyncMeasure<Value = u64>>, u64>,

    ) -> Arc<dyn AsyncMeasure<Value = u64>> {

        let mut otel_builder = self.u64_observable_counter(builder.get_name().clone());

        if let Some(desc) = builder.get_description() {

            otel_builder = otel_builder.with_description(desc.clone());

        }

        if let Some(u) = builder.get_units() {

            otel_builder = otel_builder.with_unit(u.clone());

        }

        otel_builder = otel_builder.with_callback(move |input: &dyn OtelAsyncInstrument<u64>| {

            let f = builder.callback.clone();

            f(&AsyncInstrumentWrap(input));

        });

    }

    fn create_histogram(

        &self,

        builder: InstrumentBuilder<'_, Arc<dyn Histogram>>,

    ) -> Arc<dyn Histogram> {

        let mut otel_builder = self.f64_histogram(builder.get_name().clone());

        if let Some(desc) = builder.get_description() {

            otel_builder = otel_builder.with_description(desc.clone());

        }

        if let Some(u) = builder.get_units() {

            otel_builder = otel_builder.with_unit(u.clone());

        }

    }

}

/// An OpenTelemetry based implementation of the AWS SDK's [ProvideMeter] trait

#[non_exhaustive]

#[derive(Debug)]

pub struct OtelMeterProvider {

    meter_provider: OtelSdkMeterProvider,

}

impl OtelMeterProvider {

    /// Create a new [OtelMeterProvider] from an [OtelSdkMeterProvider].

    pub fn new(otel_meter_provider: OtelSdkMeterProvider) -> Self {

        Self {

            meter_provider: otel_meter_provider,

        }

    }

    /// Flush the metric pipeline.

    pub fn flush(&self) -> Result<(), ObservabilityError> {

        match self.meter_provider.force_flush() {

            Ok(_) => Ok(()),

            Err(err) => Err(ObservabilityError::new(ErrorKind::Other, err)),

        }

    }

}

impl ProvideMeter for OtelMeterProvider {

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

        Meter::new(Arc::new(MeterWrap(self.meter_provider.meter(scope))))

    }

}

#[cfg(test)]

mod tests {

    use std::sync::Arc;

    use aws_smithy_observability::instruments::AsyncMeasure;

    use aws_smithy_observability::{AttributeValue, Attributes, TelemetryProvider};

    use opentelemetry_sdk::metrics::{

        data::{Gauge, Histogram, Sum},

        PeriodicReader, SdkMeterProvider,

    };

    use opentelemetry_sdk::runtime::Tokio;

    use super::OtelMeterProvider;

    // Without these tokio settings this test just stalls forever on flushing the metrics pipeline

    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]

    async fn sync_instruments_work() {

        // Create the OTel metrics objects

        let reader = PeriodicReader::builder(exporter.clone(), Tokio).build();

        let otel_mp = SdkMeterProvider::builder().with_reader(reader).build();

        // Create the SDK metrics types from the OTel objects

        let sdk_mp = Arc::new(OtelMeterProvider::new(otel_mp));

        let sdk_ref = sdk_mp.clone();

        let sdk_tp = TelemetryProvider::builder().meter_provider(sdk_mp).build();

        // Get the dyn versions of the SDK metrics objects

        let dyn_sdk_mp = sdk_tp.meter_provider();

        let dyn_sdk_meter = dyn_sdk_mp.get_meter("TestMeter", None);

        //Create all 3 sync instruments and record some data for each

        let mono_counter = dyn_sdk_meter

            .create_monotonic_counter("TestMonoCounter")

            .build();

        mono_counter.add(4, None, None);

        let ud_counter = dyn_sdk_meter

            .create_up_down_counter("TestUpDownCounter")

            .build();