add user agent -- first try

aws-s3-transfer-manager/Cargo.toml

@@ -15,6 +15,7 @@ aws-config = { version = "1.5.6", features = ["behavior-version-latest"] }
 aws-sdk-s3 = { version = "1.51.0", features = ["behavior-version-latest"] }
 aws-smithy-async = "1.2.1"
 aws-smithy-experimental = { version = "0.1.3", features = ["crypto-aws-lc"] }
+aws-smithy-runtime = { version = "1.7.1", features = ["client", "connector-hyper-0-14-x", "test-util", "wire-mock"] }
 aws-smithy-runtime-api = "1.7.1"
 aws-smithy-types = "1.2.6"
 aws-types = "1.3.3"

aws-s3-transfer-manager/examples/cp.rs

@@ -7,6 +7,7 @@ use std::path::PathBuf;
 use std::str::FromStr;
 use std::time;
 
+use aws_config::AppName;
 use aws_s3_transfer_manager::io::InputStream;
 use aws_s3_transfer_manager::metrics::unit::ByteUnit;
 use aws_s3_transfer_manager::metrics::Throughput;
@@ -151,6 +152,7 @@ async fn do_download(args: Args) -> Result<(), BoxError> {
     let tm_config = aws_s3_transfer_manager::from_env()
         .concurrency(ConcurrencySetting::Explicit(args.concurrency))
         .part_size(PartSize::Target(args.part_size))
+        .app_name(Some(AppName::new("rust_ts_cp").unwrap()))
         .load()
         .await;
 
@@ -228,6 +230,7 @@ async fn do_upload(args: Args) -> Result<(), BoxError> {
     let tm_config = aws_s3_transfer_manager::from_env()
         .concurrency(ConcurrencySetting::Explicit(args.concurrency))
         .part_size(PartSize::Target(args.part_size))
+        .app_name(Some(AppName::new("rust_ts_cp").unwrap()))
         .load()
         .await;
 
@@ -278,6 +281,7 @@ async fn main() -> Result<(), BoxError> {
         tracing_subscriber::fmt()
             .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
             .with_thread_ids(true)
+            .with_ansi(false) // Disable ANSI colors
             .init();
     }
 

aws-s3-transfer-manager/src/config.rs

@@ -3,6 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+use aws_config::AppName;
+
 use crate::metrics::unit::ByteUnit;
 use crate::types::{ConcurrencySetting, PartSize};
 use std::cmp;
@@ -18,6 +20,7 @@ pub struct Config {
     multipart_threshold: PartSize,
     target_part_size: PartSize,
     concurrency: ConcurrencySetting,
+    app_name: Option<AppName>,
     client: aws_sdk_s3::client::Client,
 }
 
@@ -43,6 +46,11 @@ impl Config {
         &self.concurrency
     }
 
+    /// Returns the name of the app that is using the transfer manager, if it was provided.
+    pub fn app_name(&self) -> Option<&AppName> {
+        self.app_name.as_ref()
+    }
+
     /// The Amazon S3 client instance that will be used to send requests to S3.
     pub fn client(&self) -> &aws_sdk_s3::Client {
         &self.client
@@ -55,6 +63,7 @@ pub struct Builder {
     multipart_threshold_part_size: PartSize,
     target_part_size: PartSize,
     concurrency: ConcurrencySetting,
+    app_name: Option<AppName>,
     client: Option<aws_sdk_s3::Client>,
 }
 
@@ -122,8 +131,20 @@ impl Builder {
         self
     }
 
+    /// Sets the name of the app that is using the client.
+    ///
+    /// This _optional_ name is used to identify the application in the user agent that
+    /// gets sent along with requests.
+    pub fn app_name(mut self, app_name: Option<AppName>) -> Self {
+        self.app_name = app_name;
+        self
+    }
+
     /// Set an explicit S3 client to use.
     pub fn client(mut self, client: aws_sdk_s3::Client) -> Self {
+        // TODO - decide the approach here:
+        // - Convert the client to build to modify it based on other configs for transfer manager
+        // - Instead of taking the client, take sdk-config/s3-config/builder?
         self.client = Some(client);
         self
     }
@@ -134,6 +155,7 @@ impl Builder {
             multipart_threshold: self.multipart_threshold_part_size,
             target_part_size: self.target_part_size,
             concurrency: self.concurrency,
+            app_name: self.app_name,
             client: self.client.expect("client set"),
         }
     }

aws-s3-transfer-manager/src/config/loader.rs

@@ -3,13 +3,39 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+use aws_config::{AppName, BehaviorVersion};
+use aws_sdk_s3::config::{Intercept, IntoShared};
+use aws_smithy_runtime::client::sdk_feature::SmithySdkFeature;
+
 use crate::config::Builder;
 use crate::{
     http,
     types::{ConcurrencySetting, PartSize},
     Config,
 };
 
+#[derive(Debug)]
+struct TransferManagerFeatureInterceptor;
+
+impl Intercept for TransferManagerFeatureInterceptor {
+    fn name(&self) -> &'static str {
+        "TransferManagerFeature"
+    }
+
+    fn read_before_execution(
+        &self,
+        _ctx: &aws_sdk_s3::config::interceptors::BeforeSerializationInterceptorContextRef<'_>,
+        cfg: &mut aws_sdk_s3::config::ConfigBag,
+    ) -> Result<(), aws_sdk_s3::error::BoxError> {
+        cfg.interceptor_state()
+            // .store_put(AppName::new("crt-dengket").unwrap())
+            // .store_append(AwsSdkFeature::S3Transfer)
+            .store_append::<SmithySdkFeature>(SmithySdkFeature::ProtocolRpcV2Cbor)
+            .store_append::<SmithySdkFeature>(SmithySdkFeature::Waiter);
+        Ok(())
+    }
+}
+
 /// Load transfer manager [`Config`] from the environment.
 #[derive(Default, Debug)]
 pub struct ConfigLoader {
@@ -52,17 +78,32 @@ impl ConfigLoader {
         self
     }
 
+    /// Sets the name of the app that is using the client.
+    ///
+    /// This _optional_ name is used to identify the application in the user agent that
+    /// gets sent along with requests.
+    pub fn app_name(mut self, app_name: Option<AppName>) -> Self {
+        self.builder = self.builder.app_name(app_name);
+        self
+    }
+
     /// Load the default configuration
     ///
     /// If fields have been overridden during builder construction, the override values will be
     /// used. Otherwise, the default values for each field will be provided.
     pub async fn load(self) -> Config {
-        let shared_config = aws_config::from_env()
-            .http_client(http::default_client())
-            .load()
-            .await;
-        let s3_client = aws_sdk_s3::Client::new(&shared_config);
-        let builder = self.builder.client(s3_client);
+        let mut config_loader =
+            aws_config::defaults(BehaviorVersion::latest()).http_client(http::default_client());
+        if let Some(app_name) = self.builder.app_name.as_ref() {
+            config_loader = config_loader.app_name(app_name.clone());
+        }
+        let shared_config = config_loader.load().await;
+
+        let mut sdk_client_builder = aws_sdk_s3::config::Builder::from(&shared_config);
+        sdk_client_builder.push_interceptor(TransferManagerFeatureInterceptor.into_shared());
+        let builder = self
+            .builder
+            .client(aws_sdk_s3::Client::from_conf(sdk_client_builder.build()));
         builder.build()
     }
 }