Use Baggage directly in Tracer API

Author: slashmo

Sources/Tracing/NoOpTracer.swift

@@ -11,18 +11,18 @@
 //
 //===----------------------------------------------------------------------===//
 
-import BaggageContext
+import Baggage
 import Instrumentation
 
 /// No operation Tracer, used when no tracing is required.
 public struct NoOpTracer: Tracer {
     public func startSpan(
         named operationName: String,
-        context: BaggageContext,
+        baggage: Baggage,
         ofKind kind: SpanKind,
         at timestamp: Timestamp
     ) -> Span {
-        return NoOpSpan(baggage: context.baggage)
+        return NoOpSpan(baggage: baggage)
     }
 
     public func forceFlush() {}

Sources/Tracing/Tracer.swift

@@ -11,21 +11,22 @@
 //
 //===----------------------------------------------------------------------===//
 
-import BaggageContext
+import Baggage
 import Instrumentation
 
 /// An `Instrument` with added functionality for distributed tracing. Is uses the span-based tracing model and is
 /// based on the OpenTracing/OpenTelemetry spec.
 public protocol Tracer: Instrument {
-    /// Start a new `Span` within the given `BaggageContext` at a given timestamp.
+    /// Start a new `Span` with the given `Baggage` at a given timestamp.
+    ///
     /// - Parameters:
     ///   - operationName: The name of the operation being traced. This may be a handler function, database call, ...
-    ///   - context: The carrier of a `BaggageContext` within to start the new `Span`.
+    ///   - baggage: The `Baggage` providing information on where to start the new `Span`.
     ///   - kind: The `SpanKind` of the new `Span`.
     ///   - timestamp: The `DispatchTime` at which to start the new `Span`.
     func startSpan(
         named operationName: String,
-        context: BaggageContext,
+        baggage: Baggage,
         ofKind kind: SpanKind,
         at timestamp: Timestamp
     ) -> Span
@@ -40,19 +41,17 @@ public protocol Tracer: Instrument {
 }
 
 extension Tracer {
-    /// Start a new `Span` within the given `BaggageContext`. This passes `nil` as the timestamp to the tracer, which
-    /// usually means it should default to the current timestamp.
+    /// Start a new `Span` with the given `Baggage` starting at `Timestamp.now()`.
+    ///
     /// - Parameters:
     ///   - operationName: The name of the operation being traced. This may be a handler function, database call, ...
     ///   - context: The carrier of a `BaggageContext` within to start the new `Span`.
     ///   - kind: The `SpanKind` of the `Span` to be created. Defaults to `.internal`.
-    ///   - timestamp: The `DispatchTime` at which to start the new `Span`. Defaults to `.now()`.
     public func startSpan(
         named operationName: String,
-        context: BaggageContext,
-        ofKind kind: SpanKind = .internal,
-        at timestamp: Timestamp = .now()
+        baggage: Baggage,
+        ofKind kind: SpanKind = .internal
     ) -> Span {
-        return self.startSpan(named: operationName, context: context, ofKind: kind, at: timestamp)
+        return self.startSpan(named: operationName, baggage: baggage, ofKind: kind, at: .now())
     }
 }

Tests/TracingTests/TestTracer.swift

@@ -11,7 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import BaggageContext
+import Baggage
 import Foundation
 import Instrumentation
 import Tracing
@@ -21,14 +21,14 @@ final class TestTracer: Tracer {
 
     func startSpan(
         named operationName: String,
-        context: BaggageContext,
+        baggage: Baggage,
         ofKind kind: SpanKind,
         at timestamp: Timestamp
     ) -> Span {
         let span = TestSpan(
             operationName: operationName,
             startTimestamp: timestamp,
-            baggage: context.baggage,
+            baggage: baggage,
             kind: kind
         ) { _ in }
         self.spans.append(span)

Tests/TracingTests/TracedLock.swift

@@ -30,10 +30,7 @@ final class TracedLock {
     func lock(baggage: Baggage) {
         // time here
         self.underlyingLock.lock()
-        self.activeSpan = InstrumentationSystem.tracer.startSpan(
-            named: self.name,
-            context: DefaultContext(baggage: baggage, logger: .init(label: "test"))
-        )
+        self.activeSpan = InstrumentationSystem.tracer.startSpan(named: self.name, baggage: baggage)
     }
 
     func unlock(baggage: Baggage) {

Tests/TracingTests/TracedLockTests.swift

@@ -11,7 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import BaggageContext
+import Baggage
 @testable import Instrumentation
 import Tracing
 import XCTest
@@ -60,15 +60,15 @@ enum TaskIDKey: Baggage.Key {
 private final class TracedLockPrintlnTracer: Tracer {
     func startSpan(
         named operationName: String,
-        context: BaggageContext,
+        baggage: Baggage,
         ofKind kind: SpanKind,
         at timestamp: Timestamp
     ) -> Span {
         return TracedLockPrintlnSpan(
             operationName: operationName,
             startTimestamp: timestamp,
             kind: kind,
-            baggage: context.baggage
+            baggage: baggage
         )
     }
 

Tests/TracingTests/TracerTests.swift

@@ -96,10 +96,7 @@ struct FakeHTTPServer {
         var baggage = Baggage.topLevel
         InstrumentationSystem.instrument.extract(request.headers, into: &baggage, using: HTTPHeadersExtractor())
 
-        let span = tracer.startSpan(
-            named: "GET \(request.path)",
-            context: DefaultContext(baggage: baggage, logger: .init(label: "test"))
-        )
+        let span = tracer.startSpan(named: "GET \(request.path)", baggage: baggage)
 
         let response = self.catchAllHandler(span.baggage, request, self.client)
         span.attributes["http.status"] = .int(response.status)
@@ -115,10 +112,7 @@ final class FakeHTTPClient {
 
     func performRequest(_ baggage: Baggage, request: FakeHTTPRequest) {
         var request = request
-        let span = InstrumentationSystem.tracer.startSpan(
-            named: "GET \(request.path)",
-            context: DefaultContext(baggage: baggage, logger: .init(label: "test")), ofKind: .client
-        )
+        let span = InstrumentationSystem.tracer.startSpan(named: "GET \(request.path)", baggage: baggage)
         self.baggages.append(span.baggage)
         InstrumentationSystem.instrument.inject(baggage, into: &request.headers, using: HTTPHeadersInjector())
         span.end()