feat: Add retry information headers (#692)

* Organize test files and directories to mirror code files and directory structure.

* Add withSocket utility method & AttributeKeys related to TTL (socketTimeout & estimatedSkew).

* Make socketTimeout to default to 60 seconds.

* Add codegen that saves socketTimeout from HttpClientConfiguration into middleware context.

* Add utility functions; one that calculates estimated skew from date string & one that calculates TTL by adding estimated skew and socket timeout to current time according to local machine clock.

* Make DeserializeMiddleware save estimated skew calculated from returned HTTP response's Date header value.

* Make RetryMiddleware add retry information headers as defined in SEP.

* Fix dateFormatter in getTTL utility method to take raw date and convert to string without any adjustments.

* Add tests for the 2 utility methods getTTL & getEstimatedSkew. Augment existing RetryIntegrationTests to check retry information headers in inputs.

* Update codegen test to include socketTimeout addition.

* Add dummy values needed for context used by retry middleware tests.

* Change a couple XCTAssert to XCTAssertEqual for better log message.

* Make socketTimeout non-optional given default value is being set now.

* Log .info level message then proceed with default values instead of throwing an error.

* Fix socket timeout related errors.

* Fix syntax error.

---------

Co-authored-by: Sichan Yoo <[email protected]>

Author: sichanyoo

Sources/ClientRuntime/Config/DefaultSDKRuntimeConfiguration.swift

@@ -96,7 +96,7 @@ public extension DefaultSDKRuntimeConfiguration {
         return URLSessionHTTPClient(httpClientConfiguration: httpClientConfiguration)
         #else
         let connectTimeoutMs = httpClientConfiguration.connectTimeout.map { UInt32($0 * 1000) }
-        let socketTimeout = httpClientConfiguration.connectTimeout.map { UInt32($0) }
+        let socketTimeout = UInt32(httpClientConfiguration.socketTimeout)
         let config = CRTClientEngineConfig(connectTimeoutMs: connectTimeoutMs, socketTimeout: socketTimeout)
         return CRTClientEngine(config: config)
         #endif

Sources/ClientRuntime/Middleware/RetryMiddleware.swift

@@ -5,6 +5,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+import class Foundation.DateFormatter
+import struct Foundation.Locale
+import struct Foundation.TimeInterval
+import struct Foundation.TimeZone
+import struct Foundation.UUID
+
 public struct RetryMiddleware<Strategy: RetryStrategy,
                               ErrorInfoProvider: RetryErrorInfoProvider,
                               OperationStackOutput>: Middleware {
@@ -16,23 +22,36 @@ public struct RetryMiddleware<Strategy: RetryStrategy,
     public var id: String { "Retry" }
     public var strategy: Strategy
 
+    // The UUID string used to uniquely identify an API call and all of its subsequent retries.
+    private let invocationID = UUID().uuidString.lowercased()
+    // Max number of retries configured for retry strategy.
+    private var maxRetries: Int
+
     public init(options: RetryStrategyOptions) {
         self.strategy = Strategy(options: options)
+        self.maxRetries = options.maxRetriesBase
     }
 
     public func handle<H>(context: Context, input: SdkHttpRequestBuilder, next: H) async throws ->
         OperationOutput<OperationStackOutput>
         where H: Handler, MInput == H.Input, MOutput == H.Output, Context == H.Context {
 
+        input.headers.add(name: "amz-sdk-invocation-id", value: invocationID)
+
         let partitionID = try getPartitionID(context: context, input: input)
         let token = try await strategy.acquireInitialRetryToken(tokenScope: partitionID)
-        return try await sendRequest(token: token, context: context, input: input, next: next)
+        input.headers.add(name: "amz-sdk-request", value: "attempt=1; max=\(maxRetries)")
+        return try await sendRequest(attemptNumber: 1, token: token, context: context, input: input, next: next)
     }
 
-    private func sendRequest<H>(token: Strategy.Token, context: Context, input: MInput, next: H) async throws ->
+    private func sendRequest<H>(
+        attemptNumber: Int,
+        token: Strategy.Token,
+        context: Context,
+        input: MInput, next: H
+    ) async throws ->
         OperationOutput<OperationStackOutput>
         where H: Handler, MInput == H.Input, MOutput == H.Output, Context == H.Context {
-
         do {
             let serviceResponse = try await next.handle(context: context, input: input)
             await strategy.recordSuccess(token: token)
@@ -45,7 +64,28 @@ public struct RetryMiddleware<Strategy: RetryStrategy,
                 // TODO: log token error here
                 throw operationError
             }
-            return try await sendRequest(token: token, context: context, input: input, next: next)
+            var estimatedSkew = context.attributes.get(key: AttributeKeys.estimatedSkew)
+            if estimatedSkew == nil {
+                estimatedSkew = 0
+                context.getLogger()!.info("Estimated skew not found; defaulting to zero.")
+            }
+            var socketTimeout = context.attributes.get(key: AttributeKeys.socketTimeout)
+            if socketTimeout == nil {
+                socketTimeout = 60.0
+                context.getLogger()!.info("Socket timeout value not found; defaulting to 60 seconds.")
+            }
+            let ttlDateUTCString = getTTL(now: Date(), estimatedSkew: estimatedSkew!, socketTimeout: socketTimeout!)
+            input.headers.update(
+                name: "amz-sdk-request",
+                value: "ttl=\(ttlDateUTCString); attempt=\(attemptNumber + 1); max=\(maxRetries)"
+            )
+            return try await sendRequest(
+                attemptNumber: attemptNumber + 1,
+                token: token,
+                context: context,
+                input: input,
+                next: next
+            )
         }
     }
 
@@ -66,3 +106,24 @@ public struct RetryMiddleware<Strategy: RetryStrategy,
         }
     }
 }
+
+// Calculates & returns TTL datetime in strftime format `YYYYmmddTHHMMSSZ`.
+func getTTL(now: Date, estimatedSkew: TimeInterval, socketTimeout: TimeInterval) -> String {
+    let dateFormatter = DateFormatter()
+    dateFormatter.dateFormat = "yyyyMMdd'T'HHmmss'Z'"
+    dateFormatter.locale = Locale(identifier: "en_US_POSIX")
+    dateFormatter.timeZone = TimeZone(abbreviation: "UTC")
+    let ttlDate = now.addingTimeInterval(estimatedSkew + socketTimeout)
+    return dateFormatter.string(from: ttlDate)
+}
+
+// Calculates & returns estimated skew.
+func getEstimatedSkew(now: Date, responseDateString: String) -> TimeInterval {
+    let dateFormatter = DateFormatter()
+    dateFormatter.dateFormat = "EEE, dd MMM yyyy HH:mm:ss z"
+    dateFormatter.locale = Locale(identifier: "en_US_POSIX")
+    dateFormatter.timeZone = TimeZone(abbreviation: "GMT")
+    let responseDate: Date = dateFormatter.date(from: responseDateString) ?? now
+    // (Estimated skew) = (Date header from HTTP response) - (client's current time)).
+    return responseDate.timeIntervalSince(now)
+}

Sources/ClientRuntime/Networking/Http/HttpClientConfiguration.swift

@@ -18,8 +18,8 @@ public class HttpClientConfiguration {
     /// Sets maximum time to wait between two data packets.
     /// Used to close stale connections that have no activity.
     ///
-    /// If no value is provided, the defaut client won't have a socket timeout.
-    public var socketTimeout: TimeInterval?
+    /// Defaults to 60 seconds if no value is provided.
+    public var socketTimeout: TimeInterval
 
     /// HTTP headers to be submitted with every HTTP request.
     ///
@@ -45,7 +45,7 @@ public class HttpClientConfiguration {
     ///   - protocolType: The HTTP scheme (`http` or `https`) to be used for API requests.  Defaults to the operation's standard configuration.
     public init(
         connectTimeout: TimeInterval? = nil,
-        socketTimeout: TimeInterval? = nil,
+        socketTimeout: TimeInterval = 60.0,
         protocolType: ProtocolType = .https,
         defaultHeaders: Headers = Headers()
     ) {

Sources/ClientRuntime/Networking/Http/HttpContext.swift

@@ -308,6 +308,12 @@ public class HttpContextBuilder {
         return self
     }
 
+    @discardableResult
+    public func withSocketTimeout(value: TimeInterval?) -> HttpContextBuilder {
+        self.attributes.set(key: AttributeKeys.socketTimeout, value: value)
+        return self
+    }
+
     @discardableResult
     public func withUnsignedPayloadTrait(value: Bool) -> HttpContextBuilder {
         self.attributes.set(key: AttributeKeys.hasUnsignedPayloadTrait, value: value)
@@ -356,6 +362,10 @@ public enum AttributeKeys {
 
     // Streams
     public static let isChunkedEligibleStream = AttributeKey<Bool>(name: "isChunkedEligibleStream")
+
+    // TTL calculation in retries.
+    public static let estimatedSkew = AttributeKey<TimeInterval>(name: "EstimatedSkew")
+    public static let socketTimeout = AttributeKey<TimeInterval>(name: "SocketTimeout")
 }
 
 // The type of flow the mdidleware context is being constructed for

Sources/ClientRuntime/Networking/Http/Middlewares/DeserializeMiddleware.swift

@@ -27,6 +27,11 @@ public struct DeserializeMiddleware<OperationStackOutput>: Middleware {
 
             let response = try await next.handle(context: context, input: input) // call handler to get http response
 
+            if let responseDateString = response.httpResponse.headers.value(for: "Date") {
+                let estimatedSkew = getEstimatedSkew(now: Date(), responseDateString: responseDateString)
+                context.attributes.set(key: AttributeKeys.estimatedSkew, value: estimatedSkew)
+            }
+
             // check if the response body was effected by a previous middleware
             if let contextBody = context.response?.body {
                 response.httpResponse.body = contextBody

Sources/ClientRuntime/Networking/Http/URLSession/URLSessionConfiguration+HTTPClientConfiguration.swift

@@ -13,9 +13,7 @@ extension URLSessionConfiguration {
 
     public static func from(httpClientConfiguration: HttpClientConfiguration) -> URLSessionConfiguration {
         let config = URLSessionConfiguration.default
-        if let socketTimeout = httpClientConfiguration.socketTimeout {
-            config.timeoutIntervalForRequest = socketTimeout
-        }
+        config.timeoutIntervalForRequest = httpClientConfiguration.socketTimeout
         return config
     }
 }