Trace HTTPClient request execution

.dockerignore

@@ -0,0 +1,2 @@
+.build
+.git

.gitignore

@@ -4,3 +4,4 @@ Package.resolved
 DerivedData
 .DS_Store
 .swiftpm/
+.SourceKitten

Package.swift

@@ -21,17 +21,20 @@ let package = Package(
         .library(name: "AsyncHTTPClient", targets: ["AsyncHTTPClient"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-nio.git", from: "2.19.0"),
-        .package(url: "https://github.com/apple/swift-nio-ssl.git", from: "2.8.0"),
+        .package(url: "https://github.com/apple/swift-nio.git", from: "2.27.0"),
+        .package(url: "https://github.com/apple/swift-nio-ssl.git", from: "2.13.0"),
         .package(url: "https://github.com/apple/swift-nio-extras.git", from: "1.3.0"),
         .package(url: "https://github.com/apple/swift-nio-transport-services.git", from: "1.5.1"),
         .package(url: "https://github.com/apple/swift-log.git", from: "1.4.0"),
+        .package(url: "https://github.com/apple/swift-distributed-tracing.git", from: "0.1.1"),
+        .package(url: "https://github.com/apple/swift-distributed-tracing-baggage", .upToNextMinor(from: "0.1.1")),
     ],
     targets: [
         .target(
             name: "AsyncHTTPClient",
             dependencies: ["NIO", "NIOHTTP1", "NIOSSL", "NIOConcurrencyHelpers", "NIOHTTPCompression",
-                           "NIOFoundationCompat", "NIOTransportServices", "Logging"]
+                           "NIOFoundationCompat", "NIOTransportServices", "Logging", "Instrumentation",
+                           "Tracing", "TracingOpenTelemetrySupport", "Baggage"]
         ),
         .testTarget(
             name: "AsyncHTTPClientTests",

README.md

@@ -24,7 +24,7 @@ Add the following entry in your <code>Package.swift</code> to start using <code>
 ```
 and  `AsyncHTTPClient` dependency to your target:
 ```swift
-.target(name: "MyApp", dependencies: ["AsyncHTTPClient"]),
+.target(name: "MyApp", dependencies: [.product(name: "AsyncHTTPClient", package: "async-http-client")]),
 ```
 
 #### Request-Response API
@@ -94,7 +94,7 @@ let httpClient = HTTPClient(eventLoopGroupProvider: .createNew,
 ### Timeouts
 Timeouts (connect and read) can also be set using the client configuration:
 ```swift
-let timeout = HTTPClient.Timeout(connect: .seconds(1), read: .seconds(1))
+let timeout = HTTPClient.Configuration.Timeout(connect: .seconds(1), read: .seconds(1))
 let httpClient = HTTPClient(eventLoopGroupProvider: .createNew,
                             configuration: HTTPClient.Configuration(timeout: timeout))
 ```

Sources/AsyncHTTPClient/BestEffortHashableTLSConfiguration.swift

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the AsyncHTTPClient open source project
+//
+// Copyright (c) 2021 Apple Inc. and the AsyncHTTPClient project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of AsyncHTTPClient project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import NIOSSL
+
+/// Wrapper around `TLSConfiguration` from NIOSSL to provide a best effort implementation of `Hashable`
+struct BestEffortHashableTLSConfiguration: Hashable {
+    let base: TLSConfiguration
+
+    init(wrapping base: TLSConfiguration) {
+        self.base = base
+    }
+
+    func hash(into hasher: inout Hasher) {
+        self.base.bestEffortHash(into: &hasher)
+    }
+
+    static func == (lhs: BestEffortHashableTLSConfiguration, rhs: BestEffortHashableTLSConfiguration) -> Bool {
+        return lhs.base.bestEffortEquals(rhs.base)
+    }
+}

Sources/AsyncHTTPClient/Connection.swift

@@ -12,6 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Baggage
 import Foundation
 import Logging
 import NIO
@@ -51,27 +52,31 @@ extension Connection {
     /// Release this `Connection` to its associated `HTTP1ConnectionProvider`.
     ///
     /// - Warning: This only releases the connection and doesn't take care of cleaning handlers in the `Channel` pipeline.
-    func release(closing: Bool, logger: Logger) {
+    func release(closing: Bool, context: LoggingContext) {
         self.channel.eventLoop.assertInEventLoop()
-        self.provider.release(connection: self, closing: closing, logger: logger)
+        self.provider.release(connection: self, closing: closing, context: context)
     }
 
     /// Called when channel exceeds idle time in pool.
-    func timeout(logger: Logger) {
+    func timeout(context: LoggingContext) {
         self.channel.eventLoop.assertInEventLoop()
-        self.provider.timeout(connection: self, logger: logger)
+        self.provider.timeout(connection: self, context: context)
     }
 
     /// Called when channel goes inactive while in the pool.
-    func remoteClosed(logger: Logger) {
+    func remoteClosed(context: LoggingContext) {
         self.channel.eventLoop.assertInEventLoop()
-        self.provider.remoteClosed(connection: self, logger: logger)
+        self.provider.remoteClosed(connection: self, context: context)
     }
 
     /// Called from `HTTP1ConnectionProvider.close` when client is shutting down.
     func close() -> EventLoopFuture<Void> {
         return self.channel.close()
     }
+
+    func close(promise: EventLoopPromise<Void>?) {
+        return self.channel.close(promise: promise)
+    }
 }
 
 /// Methods of Connection which are used in ConnectionsState extracted as protocol
@@ -100,9 +105,9 @@ extension Connection: PoolManageableConnection {
 
 extension Connection {
     /// Sets idle timeout handler and channel inactivity listener.
-    func setIdleTimeout(timeout: TimeAmount?, logger: Logger) {
+    func setIdleTimeout(timeout: TimeAmount?, context: LoggingContext) {
         _ = self.channel.pipeline.addHandler(IdleStateHandler(writeTimeout: timeout), position: .first).flatMap { _ in
-            self.channel.pipeline.addHandler(IdlePoolConnectionHandler(connection: self, logger: logger))
+            self.channel.pipeline.addHandler(IdlePoolConnectionHandler(connection: self, loggingContext: context))
         }
     }
 
@@ -119,27 +124,27 @@ class IdlePoolConnectionHandler: ChannelInboundHandler, RemovableChannelHandler
 
     let connection: Connection
     var eventSent: Bool
-    let logger: Logger
+    let loggingContext: LoggingContext
 
-    init(connection: Connection, logger: Logger) {
+    init(connection: Connection, loggingContext: LoggingContext) {
         self.connection = connection
         self.eventSent = false
-        self.logger = logger
+        self.loggingContext = loggingContext
     }
 
     // this is needed to detect when remote end closes connection while connection is in the pool idling
     func channelInactive(context: ChannelHandlerContext) {
         if !self.eventSent {
             self.eventSent = true
-            self.connection.remoteClosed(logger: self.logger)
+            self.connection.remoteClosed(context: loggingContext)
         }
     }
 
     func userInboundEventTriggered(context: ChannelHandlerContext, event: Any) {
         if let idleEvent = event as? IdleStateHandler.IdleStateEvent, idleEvent == .write {
             if !self.eventSent {
                 self.eventSent = true
-                self.connection.timeout(logger: self.logger)
+                self.connection.timeout(context: loggingContext)
             }
         } else {
             context.fireUserInboundEventTriggered(event)