Adding user-agent metrics for flexible checksums

aws/rust-runtime/aws-inlineable/src/http_request_checksum.rs

@@ -12,6 +12,7 @@ use aws_runtime::{auth::SigV4OperationSigningConfig, content_encoding::header_va
 use aws_sigv4::http_request::SignableBody;
 use aws_smithy_checksums::ChecksumAlgorithm;
 use aws_smithy_checksums::{body::calculate, http::HttpChecksum};
+use aws_smithy_runtime::client::sdk_feature::SmithySdkFeature;
 use aws_smithy_runtime_api::box_error::BoxError;
 use aws_smithy_runtime_api::client::interceptors::context::{
  BeforeSerializationInterceptorContextMut, BeforeTransmitInterceptorContextMut, Input,
@@ -152,7 +153,7 @@ where
  /// Calculate a checksum and modify the request to include the checksum as a header
  /// (for in-memory request bodies) or a trailer (for streaming request bodies).
  /// Streaming bodies must be sized or this will return an error.
- fn modify_before_signing(
+ fn modify_before_retry_loop(
  &self,
  context: &mut BeforeTransmitInterceptorContextMut<'_>,
  _runtime_components: &RuntimeComponents,
@@ -187,12 +188,68 @@ where
  let checksum_algorithm = incorporate_custom_default(state.checksum_algorithm, cfg)
  .unwrap_or(ChecksumAlgorithm::Crc32);
 
+ // Set the user-agent metric for the selected checksum algorithm
+ match checksum_algorithm {
+ ChecksumAlgorithm::Crc32 => {
+ cfg.interceptor_state()
+ .store_append(SmithySdkFeature::FlexibleChecksumsReqCrc32);
+ }
+ ChecksumAlgorithm::Crc32c => {
+ cfg.interceptor_state()
+ .store_append(SmithySdkFeature::FlexibleChecksumsReqCrc32c);
+ }
+ #[allow(deprecated)]
+ ChecksumAlgorithm::Md5 => {
+ tracing::warn!(more_info = "Unsupported ChecksumAlgorithm MD5 set");
+ }
+ ChecksumAlgorithm::Sha1 => {
+ cfg.interceptor_state()
+ .store_append(SmithySdkFeature::FlexibleChecksumsReqSha1);
+ }
+ ChecksumAlgorithm::Sha256 => {
+ cfg.interceptor_state()
+ .store_append(SmithySdkFeature::FlexibleChecksumsReqSha256);
+ }
+ unsupported => tracing::warn!(
+ more_info = "Unsupported value of ChecksumAlgorithm detected when setting user-agent metrics",
+ unsupported = ?unsupported),
+ }
+
  let request = context.request_mut();
  add_checksum_for_request_body(request, checksum_algorithm, cfg)?;
  }
 
  Ok(())
  }
+
+ /// Set the user-agent metrics for `RequestChecksumCalculation` here to avoid ownership issues
+ /// with the mutable borrow of cfg in `modify_before_signing`
+ fn read_after_serialization(
+ &self,
+ _context: &aws_smithy_runtime_api::client::interceptors::context::BeforeTransmitInterceptorContextRef<'_>,
+ _runtime_components: &RuntimeComponents,
+ cfg: &mut ConfigBag,
+ ) -> Result<(), BoxError> {
+ let request_checksum_calculation = cfg
+ .load::<RequestChecksumCalculation>()
+ .unwrap_or(&RequestChecksumCalculation::WhenSupported);
+
+ match request_checksum_calculation {
+ RequestChecksumCalculation::WhenSupported => {
+ cfg.interceptor_state()
+ .store_append(SmithySdkFeature::FlexibleChecksumsReqWhenSupported);
+ }
+ RequestChecksumCalculation::WhenRequired => {
+ cfg.interceptor_state()
+ .store_append(SmithySdkFeature::FlexibleChecksumsReqWhenRequired);
+ }
+ unsupported => tracing::warn!(
+ more_info = "Unsupported value of RequestChecksumCalculation when setting user-agent metrics",
+ unsupported = ?unsupported),
+ };
+
+ Ok(())
+ }
 }
 
 fn incorporate_custom_default(

aws/rust-runtime/aws-inlineable/src/http_response_checksum.rs

@@ -8,6 +8,7 @@
 //! Interceptor for handling Smithy `@httpChecksum` response checksumming
 
 use aws_smithy_checksums::ChecksumAlgorithm;
+use aws_smithy_runtime::client::sdk_feature::SmithySdkFeature;
 use aws_smithy_runtime_api::box_error::BoxError;
 use aws_smithy_runtime_api::client::interceptors::context::{
  BeforeDeserializationInterceptorContextMut, BeforeSerializationInterceptorContextMut, Input,
@@ -78,6 +79,25 @@ where
  layer.store_put(ResponseChecksumInterceptorState { validation_enabled });
  cfg.push_layer(layer);
 
+ let response_checksum_validation = cfg
+ .load::<ResponseChecksumValidation>()
+ .unwrap_or(&ResponseChecksumValidation::WhenSupported);
+
+ // Set the user-agent feature metric for the response checksum config
+ match response_checksum_validation {
+ ResponseChecksumValidation::WhenSupported => {
+ cfg.interceptor_state()
+ .store_append(SmithySdkFeature::FlexibleChecksumsResWhenSupported);
+ }
+ ResponseChecksumValidation::WhenRequired => {
+ cfg.interceptor_state()
+ .store_append(SmithySdkFeature::FlexibleChecksumsResWhenRequired);
+ }
+ unsupported => tracing::warn!(
+ more_info = "Unsupported value of ResponseChecksumValidation when setting user-agent metrics",
+ unsupported = ?unsupported),
+ };
+
  Ok(())
  }
 

aws/rust-runtime/aws-runtime/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "aws-runtime"
-version = "1.4.3"
+version = "1.4.4"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
 description = "Runtime support code for the AWS SDK. This crate isn't intended to be used directly."
 edition = "2021"

aws/rust-runtime/aws-runtime/src/user_agent/metrics.rs

@@ -126,7 +126,17 @@ iterable_enum!(
  AccountIdModeDisabled,
  AccountIdModeRequired,
  Sigv4aSigning,
- ResolvedAccountId
+ ResolvedAccountId,
+ FlexibleChecksumsReqCrc32,
+ FlexibleChecksumsReqCrc32c,
+ FlexibleChecksumsReqCrc64,
+ FlexibleChecksumsReqSha1,
+ FlexibleChecksumsReqSha256,
+ FlexibleChecksumsReqWhenSupported,
+ FlexibleChecksumsReqWhenRequired,
+ FlexibleChecksumsResWhenSupported,
+ FlexibleChecksumsResWhenRequired,
+ DdbMapper
 );
 
 pub(crate) trait ProvideBusinessMetric {
@@ -141,6 +151,23 @@ impl ProvideBusinessMetric for SmithySdkFeature {
  Paginator => Some(BusinessMetric::Paginator),
  GzipRequestCompression => Some(BusinessMetric::GzipRequestCompression),
  ProtocolRpcV2Cbor => Some(BusinessMetric::ProtocolRpcV2Cbor),
+ FlexibleChecksumsReqCrc32 => Some(BusinessMetric::FlexibleChecksumsReqCrc32),
+ FlexibleChecksumsReqCrc32c => Some(BusinessMetric::FlexibleChecksumsReqCrc32c),
+ FlexibleChecksumsReqCrc64 => Some(BusinessMetric::FlexibleChecksumsReqCrc64),
+ FlexibleChecksumsReqSha1 => Some(BusinessMetric::FlexibleChecksumsReqSha1),
+ FlexibleChecksumsReqSha256 => Some(BusinessMetric::FlexibleChecksumsReqSha256),
+ FlexibleChecksumsReqWhenSupported => {
+ Some(BusinessMetric::FlexibleChecksumsReqWhenSupported)
+ }
+ FlexibleChecksumsReqWhenRequired => {
+ Some(BusinessMetric::FlexibleChecksumsReqWhenRequired)
+ }
+ FlexibleChecksumsResWhenSupported => {
+ Some(BusinessMetric::FlexibleChecksumsResWhenSupported)
+ }
+ FlexibleChecksumsResWhenRequired => {
+ Some(BusinessMetric::FlexibleChecksumsResWhenRequired)
+ }
  otherwise => {
  // This may occur if a customer upgrades only the `aws-smithy-runtime-api` crate
  // while continuing to use an outdated version of an SDK crate or the `aws-runtime`
@@ -250,7 +277,17 @@ mod tests {
  "ACCOUNT_ID_MODE_DISABLED": "Q",
  "ACCOUNT_ID_MODE_REQUIRED": "R",
  "SIGV4A_SIGNING": "S",
- "RESOLVED_ACCOUNT_ID": "T"
+ "RESOLVED_ACCOUNT_ID": "T",
+ "FLEXIBLE_CHECKSUMS_REQ_CRC32": "U",
+ "FLEXIBLE_CHECKSUMS_REQ_CRC32C": "V",
+ "FLEXIBLE_CHECKSUMS_REQ_CRC64": "W",
+ "FLEXIBLE_CHECKSUMS_REQ_SHA1": "X",
+ "FLEXIBLE_CHECKSUMS_REQ_SHA256": "Y",
+ "FLEXIBLE_CHECKSUMS_REQ_WHEN_SUPPORTED": "Z",
+ "FLEXIBLE_CHECKSUMS_REQ_WHEN_REQUIRED": "a",
+ "FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED": "b",
+ "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED": "c",
+ "DDB_MAPPER": "d"
 }
  "#;
 

aws/rust-runtime/aws-runtime/src/user_agent/test_util.rs

@@ -17,13 +17,8 @@ static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"m/([A-Za-z0-9+/=_,-]+)").unwr
 /// Refer to the end of the parent module file `user_agent.rs` for the complete ABNF specification
 /// of `business-metrics`.
 pub fn assert_ua_contains_metric_values(user_agent: &str, values: &[&str]) {
- match RE.find(user_agent) {
- Some(matched) => {
- let csv = matched
- .as_str()
- .strip_prefix("m/")
- .expect("prefix `m/` is guaranteed to exist by regex match");
- let metrics: Vec<&str> = csv.split(',').collect();
+ match extract_ua_values(user_agent) {
+ Some(metrics) => {
  let mut missed = vec![];
 
  for value in values.iter() {
@@ -43,6 +38,18 @@ pub fn assert_ua_contains_metric_values(user_agent: &str, values: &[&str]) {
  }
 }
 
+/// Extract the metric values from the `user_agent` string
+pub fn extract_ua_values(user_agent: &str) -> Option<Vec<&str>> {
+ RE.find(user_agent).map(|matched| {
+ matched
+ .as_str()
+ .strip_prefix("m/")
+ .expect("prefix `m/` is guaranteed to exist by regex match")
+ .split(',')
+ .collect()
+ })
+}
+
 #[cfg(test)]
 mod tests {
  use super::*;