Avoid logging signable body by default whose data can be very large

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

@@ -1,6 +1,6 @@
 [package]
 name = "aws-sigv4"
-version = "1.2.5"
+version = "1.2.6"
 authors = ["AWS Rust SDK Team <[email protected]>", "David Barsky <[email protected]>"]
 description = "SigV4 signer for HTTP requests and Event Stream messages."
 edition = "2021"

aws/rust-runtime/aws-sigv4/src/http_request/sign.rs

@@ -19,6 +19,8 @@ use std::borrow::Cow;
 use std::fmt::{Debug, Formatter};
 use std::str;
 
+const LOG_SIGNABLE_BODY: &str = "LOG_SIGNABLE_BODY";
+
 /// Represents all of the information necessary to sign an HTTP request.
 #[derive(Debug)]
 #[non_exhaustive]
@@ -72,7 +74,7 @@ impl<'a> SignableRequest<'a> {
 }
 
 /// A signable HTTP request body
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Clone, Eq, PartialEq)]
 #[non_exhaustive]
 pub enum SignableBody<'a> {
     /// A body composed of a slice of bytes
@@ -93,6 +95,35 @@ pub enum SignableBody<'a> {
     StreamingUnsignedPayloadTrailer,
 }
 
+/// Formats the value using the given formatter. To print the body data, set `LOG_SIGNABLE_BODY=true`.
+impl<'a> Debug for SignableBody<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let should_log_signable_body = std::env::var(LOG_SIGNABLE_BODY)
+            .map(|v| v.eq_ignore_ascii_case("true"))
+            .unwrap_or_default();
+        match self {
+            Self::Bytes(arg0) => {
+                if should_log_signable_body {
+                    f.debug_tuple("Bytes").field(arg0).finish()
+                } else {
+                    f.debug_tuple("Bytes").finish()
+                }
+            }
+            Self::UnsignedPayload => write!(f, "UnsignedPayload"),
+            Self::Precomputed(arg0) => {
+                if should_log_signable_body {
+                    f.debug_tuple("Precomputed").field(arg0).finish()
+                } else {
+                    f.debug_tuple("Precomputed").finish()
+                }
+            }
+            Self::StreamingUnsignedPayloadTrailer => {
+                write!(f, "StreamingUnsignedPayloadTrailer")
+            }
+        }
+    }
+}
+
 impl SignableBody<'_> {
     /// Create a new empty signable body
     pub fn empty() -> SignableBody<'static> {
@@ -1121,4 +1152,19 @@ mod tests {
             request.uri().path_and_query().unwrap().to_string()
         );
     }
+
+    #[test]
+    fn test_debug_signable_body() {
+        let sut = SignableBody::Bytes(b"hello signable body");
+        assert_eq!("Bytes", format!("{sut:?}"));
+
+        let sut = SignableBody::UnsignedPayload;
+        assert_eq!("UnsignedPayload", format!("{sut:?}"));
+
+        let sut = SignableBody::Precomputed("precomputed".to_owned());
+        assert_eq!("Precomputed", format!("{sut:?}"));
+
+        let sut = SignableBody::StreamingUnsignedPayloadTrailer;
+        assert_eq!("StreamingUnsignedPayloadTrailer", format!("{sut:?}"));
+    }
 }