Try to inline as much as possible

Author: fabianfett

Sources/AWSLambdaRuntime/Lambda+Codable.swift

@@ -80,13 +80,15 @@ internal struct CodableVoidClosureWrapper<In: Decodable>: LambdaHandler {
 
 /// Implementation of  a`ByteBuffer` to `In` decoding
 extension EventLoopLambdaHandler where In: Decodable {
+    @inlinable
     public func decode(buffer: ByteBuffer) throws -> In {
         try self.decoder.decode(In.self, from: buffer)
     }
 }
 
 /// Implementation of  `Out` to `ByteBuffer` encoding
 extension EventLoopLambdaHandler where Out: Encodable {
+    @inlinable
     public func encode(allocator: ByteBufferAllocator, value: Out) throws -> ByteBuffer? {
         try self.encoder.encode(value, using: allocator)
     }

Sources/AWSLambdaRuntimeCore/HTTPClient.swift

@@ -19,6 +19,7 @@ import NIOHTTP1
 /// A barebone HTTP client to interact with AWS Runtime Engine which is an HTTP server.
 /// Note that Lambda Runtime API dictate that only one requests runs at a time.
 /// This means we can avoid locks and other concurrency concern we would otherwise need to build into the client
+@usableFromInline
 internal final class HTTPClient {
     private let eventLoop: EventLoop
     private let configuration: Lambda.Configuration.RuntimeEngine
@@ -144,6 +145,7 @@ internal final class HTTPClient {
         var body: ByteBuffer?
     }
 
+    @usableFromInline
     internal enum Errors: Error {
         case connectionResetByPeer
         case timeout

Sources/AWSLambdaRuntimeCore/Lambda+LocalServer.swift

@@ -35,6 +35,7 @@ extension Lambda {
     ///     - body: Code to run within the context of the mock server. Typically this would be a Lambda.run function call.
     ///
     /// - note: This API is designed stricly for local testing and is behind a DEBUG flag
+    @usableFromInline
     internal static func withLocalServer<Value>(invocationEndpoint: String? = nil, _ body: @escaping () -> Value) throws -> Value {
         let server = LocalLambda.Server(invocationEndpoint: invocationEndpoint)
         try server.start().wait()

Sources/AWSLambdaRuntimeCore/Lambda+String.swift

@@ -88,6 +88,7 @@ internal struct StringVoidClosureWrapper: LambdaHandler {
 
 extension EventLoopLambdaHandler where In == String {
     /// Implementation of a `ByteBuffer` to `String` decoding
+    @inlinable
     public func decode(buffer: ByteBuffer) throws -> String {
         var buffer = buffer
         guard let string = buffer.readString(length: buffer.readableBytes) else {
@@ -99,6 +100,7 @@ extension EventLoopLambdaHandler where In == String {
 
 extension EventLoopLambdaHandler where Out == String {
     /// Implementation of `String` to `ByteBuffer` encoding
+    @inlinable
     public func encode(allocator: ByteBufferAllocator, value: String) throws -> ByteBuffer? {
         // FIXME: reusable buffer
         var buffer = allocator.buffer(capacity: value.utf8.count)

Sources/AWSLambdaRuntimeCore/Lambda.swift

@@ -25,18 +25,14 @@ import NIO
 public enum Lambda {
     public typealias Handler = ByteBufferLambdaHandler
 
-    /// `ByteBufferLambdaHandler` factory.
-    ///
-    /// A function that takes a `InitializationContext` and returns an `EventLoopFuture` of a `ByteBufferLambdaHandler`
-    public typealias HandlerFactory = (InitializationContext) -> EventLoopFuture<Handler>
-
     /// Run a Lambda defined by implementing the `LambdaHandler` protocol.
     ///
     /// - parameters:
     ///     - handler: `ByteBufferLambdaHandler` based Lambda.
     ///
     /// - note: This is a blocking operation that will run forever, as its lifecycle is managed by the AWS Lambda Runtime Engine.
-    public static func run(_ handler: Handler) {
+    @inlinable
+    public static func run<H: Handler>(_ handler: H) {
         if case .failure(let error) = self.run(handler: handler) {
             fatalError("\(error)")
         }
@@ -50,7 +46,8 @@ public enum Lambda {
     ///     - factory: A `ByteBufferLambdaHandler` factory.
     ///
     /// - note: This is a blocking operation that will run forever, as its lifecycle is managed by the AWS Lambda Runtime Engine.
-    public static func run(_ factory: @escaping HandlerFactory) {
+    @inlinable
+    public static func run<H: Handler>(_ factory: @escaping (InitializationContext) -> EventLoopFuture<H>) {
         if case .failure(let error) = self.run(factory: factory) {
             fatalError("\(error)")
         }
@@ -62,7 +59,8 @@ public enum Lambda {
     ///     - factory: A `ByteBufferLambdaHandler` factory.
     ///
     /// - note: This is a blocking operation that will run forever, as its lifecycle is managed by the AWS Lambda Runtime Engine.
-    public static func run(_ factory: @escaping (InitializationContext) throws -> Handler) {
+    @inlinable
+    public static func run<H: Handler>(_ factory: @escaping (InitializationContext) throws -> H) {
         if case .failure(let error) = self.run(factory: factory) {
             fatalError("\(error)")
         }
@@ -77,14 +75,16 @@ public enum Lambda {
     }
 
     // for testing and internal use
-    internal static func run(configuration: Configuration = .init(), handler: Handler) -> Result<Int, Error> {
+    @inlinable
+    internal static func run<H: Handler>(configuration: Configuration = .init(), handler: H) -> Result<Int, Error> {
         self.run(configuration: configuration, factory: { $0.eventLoop.makeSucceededFuture(handler) })
     }
 
     // for testing and internal use
-    internal static func run(configuration: Configuration = .init(), factory: @escaping (InitializationContext) throws -> Handler) -> Result<Int, Error> {
-        self.run(configuration: configuration, factory: { context -> EventLoopFuture<Handler> in
-            let promise = context.eventLoop.makePromise(of: Handler.self)
+    @inlinable
+    internal static func run<H: Handler>(configuration: Configuration = .init(), factory: @escaping (InitializationContext) throws -> H) -> Result<Int, Error> {
+        self.run(configuration: configuration, factory: { context -> EventLoopFuture<H> in
+            let promise = context.eventLoop.makePromise(of: H.self)
             // if we have a callback based handler factory, we offload the creation of the handler
             // onto the default offload queue, to ensure that the eventloop is never blocked.
             Lambda.defaultOffloadQueue.async {
@@ -99,8 +99,9 @@ public enum Lambda {
     }
 
     // for testing and internal use
-    internal static func run(configuration: Configuration = .init(), factory: @escaping HandlerFactory) -> Result<Int, Error> {
-        let _run = { (configuration: Configuration, factory: @escaping HandlerFactory) -> Result<Int, Error> in
+    @inlinable
+    static func run<H: Handler>(configuration: Configuration = .init(), factory: @escaping (InitializationContext) -> EventLoopFuture<H>) -> Result<Int, Error> {
+        let _run = { (configuration: Configuration, factory: @escaping (InitializationContext) -> EventLoopFuture<H>) -> Result<Int, Error> in
             Backtrace.install()
             var logger = Logger(label: "Lambda")
             logger.logLevel = configuration.general.logLevel

Sources/AWSLambdaRuntimeCore/LambdaConfiguration.swift

@@ -17,11 +17,17 @@ import Logging
 import NIO
 
 extension Lambda {
+    @usableFromInline
     internal struct Configuration: CustomStringConvertible {
+        @usableFromInline
         let general: General
+
+        @usableFromInline
         let lifecycle: Lifecycle
+        @usableFromInline
         let runtimeEngine: RuntimeEngine
 
+        @usableFromInline
         init() {
             self.init(general: .init(), lifecycle: .init(), runtimeEngine: .init())
         }
@@ -32,21 +38,30 @@ extension Lambda {
             self.runtimeEngine = runtimeEngine ?? RuntimeEngine()
         }
 
+        @usableFromInline
         struct General: CustomStringConvertible {
+            @usableFromInline
             let logLevel: Logger.Level
 
             init(logLevel: Logger.Level? = nil) {
                 self.logLevel = logLevel ?? env("LOG_LEVEL").flatMap(Logger.Level.init) ?? .info
             }
 
+            @usableFromInline
             var description: String {
                 "\(General.self)(logLevel: \(self.logLevel))"
             }
         }
 
+        @usableFromInline
         struct Lifecycle: CustomStringConvertible {
+            @usableFromInline
             let id: String
+
+            @usableFromInline
             let maxTimes: Int
+
+            @usableFromInline
             let stopSignal: Signal
 
             init(id: String? = nil, maxTimes: Int? = nil, stopSignal: Signal? = nil) {
@@ -56,16 +71,19 @@ extension Lambda {
                 precondition(self.maxTimes >= 0, "maxTimes must be equal or larger than 0")
             }
 
+            @usableFromInline
             var description: String {
                 "\(Lifecycle.self)(id: \(self.id), maxTimes: \(self.maxTimes), stopSignal: \(self.stopSignal))"
             }
         }
 
+        @usableFromInline
         struct RuntimeEngine: CustomStringConvertible {
             let ip: String
             let port: Int
             let requestTimeout: TimeAmount?
 
+            @usableFromInline
             init(address: String? = nil, keepAlive: Bool? = nil, requestTimeout: TimeAmount? = nil) {
                 let ipPort = (address ?? env("AWS_LAMBDA_RUNTIME_API"))?.split(separator: ":") ?? ["127.0.0.1", "7000"]
                 guard ipPort.count == 2, let port = Int(ipPort[1]) else {
@@ -76,11 +94,13 @@ extension Lambda {
                 self.requestTimeout = requestTimeout ?? env("REQUEST_TIMEOUT").flatMap(Int64.init).flatMap { .milliseconds($0) }
             }
 
+            @usableFromInline
             var description: String {
                 "\(RuntimeEngine.self)(ip: \(self.ip), port: \(self.port), requestTimeout: \(String(describing: self.requestTimeout))"
             }
         }
 
+        @usableFromInline
         var description: String {
             "\(Configuration.self)\n  \(self.general))\n  \(self.lifecycle)\n  \(self.runtimeEngine)"
         }

Sources/AWSLambdaRuntimeCore/LambdaContext.swift

@@ -36,6 +36,7 @@ extension Lambda {
         /// `ByteBufferAllocator` to allocate `ByteBuffer`
         public let allocator: ByteBufferAllocator
 
+        @usableFromInline
         internal init(logger: Logger, eventLoop: EventLoop, allocator: ByteBufferAllocator) {
             self.eventLoop = eventLoop
             self.logger = logger
@@ -141,6 +142,7 @@ extension Lambda {
         ///         Most importantly the `EventLoop` must never be blocked.
         public let eventLoop: EventLoop
 
+        @usableFromInline
         internal init(logger: Logger, eventLoop: EventLoop) {
             self.eventLoop = eventLoop
             self.logger = logger

Sources/AWSLambdaRuntimeCore/LambdaHandler.swift

@@ -40,6 +40,7 @@ public protocol LambdaHandler: EventLoopLambdaHandler {
 }
 
 extension Lambda {
+    @usableFromInline
     internal static let defaultOffloadQueue = DispatchQueue(label: "LambdaHandler.offload")
 }
 
@@ -128,41 +129,28 @@ public protocol EventLoopLambdaHandler: ByteBufferLambdaHandler {
 
 extension EventLoopLambdaHandler {
     /// Driver for `ByteBuffer` -> `In` decoding and `Out` -> `ByteBuffer` encoding
+    @inlinable
     public func handle(context: Lambda.Context, event: ByteBuffer) -> EventLoopFuture<ByteBuffer?> {
-        switch self.decodeIn(buffer: event) {
-        case .failure(let error):
-            return context.eventLoop.makeFailedFuture(CodecError.requestDecoding(error))
-        case .success(let `in`):
-            return self.handle(context: context, event: `in`).flatMapThrowing { out in
-                switch self.encodeOut(allocator: context.allocator, value: out) {
-                case .failure(let error):
-                    throw CodecError.responseEncoding(error)
-                case .success(let buffer):
-                    return buffer
-                }
-            }
-        }
-    }
-
-    private func decodeIn(buffer: ByteBuffer) -> Result<In, Error> {
+        let input: In
         do {
-            return .success(try self.decode(buffer: buffer))
+            input = try self.decode(buffer: event)
         } catch {
-            return .failure(error)
+            return context.eventLoop.makeFailedFuture(CodecError.requestDecoding(error))
         }
-    }
 
-    private func encodeOut(allocator: ByteBufferAllocator, value: Out) -> Result<ByteBuffer?, Error> {
-        do {
-            return .success(try self.encode(allocator: allocator, value: value))
-        } catch {
-            return .failure(error)
+        return self.handle(context: context, event: input).flatMapThrowing { output in
+            do {
+                return try self.encode(allocator: context.allocator, value: output)
+            } catch {
+                throw CodecError.responseEncoding(error)
+            }
         }
     }
 }
 
 /// Implementation of  `ByteBuffer` to `Void` decoding
 extension EventLoopLambdaHandler where Out == Void {
+    @inlinable
     public func encode(allocator: ByteBufferAllocator, value: Void) throws -> ByteBuffer? {
         nil
     }
@@ -200,7 +188,8 @@ extension ByteBufferLambdaHandler {
     }
 }
 
-private enum CodecError: Error {
+@usableFromInline
+enum CodecError: Error {
     case requestDecoding(Error)
     case responseEncoding(Error)
 }