Breaking Changes:

• ⚠ (smithy-rs#2611) Update MSRV to Rust 1.67.1

New this release:

• 🎉 (smithy-rs#2254, @eduardomourar) The AWS SDK now compiles for the wasm32-unknown-unknown and wasm32-wasi targets when no default features are enabled. WebAssembly is not officially supported yet, but this is a great first step towards it!
• 🐛🎉 (smithy-rs#2562) Update the std::fmt::Debug implementation for aws-sigv4::SigningParams so that it will no longer print sensitive information.
• (aws-sdk-rust#784, @abusch) Implement std::error::Error#source() properly for the service meta Error enum.
• 🐛 (smithy-rs#2496) The outputs for event stream operations (for example, S3's SelectObjectContent) now implement the Sync auto-trait.
• 🐛 (aws-sdk-rust#764) S3's GetObject will no longer panic when checksum validation is enabled and the target object was uploaded as a multi-part upload.
  However, these objects cannot be checksum validated by the SDK due to the way checksums are calculated for multipart uploads.
  For more information, see this page.
• 🐛 (smithy-rs#2513) AppName is now configurable from within ConfigLoader.
• (smithy-rs#2473, @martinjlowm) Add support for omitting session token in canonical requests for SigV4 signing.
• (smithy-rs#2525, @parker-timmerman) Add into_segments method to AggregatedBytes, for zero-copy conversions.
• 🐛 (smithy-rs#781, aws-sdk-rust#781) Fix bug where an incorrect endpoint was produced for WriteGetObjectResponse
• (smithy-rs#2534) aws_smithy_types::date_time::Format has been re-exported in SDK crates.
• (smithy-rs#2603) Reduce several instances of credential exposure in the SDK logs:
  • IMDS now suppresses the body of the response from logs
  • aws-sigv4 marks the x-amz-session-token header as sensitive
  • STS & SSO credentials have been manually marked as sensitive which suppresses logging of response bodies for relevant operations

Contributors
Thank you for your contributions! ❤

• @abusch (aws-sdk-rust#784)
• @eduardomourar (smithy-rs#2254)
• @martinjlowm (smithy-rs#2473)
• @parker-timmerman (smithy-rs#2525)

Crate Versions

New this release:

• 🐛🎉 (smithy-rs#2562) Update the std::fmt::Debug implementation for aws-sigv4::SigningParams so that it will no longer print sensitive information.

Crate Versions

Crate Versions

Breaking Changes:

• ⚠🎉 (smithy-rs#2467) Update MSRV to 1.66.1

• ⚠ (smithy-rs#76, smithy-rs#2129) Request IDs can now be easily retrieved on successful responses. For example, with S3:

  // Import the trait to get the `request_id` method on outputs
  use aws_sdk_s3::types::RequestId;
  let output = client.list_buckets().send().await?;
  println!("Request ID: {:?}", output.request_id());

• ⚠ (smithy-rs#76, smithy-rs#2129) Retrieving a request ID from errors now requires importing the RequestId trait. For example, with S3:

  use aws_sdk_s3::types::RequestId;
  println!("Request ID: {:?}", error.request_id());

• ⚠ (smithy-rs#76, smithy-rs#2129) The message() and code() methods on errors have been moved into ProvideErrorMetadata trait. This trait will need to be imported to continue calling these.

• ⚠ (smithy-rs#76, smithy-rs#2129, smithy-rs#2075) The *Error and *ErrorKind types have been combined to make error matching simpler.

  Example with S3

  Before:

  let result = client
      .get_object()
      .bucket(BUCKET_NAME)
      .key("some-key")
      .send()
      .await;
  match result {
      Ok(_output) => { /* Do something with the output */ }
      Err(err) => match err.into_service_error() {
          GetObjectError { kind, .. } => match kind {
              GetObjectErrorKind::InvalidObjectState(value) => println!("invalid object state: {:?}", value),
              GetObjectErrorKind::NoSuchKey(_) => println!("object didn't exist"),
          }
          err @ GetObjectError { .. } if err.code() == Some("SomeUnmodeledError") => {}
          err @ _ => return Err(err.into()),
      },
  }

  After:

  // Needed to access the `.code()` function on the error type:
  use aws_sdk_s3::types::ProvideErrorMetadata;
  let result = client
      .get_object()
      .bucket(BUCKET_NAME)
      .key("some-key")
      .send()
      .await;
  match result {
      Ok(_output) => { /* Do something with the output */ }
      Err(err) => match err.into_service_error() {
          GetObjectError::InvalidObjectState(value) => {
              println!("invalid object state: {:?}", value);
          }
          GetObjectError::NoSuchKey(_) => {
              println!("object didn't exist");
          }
          err if err.code() == Some("SomeUnmodeledError") => {}
          err @ _ => return Err(err.into()),
      },
  }

• ⚠ (smithy-rs#76, smithy-rs#2129) aws_smithy_types::Error has been renamed to aws_smithy_types::error::ErrorMetadata.

• ⚠ (smithy-rs#2433) The modules in the SDK crates have been reorganized. See the SDK Crate Reorganization Upgrade Guidance to see how to fix your code after this change.

• ⚠ (aws-sdk-rust#160, smithy-rs#2445) Reconnect on transient errors.

  If a transient error (timeout, 500, 503, 503) is encountered, the connection will be evicted from the pool and will not
  be reused. This is enabled by default for all AWS services. It can be disabled by setting RetryConfig::with_reconnect_mode

  Although there is no API breakage from this change, it alters the client behavior in a way that may cause breakage for customers.

• ⚠ (smithy-rs#2390, smithy-rs#1784) Remove deprecated ResolveAwsEndpoint interfaces.
  For details see the longform changelog entry.

• ⚠🎉 (smithy-rs#2222, @Nugine) Upgrade Rust MSRV to 1.63.0

New this release:

• 🐛🎉 (aws-sdk-rust#740) Fluent builder methods on the client are now marked as deprecated when the related operation is deprecated.

• 🎉 (smithy-rs#2428, smithy-rs#2208) SdkError variants can now be constructed for easier unit testing.

• 🎉 (aws-sdk-rust#753, smithy-rs#2451) Enable presigning for S3's HeadObject operation.

• (smithy-rs#2437, aws-sdk-rust#600) Add more client re-exports. Specifically, it re-exports aws_smithy_http::body::SdkBody, aws_smithy_http::byte_stream::error::Error, and aws_smithy_http::operation::{Request, Response}.

• 🐛 (smithy-rs#2471, smithy-rs#2333, smithy-rs#2151) Default connector provided by aws-config now respects ConnectorSettings.

  Previously, it used the timeout settings provided by aws-config. A test from @Oliboy50 has been incorporated to verify this behavior.

  Behavior Change: Prior to this change, the Hyper client would be shared between all service clients. After this change, each service client will use its own Hyper Client.
  To revert to the previous behavior, set HttpConnector::Prebuilt on SdkConfig::http_connector.

• (smithy-rs#2474) Increase Tokio version to 1.23.1 for all crates. This is to address RUSTSEC-2023-0001

• 🎉 (smithy-rs#2258) Add static stability support to IMDS credentials provider. It does not alter common use cases for the provider, but allows the provider to serve expired credentials in case IMDS is unreachable. This allows requests to be dispatched to a target service with expired credentials. This, in turn, allows the target service to make the ultimate decision as to whether requests sent are valid or not.

• (smithy-rs#2246) Provide a way to retrieve fallback credentials if a call to provide_credentials is interrupted. An interrupt can occur when a timeout future is raced against a future for provide_credentials, and the former wins the race. A new method, fallback_on_interrupt on the ProvideCredentials trait, can be used in that case. The following code snippet from LazyCredentialsCache::provide_cached_credentials has been updated like so:

  Before:

  let timeout_future = self.sleeper.sleep(self.load_timeout);
  // --snip--
  let future = Timeout::new(provider.provide_credentials(), timeout_future);
  let result = cache
      .get_or_load(|| {
          async move {
              let credentials = future.await.map_err(|_err| {
                  CredentialsError::provider_timed_out(load_timeout)
              })??;
              // --snip--
          }
      }).await;
  // --snip--

  After:

  let timeout_future = self.sleeper.sleep(self.load_timeout);
  // --snip--
  let future = Timeout::new(provider.provide_credentials(), timeout_future);
  let result = cache
      .get_or_load(|| {
          async move {
             let credentials = match future.await {
                  Ok(creds) => creds?,
                  Err(_err) => match provider.fallback_on_interrupt() { // can provide fallback credentials
                      Some(creds) => creds,
                      None => return Err(CredentialsError::provider_timed_out(load_timeout)),
                  }
              };
              // --snip--
          }
      }).await;
  // --snip--

• 🐛 (smithy-rs#2271) Fix broken doc link for tokio_stream::Stream that is a re-export of futures_core::Stream.

• 🐛 (smithy-rs#2261, aws-sdk-rust#720, @nipunn1313) Fix request canonicalization for HTTP requests with repeated headers (for example S3's GetObjectAttributes). Previously requests with repeated headers would fail with a 403 signature mismatch due to this bug.

• (smithy-rs#2335) Adds jitter to LazyCredentialsCache. This allows credentials with the same expiry to expire at slightly different times, thereby preventing thundering herds.

• 🐛 (aws-sdk-rust#736) Fix issue where clients using native-tls connector were prevented from making HTTPS requests.

Crate Versions

Breaking Changes:

• ⚠ (smithy-rs#2122, smithy-rs#2227) Improve SDK credentials caching through type safety. LazyCachingCredentialsProvider has been renamed to LazyCredentialsCache and is no longer treated as a credentials provider. Furthermore, you do not create a LazyCredentialsCache directly, and instead you interact with CredentialsCache. This introduces the following breaking changes.

  If you previously used LazyCachingCredentialsProvider, you can replace it with CredentialsCache.

  Example

  Before:

  use aws_config::meta::credentials::lazy_caching::LazyCachingCredentialsProvider;
  use aws_types::provider::ProvideCredentials;
  
  fn make_provider() -> impl ProvideCredentials {
      // --snip--
  }
  
  let credentials_provider =
      LazyCachingCredentialsProvider::builder()
          .load(make_provider())
          .build();
  
  let sdk_config = aws_config::from_env()
      .credentials_provider(credentials_provider)
      .load()
      .await;
  
  let client = aws_sdk_s3::Client::new(&sdk_config);

  After:

  use aws_credential_types::cache::CredentialsCache;
  use aws_types::provider::ProvideCredentials;
  
  fn make_provider() -> impl ProvideCredentials {
      // --snip--
  }
  
  // Wrapping a result of `make_provider` in `LazyCredentialsCache` is done automatically.
  let sdk_config = aws_config::from_env()
      .credentials_cache(CredentialsCache::lazy()) // This line can be omitted because it is on by default.
      .credentials_provider(make_provider())
      .load()
      .await;
  
  let client = aws_sdk_s3::Client::new(&sdk_config);

  If you previously configured a LazyCachingCredentialsProvider, you can use the builder for LazyCredentialsCache instead.

  Before:

  use aws_config::meta::credentials::lazy_caching::LazyCachingCredentialsProvider;
  use aws_types::provider::ProvideCredentials;
  use std::time::Duration;
  
  fn make_provider() -> impl ProvideCredentials {
      // --snip--
  }
  
  let credentials_provider =
      LazyCachingCredentialsProvider::builder()
          .load(make_provider())
          .load_timeout(Duration::from_secs(60)) // Configures timeout.
          .build();
  
  let sdk_config = aws_config::from_env()
      .credentials_provider(credentials_provider)
      .load()
      .await;
  
  let client = aws_sdk_s3::Client::new(&sdk_config);

  After:

  use aws_credential_types::cache::CredentialsCache;
  use aws_types::provider::ProvideCredentials;
  use std::time::Duration;
  
  fn make_provider() -> impl ProvideCredentials {
      // --snip--
  }
  
  let sdk_config = aws_config::from_env()
      .credentials_cache(
          CredentialsCache::lazy_builder()
              .load_timeout(Duration::from_secs(60)) // Configures timeout.
              .into_credentials_cache(),
      )
      .credentials_provider(make_provider())
      .load()
      .await;
  
  let client = aws_sdk_s3::Client::new(&sdk_config);

  The examples above only demonstrate how to use credentials_cache and credentials_provider methods on aws_config::ConfigLoader but the same code update can be applied when you interact with aws_types::sdk_config::Builder or the builder for a service-specific config, e.g. aws_sdk_s3::config::Builder.

  If you previously configured a DefaultCredentialsChain by calling load_timeout, buffer_time, or default_credential_expiration on its builder, you need to call the same set of methods on the builder for LazyCredentialsCache instead.

  Example

  Before:

  use aws_config::default_provider::credentials::DefaultCredentialsChain;
  use std::time::Duration;
  
  let credentials_provider = DefaultCredentialsChain::builder()
      .buffer_time(Duration::from_secs(30))
      .default_credential_expiration(Duration::from_secs(20 * 60))
      .build()
      .await;
  
  let sdk_config = aws_config::from_env()
      .credentials_provider(credentials_provider)
      .load()
      .await;
  
  let client = aws_sdk_s3::Client::new(&sdk_config);

  After:

  use aws_config::default_provider::credentials::default_provider;
  use aws_credential_types::cache::CredentialsCache;
  use std::time::Duration;
  
  // Previously used methods no longer exist on the builder for `DefaultCredentialsChain`.
  let credentials_provider = default_provider().await;
  
  let sdk_config = aws_config::from_env()
      .credentials_cache(
          CredentialsCache::lazy_builder()
              .buffer_time(Duration::from_secs(30))
              .default_credential_expiration(Duration::from_secs(20 * 60))
              .into_credentials_cache(),
      )
      .credentials_provider(credentials_provider)
      .load()
      .await;
  
  let client = aws_sdk_s3::Client::new(&sdk_config);

• ⚠ (smithy-rs#2122, smithy-rs#2227) The introduction of CredentialsCache comes with an accompanying type SharedCredentialsCache, which we will store in the property bag instead of a SharedCredentialsProvider. As a result, aws_http::auth:set_provider has been updated to aws_http::auth::set_credentials_cache.

  Before:

  use aws_credential_types::Credentials;
  use aws_credential_types::provider::SharedCredentialsProvider;
  use aws_http::auth::set_provider;
  use aws_smithy_http::body::SdkBody;
  use aws_smithy_http::operation;
  
  let mut req = operation::Request::new(http::Request::new(SdkBody::from("some body")));
  let credentials = Credentials::new("example", "example", None, None, "my_provider_name");
  set_provider(
      &mut req.properties_mut(),
      SharedCredentialsProvider::new(credentials),
  );

  After:

  use aws_credential_types::Credentials;
  use aws_credential_types::cache::{CredentialsCache, SharedCredentialsCache};
  use aws_credential_types::provider::SharedCredentialsProvider;
  use aws_http::auth::set_credentials_cache;
  use aws_smithy_http::body::SdkBody;
  use aws_smithy_http::operation;
  
  let mut req = operation::Request::new(http::Request::new(SdkBody::from("some body")));
  let credentials = Credentials::new("example", "example", None, None, "my_provider_name");
  let credentials_cache = CredentialsCache::lazy_builder()
      .into_credentials_cache()
      .create_cache(SharedCredentialsProvider::new(credentials));
  set_credentials_cache(
      &mut req.properties_mut(),
      SharedCredentialsCache::new(credentials_cache),
  );

New this release:

• 🐛 (smithy-rs#2204) Fix endpoint for s3.write_get_object_response(). This bug was introduced in 0.53.
• (smithy-rs#2204) Add with_test_defaults() and set_test_defaults() to <service>::Config. These methods fill in defaults for configuration that is mandatory to successfully send a request.

Breaking Changes:

• ⚠🎉 (smithy-rs#1784, smithy-rs#2074) Integrate Endpoints 2.0 into the Rust SDK. Endpoints 2.0 enables features like S3 virtual addressing & S3
  object lambda. As part of this change, there are several breaking changes although efforts have been made to deprecate
  where possible to smooth the upgrade path.

  1. aws_smithy_http::endpoint::Endpoint and the endpoint_resolver methods have been deprecated. In general, these usages
     should be replaced with usages of endpoint_url instead. endpoint_url accepts a string so an aws_smithy_http::Endpoint
     does not need to be constructed. This structure and methods will be removed in a future release.
  2. The endpoint_resolver method on <service>::config::Builder now accepts a service specific endpoint resolver instead
     of an implementation of ResolveAwsEndpoint. Most users will be able to replace these usages with a usage of endpoint_url.
  3. ResolveAwsEndpoint has been deprecated and will be removed in a future version of the SDK.
  4. The SDK does not support "pseudo regions" anymore. Specifically, regions like iam-fips will no longer resolve to a FIPS endpoint.

• ⚠🎉 (smithy-rs#1784, smithy-rs#2074) Add additional configuration parameters to aws_sdk_s3::Config.

  The launch of endpoints 2.0 includes more configuration options for S3. The default behavior for endpoint resolution has
  been changed. Before, all requests hit the path-style endpoint. Going forward, all requests that can be routed to the
  virtually hosted bucket will be routed there automatically.

  • force_path_style: Requests will now default to the virtually-hosted endpoint <bucketname>.s3.<region>.amazonaws.com
  • use_arn_region: Enables this client to use an ARN’s region when constructing an endpoint instead of the client’s configured region.
  • accelerate: Enables this client to use S3 Transfer Acceleration endpoints.

  Note: the AWS SDK for Rust does not currently support Multi Region Access Points (MRAP).

• ⚠ (smithy-rs#2108) Move types for AWS SDK credentials to a separate crate.
  A new AWS runtime crate called aws-credential-types has been introduced. Types for AWS SDK credentials have been moved to that crate from aws-config and aws-types. The new crate is placed at the top of the dependency graph among AWS runtime crates with the aim of the downstream crates having access to the types defined in it.

• ⚠ (smithy-rs#2162) aws_config::profile::retry_config && aws_config::environment::retry_config have been removed. Use aws_config::default_provider::retry_config instead.

New this release:

• 🎉 (smithy-rs#2168) Add support for resolving FIPS and dual-stack endpoints.

  FIPS and dual-stack endpoints can each be configured in multiple ways:

  1. Automatically from the environment and AWS profile
  2. Across all clients loaded from the same SdkConfig via from_env().use_dual_stack(true).load().await
  3. At a client level when constructing the configuration for an individual client.

  Note: Not all services support FIPS and dual-stack.

• (smithy-rs#2152) Add support for overriding profile name and profile file location across all providers. Prior to this change, each provider needed to be updated individually.

  Before

  use aws_config::profile::{ProfileFileCredentialsProvider, ProfileFileRegionProvider};
  use aws_config::profile::profile_file::{ProfileFiles, ProfileFileKind};
  
  let profile_files = ProfileFiles::builder()
      .with_file(ProfileFileKind::Credentials, "some/path/to/credentials-file")
      .build();
  let credentials_provider = ProfileFileCredentialsProvider::builder()
      .profile_files(profile_files.clone())
      .build();
  let region_provider = ProfileFileRegionProvider::builder()
      .profile_files(profile_files)
      .build();
  
  let sdk_config = aws_config::from_env()
      .credentials_provider(credentials_provider)
      .region(region_provider)
      .load()
      .await;

  After

  use aws_config::profile::{ProfileFileCredentialsProvider, ProfileFileRegionProvider};
  use aws_config::profile::profile_file::{ProfileFiles, ProfileFileKind};
  
  let profile_files = ProfileFiles::builder()
      .with_file(ProfileFileKind::Credentials, "some/path/to/credentials-file")
      .build();
  let sdk_config = aws_config::from_env()
      .profile_files(profile_files)
      .load()
      .await;
  /// ```
  

Breaking Changes:

• 🐛⚠ (smithy-rs#1847) Support Sigv4 signature generation on PowerPC 32 and 64 bit. This architecture cannot compile ring, so the implementation has been updated to rely on hamc + sha2 to achive the same result with broader platform compatibility and higher performance. We also updated the CI which is now running as many tests as possible against i686 and PowerPC 32 and 64 bit.

• ⚠ (smithy-rs#1225, smithy-rs#1918) <service>::Client::from_conf_conn has been removed since it's now possible to configure the connection from the
  shared and service configs. To update your code, pass connections to the http_connector method during config creation.

  Example

  before:

      let conf = aws_sdk_sts::Config::builder()
          // The builder has no defaults but setting other fields is omitted for brevity...
          .build();
      let (server, request) = capture_request(None);
      let client = aws_sdk_sts::Client::from_conf_conn(conf, server);

  after:

      let (server, request) = capture_request(None);
      let conf = aws_sdk_sts::Config::builder()
          // The builder has no defaults but setting other fields is omitted for brevity...
          .http_connector(server)
          .build();
      let client = aws_sdk_sts::Client::from_conf(conf);

• ⚠ (smithy-rs#1935) Removed re-export of aws_smithy_client::retry::Config from the middleware module.

• ⚠ (smithy-rs#1926, smithy-rs#1819) Several breaking changes have been made to errors. See the upgrade guide for more information.

• ⚠ (smithy-rs#1945) Generate enums that guide the users to write match expressions in a forward-compatible way.
  Before this change, users could write a match expression against an enum in a non-forward-compatible way:

  match some_enum {
      SomeEnum::Variant1 => { /* ... */ },
      SomeEnum::Variant2 => { /* ... */ },
      Unknown(value) if value == "NewVariant" => { /* ... */ },
      _ => { /* ... */ },
  }

  This code can handle a case for "NewVariant" with a version of SDK where the enum does not yet include SomeEnum::NewVariant, but breaks with another version of SDK where the enum defines SomeEnum::NewVariant because the execution will hit a different match arm, i.e. the last one.
  After this change, users are guided to write the above match expression as follows:

  match some_enum {
      SomeEnum::Variant1 => { /* ... */ },
      SomeEnum::Variant2 => { /* ... */ },
      other @ _ if other.as_str() == "NewVariant" => { /* ... */ },
      _ => { /* ... */ },
  }

  This is forward-compatible because the execution will hit the second last match arm regardless of whether the enum defines SomeEnum::NewVariant or not.

• ⚠ (smithy-rs#1984, smithy-rs#1496) Functions on aws_smithy_http::endpoint::Endpoint now return a Result instead of panicking.

• ⚠ (smithy-rs#1984, smithy-rs#1496) Endpoint::mutable now takes impl AsRef<str> instead of Uri. For the old functionality, use Endpoint::mutable_uri.

• ⚠ (smithy-rs#1984, smithy-rs#1496) Endpoint::immutable now takes impl AsRef<str> instead of Uri. For the old functionality, use Endpoint::immutable_uri.

• ⚠ (smithy-rs#1983, smithy-rs#2029) Implementation of the Debug trait for container shapes now redacts what is printed per the sensitive trait.

• ⚠ (smithy-rs#2065) SdkBody callbacks have been removed. If you were using these, please file an issue so that we can better understand your use-case and provide the support you need.

• ⚠ (smithy-rs#2063) AwsEndpointStage, a middleware which set endpoints and auth has been split into AwsAuthStage and SmithyEndpointStage. Related types have also been renamed.

• ⚠ (smithy-rs#1989) The Unit type for a Union member is no longer rendered. The serializers and parsers generated now function accordingly in the absence of the inner data associated with the Unit type.

New this release:

• 🎉 (smithy-rs#1225, smithy-rs#1918)

  The HTTP connector used when making requests is now configurable through `SdkConfig`.

  use std::time::Duration;
  use aws_smithy_client::{Client, hyper_ext};
  use aws_smithy_client::erase::DynConnector;
  use aws_smithy_client::http_connector::ConnectorSettings;
  use aws_types::SdkConfig;
  
  let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
      .with_webpki_roots()
      .https_only()
      .enable_http1()
      .enable_http2()
      .build();
  
  let smithy_connector = hyper_ext::Adapter::builder()
      // Optionally set things like timeouts as well
      .connector_settings(
          ConnectorSettings::builder()
              .connect_timeout(Duration::from_secs(5))
              .build()
      )
      .build(https_connector);
  
  let sdk_config = aws_config::from_env()
      .http_connector(smithy_connector)
      .load()
      .await;
  
  let client = Client::new(&sdk_config);
  
  // When sent, this operation will go through the custom smithy connector instead of
  // the default HTTP connector.
  let op = client
      .get_object()
      .bucket("some-test-bucket")
      .key("test.txt")
      .send()
      .await
      .unwrap();

• 🎉 (aws-sdk-rust#641, smithy-rs#1892, @albe-rosado) Ability to add an inline policy or a list of policy ARNs to the AssumeRoleProvider builder.

• 🎉 (smithy-rs#2044, smithy-rs#371) Fixed and improved the request tracing span hierarchy to improve log messages, profiling, and debuggability.

• (smithy-rs#1890) Add test to exercise excluded headers in aws-sigv4.

• (smithy-rs#1801) Add test ensuring that a response will error if the response body returns an EOF before the entire body has been read.

• (smithy-rs#1923) Fix cargo audit issue on criterion.

• (smithy-rs#1918) Add to_vec method to aws_smithy_http::byte_stream::AggregatedBytes.

• 🐛 (smithy-rs#1957) It was possible in some cases to send some S3 requests without a required upload ID, causing a risk of unintended data
  deletion and modification. Now, when an operation has query parameters that are marked as required, the omission of
  those query parameters will cause a BuildError, preventing the invalid operation from being sent.

• 🐛 (smithy-rs#2018) Normalize URI paths per RFC3986 when constructing canonical requests, except for S3.

• (smithy-rs#2064, aws-sdk-rust#632) The SDK clients now default max idle connections to 70 (previously unlimited) to reduce the likelihood of hitting max file handles in AWS Lambda.

• (smithy-rs#2057, smithy-rs#371) Add more tracing events to signing and event streams

• (smithy-rs#2062) Log an info on credentials cache miss and adjust level of some credential tracing spans/events.

Contributors
Thank you for your contributions! ❤

• @albe-rosado (aws-sdk-rust#641, smithy-rs#1892)

Breaking Changes:

• ⚠ (smithy-rs#1825) Bump MSRV to be 1.62.0.
• ⚠ (smithy-rs#1740, smithy-rs#256) The SDK, by default, now times out if socket connect or time to first byte read takes longer than
  3.1 seconds. There are a large number of breaking changes that come with this change that may
  affect you if you customize the client configuration at all.
  See the upgrade guide for information
  on how to configure timeouts, and how to resolve compilation issues after upgrading.

New this release:

• 🎉 (aws-sdk-rust#237, smithy-rs#1770) It is now possible to programmatically customize the locations of the profile config/credentials files in aws-config:

  use aws_config::profile::{ProfileFileCredentialsProvider, ProfileFileRegionProvider};
  use aws_config::profile::profile_file::{ProfileFiles, ProfileFileKind};
  
  let profile_files = ProfileFiles::builder()
      .with_file(ProfileFileKind::Credentials, "some/path/to/credentials-file")
      .build();
  let credentials_provider = ProfileFileCredentialsProvider::builder()
      .profile_files(profile_files.clone())
      .build();
  let region_provider = ProfileFileRegionProvider::builder()
      .profile_files(profile_files)
      .build();
  
  let sdk_config = aws_config::from_env()
      .credentials_provider(credentials_provider)
      .region(region_provider)
      .load()
      .await;

• 🐛 (smithy-rs#1740, smithy-rs#256) Setting connect/read timeouts with SdkConfig now works. Previously, these timeout config values
  were lost during connector creation, so the only reliable way to set them was to manually override
  the HTTP connector.
• 🐛 (aws-sdk-rust#620, smithy-rs#1748) Paginators now stop on encountering a duplicate token by default rather than panic. This behavior can be customized by toggling the stop_on_duplicate_token property on the paginator before calling send.
• 🐛 (smithy-rs#1747, @kastolars) The client Config now has getters for every value that it holds.
• 🐛 (smithy-rs#1822, @kevinpark1217) Fix regression where connect_timeout and read_timeout fields are unused in the IMDS client
• (aws-sdk-rust#625, @kevinpark1217) Ability to override the IMDS client in DefaultCredentialsChain
• 🐛 (smithy-rs#1656) Fix aws-sigv4 canonical request formatting fallibility.
• (smithy-rs#1890) Add test to exercise excluded headers in aws-sigv4.

Contributors
Thank you for your contributions! ❤

• @kastolars (smithy-rs#1747)
• @kevinpark1217 (aws-sdk-rust#625, smithy-rs#1822)

There were issues with release automation for this release, and it has been yanked from crates.io.

Breaking Changes:

• ⚠ (smithy-rs#1603, aws-sdk-rust#586) aws_config::RetryConfig no longer implements Default, and its new function has been replaced with standard.
• ⚠ (smithy-rs#1603, aws-sdk-rust#586) Direct configuration of aws_config::SdkConfig now defaults to retries being disabled.
  If you're using aws_config::load_from_env() or aws_config::from_env() to configure
  the SDK, then you are NOT affected by this change. If you use SdkConfig::builder() to
  configure the SDK, then you ARE affected by this change and should set the retry config
  on that builder.
• ⚠ (smithy-rs#1603, aws-sdk-rust#586) Client creation now panics if retries or timeouts are enabled without an async sleep
  implementation set on the SDK config.
  If you're using the Tokio runtime and have the rt-tokio feature enabled (which is enabled by default),
  then you shouldn't notice this change at all.
  Otherwise, if using something other than Tokio as the async runtime, the AsyncSleep trait must be implemented,
  and that implementation given to the config builder via the sleep_impl method. Alternatively, retry can be
  explicitly turned off by setting the retry config to RetryConfig::disabled(), which will result in successful
  client creation without an async sleep implementation.
• ⚠ (smithy-rs#1715, smithy-rs#1717) ClassifyResponse was renamed to ClassifyRetry and is no longer implemented for the unit type.
• ⚠ (smithy-rs#1715, smithy-rs#1717) The with_retry_policy and retry_policy functions on aws_smithy_http::operation::Operation have been
  renamed to with_retry_classifier and retry_classifier respectively. Public member retry_policy on
  aws_smithy_http::operation::Parts has been renamed to retry_classifier.

New this release:

• 🎉 (smithy-rs#1647, smithy-rs#1112) Implemented customizable operations per RFC-0017.

  Before this change, modifying operations before sending them required using lower-level APIs:

  let input = SomeOperationInput::builder().some_value(5).build()?;
  
  let operation = {
      let op = input.make_operation(&service_config).await?;
      let (request, response) = op.into_request_response();
  
      let request = request.augment(|req, _props| {
          req.headers_mut().insert(
              HeaderName::from_static("x-some-header"),
              HeaderValue::from_static("some-value")
          );
          Result::<_, Infallible>::Ok(req)
      })?;
  
      Operation::from_parts(request, response)
  };
  
  let response = smithy_client.call(operation).await?;

  Now, users may easily modify operations before sending with the customize method:

  let response = client.some_operation()
      .some_value(5)
      .customize()
      .await?
      .mutate_request(|mut req| {
          req.headers_mut().insert(
              HeaderName::from_static("x-some-header"),
              HeaderValue::from_static("some-value")
          );
      })
      .send()
      .await?;

• 🐛 (smithy-rs#966, smithy-rs#1718) The AWS STS SDK now automatically retries IDPCommunicationError when calling AssumeRoleWithWebIdentity

• 🐛 (aws-sdk-rust#303, smithy-rs#1717) The SdkError::ResponseError, typically caused by a connection terminating before the full response is received, is now treated as a transient failure and retried.