AWS SDK

rev. 39e8f0a4a4cd7fc94cae1e2f796e9c21897d9cb9 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/client/connection.rs

@@ -1,1 +369,431 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 //! Types related to connection monitoring and management.
-7
 mod establishment;
-+
 pub use establishment::{ConnectionEstablishmentMetadata, ConnectionEstablishmentMetadataBuilder};
-+
 use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use std::fmt;
 use std::net::SocketAddr;
 use std::sync::{Arc, Mutex};
-16
 /// Opaque identifier for a physical HTTP connection.
 ///
 /// The assigning HTTP client defines the scope of an ID. IDs from different
 /// clients or pools are not comparable.
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub struct ConnectionId(u64);
-23
 impl ConnectionId {
     /// Creates an ID from a value assigned by an HTTP client.
     pub const fn new(value: u64) -> Self {
         Self(value)
-28
+    }
-29
+}
-30
 impl fmt::Display for ConnectionId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)
-34
+    }
-35
+}
-36
 /// Metadata that tracks the state of an active connection.
 #[derive(Clone)]
 pub struct ConnectionMetadata {
     is_proxied: bool,
     remote_addr: Option<SocketAddr>,
     local_addr: Option<SocketAddr>,
     poison_fn: Arc<dyn Fn() + Send + Sync>,
     connection_id: Option<ConnectionId>,
     establishment: Option<ConnectionEstablishmentMetadata>,
-46
+}
-47
 impl ConnectionMetadata {
     /// Poison this connection, ensuring that it won't be reused.
     pub fn poison(&self) {
         tracing::debug!(
             see_for_more_info = "https://smithy-lang.github.io/smithy-rs/design/client/detailed_error_explanations.html",
             "Connection encountered an issue and should not be re-used. Marking it for closure"
         );
         (self.poison_fn)()
-56
+    }
-57
     /// Create a new [`ConnectionMetadata`].
     #[deprecated(
         since = "1.1.0",
         note = "`ConnectionMetadata::new` is deprecated in favour of `ConnectionMetadata::builder`."
     )]
     pub fn new(
         is_proxied: bool,
         remote_addr: Option<SocketAddr>,
         poison: impl Fn() + Send + Sync + 'static,
     ) -> Self {
         Self {
             is_proxied,
             remote_addr,
             // need to use builder to set this field
             local_addr: None,
             poison_fn: Arc::new(poison),
             connection_id: None,
             establishment: None,
-76
+        }
-77
+    }
-78
     /// Builder for this connection metadata
     pub fn builder() -> ConnectionMetadataBuilder {
         ConnectionMetadataBuilder::new()
-82
+    }
-83
     /// Get the remote address for this connection, if one is set.
     pub fn remote_addr(&self) -> Option<SocketAddr> {
         self.remote_addr
-87
+    }
-88
     /// Get the local address for this connection, if one is set.
     pub fn local_addr(&self) -> Option<SocketAddr> {
         self.local_addr
-92
+    }
-93
     /// Get the ID assigned to this connection, if the HTTP client provides one.
     ///
     /// Clients that do not track physical connection identity leave this unset.
     pub fn connection_id(&self) -> Option<ConnectionId> {
         self.connection_id
-99
+    }
-+
     /// Get measurements from the establishment that installed this connection.
     ///
     /// Clients that do not expose successful establishment measurements leave
     /// this unset.
     pub fn establishment(&self) -> Option<&ConnectionEstablishmentMetadata> {
         self.establishment.as_ref()
-+
+    }
-108
+}
-109
 impl fmt::Debug for ConnectionMetadata {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("SmithyConnection")
             .field("is_proxied", &self.is_proxied)
             .field("remote_addr", &self.remote_addr)
             .field("local_addr", &self.local_addr)
             .field("connection_id", &self.connection_id)
             .field("establishment", &self.establishment)
             .finish()
-119
+    }
-120
+}
-121
 /// Builder type that is used to construct a [`ConnectionMetadata`] value.
 #[derive(Default)]
 pub struct ConnectionMetadataBuilder {
     is_proxied: Option<bool>,
     remote_addr: Option<SocketAddr>,
     local_addr: Option<SocketAddr>,
     poison_fn: Option<Arc<dyn Fn() + Send + Sync>>,
     connection_id: Option<ConnectionId>,
     establishment: Option<ConnectionEstablishmentMetadata>,
-131
+}
-132
 impl fmt::Debug for ConnectionMetadataBuilder {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ConnectionMetadataBuilder")
             .field("is_proxied", &self.is_proxied)
             .field("remote_addr", &self.remote_addr)
             .field("local_addr", &self.local_addr)
             .field("connection_id", &self.connection_id)
             .field("establishment", &self.establishment)
             .finish()
-142
+    }
-143
+}
-144
 impl ConnectionMetadataBuilder {
     /// Creates a new builder.
     pub fn new() -> Self {
         Self::default()
-149
+    }
-150
     /// Set whether or not the associated connection is to an HTTP proxy.
     pub fn proxied(mut self, proxied: bool) -> Self {
         self.set_proxied(Some(proxied));
         self
-155
+    }
-156
     /// Set whether or not the associated connection is to an HTTP proxy.
     pub fn set_proxied(&mut self, proxied: Option<bool>) -> &mut Self {
         self.is_proxied = proxied;
         self
-161
+    }
-162
     /// Set the remote address of the connection used.
     pub fn remote_addr(mut self, remote_addr: SocketAddr) -> Self {
         self.set_remote_addr(Some(remote_addr));
         self
-167
+    }
-168
     /// Set the remote address of the connection used.
     pub fn set_remote_addr(&mut self, remote_addr: Option<SocketAddr>) -> &mut Self {
         self.remote_addr = remote_addr;
         self
-173
+    }
-174
     /// Set the local address of the connection used.
     pub fn local_addr(mut self, local_addr: SocketAddr) -> Self {
         self.set_local_addr(Some(local_addr));
         self
-179
+    }
-180
     /// Set the local address of the connection used.
     pub fn set_local_addr(&mut self, local_addr: Option<SocketAddr>) -> &mut Self {
         self.local_addr = local_addr;
         self
-185
+    }
-186
     /// Set the [`ConnectionId`] assigned by the HTTP client.
     pub fn connection_id(mut self, connection_id: ConnectionId) -> Self {
         self.set_connection_id(Some(connection_id));
         self
-191
+    }
-192
     /// Set the [`ConnectionId`] assigned by the HTTP client.
     pub fn set_connection_id(&mut self, connection_id: Option<ConnectionId>) -> &mut Self {
         self.connection_id = connection_id;
         self
-197
+    }
-198
     /// Sets measurements from the establishment that installed this connection.
     pub fn establishment(mut self, establishment: ConnectionEstablishmentMetadata) -> Self {
         self.set_establishment(Some(establishment));
         self
-+
+    }
-+
     /// Sets measurements from the establishment that installed this connection.
     pub fn set_establishment(
         &mut self,
         establishment: Option<ConnectionEstablishmentMetadata>,
     ) -> &mut Self {
         self.establishment = establishment;
         self
-+
+    }
-+
     /// Set a closure which will poison the associated connection.
     ///
     /// A poisoned connection will not be reused for subsequent requests by the pool
     pub fn poison_fn(mut self, poison_fn: impl Fn() + Send + Sync + 'static) -> Self {
         self.set_poison_fn(Some(poison_fn));
         self
-220
+    }
-221
     /// Set a closure which will poison the associated connection.
     ///
     /// A poisoned connection will not be reused for subsequent requests by the pool
     pub fn set_poison_fn(
         &mut self,
         poison_fn: Option<impl Fn() + Send + Sync + 'static>,
     ) -> &mut Self {
         self.poison_fn =
             poison_fn.map(|poison_fn| Arc::new(poison_fn) as Arc<dyn Fn() + Send + Sync>);
         self
-232
+    }
-233
     /// Build a [`ConnectionMetadata`] value.
     ///
     /// # Panics
     ///
     /// If either the `is_proxied` or `poison_fn` has not been set, then this method will panic
     pub fn build(self) -> ConnectionMetadata {
         ConnectionMetadata {
             is_proxied: self
                 .is_proxied
                 .expect("is_proxied should be set for ConnectionMetadata"),
             remote_addr: self.remote_addr,
             local_addr: self.local_addr,
             poison_fn: self
                 .poison_fn
                 .expect("poison_fn should be set for ConnectionMetadata"),
             connection_id: self.connection_id,
             establishment: self.establishment,
-251
+        }
-252
+    }
-253
+}
-254
 type LoaderFn = dyn Fn() -> Option<ConnectionMetadata> + Send + Sync;
-256
 /// State for a middleware that will monitor and manage connections.
 #[derive(Clone, Default)]
 pub struct CaptureSmithyConnection {
     loader: Arc<Mutex<Option<Box<LoaderFn>>>>,
-261
+}
-262
 impl CaptureSmithyConnection {
     /// Create a new connection monitor.
     pub fn new() -> Self {
         Self {
             loader: Default::default(),
-268
+        }
-269
+    }
-270
     /// Set the retriever that will capture the `hyper` connection.
     pub fn set_connection_retriever<F>(&self, f: F)
     where
         F: Fn() -> Option<ConnectionMetadata> + Send + Sync + 'static,
-275
+    {
         *self.loader.lock().unwrap() = Some(Box::new(f));
-277
+    }
-278
     /// Get the associated connection metadata.
     pub fn get(&self) -> Option<ConnectionMetadata> {
         match self.loader.lock().unwrap().as_ref() {
             Some(loader) => loader(),
             None => {
                 tracing::debug!("no loader was set on the CaptureSmithyConnection");
                 None
-286
+            }
-287
+        }
-288
+    }
-289
+}
-290
 impl fmt::Debug for CaptureSmithyConnection {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "CaptureSmithyConnection")
-294
+    }
-295
+}
-296
 impl Storable for CaptureSmithyConnection {
     type Storer = StoreReplace<Self>;
-299
+}
-300
 #[cfg(test)]
 mod tests {
     use std::{
         net::{IpAddr, Ipv6Addr},
         sync::Mutex,
         time::Duration,
     };
-308
     use super::*;
-310
     const TEST_SOCKET_ADDR: SocketAddr = SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), 100);
-312
     #[test]
     #[should_panic]
     fn builder_panic_missing_proxied() {
         ConnectionMetadataBuilder::new()
             .poison_fn(|| {})
             .local_addr(TEST_SOCKET_ADDR)
             .remote_addr(TEST_SOCKET_ADDR)
             .build();
-321
+    }
-322
     #[test]
     #[should_panic]
     fn builder_panic_missing_poison_fn() {
         ConnectionMetadataBuilder::new()
             .proxied(true)
             .local_addr(TEST_SOCKET_ADDR)
             .remote_addr(TEST_SOCKET_ADDR)
             .build();
-331
+    }
-332
     #[test]
     fn builder_all_fields_successful() {
         let mutable_flag = Arc::new(Mutex::new(false));
         let establishment = ConnectionEstablishmentMetadata::builder()
             .total_duration(Duration::from_millis(13))
             .transport_duration(Duration::from_millis(8))
             .protocol_handshake_duration(Duration::from_millis(5))
             .dns_duration(Duration::from_millis(1))
             .socket_connect_duration(Duration::from_millis(2))
             .proxy_duration(Duration::from_millis(3))
             .tls_duration(Duration::from_millis(4))
             .build();
-345
         let connection_metadata = ConnectionMetadataBuilder::new()
             .proxied(true)
             .local_addr(TEST_SOCKET_ADDR)
             .remote_addr(TEST_SOCKET_ADDR)
             .connection_id(ConnectionId::new(17))
             .establishment(establishment.clone())
             .poison_fn({
                 let mutable_flag = Arc::clone(&mutable_flag);
                 move || {
                     let mut guard = mutable_flag.lock().unwrap();
                     *guard = !*guard;
-357
+                }
             })
             .build();
-360
         assert!(connection_metadata.is_proxied);
         assert_eq!(connection_metadata.remote_addr(), Some(TEST_SOCKET_ADDR));
         assert_eq!(connection_metadata.local_addr(), Some(TEST_SOCKET_ADDR));
         assert_eq!(
             connection_metadata.connection_id(),
             Some(ConnectionId::new(17))
         );
         assert_eq!(connection_metadata.establishment(), Some(&establishment));
         assert_eq!(establishment.total_duration(), Duration::from_millis(13));
         assert_eq!(establishment.transport_duration(), Duration::from_millis(8));
         assert_eq!(
             establishment.protocol_handshake_duration(),
             Some(Duration::from_millis(5))
         );
         assert_eq!(establishment.dns_duration(), Some(Duration::from_millis(1)));
         assert_eq!(
             establishment.socket_connect_duration(),
             Some(Duration::from_millis(2))
         );
         assert_eq!(
             establishment.proxy_duration(),
             Some(Duration::from_millis(3))
         );
         assert_eq!(establishment.tls_duration(), Some(Duration::from_millis(4)));
         assert_eq!("17", ConnectionId::new(17).to_string());
         assert!(!(*mutable_flag.lock().unwrap()));
         connection_metadata.poison();
         assert!(*mutable_flag.lock().unwrap());
-389
+    }
-390
     #[test]
     fn builder_optional_fields_translate() {
         let metadata1 = ConnectionMetadataBuilder::new()
             .proxied(true)
             .poison_fn(|| {})
             .build();
-397
         assert_eq!(metadata1.local_addr(), None);
         assert_eq!(metadata1.remote_addr(), None);
         assert_eq!(metadata1.connection_id(), None);
         assert_eq!(metadata1.establishment(), None);
-402
         let metadata2 = ConnectionMetadataBuilder::new()
             .proxied(true)
             .poison_fn(|| {})
             .local_addr(TEST_SOCKET_ADDR)
             .build();
-408
         assert_eq!(metadata2.local_addr(), Some(TEST_SOCKET_ADDR));
         assert_eq!(metadata2.remote_addr(), None);
-411

↧ Expand context

         let metadata3 = ConnectionMetadataBuilder::new()
             .proxied(true)
             .poison_fn(|| {})
             .remote_addr(TEST_SOCKET_ADDR)
             .build();
-417
         assert_eq!(metadata3.local_addr(), None);
         assert_eq!(metadata3.remote_addr(), Some(TEST_SOCKET_ADDR));
-420
+    }
-421
     #[test]
     #[allow(clippy::redundant_clone)]
     fn retrieve_connection_metadata() {
         let retriever = CaptureSmithyConnection::new();
         let retriever_clone = retriever.clone();
         assert!(retriever.get().is_none());
         retriever.set_connection_retriever(|| {
             Some(
                 ConnectionMetadata::builder()
                     .proxied(true)

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/client/connection/establishment.rs

@@ -0,1 +0,197 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 use std::sync::Arc;
 use std::time::Duration;
-+
 /// Measurements from one successful connection establishment.
 ///
 /// The total and transport durations are available when an HTTP client exposes
 /// this value. Transport substages remain optional because a custom connector
 /// may expose only its aggregate connection work.
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[non_exhaustive]
 pub struct ConnectionEstablishmentMetadata {
     inner: Arc<ConnectionEstablishmentMetadataInner>,
-+
+}
-+
 #[derive(Debug, Eq, PartialEq)]
 struct ConnectionEstablishmentMetadataInner {
     total_duration: Duration,
     transport_duration: Duration,
     protocol_handshake_duration: Option<Duration>,
     dns_duration: Option<Duration>,
     socket_connect_duration: Option<Duration>,
     proxy_duration: Option<Duration>,
     tls_duration: Option<Duration>,
-+
+}
-+
 impl ConnectionEstablishmentMetadata {
     /// Creates a builder for successful establishment measurements.
     pub fn builder() -> ConnectionEstablishmentMetadataBuilder {
         ConnectionEstablishmentMetadataBuilder::new()
-+
+    }
-+
     /// Returns elapsed time from establishment start until pool installation.
     pub fn total_duration(&self) -> Duration {
         self.inner.total_duration
-+
+    }
-+
     /// Returns elapsed time spent in the configured transport connector.
     pub fn transport_duration(&self) -> Duration {
         self.inner.transport_duration
-+
+    }
-+
     /// Returns elapsed time spent in the HTTP protocol handshake, when known.
     pub fn protocol_handshake_duration(&self) -> Option<Duration> {
         self.inner.protocol_handshake_duration
-+
+    }
-+
     /// Returns elapsed time spent resolving DNS, when reported by the connector.
     pub fn dns_duration(&self) -> Option<Duration> {
         self.inner.dns_duration
-+
+    }
-+
     /// Returns elapsed time spent establishing the selected socket, when reported.
     pub fn socket_connect_duration(&self) -> Option<Duration> {
         self.inner.socket_connect_duration
-+
+    }
-+
     /// Returns elapsed time spent negotiating a proxy path, when reported.
     pub fn proxy_duration(&self) -> Option<Duration> {
         self.inner.proxy_duration
-+
+    }
-+
     /// Returns elapsed time spent in TLS establishment, when reported.
     pub fn tls_duration(&self) -> Option<Duration> {
         self.inner.tls_duration
-+
+    }
-+
+}
-+
 /// Builder for [`ConnectionEstablishmentMetadata`].
 #[derive(Clone, Debug, Default)]
 pub struct ConnectionEstablishmentMetadataBuilder {
     total_duration: Option<Duration>,
     transport_duration: Option<Duration>,
     protocol_handshake_duration: Option<Duration>,
     dns_duration: Option<Duration>,
     socket_connect_duration: Option<Duration>,
     proxy_duration: Option<Duration>,
     tls_duration: Option<Duration>,
-+
+}
-+
 impl ConnectionEstablishmentMetadataBuilder {
     /// Creates an empty builder.
     pub fn new() -> Self {
         Self::default()
-+
+    }
-+
     /// Sets total elapsed establishment time.
     pub fn total_duration(mut self, duration: Duration) -> Self {
         self.set_total_duration(Some(duration));
         self
-+
+    }
-+
     /// Sets total elapsed establishment time.
     pub fn set_total_duration(&mut self, duration: Option<Duration>) -> &mut Self {
         self.total_duration = duration;
         self
-+
+    }
-+
     /// Sets aggregate transport-connector time.
     pub fn transport_duration(mut self, duration: Duration) -> Self {
         self.set_transport_duration(Some(duration));
         self
-+
+    }
-+
     /// Sets aggregate transport-connector time.
     pub fn set_transport_duration(&mut self, duration: Option<Duration>) -> &mut Self {
         self.transport_duration = duration;
         self
-+
+    }
-+
     /// Sets HTTP protocol-handshake time.
     pub fn protocol_handshake_duration(mut self, duration: Duration) -> Self {
         self.set_protocol_handshake_duration(Some(duration));
         self
-+
+    }
-+
     /// Sets HTTP protocol-handshake time.
     pub fn set_protocol_handshake_duration(&mut self, duration: Option<Duration>) -> &mut Self {
         self.protocol_handshake_duration = duration;
         self
-+
+    }
-+
     /// Sets DNS resolution time.
     pub fn dns_duration(mut self, duration: Duration) -> Self {
         self.set_dns_duration(Some(duration));
         self
-+
+    }
-+
     /// Sets DNS resolution time.
     pub fn set_dns_duration(&mut self, duration: Option<Duration>) -> &mut Self {
         self.dns_duration = duration;
         self
-+
+    }
-+
     /// Sets socket establishment time.
     pub fn socket_connect_duration(mut self, duration: Duration) -> Self {
         self.set_socket_connect_duration(Some(duration));
         self
-+
+    }
-+
     /// Sets socket establishment time.
     pub fn set_socket_connect_duration(&mut self, duration: Option<Duration>) -> &mut Self {
         self.socket_connect_duration = duration;
         self
-+
+    }
-+
     /// Sets proxy negotiation time.
     pub fn proxy_duration(mut self, duration: Duration) -> Self {
         self.set_proxy_duration(Some(duration));
         self
-+
+    }
-+
     /// Sets proxy negotiation time.
     pub fn set_proxy_duration(&mut self, duration: Option<Duration>) -> &mut Self {
         self.proxy_duration = duration;
         self
-+
+    }
-+
     /// Sets TLS establishment time.
     pub fn tls_duration(mut self, duration: Duration) -> Self {
         self.set_tls_duration(Some(duration));
         self
-+
+    }
-+
     /// Sets TLS establishment time.
     pub fn set_tls_duration(&mut self, duration: Option<Duration>) -> &mut Self {
         self.tls_duration = duration;
         self
-+
+    }
-+
     /// Builds successful connection-establishment metadata.
     ///
     /// # Panics
     ///
     /// Panics when total or transport duration is unset.
     pub fn build(self) -> ConnectionEstablishmentMetadata {
         ConnectionEstablishmentMetadata {
             inner: Arc::new(ConnectionEstablishmentMetadataInner {
                 total_duration: self
                     .total_duration
                     .expect("total_duration is required for connection establishment metadata"),
                 transport_duration: self
                     .transport_duration
                     .expect("transport_duration is required for connection establishment metadata"),
                 protocol_handshake_duration: self.protocol_handshake_duration,
                 dns_duration: self.dns_duration,
                 socket_connect_duration: self.socket_connect_duration,
                 proxy_duration: self.proxy_duration,
                 tls_duration: self.tls_duration,
             }),
-+
+        }
-+
+    }
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/client/http.rs

@@ -23,23 +82,84 @@

↥ Expand context

 //!
 //! # Responsibilities of a connector
 //!
 //! A connector primarily makes HTTP requests, but is also the place where connect and read timeouts are
 //! implemented. The `HyperConnector` in [`aws-smithy-runtime`] is an example where timeouts are implemented
 //! as part of the connector.
 //!
 //! Connectors are also responsible for DNS lookup, TLS, connection reuse, pooling, and eviction.
 //! The Smithy clients have no knowledge of such concepts.
 //!
 //! # The [`HttpClient`] trait
 //!
 //! Connectors allow us to make requests, but we need a layer on top of connectors so that we can handle
 //! varying connector settings. For example, say we configure some default HTTP connect/read timeouts on
 //! Client, and then configure some override connect/read timeouts for a specific operation. These timeouts
 //! ultimately are part of the connector, so the same connector can't be reused for the two different sets
 //! of timeouts. Thus, the [`HttpClient`] implementation is responsible for managing multiple connectors
 //! with varying config. Some example configs that can impact which connector is used:
 //!
 //! - HTTP protocol versions

 //! - TLS settings
 //! - Timeouts
 //!
 //! Some of these aren't implemented yet, but they will appear in the [`HttpConnectorSettings`] struct
 //! once they are.
 //!
 //! [`hyper`]: https://crates.io/crates/hyper
 //! [`tower`]: https://crates.io/crates/tower
 //! [`aws-smithy-runtime`]: https://crates.io/crates/aws-smithy-runtime
-52
 pub mod telemetry;
-+
 use crate::box_error::BoxError;
 use crate::client::connector_metadata::ConnectorMetadata;
 use crate::client::orchestrator::{HttpRequest, HttpResponse};
 use crate::client::result::ConnectorError;
 use crate::client::runtime_components::sealed::ValidateConfig;
 use crate::client::runtime_components::{RuntimeComponents, RuntimeComponentsBuilder};
 use crate::impl_shared_conversions;
 use aws_smithy_types::config_bag::ConfigBag;
 use std::fmt;
 use std::sync::Arc;

↧ Expand context

 use std::time::Duration;
-66
 new_type_future! {
     #[doc = "Future for [`HttpConnector::call`]."]
     pub struct HttpConnectorFuture<'static, HttpResponse, ConnectorError>;
-70
+}
-71
 /// Trait with a `call` function that asynchronously converts a request into a response.
 ///
 /// Ordinarily, a connector would use an underlying HTTP library such as [hyper](https://crates.io/crates/hyper),
 /// and any associated HTTPS implementation alongside it to service requests.
 ///
 /// However, it can also be useful to create fake/mock connectors implementing this trait
 /// for testing.
 pub trait HttpConnector: Send + Sync + fmt::Debug {
     /// Asynchronously converts a request into a response.
     fn call(&self, request: HttpRequest) -> HttpConnectorFuture;
-82
+}
-83
 /// A shared [`HttpConnector`] implementation.

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/client/http/telemetry.rs

@@ -0,1 +0,255 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! Provider-neutral observations from one HTTP request attempt.
 //!
 //! A runtime installs [`CaptureHttpAttemptTelemetry`] on a request before
 //! transmission. A compatible HTTP client records the facts it owns without
 //! depending on metric instruments, exporters, or tracing providers.
-+
 use crate::client::connection::ConnectionMetadata;
 use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use std::fmt;
 use std::sync::{Arc, Mutex, MutexGuard};
 use std::time::{Duration, SystemTime};
-+
 /// Whether the selected connection had accepted an earlier request.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[non_exhaustive]
 pub enum ConnectionUsage {
     /// The connection had not accepted an earlier request.
     ///
     /// For a multiplexed connection, only the first accepted request is fresh.
     /// Concurrent requests accepted afterward observe reuse.
     Fresh,
     /// The connection had accepted at least one earlier request.
     Reused,
-+
+}
-+
 /// Timing and reuse state for the connection selected by one request attempt.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[non_exhaustive]
 pub struct ConnectionAcquisitionTelemetry {
     duration: Option<Duration>,
     usage: ConnectionUsage,
-+
+}
-+
 impl ConnectionAcquisitionTelemetry {
     /// Creates a completed connection-acquisition observation.
     pub fn new(duration: Duration, usage: ConnectionUsage) -> Self {
         Self {
             duration: Some(duration),
             usage,
-+
+        }
-+
+    }
-+
     /// Creates an observation from acquisition start and completion times.
     ///
     /// The duration is absent when `completed_at` precedes `started_at`. The
     /// selected connection and its reuse state remain valid observations.
     pub fn from_interval(
         started_at: SystemTime,
         completed_at: SystemTime,
         usage: ConnectionUsage,
     ) -> Self {
         Self {
             duration: completed_at.duration_since(started_at).ok(),
             usage,
-+
+        }
-+
+    }
-+
     /// Returns elapsed time until the selected connection accepted the request.
     ///
     /// This is absent when the HTTP client's clock did not produce a valid
     /// interval.
     pub fn duration(&self) -> Option<Duration> {
         self.duration
-+
+    }
-+
     /// Returns whether the selected connection had accepted an earlier request.
     pub fn usage(&self) -> ConnectionUsage {
         self.usage
-+
+    }
-+
+}
-+
 /// Facts recorded by a compatible HTTP client for one request attempt.
 #[derive(Clone, Debug, Default)]
 #[non_exhaustive]
 pub struct HttpAttemptTelemetry {
     selection: Option<ConnectionSelection>,
     connector_call_duration: Option<Duration>,
-+
+}
-+
 impl HttpAttemptTelemetry {
     /// Returns completed connection-acquisition telemetry, when supplied.
     pub fn acquisition(&self) -> Option<&ConnectionAcquisitionTelemetry> {
         self.selection
             .as_ref()
             .map(|selection| &selection.acquisition)
-+
+    }
-+
     /// Returns metadata for the connection that accepted the request, when supplied.
     pub fn connection(&self) -> Option<&ConnectionMetadata> {
         self.selection
             .as_ref()
             .map(|selection| &selection.connection)
-+
+    }
-+
     /// Returns the complete HTTP connector call duration, when supplied.
     ///
     /// This ends when the connector returns a response head or terminal error.
     /// It does not measure response-body transfer or time to first response byte.
     pub fn connector_call_duration(&self) -> Option<Duration> {
         self.connector_call_duration
-+
+    }
-+
+}
-+
 #[derive(Clone, Debug)]
 struct ConnectionSelection {
     acquisition: ConnectionAcquisitionTelemetry,
     connection: ConnectionMetadata,
-+
+}
-+
 /// Shared request extension used to capture HTTP-attempt telemetry.
 ///
 /// Each observation is recorded at most once. Acquisition timing and selected
 /// connection metadata are committed together.
 #[derive(Clone, Default)]
 pub struct CaptureHttpAttemptTelemetry {
     state: Arc<Mutex<HttpAttemptTelemetry>>,
-+
+}
-+
 impl CaptureHttpAttemptTelemetry {
     /// Creates an empty attempt capture.
     pub fn new() -> Self {
         Self::default()
-+
+    }
-+
     /// Returns the observations recorded so far.
     pub fn get(&self) -> HttpAttemptTelemetry {
         self.lock().clone()
-+
+    }
-+
     /// Records the complete HTTP connector call duration.
     ///
     /// Returns `true` when this call recorded the value.
     pub fn record_connector_call_duration(&self, duration: Duration) -> bool {
         let mut state = self.lock();
         if state.connector_call_duration.is_some() {
             return false;
-+
+        }
         state.connector_call_duration = Some(duration);
         true
-+
+    }
-+
     /// Records the connection selection that accepted the request.
     ///
     /// Acquisition and connection metadata are committed together. Returns
     /// `true` when this call recorded the selection.
     pub fn record_connection_selection(
         &self,
         acquisition: ConnectionAcquisitionTelemetry,
         connection: ConnectionMetadata,
     ) -> bool {
         let mut state = self.lock();
         if state.selection.is_some() {
             return false;
-+
+        }
         state.selection = Some(ConnectionSelection {
             acquisition,
             connection,
         });
         true
-+
+    }
-+
     fn lock(&self) -> MutexGuard<'_, HttpAttemptTelemetry> {
         self.state
             .lock()
             .unwrap_or_else(std::sync::PoisonError::into_inner)
-+
+    }
-+
+}
-+
 impl fmt::Debug for CaptureHttpAttemptTelemetry {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("CaptureHttpAttemptTelemetry")
             .finish_non_exhaustive()
-+
+    }
-+
+}
-+
 impl Storable for CaptureHttpAttemptTelemetry {
     type Storer = StoreReplace<Self>;
-+
+}
-+
 #[cfg(test)]
 mod tests {
     use super::*;
-+
     fn connection() -> ConnectionMetadata {
         ConnectionMetadata::builder()
             .proxied(false)
             .poison_fn(|| {})
             .build()
-+
+    }
-+
     #[test]
     fn records_connector_call_and_selection_independently() {
         let capture = CaptureHttpAttemptTelemetry::new();
         let acquisition =
             ConnectionAcquisitionTelemetry::new(Duration::from_millis(3), ConnectionUsage::Fresh);
-+
         assert!(capture.record_connection_selection(acquisition, connection()));
         assert!(capture.record_connector_call_duration(Duration::from_millis(7)));
-+
         let telemetry = capture.get();
         assert_eq!(telemetry.acquisition(), Some(&acquisition));
         assert_eq!(
             telemetry.connector_call_duration(),
             Some(Duration::from_millis(7))
         );
         assert!(telemetry.connection().is_some());
-+
+    }
-+
     #[test]
     fn first_recorded_value_wins() {
         let capture = CaptureHttpAttemptTelemetry::new();
         let first =
             ConnectionAcquisitionTelemetry::new(Duration::from_millis(3), ConnectionUsage::Fresh);
         let second =
             ConnectionAcquisitionTelemetry::new(Duration::from_millis(9), ConnectionUsage::Reused);
         assert!(capture.record_connection_selection(first, connection()));
         assert!(!capture.record_connection_selection(second, connection()));
         assert!(capture.record_connector_call_duration(Duration::from_millis(4)));
         assert!(!capture.record_connector_call_duration(Duration::from_millis(8)));
-+
         let telemetry = capture.get();
         assert_eq!(telemetry.acquisition(), Some(&first));
         assert_eq!(
             telemetry.connector_call_duration(),
             Some(Duration::from_millis(4))
         );
-+
+    }
-+
     #[test]
     fn backwards_acquisition_interval_retains_selection_facts() {
         let started_at = SystemTime::UNIX_EPOCH + Duration::from_secs(2);
         let completed_at = SystemTime::UNIX_EPOCH + Duration::from_secs(1);
-+
         let acquisition = ConnectionAcquisitionTelemetry::from_interval(
             started_at,
             completed_at,
             ConnectionUsage::Fresh,
         );
         let capture = CaptureHttpAttemptTelemetry::new();
         assert!(capture.record_connection_selection(acquisition, connection()));
-+
         let telemetry = capture.get();
         assert_eq!(telemetry.acquisition().expect("selection").duration(), None);
         assert_eq!(
             telemetry.acquisition().expect("selection").usage(),
             ConnectionUsage::Fresh
         );
         assert!(telemetry.connection().is_some());
-+
+    }
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/client/result.rs

@@ -546,546 +640,640 @@

↥ Expand context

-546
     /// An unclassified Error with an explicit error kind
     Other(Option<ErrorKind>),
-549
+}
-550
 /// Error from the underlying Connector
 ///
 /// Connector exists to attach a `ConnectorErrorKind` to what would otherwise be an opaque `Box<dyn Error>`
 /// that comes off a potentially generic or dynamic connector.
 /// The attached `kind` is used to determine what retry behavior should occur (if any) based on the
 /// connector error.
 #[derive(Debug)]
 pub struct ConnectorError {
     kind: ConnectorErrorKind,
     source: BoxError,
     connection: ConnectionStatus,
-562
+}
-563
 #[non_exhaustive]
 #[derive(Debug)]

 pub(crate) enum ConnectionStatus {
     /// This request was never connected to the remote
     ///
     /// This indicates the failure was during connection establishment
     NeverConnected,
-571
     /// It is unknown whether a connection was established
     Unknown,
-574
     /// The request connected to the remote prior to failure
     Connected(ConnectionMetadata),
     Connected(Box<ConnectionMetadata>),
-577
+}
-578
 impl Display for ConnectorError {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self.kind {
             ConnectorErrorKind::Timeout => write!(f, "timeout"),
             ConnectorErrorKind::User => write!(f, "user error"),
             ConnectorErrorKind::Io => write!(f, "io error"),
             ConnectorErrorKind::Other(_) => write!(f, "other"),
-586
+        }
-587
+    }
-588
+}
-589
 impl Error for ConnectorError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         Some(self.source.as_ref())
-593
+    }
-594
+}
-595
 impl ConnectorError {
     /// Construct a [`ConnectorError`] from an error caused by a timeout
     ///
     /// Timeout errors are typically retried on a new connection.
     pub fn timeout(source: BoxError) -> Self {
         Self {
             kind: ConnectorErrorKind::Timeout,
             source,
             connection: ConnectionStatus::Unknown,
-605
+        }
-606
+    }
-607
     /// Include connection information along with this error
     pub fn with_connection(mut self, info: ConnectionMetadata) -> Self {
         self.connection = ConnectionStatus::Connected(info);
         self.connection = ConnectionStatus::Connected(Box::new(info));
         self
-612
+    }
-613
     /// Set the connection status on this error to report that a connection was never established
     pub fn never_connected(mut self) -> Self {
         self.connection = ConnectionStatus::NeverConnected;
         self
-618
+    }
-619
     /// Construct a [`ConnectorError`] from an error caused by the user (e.g. invalid HTTP request)

↧ Expand context

     pub fn user(source: BoxError) -> Self {
         Self {
             kind: ConnectorErrorKind::User,
             source,
             connection: ConnectionStatus::Unknown,
-626
+        }
-627
+    }
-628
     /// Construct a [`ConnectorError`] from an IO related error (e.g. socket hangup)
     pub fn io(source: BoxError) -> Self {
         Self {
             kind: ConnectorErrorKind::Io,
             source,
             connection: ConnectionStatus::Unknown,
-635
+        }
-636
+    }
-637
     /// Construct a [`ConnectorError`] from an different unclassified error.
     ///
     /// Optionally, an explicit `Kind` may be passed.

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/http/extensions.rs

@@ -1,1 +59,62 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 use crate::http::HttpError;
-7
 #[derive(Default, Debug)]
 pub(crate) struct Extensions {
     #[cfg(feature = "http-02x")]
     extensions_02x: http_02x::Extensions,
     extensions_1x: http_1x::Extensions,
-13
+}
-14
 impl Extensions {
     pub(crate) fn new() -> Self {

         Self::default()
-18
+    }
-19
     /// Adds an extension to the request extensions
     pub(crate) fn insert<T: Send + Sync + Clone + 'static>(&mut self, extension: T) {
         #[cfg(feature = "http-02x")]
         self.extensions_02x.insert(extension.clone());
         self.extensions_1x.insert(extension);
-25
+    }
-26
     // Reads a previously-inserted extension of type `T`, if present.
     /// Reads a previously inserted extension of type `T`, if present.
     pub(crate) fn get<T: Send + Sync + 'static>(&self) -> Option<&T> {
         self.extensions_1x.get::<T>()
         let extension = self.extensions_1x.get::<T>();
         #[cfg(feature = "http-02x")]
         let extension = extension.or_else(|| self.extensions_02x.get::<T>());
         extension
-33
+    }
-34
+}
-35
 #[cfg(feature = "http-02x")]
 impl From<http_02x::Extensions> for Extensions {
     fn from(value: http_02x::Extensions) -> Self {
         Self {
             extensions_02x: value,
             extensions_1x: Default::default(),
-42
+        }

↧ Expand context

-43
+    }
-44
+}
-45
 impl From<http_1x::Extensions> for Extensions {
     fn from(value: http_1x::Extensions) -> Self {
         Self {
             #[cfg(feature = "http-02x")]
             extensions_02x: Default::default(),
             extensions_1x: value,
-52
+        }
-53
+    }
-54
+}
-55
 #[cfg(feature = "http-02x")]
 impl TryFrom<Extensions> for http_02x::Extensions {
     type Error = HttpError;
-59
     fn try_from(value: Extensions) -> Result<Self, Self::Error> {
         if value.extensions_1x.len() > value.extensions_02x.len() {
             Err(HttpError::invalid_extensions())

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/http/request.rs

@@ -319,319 +378,383 @@

↥ Expand context

     pub fn set_method(&mut self, method: &str) -> Result<(), HttpError> {
         self.method =
             http_1x::Method::from_bytes(method.as_bytes()).map_err(HttpError::invalid_method)?;
         Ok(())
-323
+    }
-324
     /// Returns the URI associated with this request
     pub fn uri(&self) -> &str {
         &self.uri.as_string
-328
+    }
-329
     /// Returns a mutable reference the the URI of this http::Request
     pub fn uri_mut(&mut self) -> &mut Uri {
         &mut self.uri
-333
+    }
-334
     /// Sets the URI of this request
     pub fn set_uri<U>(&mut self, uri: U) -> Result<(), U::Error>
     where
         U: TryInto<Uri>,

-339
+    {
         let uri = uri.try_into()?;
         self.uri = uri;
         Ok(())
-343
+    }
-344
     /// Adds an extension to the request extensions
     pub fn add_extension<T: Send + Sync + Clone + 'static>(&mut self, extension: T) {
         self.extensions.insert(extension.clone());
-348
+    }
-+
     /// Returns an extension previously added to this request.
     pub fn extension<T: Send + Sync + 'static>(&self) -> Option<&T> {
         self.extensions.get()
-+
+    }
-354
+}
-355
 impl Request<SdkBody> {
     /// Attempts to clone this request
     ///
     /// On clone, any extensions will be cleared.
     ///
     /// If the body is cloneable, this will clone the request. Otherwise `None` will be returned
     pub fn try_clone(&self) -> Option<Self> {
         let body = self.body().try_clone()?;

↧ Expand context

         Some(Self {
             body,
             uri: self.uri.clone(),
             method: self.method.clone(),
             extensions: Extensions::new(),
             headers: self.headers.clone(),
         })
-371
+    }
-372
     /// Replaces this request's body with [`SdkBody::taken()`]
     pub fn take_body(&mut self) -> SdkBody {
         std::mem::replace(self.body_mut(), SdkBody::taken())
-376
+    }
-377
     /// Create a GET request to `/` with an empty body
     pub fn empty() -> Self {
         Self::new(SdkBody::empty())
-381
+    }
-382
     /// Creates a GET request to `uri` with an empty body

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime/src/client/metrics.rs

@@ -1,1 +137,160 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 use aws_smithy_async::time::{SharedTimeSource, TimeSource};
 use aws_smithy_observability::{
     global::get_telemetry_provider, instruments::Histogram, AttributeValue, Attributes,
     ObservabilityError,
 };
 use aws_smithy_runtime_api::client::http::telemetry::{
     CaptureHttpAttemptTelemetry, ConnectionAcquisitionTelemetry, HttpAttemptTelemetry,
 };
 use aws_smithy_runtime_api::client::{
     interceptors::{dyn_dispatch_hint, Intercept, SharedInterceptor},
     interceptors::{
         context::BeforeTransmitInterceptorContextMut, dyn_dispatch_hint, Intercept,
         SharedInterceptor,
     },
     orchestrator::Metadata,
     runtime_components::RuntimeComponentsBuilder,
     runtime_plugin::RuntimePlugin,
 };
 use aws_smithy_types::config_bag::{FrozenLayer, Layer, Storable, StoreReplace};
 use aws_smithy_types::telemetry::{CapturedTelemetryAttributes, RequestedTelemetryAttributes};
 use std::{borrow::Cow, sync::Arc, time::SystemTime};
-26
 /// Sets the outcome attributes (`error.type` and `http.status_code`) on `attrs` from a
 /// finalizer-phase context.
 fn add_outcome_attrs(
     attrs: &mut Attributes,
     context: &aws_smithy_runtime_api::client::interceptors::context::FinalizerInterceptorContextRef<
         '_,
     >,
 ) {
     // Coarse category only; the error is type-erased here, so the modeled name isn't reachable.
     // Absent on success, per OTel convention.
     if let Some(Err(err)) = context.output_or_error() {
         let category = if err.is_timeout_error() {
             "timeout"
         } else if err.is_connector_error() {
             "connector"
         } else if err.is_response_error() {
             "response"
         } else if err.is_operation_error() {
             "operation"
         } else {
             "other"
         };
         attrs.set("error.type", AttributeValue::String(category.into()));
-50
+    }
-51
     // Raw HTTP status code, whenever a response reached us.
     if let Some(response) = context.response() {
         attrs.set(
             "http.status_code",
             AttributeValue::I64(i64::from(response.status().as_u16())),
         );
-58
+    }
-59
+}
-60
 /// Struct to hold metric data in the ConfigBag
 #[derive(Debug, Clone)]
 pub(crate) struct MeasurementsContainer {
     call_start: SystemTime,
     attempts: u32,
     attempt_start: SystemTime,
     attempt_capture: Option<CaptureHttpAttemptTelemetry>,
-68
+}
-69
 impl Storable for MeasurementsContainer {
     type Storer = StoreReplace<Self>;
-72
+}
-73
 /// Instruments for recording a single operation
 #[derive(Debug, Clone)]
 pub(crate) struct OperationTelemetry {
     pub(crate) operation_duration: Arc<dyn Histogram>,
     pub(crate) attempt_duration: Arc<dyn Histogram>,
     pub(crate) connection_acquisition_duration: Arc<dyn Histogram>,
     // Body sizes are their own instruments rather than attributes on the duration histogram: body
     // size is near-unique per call, so attaching it as a label would fragment the duration metric
     // into one time series per byte count.
     pub(crate) request_body_size: Arc<dyn Histogram>,
     pub(crate) response_body_size: Arc<dyn Histogram>,
-85
+}
-86
 impl OperationTelemetry {
     pub(crate) fn new(scope: &'static str) -> Result<Self, ObservabilityError> {
         let meter = get_telemetry_provider()?
             .meter_provider()
             .get_meter(scope, None);
-92
         Ok(Self{
             operation_duration: meter
                 .create_histogram("smithy.client.call.duration")
                 .set_units("s")
                 .set_description("Overall call duration (including retries and time to send or receive request and response body)")
                 .build(),
             attempt_duration: meter
                 .create_histogram("smithy.client.call.attempt.duration")
                 .set_units("s")
                 .set_description("The time it takes to connect to the service, send the request, and get back HTTP status code and headers (including time queued waiting to be sent)")
                 .build(),
             connection_acquisition_duration: meter
                 .create_histogram("smithy.client.http.connections.acquire_duration")
                 .set_units("s")
                 .set_description("Time spent acquiring the connection that accepted the request")
                 .build(),
             request_body_size: meter
                 .create_histogram("smithy.client.call.request.size")
                 .set_units("By")
                 .set_description("Size of the transferred request body, in bytes")
                 .build(),
             response_body_size: meter
                 .create_histogram("smithy.client.call.response.size")
                 .set_units("By")
                 .set_description("Size of the transferred response body, in bytes")
                 .build(),
         })
-120
+    }
-+
     fn record_connection_acquisition(&self, telemetry: &HttpAttemptTelemetry) {
         if let Some(duration) = telemetry
             .acquisition()
             .and_then(ConnectionAcquisitionTelemetry::duration)
-+
+        {
             self.connection_acquisition_duration
                 .record(duration.as_secs_f64(), None, None);
-+
+        }
-+
+    }
-131
+}
-132
 impl Storable for OperationTelemetry {
     type Storer = StoreReplace<Self>;
-135
+}
-136
 #[derive(Debug)]
 pub(crate) struct MetricsInterceptor {
     // Holding a TimeSource here isn't ideal, but RuntimeComponents aren't available in
     // the read_before_execution hook and that is when we need to start the timer for

↧ Expand context

     // the operation.
     time_source: SharedTimeSource,
-143
+}
-144
 impl MetricsInterceptor {
     pub(crate) fn new(time_source: SharedTimeSource) -> Result<Self, ObservabilityError> {
         Ok(MetricsInterceptor { time_source })
-148
+    }
-149
     pub(crate) fn get_attrs_from_cfg(
         &self,
         cfg: &aws_smithy_types::config_bag::ConfigBag,
     ) -> Option<Attributes> {
         let operation_metadata = cfg.load::<Metadata>();
-155
         if let Some(md) = operation_metadata {
             let mut attributes = Attributes::new();
             attributes.set("rpc.service", AttributeValue::String(md.service().into()));
             attributes.set("rpc.method", AttributeValue::String(md.name().into()));
-160

@@ -159,182 +283,361 @@

↥ Expand context

         &self,
         cfg: &'a aws_smithy_types::config_bag::ConfigBag,
     ) -> (&'a MeasurementsContainer, &'a OperationTelemetry) {
         let measurements = cfg
             .load::<MeasurementsContainer>()
             .expect("set in `read_before_execution`");
-188
         let instruments = cfg
             .load::<OperationTelemetry>()
             .expect("set in RuntimePlugin");
-192
         (measurements, instruments)
-194
+    }
-195
+}
-196
 #[dyn_dispatch_hint]
 impl Intercept for MetricsInterceptor {
     fn name(&self) -> &'static str {
         "MetricsInterceptor"
-201
+    }

-202
     fn read_before_execution(
         &self,
         _context: &aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<'_>,
         cfg: &mut aws_smithy_types::config_bag::ConfigBag,
     ) -> Result<(), aws_smithy_runtime_api::box_error::BoxError> {
         cfg.interceptor_state().store_put(MeasurementsContainer {
             call_start: self.time_source.now(),
             attempts: 0,
             attempt_start: SystemTime::UNIX_EPOCH,
             attempt_capture: None,
         });
-214
         Ok(())
-216
+    }
-217
     fn read_after_execution(
         &self,
         context: &aws_smithy_runtime_api::client::interceptors::context::FinalizerInterceptorContextRef<'_>,
         _runtime_components: &aws_smithy_runtime_api::client::runtime_components::RuntimeComponents,
         cfg: &mut aws_smithy_types::config_bag::ConfigBag,
     ) -> Result<(), aws_smithy_runtime_api::box_error::BoxError> {
         let (measurements, instruments) = self.get_measurements_and_instruments(cfg);
-225
         let attributes = self.get_attrs_from_cfg(cfg);
-227
         if let Some(mut attrs) = attributes {
             // The outcome is only known at the finalizer, so it is set here rather than in
             // `get_attrs_from_cfg` (which also serves the per-attempt path).
             add_outcome_attrs(&mut attrs, context);
-232
             // Transferred byte sizes are recorded on their own instruments by the byte
             // interceptor (see `telemetry_bytes`), not as attributes on the duration histogram.
-235
             let call_end = self.time_source.now();
             let call_duration = call_end.duration_since(measurements.call_start);
             if let Ok(elapsed) = call_duration {
                 instruments
                     .operation_duration
                     .record(elapsed.as_secs_f64(), Some(&attrs), None);
-242
+            }
-243
+        }
-244
         Ok(())
-246
+    }
-247
     fn read_before_attempt(
         &self,
         _context: &aws_smithy_runtime_api::client::interceptors::context::BeforeTransmitInterceptorContextRef<'_>,
         _runtime_components: &aws_smithy_runtime_api::client::runtime_components::RuntimeComponents,
         cfg: &mut aws_smithy_types::config_bag::ConfigBag,
     ) -> Result<(), aws_smithy_runtime_api::box_error::BoxError> {
         let measurements = cfg
             .get_mut::<MeasurementsContainer>()
             .expect("set in `read_before_execution`");
-257
         measurements.attempts += 1;
         measurements.attempt_start = self.time_source.now();
         measurements.attempt_capture = None;
-+
         Ok(())
-+
+    }
-+
     fn modify_before_transmit(
         &self,
         context: &mut BeforeTransmitInterceptorContextMut<'_>,
         _runtime_components: &aws_smithy_runtime_api::client::runtime_components::RuntimeComponents,
         _cfg: &mut aws_smithy_types::config_bag::ConfigBag,
     ) -> Result<(), aws_smithy_runtime_api::box_error::BoxError> {
         if context
             .request()
             .extension::<CaptureHttpAttemptTelemetry>()
             .is_none()
-+
+        {
             context
                 .request_mut()
                 .add_extension(CaptureHttpAttemptTelemetry::new());
-+
+        }
         Ok(())
-+
+    }
-282
     fn read_before_transmit(
         &self,
         context: &aws_smithy_runtime_api::client::interceptors::context::BeforeTransmitInterceptorContextRef<'_>,
         _runtime_components: &aws_smithy_runtime_api::client::runtime_components::RuntimeComponents,
         cfg: &mut aws_smithy_types::config_bag::ConfigBag,
     ) -> Result<(), aws_smithy_runtime_api::box_error::BoxError> {
         let capture = context
             .request()
             .extension::<CaptureHttpAttemptTelemetry>()
             .cloned();
         cfg.get_mut::<MeasurementsContainer>()
             .expect("set in `read_before_execution`")
             .attempt_capture = capture;
         Ok(())
-297
+    }
-298
     fn read_after_attempt(
         &self,
         _context: &aws_smithy_runtime_api::client::interceptors::context::FinalizerInterceptorContextRef<'_>,
         _runtime_components: &aws_smithy_runtime_api::client::runtime_components::RuntimeComponents,
         cfg: &mut aws_smithy_types::config_bag::ConfigBag,
     ) -> Result<(), aws_smithy_runtime_api::box_error::BoxError> {
         let (measurements, instruments) = self.get_measurements_and_instruments(cfg);
         let (attempts, attempt_start, http_telemetry) = {
             let measurements = cfg
                 .get_mut::<MeasurementsContainer>()
                 .expect("set in `read_before_execution`");
-+
+            (
                 measurements.attempts,
                 measurements.attempt_start,
                 measurements
                     .attempt_capture
                     .take()
                     .map(|capture| capture.get()),
-+
+            )
         };
         let instruments = cfg
             .load::<OperationTelemetry>()
             .expect("set in RuntimePlugin");
-321
         let attempt_end = self.time_source.now();
         let attempt_duration = attempt_end.duration_since(measurements.attempt_start);
         let attempt_duration = attempt_end.duration_since(attempt_start);
         let attributes = self.get_attrs_from_cfg(cfg);
-325
         if let Some(http_telemetry) = http_telemetry {
             instruments.record_connection_acquisition(&http_telemetry);
-+
+        }
-+
         if let (Ok(elapsed), Some(mut attrs)) = (attempt_duration, attributes) {
             attrs.set("attempt", AttributeValue::I64(measurements.attempts.into()));
             attrs.set("attempt", AttributeValue::I64(attempts.into()));
-332
             instruments
                 .attempt_duration
                 .record(elapsed.as_secs_f64(), Some(&attrs), None);
-336
+        }
         Ok(())
-338
+    }
-339
+}
-340
 /// Runtime plugin that adds an interceptor for collecting metrics

↧ Expand context

 #[derive(Debug, Default)]
 pub struct MetricsRuntimePlugin {
     scope: &'static str,
     time_source: SharedTimeSource,
     metadata: Option<Metadata>,
-347
+}
-348
 impl MetricsRuntimePlugin {
     /// Create a [MetricsRuntimePluginBuilder]
     pub fn builder() -> MetricsRuntimePluginBuilder {
         MetricsRuntimePluginBuilder::default()
-353
+    }
-354
+}
-355
 impl RuntimePlugin for MetricsRuntimePlugin {
     fn runtime_components(
         &self,
         _current_components: &RuntimeComponentsBuilder,
     ) -> Cow<'_, RuntimeComponentsBuilder> {
         let interceptor = MetricsInterceptor::new(self.time_source.clone());

@@ -336,414 +496,782 @@

↥ Expand context

-414
     /// Set the [Metadata] for the metrics.
     ///
     /// Note: the Metadata is optional, most operations set it themselves, but this is useful
     /// for operations that do not, like some of the credential providers.
     pub fn with_metadata(mut self, metadata: Metadata) -> Self {
         self.metadata = Some(metadata);
         self
-422
+    }
-423
     /// Build a [MetricsRuntimePlugin]
     pub fn build(
         self,
     ) -> Result<MetricsRuntimePlugin, aws_smithy_runtime_api::box_error::BoxError> {
         if let Some(scope) = self.scope {
             Ok(MetricsRuntimePlugin {
                 scope,
                 time_source: self.time_source.unwrap_or_default(),
                 metadata: self.metadata,
             })

         } else {
             Err("Scope is required for MetricsRuntimePlugin.".into())
-436
+        }
-437
+    }
-438
+}
-439
 #[cfg(test)]
 mod test {
     use super::*;
     use aws_smithy_async::time::SystemTimeSource;
     use aws_smithy_runtime_api::client::connection::ConnectionMetadata;
     use aws_smithy_runtime_api::client::http::telemetry::{
         ConnectionAcquisitionTelemetry, ConnectionUsage,
     };
     use aws_smithy_runtime_api::client::interceptors::context::{Input, InterceptorContext};
     use aws_smithy_runtime_api::client::orchestrator::HttpRequest;
     use aws_smithy_types::config_bag::ConfigBag;
     use std::sync::Mutex;
-+
     #[derive(Debug, Default)]
     struct RecordingHistogram {
         records: Mutex<Vec<(f64, Option<Attributes>)>>,
-+
+    }
-+
     impl RecordingHistogram {
         fn only_record(&self) -> (f64, Option<Attributes>) {
             let records = self.records.lock().unwrap();
             assert_eq!(records.len(), 1);
             records[0].clone()
-+
+        }
-+
         fn record_count(&self) -> usize {
             self.records.lock().unwrap().len()
-+
+        }
-+
+    }
-+
     impl Histogram for RecordingHistogram {
         fn record(
             &self,
             value: f64,
             attributes: Option<&Attributes>,
             _context: Option<&dyn aws_smithy_observability::Context>,
         ) {
             self.records
                 .lock()
                 .unwrap()
                 .push((value, attributes.cloned()));
-+
+        }
-+
+    }
-483
     fn interceptor() -> MetricsInterceptor {
         MetricsInterceptor::new(SharedTimeSource::new(SystemTimeSource::new())).unwrap()
-486
+    }
-487
     fn cfg_with(layer: Layer) -> ConfigBag {
         ConfigBag::of_layers(vec![layer])
-490
+    }
-491
     fn string_attr<'a>(attrs: &'a Attributes, key: &str) -> Option<&'a str> {
         match attrs.get(key) {
             Some(AttributeValue::String(s)) => Some(s.as_str()),
             _ => None,
-496
+        }
-497
+    }
-498
     #[test]
     fn base_attrs_are_service_and_method() {
         let mut layer = Layer::new("test");
         layer.store_put(Metadata::new("GetObject", "S3"));
-503
         let attrs = interceptor()
             .get_attrs_from_cfg(&cfg_with(layer))
             .expect("metadata present");
-507
         assert_eq!(Some("S3"), string_attr(&attrs, "rpc.service"));
         assert_eq!(Some("GetObject"), string_attr(&attrs, "rpc.method"));
-510
+    }
-511
     #[test]
     fn no_attrs_without_metadata() {
         // Nothing to key the metric on, so no attributes are produced.
         assert!(interceptor()
             .get_attrs_from_cfg(&cfg_with(Layer::new("test")))
             .is_none());
-518
+    }
-519
     fn test_instruments(acquisition: Arc<RecordingHistogram>) -> OperationTelemetry {
         let ignored: Arc<dyn Histogram> = Arc::new(RecordingHistogram::default());
         OperationTelemetry {
             operation_duration: ignored.clone(),
             attempt_duration: ignored.clone(),
             connection_acquisition_duration: acquisition,
             request_body_size: ignored.clone(),
             response_body_size: ignored,
-+
+        }
-+
+    }
-+
     fn install_measurements(cfg: &mut ConfigBag) {
         cfg.interceptor_state().store_put(MeasurementsContainer {
             call_start: SystemTime::UNIX_EPOCH,
             attempts: 0,
             attempt_start: SystemTime::UNIX_EPOCH,
             attempt_capture: None,
         });
-+
+    }
-+
     #[test]
     fn before_transmit_adopts_an_existing_attempt_capture() {
         let runtime_components = RuntimeComponentsBuilder::for_tests().build().unwrap();
         let mut context = InterceptorContext::new(Input::doesnt_matter());
         context.set_request(HttpRequest::empty());
         let mut cfg = cfg_with(Layer::new("test"));
         install_measurements(&mut cfg);
         let caller_capture = CaptureHttpAttemptTelemetry::new();
         context
             .request_mut()
             .unwrap()
             .add_extension(caller_capture.clone());
-+
         interceptor()
             .modify_before_transmit(&mut (&mut context).into(), &runtime_components, &mut cfg)
             .unwrap();
         interceptor()
             .read_before_transmit(&(&context).into(), &runtime_components, &mut cfg)
             .unwrap();
-+
         let request_capture = context
             .request()
             .unwrap()
             .extension::<CaptureHttpAttemptTelemetry>()
             .expect("request capture");
         request_capture.record_connector_call_duration(std::time::Duration::from_millis(4));
         assert_eq!(
             cfg.load::<MeasurementsContainer>()
                 .and_then(|measurements| measurements.attempt_capture.as_ref())
                 .expect("attempt capture")
                 .get()
                 .connector_call_duration(),
             Some(std::time::Duration::from_millis(4))
         );
         assert_eq!(
             caller_capture.get().connector_call_duration(),
             Some(std::time::Duration::from_millis(4))
         );
-+
+    }
-+
     #[test]
     fn before_transmit_adopts_the_final_replacement_capture() {
         let runtime_components = RuntimeComponentsBuilder::for_tests().build().unwrap();
         let mut context = InterceptorContext::new(Input::doesnt_matter());
         context.set_request(HttpRequest::empty());
         let mut cfg = cfg_with(Layer::new("test"));
         install_measurements(&mut cfg);
-+
         interceptor()
             .modify_before_transmit(&mut (&mut context).into(), &runtime_components, &mut cfg)
             .unwrap();
         let replacement = CaptureHttpAttemptTelemetry::new();
         context
             .request_mut()
             .unwrap()
             .add_extension(replacement.clone());
         interceptor()
             .read_before_transmit(&(&context).into(), &runtime_components, &mut cfg)
             .unwrap();
-+
         replacement.record_connector_call_duration(std::time::Duration::from_millis(6));
         assert_eq!(
             cfg.load::<MeasurementsContainer>()
                 .and_then(|measurements| measurements.attempt_capture.as_ref())
                 .expect("attempt capture")
                 .get()
                 .connector_call_duration(),
             Some(std::time::Duration::from_millis(6))
         );
-+
+    }
-+
     #[test]
     fn attempt_capture_is_consumed_once_and_cleared_before_retry() {
         let runtime_components = RuntimeComponentsBuilder::for_tests().build().unwrap();
         let acquisition = Arc::new(RecordingHistogram::default());
         let mut layer = Layer::new("test");
         layer.store_put(Metadata::new("GetObject", "S3"));
         layer.store_put(test_instruments(acquisition.clone()));
         let mut cfg = cfg_with(layer);
         install_measurements(&mut cfg);
         let mut context = InterceptorContext::new(Input::doesnt_matter());
         context.set_request(HttpRequest::empty());
         let metrics = interceptor();
-+
         metrics
             .read_before_attempt(&(&context).into(), &runtime_components, &mut cfg)
             .unwrap();
         metrics
             .modify_before_transmit(&mut (&mut context).into(), &runtime_components, &mut cfg)
             .unwrap();
         metrics
             .read_before_transmit(&(&context).into(), &runtime_components, &mut cfg)
             .unwrap();
         context
             .request()
             .unwrap()
             .extension::<CaptureHttpAttemptTelemetry>()
             .expect("request capture")
             .record_connection_selection(
                 ConnectionAcquisitionTelemetry::new(
                     std::time::Duration::from_millis(3),
                     ConnectionUsage::Fresh,
                 ),
                 ConnectionMetadata::builder()
                     .proxied(false)
                     .poison_fn(|| {})
                     .build(),
             );
         metrics
             .read_after_attempt(&(&context).into(), &runtime_components, &mut cfg)
             .unwrap();
         assert_eq!(acquisition.record_count(), 1);
-+
         metrics
             .read_before_attempt(&(&context).into(), &runtime_components, &mut cfg)
             .unwrap();
         metrics
             .read_after_attempt(&(&context).into(), &runtime_components, &mut cfg)
             .unwrap();
         assert_eq!(
             acquisition.record_count(),
 ,
             "a pre-transmit retry halt must not repeat the prior acquisition"
         );
-+
+    }
-+
     #[test]
     fn records_connection_acquisition_without_attributes() {
         let acquisition = Arc::new(RecordingHistogram::default());
         let instruments = test_instruments(acquisition.clone());
         let capture = CaptureHttpAttemptTelemetry::new();
         capture.record_connector_call_duration(std::time::Duration::from_millis(7));
         capture.record_connection_selection(
             ConnectionAcquisitionTelemetry::new(
                 std::time::Duration::from_millis(3),
                 ConnectionUsage::Reused,
             ),
             ConnectionMetadata::builder()
                 .proxied(false)
                 .poison_fn(|| {})
                 .build(),
         );
         instruments.record_connection_acquisition(&capture.get());
-+
         let (acquisition_value, acquisition_attrs) = acquisition.only_record();
         assert_eq!(
             acquisition_value,
             std::time::Duration::from_millis(3).as_secs_f64()
         );
         assert!(acquisition_attrs.is_none());
-+
+    }
-+
     #[test]
     fn emitted_members_are_merged_onto_attrs() {
         let mut captured = CapturedTelemetryAttributes::new();
         captured.insert("Bucket", "my-bucket");
-696
         let mut layer = Layer::new("test");
         layer.store_put(Metadata::new("GetObject", "S3"));
         layer.store_put(captured);
         layer.store_put(RequestedTelemetryAttributes::new(["Bucket"]));
-701
         let attrs = interceptor()
             .get_attrs_from_cfg(&cfg_with(layer))
             .expect("metadata present");
-705
         // The emitted input member rides alongside the built-in rpc.* attributes.
         assert_eq!(Some("my-bucket"), string_attr(&attrs, "Bucket"));
         assert_eq!(Some("S3"), string_attr(&attrs, "rpc.service"));
-709
+    }
-710
     #[test]
     fn capture_only_members_are_not_emitted() {
         // A value captured for in-process reads must not land on the metric.
         let mut captured = CapturedTelemetryAttributes::new();
         captured.insert("Prefix", "logs/");
-716
         let mut requested = RequestedTelemetryAttributes::default();
         requested.capture_only(["Prefix"]);
-719
         let mut layer = Layer::new("test");
         layer.store_put(Metadata::new("GetObject", "S3"));
         layer.store_put(captured);
         layer.store_put(requested);
-724
         let attrs = interceptor()
             .get_attrs_from_cfg(&cfg_with(layer))
             .expect("metadata present");
-728
         assert!(
             attrs.get("Prefix").is_none(),
             "capture-only member must not be emitted on the metric"
         );
-733
+    }
-734
     #[test]
     fn nothing_captured_leaves_only_base_attrs() {
         // Opt-in is off by default: an empty capture set adds nothing.
         let mut layer = Layer::new("test");
         layer.store_put(Metadata::new("GetObject", "S3"));
         layer.store_put(CapturedTelemetryAttributes::new());
-741
         let attrs = interceptor()
             .get_attrs_from_cfg(&cfg_with(layer))
             .expect("metadata present");
-745
         assert_eq!(Some("GetObject"), string_attr(&attrs, "rpc.method"));
         assert!(attrs.get("Bucket").is_none());
-748
+    }
-749
     // --- add_outcome_attrs (the `status` dimension) ---
-751
     use aws_smithy_runtime_api::client::interceptors::context::{
         Error, Input, InterceptorContext, Output,
     };
     use aws_smithy_runtime_api::client::interceptors::context::{Error, Output};
     use aws_smithy_runtime_api::client::orchestrator::OrchestratorError;
     use aws_smithy_runtime_api::client::result::ConnectorError;
     use aws_smithy_runtime_api::http::{Response, StatusCode};
     use aws_smithy_types::body::SdkBody;
-757
     fn i64_attr(attrs: &Attributes, key: &str) -> Option<i64> {
         match attrs.get(key) {
             Some(AttributeValue::I64(v)) => Some(*v),
             _ => None,
-762
+        }

↧ Expand context

-763
+    }
-764
     #[test]
     fn outcome_on_success_has_status_code_and_no_error_type() {
         let mut ctx = InterceptorContext::new(Input::doesnt_matter());
         ctx.set_output_or_error(Ok(Output::doesnt_matter()));
         ctx.set_response(Response::new(
             StatusCode::try_from(200).unwrap(),
             SdkBody::empty(),
         ));
-773
         let mut attrs = Attributes::new();
         add_outcome_attrs(&mut attrs, &(&ctx).into());
-776
         // error.type is absent on success (OTel convention); status code is present.
         assert!(attrs.get("error.type").is_none());
         assert_eq!(Some(200), i64_attr(&attrs, "http.status_code"));
-780
+    }
-781
     #[test]

Pages: 1 2 3 4