feat: create XRayInstrument

.swiftformat

@@ -6,6 +6,7 @@
 --exclude Sources/AWSXRayRecorder/Utils/Locks.swift
 --exclude Sources/AWSXRayRecorder/AnyCodable
 --exclude Tests/AWSXRayRecorderTests/AnyCodable
+--exclude Examples/Sources/AWSXRaySDKExampleAWS/S3
 
 # format options
 #--self insert

Examples/Package.swift

@@ -5,17 +5,24 @@ import PackageDescription
 let package = Package(
     name: "aws-xray-sdk-swift-examples",
     platforms: [
-        .macOS(.v10_14),
+        .macOS(.v10_14), // TODO: remove when new swift-aws-lambda-runtime is released
     ],
     products: [
         .executable(name: "AWSXRaySDKExample", targets: ["AWSXRaySDKExample"]),
+        .executable(name: "AWSXRayInstrumentExample", targets: ["AWSXRayInstrumentExample"]),
         .executable(name: "AWSXRaySDKExampleAWS", targets: ["AWSXRaySDKExampleAWS"]),
         .executable(name: "AWSXRaySDKExampleLambda", targets: ["AWSXRaySDKExampleLambda"]),
     ],
     dependencies: [
         .package(name: "aws-xray-sdk-swift", path: ".."),
-        .package(url: "https://github.com/swift-aws/aws-sdk-swift.git", .upToNextMinor(from: "5.0.0-alpha.5")),
-        .package(url: "https://github.com/swift-server/async-http-client.git", .upToNextMajor(from: "1.0.0")),
+//        .package(name: "swift-baggage-context", url: "https://github.com/slashmo/gsoc-swift-baggage-context.git", .upToNextMajor(from: "0.1.0")),
+        .package(url: "https://github.com/slashmo/gsoc-swift-tracing.git", .revision("fe80d764ad225b1dfd06dcb57d08b5e3485662f9")),
+        .package(url: "https://github.com/apple/swift-nio.git", .upToNextMajor(from: "2.17.0")),
+//        .package(url: "https://github.com/swift-server/async-http-client.git", .upToNextMajor(from: "1.0.0")),
+//        .package(url: "https://github.com/pokryfka/async-http-client.git", .branch("feature/instrumentation")),
+//        .package(name: "aws-sdk-swift-core", path: "../../aws-sdk-swift-core"),
+        .package(url: "https://github.com/pokryfka/aws-sdk-swift-core.git", .branch("feature/tracing")),
+//        .package(url: "https://github.com/swift-aws/aws-sdk-swift.git", .upToNextMinor(from: "5.0.0-alpha.5")),
         .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", .upToNextMajor(from: "0.2.0")),
     ],
     targets: [
@@ -26,12 +33,24 @@ let package = Package(
 //                .product(name: "AWSXRayTesting", package: "aws-xray-sdk-swift"),
             ]
         ),
+        .target(
+            name: "AWSXRayInstrumentExample",
+            dependencies: [
+                .product(name: "AWSXRaySDK", package: "aws-xray-sdk-swift"),
+                .product(name: "AWSXRayInstrument", package: "aws-xray-sdk-swift"),
+//                .product(name: "Baggage", package: "swift-baggage-context"),
+                .product(name: "NIOInstrumentation", package: "gsoc-swift-tracing"),
+                .product(name: "NIO", package: "swift-nio"),
+                .product(name: "NIOHTTP1", package: "swift-nio"),
+            ]
+        ),
         .target(
             name: "AWSXRaySDKExampleAWS",
             dependencies: [
                 .product(name: "AWSXRaySDK", package: "aws-xray-sdk-swift"),
-                .product(name: "AsyncHTTPClient", package: "async-http-client"),
-                .product(name: "AWSS3", package: "aws-sdk-swift"),
+                .product(name: "AWSXRayInstrument", package: "aws-xray-sdk-swift"),
+                .product(name: "NIO", package: "swift-nio"),
+                .product(name: "AWSSDKSwiftCore", package: "aws-sdk-swift-core"),
             ]
         ),
         .target(

Examples/Sources/AWSXRayInstrumentExample/main.swift

@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the aws-xray-sdk-swift open source project
+//
+// Copyright (c) 2020 pokryfka and the aws-xray-sdk-swift project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import AsyncHTTPClient
+import AWSXRayInstrument
+import AWSXRaySDK
+import Baggage // BaggageContext
+import BaggageLogging // LoggingBaggageContextCarrier
+import Instrumentation // InstrumentationSystem
+import Logging // Logger
+import NIOHTTP1 // HTTPHeaders
+import NIOInstrumentation // HTTPHeadersExtractor
+import TracingInstrumentation
+
+extension BaggageContext: LoggingBaggageContextCarrier {
+    public var logger: Logger {
+        get { Logger(label: "", factory: { _ in Logging.SwiftLogNoOpLogHandler() }) }
+        set(newValue) {}
+    }
+}
+
+// create and boostrap the instrument
+let instrument = XRayRecorder(config: .init(logLevel: .debug)) // XRayUDPEmitter
+defer { instrument.shutdown() }
+InstrumentationSystem.bootstrap(instrument)
+
+// get the tracer
+let tracer = InstrumentationSystem.tracingInstrument
+
+// create new trace
+let tracingHeader = XRayRecorder.TraceContext().tracingHeader
+
+// extract the context from HTTP headers
+let headers = HTTPHeaders([
+    ("X-Amzn-Trace-Id", tracingHeader),
+])
+var baggage = BaggageContext()
+tracer.extract(headers, into: &baggage, using: HTTPHeadersExtractor())
+
+// create instrumented HTTP client
+let http = HTTPClient(eventLoopGroupProvider: .createNew)
+defer { http.shutdown { _ in } }
+
+// create new span
+var span = tracer.startSpan(named: "Span 1", context: baggage)
+span.attributes["key"] = "value"
+span.addLink(.init(context: baggage))
+span.addEvent(.init(name: "Event"))
+span.addEvent(.init(name: "Event 2"))
+
+var span2 = tracer.startSpan(named: "Span 2", context: baggage)
+span.attributes["key2"] = 2
+
+// TODO: XRay subsegment parent needs to be sent before, consider sending parent twice - when started and when ended (?)
+span.end()
+
+tracer.forceFlush()
+
+let url = "https://nf5g0bsxz5.execute-api.us-east-1.amazonaws.com/dev/hello"
+_ = try http.get(url: url, context: span.context).wait()
+
+span2.end()

Examples/Sources/AWSXRaySDKExampleAWS/S3/S3RequestMiddleware.swift

@@ -0,0 +1,142 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the AWSSDKSwift open source project
+//
+// Copyright (c) 2017-2020 the AWSSDKSwift project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of AWSSDKSwift project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import AWSCrypto
+import AWSSDKSwiftCore
+import AWSXML
+import Foundation
+
+public struct S3RequestMiddleware: AWSServiceMiddleware {
+    public init() {}
+
+    /// edit request before sending to S3
+    public func chain(request: AWSRequest) throws -> AWSRequest {
+        var request = request
+
+        self.virtualAddressFixup(request: &request)
+        self.createBucketFixup(request: &request)
+        self.calculateMD5(request: &request)
+
+        return request
+    }
+
+    /// Edit responses coming back from S3
+    public func chain(response: AWSResponse) throws -> AWSResponse {
+        var response = response
+
+        self.metadataFixup(response: &response)
+        self.getLocationResponseFixup(response: &response)
+
+        return response
+    }
+
+    func virtualAddressFixup(request: inout AWSRequest) {
+        /// process URL into form ${bucket}.s3.amazon.com
+        let paths = request.url.path.split(separator: "/", omittingEmptySubsequences: true)
+        if paths.count > 0 {
+            guard var host = request.url.host else { return }
+            if let port = request.url.port {
+                host = "\(host):\(port)"
+            }
+            let bucket = paths[0]
+            var urlPath: String
+            var urlHost: String
+            // if host name contains amazonaws.com and bucket name doesn't contain a period do virtual address look up
+            if host.contains("amazonaws.com"), !bucket.contains(".") {
+                let pathsWithoutBucket = paths.dropFirst() // bucket
+                urlPath = pathsWithoutBucket.joined(separator: "/")
+                if let firstHostComponent = host.split(separator: ".").first, bucket == firstHostComponent {
+                    // Bucket name is part of host. No need to append bucket
+                    urlHost = host
+                } else {
+                    urlHost = "\(bucket).\(host)"
+                }
+            } else {
+                urlPath = paths.joined(separator: "/")
+                urlHost = host
+            }
+            // add percent encoding back into path as converting from URL to String has removed it
+            let percentEncodedUrlPath = urlPath.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? urlPath
+            var urlString = "\(request.url.scheme ?? "https")://\(urlHost)/\(percentEncodedUrlPath)"
+            if let query = request.url.query {
+                urlString += "?\(query)"
+            }
+            request.url = URL(string: urlString)!
+        }
+    }
+
+    func createBucketFixup(request: inout AWSRequest) {
+        switch request.operation {
+        // fixup CreateBucket to include location
+        case "CreateBucket":
+            var xml = ""
+            if request.region != .useast1 {
+                xml += "<CreateBucketConfiguration xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
+                xml += "<LocationConstraint>"
+                xml += request.region.rawValue
+                xml += "</LocationConstraint>"
+                xml += "</CreateBucketConfiguration>"
+            }
+            request.body = .text(xml)
+
+        default:
+            break
+        }
+    }
+
+    func calculateMD5(request: inout AWSRequest) {
+        // if request has a body, calculate the MD5 for that body
+        if let byteBuffer = request.body.asByteBuffer() {
+            let byteBufferView = byteBuffer.readableBytesView
+            if let encoded = byteBufferView.withContiguousStorageIfAvailable({ bytes in
+                return Data(Insecure.MD5.hash(data: bytes)).base64EncodedString()
+            }) {
+                request.httpHeaders.replaceOrAdd(name: "Content-MD5", value: encoded)
+            }
+        }
+    }
+
+    func getLocationResponseFixup(response: inout AWSResponse) {
+        if case .xml(let element) = response.body {
+            // GetBucketLocation comes back without a containing xml element
+            if element.name == "LocationConstraint" {
+                if element.stringValue == "" {
+                    element.addChild(.text(stringValue: "us-east-1"))
+                }
+                let parentElement = XML.Element(name: "BucketLocation")
+                parentElement.addChild(element)
+                response.body = .xml(parentElement)
+            }
+        }
+    }
+
+    func metadataFixup(response: inout AWSResponse) {
+        // convert x-amz-meta-* header values into a dictionary, which we add as a "x-amz-meta-" header. This is processed by AWSClient to fill metadata values in GetObject and HeadObject
+        switch response.body {
+        case .raw(_), .empty:
+            var metadata: [String: String] = [:]
+            for (key, value) in response.headers {
+                if key.hasPrefix("x-amz-meta-"), let value = value as? String {
+                    let keyWithoutPrefix = key.dropFirst("x-amz-meta-".count)
+                    metadata[String(keyWithoutPrefix)] = value
+                }
+            }
+            if !metadata.isEmpty {
+                response.headers["x-amz-meta-"] = metadata
+            }
+        default:
+            break
+        }
+    }
+}