Remove DetachedTasks

Author: fabianfett

Sources/AWSLambdaRuntimeCore/DetachedTasks.swift

@@ -81,7 +81,6 @@ public struct LambdaContext: CustomDebugStringConvertible, Sendable {
         let logger: Logger
         let eventLoop: EventLoop
         let allocator: ByteBufferAllocator
-        let tasks: DetachedTasksContainer
 
         init(
             requestID: String,
@@ -92,8 +91,7 @@ public struct LambdaContext: CustomDebugStringConvertible, Sendable {
             clientContext: String?,
             logger: Logger,
             eventLoop: EventLoop,
-            allocator: ByteBufferAllocator,
-            tasks: DetachedTasksContainer
+            allocator: ByteBufferAllocator
         ) {
             self.requestID = requestID
             self.traceID = traceID
@@ -104,7 +102,6 @@ public struct LambdaContext: CustomDebugStringConvertible, Sendable {
             self.logger = logger
             self.eventLoop = eventLoop
             self.allocator = allocator
-            self.tasks = tasks
         }
     }
 
@@ -182,13 +179,7 @@ public struct LambdaContext: CustomDebugStringConvertible, Sendable {
             clientContext: clientContext,
             logger: logger,
             eventLoop: eventLoop,
-            allocator: allocator,
-            tasks: DetachedTasksContainer(
-                context: DetachedTasksContainer.Context(
-                    eventLoop: eventLoop,
-                    logger: logger
-                )
-            )
+            allocator: allocator
         )
     }
 
@@ -200,22 +191,6 @@ public struct LambdaContext: CustomDebugStringConvertible, Sendable {
         return .milliseconds(remaining)
     }
 
-    var tasks: DetachedTasksContainer {
-        self.storage.tasks
-    }
-
-    /// Registers a background task that continues running after the synchronous invocation has completed.
-    /// This is useful for tasks like flushing metrics or performing clean-up operations without delaying the response.
-    ///
-    /// - Parameter body: An asynchronous closure that performs the background task.
-    /// - Warning: You will be billed for the milliseconds of Lambda execution time until the very last
-    ///   background task is finished.
-    public func detachedBackgroundTask(_ body: @escaping @Sendable () async -> Void) {
-        Task {
-            await self.tasks.detached(task: body)
-        }
-    }
-
     public var debugDescription: String {
         "\(Self.self)(requestID: \(self.requestID), traceID: \(self.traceID), invokedFunctionARN: \(self.invokedFunctionARN), cognitoIdentity: \(self.cognitoIdentity ?? "nil"), clientContext: \(self.clientContext ?? "nil"), deadline: \(self.deadline))"
     }

Sources/AWSLambdaRuntimeCore/LambdaContext.swift

@@ -97,28 +97,13 @@ final class LambdaRunner {
                     if case .failure(let error) = result {
                         logger.warning("lambda handler returned an error: \(error)")
                     }
-                    return (invocation, result, context)
+                    return (invocation, result)
                 }
-        }.flatMap { invocation, result, context in
+        }.flatMap { invocation, result in
             // 3. report results to runtime engine
-            self.runtimeClient.reportResults(logger: logger, invocation: invocation, result: result).peekError {
-                error in
+            self.runtimeClient.reportResults(logger: logger, invocation: invocation, result: result).peekError { error in
                 logger.error("could not report results to lambda runtime engine: \(error)")
-                // To discuss:
-                // Do we want to await the tasks in this case?
-                let promise = context.eventLoop.makePromise(of: Void.self)
-                promise.completeWithTask {
-                    try await context.tasks.awaitAll().get()
-                }
-                return promise.futureResult
-            }.map { _ in context }
-        }
-        .flatMap { (context: LambdaContext) -> EventLoopFuture<Void> in
-            let promise = context.eventLoop.makePromise(of: Void.self)
-            promise.completeWithTask {
-                try await context.tasks.awaitAll().get()
             }
-            return promise.futureResult
         }
     }