[WIP] Set SpanStatus based on response code

Author: slashmo

Sources/AsyncHTTPClient/HTTPClient.swift

@@ -402,7 +402,7 @@ public class HTTPClient {
         // TODO: net.peer.ip / Not required, but recommended
 
         var request = request
-        InstrumentationSystem.instrument.inject(context.baggage, into: &request.headers, using: HTTPHeadersInjector())
+        InstrumentationSystem.instrument.inject(span.context.baggage, into: &request.headers, using: HTTPHeadersInjector())
 
         let logger = context.logger.attachingRequestInformation(request, requestID: globalRequestID.add(1))
 
@@ -479,7 +479,6 @@ public class HTTPClient {
                                     "ahc-request": "\(request.method) \(request.url)",
                                     "ahc-channel-el": "\(connection.channel.eventLoop)",
                                     "ahc-task-el": "\(taskEL)"])
-
             let channel = connection.channel
             let future: EventLoopFuture<Void>
             if let timeout = self.resolve(timeout: self.configuration.timeout.read, deadline: deadline) {
@@ -513,10 +512,15 @@ public class HTTPClient {
         }
         .and(task.futureResult)
         .always { result in
-            if case let .success((_, response)) = result, let httpResponse = response as? HTTPClient.Response {
+            switch result {
+            case .success(let (_, response)):
+                guard let httpResponse = response as? HTTPClient.Response else { return }
+                span.status = .init(httpResponse.status)
                 span.attributes.http.statusCode = Int(httpResponse.status.code)
                 span.attributes.http.statusText = httpResponse.status.reasonPhrase
                 span.attributes.http.responseContentLength = httpResponse.body?.readableBytes ?? 0
+            case .failure(let error):
+                span.recordError(error)
             }
             span.end()
             setupComplete.succeed(())

Sources/AsyncHTTPClient/Utils.swift

@@ -21,6 +21,7 @@ import NIOHTTP1
 import NIOHTTPCompression
 import NIOSSL
 import NIOTransportServices
+import TracingInstrumentation
 
 internal extension String {
     var isIPAddress: Bool {
@@ -147,3 +148,37 @@ extension Connection {
         }.recover { _ in }
     }
 }
+
+extension SpanStatus {
+    /// Map status code to canonical code according to OTel spec
+    ///
+    /// - SeeAlso: https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/semantic_conventions/http.md#status
+    init(_ responseStatus: HTTPResponseStatus) {
+        switch responseStatus.code {
+        case 100...399:
+            self = SpanStatus(canonicalCode: .ok)
+        case 400, 402, 405 ... 428, 430 ... 498:
+            self = SpanStatus(canonicalCode: .invalidArgument, message: responseStatus.reasonPhrase)
+        case 401:
+            self = SpanStatus(canonicalCode: .unauthenticated, message: responseStatus.reasonPhrase)
+        case 403:
+            self = SpanStatus(canonicalCode: .permissionDenied, message: responseStatus.reasonPhrase)
+        case 404:
+            self = SpanStatus(canonicalCode: .notFound, message: responseStatus.reasonPhrase)
+        case 429:
+            self = SpanStatus(canonicalCode: .resourceExhausted, message: responseStatus.reasonPhrase)
+        case 499:
+            self = SpanStatus(canonicalCode: .cancelled, message: responseStatus.reasonPhrase)
+        case 500, 505 ... 599:
+            self = SpanStatus(canonicalCode: .internal, message: responseStatus.reasonPhrase)
+        case 501:
+            self = SpanStatus(canonicalCode: .unimplemented, message: responseStatus.reasonPhrase)
+        case 503:
+            self = SpanStatus(canonicalCode: .unavailable, message: responseStatus.reasonPhrase)
+        case 504:
+            self = SpanStatus(canonicalCode: .deadlineExceeded, message: responseStatus.reasonPhrase)
+        default:
+            self = SpanStatus(canonicalCode: .unknown, message: responseStatus.reasonPhrase)
+        }
+    }
+}

Tests/AsyncHTTPClientTests/HTTPClientTests.swift

@@ -17,6 +17,8 @@
     import Network
 #endif
 import Baggage
+import Instrumentation
+import TracingInstrumentation
 import Logging
 import NIO
 import NIOConcurrencyHelpers
@@ -2608,4 +2610,91 @@ class HTTPClientTests: XCTestCase {
 
         XCTAssertThrowsError(try future.wait())
     }
+
+    // MARK: - Tracing -
+
+    func testSemanticHTTPAttributesSet() throws {
+        let tracer = TestTracer()
+        InstrumentationSystem.bootstrap(tracer)
+
+        let localHTTPBin = HTTPBin(ssl: true)
+        let localClient = HTTPClient(eventLoopGroupProvider: .shared(self.clientGroup),
+                                     configuration: HTTPClient.Configuration(certificateVerification: .none))
+        defer {
+            XCTAssertNoThrow(try localClient.syncShutdown())
+            XCTAssertNoThrow(try localHTTPBin.shutdown())
+        }
+
+        let url = "https://localhost:\(localHTTPBin.port)/get"
+        let response = try localClient.get(url: url, context: testContext()).wait()
+        XCTAssertEqual(.ok, response.status)
+
+        print(tracer.recordedSpans.map(\.attributes))
+    }
+}
+
+private final class TestTracer: TracingInstrument {
+    private(set) var recordedSpans = [TestSpan]()
+
+    func startSpan(
+        named operationName: String,
+        context: BaggageContextCarrier,
+        ofKind kind: SpanKind,
+        at timestamp: Timestamp?
+    ) -> Span {
+        let span = TestSpan(operationName: operationName,
+                            kind: kind,
+                            startTimestamp: timestamp ?? .now(),
+                            context: context.baggage)
+        recordedSpans.append(span)
+        return span
+    }
+
+    func extract<Carrier, Extractor>(
+        _ carrier: Carrier,
+        into context: inout BaggageContext,
+        using extractor: Extractor
+    )
+    where
+    Carrier == Extractor.Carrier,
+    Extractor: ExtractorProtocol {}
+
+    func inject<Carrier, Injector>(
+        _ context: BaggageContext,
+        into carrier: inout Carrier,
+        using injector: Injector
+    )
+    where
+    Carrier == Injector.Carrier,
+    Injector: InjectorProtocol {}
+
+    final class TestSpan: Span {
+        let operationName: String
+        let kind: SpanKind
+        var status: SpanStatus?
+        let context: BaggageContext
+        private(set) var isRecording = false
+
+        var attributes: SpanAttributes = [:]
+
+        let startTimestamp: Timestamp
+        var endTimestamp: Timestamp?
+
+        func addEvent(_ event: SpanEvent) {}
+
+        func addLink(_ link: SpanLink) {}
+
+        func recordError(_ error: Error) {}
+
+        func end(at timestamp: Timestamp) {
+            self.endTimestamp = timestamp
+        }
+
+        init(operationName: String, kind: SpanKind, startTimestamp: Timestamp, context: BaggageContext) {
+            self.operationName = operationName
+            self.kind = kind
+            self.startTimestamp = startTimestamp
+            self.context = context
+        }
+    }
 }