Generate time independent requestID + add a test for rapid fire

Author: Sebastien Stormacq

Sources/AWSLambdaRuntime/Lambda+LocalServer.swift

@@ -20,6 +20,13 @@ import NIOHTTP1
 import NIOPosix
 import Synchronization
 
+// for UUID
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
 // This functionality is designed for local testing when the LocalServerSupport trait is enabled.
 
 // For example:
@@ -389,7 +396,7 @@ internal struct LambdaHTTPServer {
                 )
             }
             // we always accept the /invoke request and push them to the pool
-            let requestId = "\(LambdaClock().now))"
+            let requestId = "\(UUID().uuidString))"
             logger[metadataKey: "requestId"] = "\(requestId)"
 
             logger.trace("/invoke received invocation, pushing it to the pool and wait for a lambda response")
@@ -412,15 +419,15 @@ internal struct LambdaHTTPServer {
                         isComplete = true
                     }
                 }
-            } catch is LambdaHTTPServer.Pool<LambdaHTTPServer.LocalServerResponse>.PoolError {
+            } catch let error as LambdaHTTPServer.Pool<LambdaHTTPServer.LocalServerResponse>.PoolError {
                 logger.trace("PoolError catched")
                 // detect concurrent invocations of POST and gently decline the requests while we're processing one.
                 let response = LocalServerResponse(
                     id: requestId,
                     status: .badRequest,
                     body: ByteBuffer(
                         string:
-                            "It is not allowed to invoke multiple Lambda function executions in parallel. (The Lambda runtime environment on AWS will never do that)"
+                            "\(error): It is not allowed to invoke multiple Lambda function executions in parallel. (The Lambda runtime environment on AWS will never do that)"
                     )
                 )
                 try await self.sendResponse(response, outbound: outbound, logger: logger)

Tests/AWSLambdaRuntimeTests/LambdaLocalServerTests.swift

@@ -19,6 +19,12 @@ import Testing
 
 @testable import AWSLambdaRuntime
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
 extension LambdaRuntimeTests {
 
     @Test("Local server respects LOCAL_LAMBDA_PORT environment variable")
@@ -77,6 +83,88 @@ extension LambdaRuntimeTests {
         #expect(result == true)
     }
 
+    @Test("Local server handles rapid concurrent requests without HTTP 400 errors")
+    @available(LambdaSwift 2.0, *)
+    func testRapidConcurrentRequests() async throws {
+        let customPort = 8081
+
+        // Set environment variable
+        setenv("LOCAL_LAMBDA_PORT", "\(customPort)", 1)
+        defer { unsetenv("LOCAL_LAMBDA_PORT") }
+
+        let results = try await withThrowingTaskGroup(of: [Int].self) { group in
+
+            // Start the Lambda runtime with local server
+            group.addTask {
+                let runtime = LambdaRuntime { (event: String, context: LambdaContext) in
+                    try await Task.sleep(for: .milliseconds(100))
+                    return "Hello \(event)"
+                }
+
+                // Start runtime (this will block until cancelled)
+                try await runtime._run()
+                return []
+            }
+
+            // Start HTTP client to make rapid requests
+            group.addTask {
+                // Give server time to start
+                try await Task.sleep(for: .milliseconds(200))
+
+                // Make 10 rapid concurrent POST requests to /invoke
+                return try await withThrowingTaskGroup(of: Int.self) { clientGroup in
+                    var statuses: [Int] = []
+
+                    for i in 0..<10 {
+                        try await Task.sleep(for: .milliseconds(0))
+                        clientGroup.addTask {
+                            let (_, response) = try await self.makeInvokeRequest(
+                                host: "127.0.0.1",
+                                port: customPort,
+                                payload: "\"World\(i)\""
+                            )
+                            return response.statusCode
+                        }
+                    }
+
+                    for try await status in clientGroup {
+                        statuses.append(status)
+                    }
+
+                    return statuses
+                }
+            }
+
+            // Get the first result (HTTP statuses) and cancel the runtime
+            let first = try await group.next()
+            group.cancelAll()
+            return first ?? []
+        }
+
+        // Verify all requests returned 200 OK (no HTTP 400 errors)
+        #expect(results.count == 10, "Expected 10 responses")
+        for (index, status) in results.enumerated() {
+            #expect(status == 202, "Request \(index) returned \(status), expected 202 OK")
+        }
+    }
+
+    private func makeInvokeRequest(host: String, port: Int, payload: String) async throws -> (Data, HTTPURLResponse) {
+        let url = URL(string: "http://\(host):\(port)/invoke")!
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpBody = payload.data(using: .utf8)
+        request.timeoutInterval = 10.0
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw URLError(.badServerResponse)
+        }
+
+        return (data, httpResponse)
+    }
+
     private func isPortResponding(host: String, port: Int) async throws -> Bool {
         let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)