more mass renames

Author: ktoso

IntegrationTests/tests_01_performance/test_01_resources/run-nio-alloc-counter-tests.sh

@@ -53,7 +53,7 @@ fi
 
 "$here/../../allocation-counter-tests-framework/run-allocation-counter.sh" \
     -p "$here/../../.." \
-    -m Baggage \
+    -m ServiceContext \
     -m Instrumentation \
     -m NIOInstrumentation \
     -s "$here/shared.swift" \

Package.swift

@@ -14,7 +14,8 @@ let package = Package(
         .library(name: "Tracing", targets: ["Tracing"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-service-context.git", .upToNextMinor(from: "1.0.0")),
+//        .package(url: "https://github.com/apple/swift-service-context.git", from: "1.0.0"),
+        .package(url: "https://github.com/apple/swift-service-context.git", branch: "main"),
         .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
     ],
     targets: [

README.md

@@ -14,7 +14,7 @@ While Swift Distributed Tracing allows building all kinds of _instruments_, whic
 
 This project uses the context progagation type defined independently in:
 
-- 🧳 [swift-service-context](https://github.com/apple/swift-service-context) -- [`Baggage`](https://apple.github.io/swift-service-context/docs/current/ServiceContextModule/Structs/Baggage.html) (zero dependencies)
+- 🧳 [swift-service-context](https://github.com/apple/swift-service-context) -- [`ServiceContext`](https://apple.github.io/swift-service-context/docs/current/ServiceContextModule/Structs/ServiceContext.html) (zero dependencies)
 
 ---
 
@@ -37,7 +37,7 @@ This project uses the context progagation type defined independently in:
     + [Working with `Span`s](#spans)
 * In-Depth Guide for: **Library/Framework developers**
     + [Instrumenting your software](#library-framework-developers--instrumenting-your-software)
-    + [Extracting & injecting Baggage](#extracting--injecting-baggage)
+    + [Extracting & injecting ServiceContext](#extracting--injecting-baggage)
     + [Tracing your library](#tracing-your-library)
 * In-Depth Guide for: **Instrument developers**
     + [Creating an `Instrument`](#instrument-developers--creating-an-instrument)
@@ -74,7 +74,7 @@ As this API package was just released, no projects have yet fully adopted it, th
 | AsyncHTTPClient | Tracing | Old* [Proof of Concept PR](https://github.com/swift-server/async-http-client/pull/289) |
 | Swift gRPC | Tracing | Old* [Proof of Concept PR](https://github.com/grpc/grpc-swift/pull/941) |
 | Swift AWS Lambda Runtime | Tracing | Old* [Proof of Concept PR](https://github.com/swift-server/swift-aws-lambda-runtime/pull/167) |
-| Swift NIO | Baggage | Old* [Proof of Concept PR](https://github.com/apple/swift-nio/pull/1574) |
+| Swift NIO | ServiceContext | Old* [Proof of Concept PR](https://github.com/apple/swift-nio/pull/1574) |
 | RediStack (Redis) | Tracing | Signalled intent to adopt tracing. |
 | Soto AWS Client | Tracing | Signalled intent to adopt tracing. |
 | _Your library?_ | ... | [Get in touch!](https://forums.swift.org/c/server/43) | 
@@ -135,7 +135,7 @@ If you don't bootstrap  (or other instrument) the default no-op tracer is used,
 
 **Automatically reported spans**: When using an already instrumented library, e.g. an HTTP Server which automatically emits spans internally, this is all you have to do to enable tracing. It should now automatically record and emit spans using your configured backend.
 
-**Using baggage and logging context**: The primary transport type for tracing metadata is called `Baggage`, and the primary type used to pass around baggage context and loggers is `LoggingContext`. Logging context combines baggage context values with a smart `Logger` that automatically includes any baggage values ("trace metadata") when it is used for logging. For example, when using an instrumented HTTP server, the API could look like this:
+**Using baggage and logging context**: The primary transport type for tracing metadata is called `ServiceContext`, and the primary type used to pass around baggage context and loggers is `LoggingContext`. Logging context combines baggage context values with a smart `Logger` that automatically includes any baggage values ("trace metadata") when it is used for logging. For example, when using an instrumented HTTP server, the API could look like this:
 
 ```swift
 SomeHTTPLibrary.handle { (request, context) in 
@@ -157,9 +157,9 @@ In this snippet, we use the context logger to log a very useful message. However
 
 Thanks to tracing, and trace identifiers, even if not using tracing visualization libraries, we can immediately co-relate log statements and know that the request `1111-23-1234556` has failed. Since our application can also _add_ values to the context, we can quickly notice that the error seems to occur for the user `Charlie` and not for user `Alice`. Perhaps the user Charlie has exceeded some quotas, does not have permissions or we have a bug in parsing names that include the letter `h`? We don't know _yet_, but thanks to tracing we can much quicker begin our investigation.
 
-**Passing context to client libraries**: When using client libraries that support distributed tracing, they will accept a `Baggage.LoggingContext` type as their _last_ parameter in many calls.
+**Passing context to client libraries**: When using client libraries that support distributed tracing, they will accept a `ServiceContext.LoggingContext` type as their _last_ parameter in many calls.
 
-When using client libraries that support distributed tracing, they will accept a `Baggage.LoggingContext` type as their _last_ parameter in many calls. Please refer to [Context argument naming/positioning](#context-propagation-by-explicit-loggingcontext-passing) in the [Context propagation](#context-propagation-by-explicit-loggingcontext-passing) section of this readme to learn more about how to properly pass context values around.
+When using client libraries that support distributed tracing, they will accept a `ServiceContext.LoggingContext` type as their _last_ parameter in many calls. Please refer to [Context argument naming/positioning](#context-propagation-by-explicit-loggingcontext-passing) in the [Context propagation](#context-propagation-by-explicit-loggingcontext-passing) section of this readme to learn more about how to properly pass context values around.
 
 ### Instrumenting your code
 
@@ -330,7 +330,7 @@ InstrumentationSystem.bootstrap(MultiplexInstrument([FancyInstrument(), OtherFan
 <a name="passing-context-objects"></a>
 ### Context propagation, by explicit `LoggingContext` passing
 
-> `LoggingContext` naming has been carefully selected and it reflects the type's purpose and utility: It binds a [Swift Log `Logger`](https://github.com/apple/swift-log) with an associated distributed tracing [Baggage](https://github.com/apple/swift-service-context).
+> `LoggingContext` naming has been carefully selected and it reflects the type's purpose and utility: It binds a [Swift Log `Logger`](https://github.com/apple/swift-log) with an associated distributed tracing [ServiceContext](https://github.com/apple/swift-service-context).
 > 
 > It _also_ is used for tracing, by tracers reaching in to read or modify the carried baggage. 
 
@@ -397,7 +397,7 @@ Frameworks may need to be more opinionated here, and e.g. already have some form
 
 When adapting an existing library/framework to support `LoggingContext` and it already has a "framework context" which is expected to be passed through "everywhere", we suggest to follow these guidelines for adopting LoggingContext:
 
-1. Add a `Baggage` as a property called `baggage` to your own `context` type, so that the call side for your
+1. Add a `ServiceContext` as a property called `baggage` to your own `context` type, so that the call side for your
    users becomes `context.baggage` (rather than the confusing `context.context`)
 2. If you cannot or it would not make sense to carry baggage inside your framework's context object, pass (and accept (!)) the `LoggingContext` in your framework functions like follows:
 - if they take no framework context, accept a `context: LoggingContext` which is the same guideline as for all other cases
@@ -417,8 +417,8 @@ Generally application developers _should not_ create new context objects, but ra
 
 If really necessary, or for the purposes of testing, one can create a baggage or context using one of the two factory functions:
 
-- [`DefaultLoggingContext.topLevel(logger:)`](https://github.com/apple/swift-service-context/blob/main/Sources/Baggage/LoggingContext.swift) or [`Baggage.topLevel`](https://github.com/apple/swift-service-context-core/blob/main/Sources/CoreBaggage/Baggage.swift) - which creates an empty context/baggage, without any values. It should _not_ be used too frequently, and as the name implies in applications it only should be used on the "top level" of the application, or at the beginning of a contextless (e.g. timer triggered) event processing.
-- [`DefaultLoggingContext.TODO(logger:reason:)`](https://github.com/apple/swift-service-context/blob/main/Sources/Baggage/LoggingContext.swift) or [`Baggage.TODO`](https://github.com/apple/swift-service-context-core/blob/main/Sources/CoreBaggage/Baggage.swift) - which should be used to mark a parameter where "before this code goes into production, a real context should be passed instead." An application can be run with `-DBAGGAGE_CRASH_TODOS` to cause the application to crash whenever a TODO context is still in use somewhere, making it easy to diagnose and avoid breaking context propagation by accidentally leaving in a `TODO` context in production.
+- [`DefaultLoggingContext.topLevel(logger:)`](https://github.com/apple/swift-service-context/blob/main/Sources/ServiceContext/LoggingContext.swift) or [`ServiceContext.topLevel`](https://github.com/apple/swift-service-context-core/blob/main/Sources/CoreBaggage/ServiceContext.swift) - which creates an empty context/baggage, without any values. It should _not_ be used too frequently, and as the name implies in applications it only should be used on the "top level" of the application, or at the beginning of a contextless (e.g. timer triggered) event processing.
+- [`DefaultLoggingContext.TODO(logger:reason:)`](https://github.com/apple/swift-service-context/blob/main/Sources/ServiceContext/LoggingContext.swift) or [`ServiceContext.TODO`](https://github.com/apple/swift-service-context-core/blob/main/Sources/CoreBaggage/ServiceContext.swift) - which should be used to mark a parameter where "before this code goes into production, a real context should be passed instead." An application can be run with `-DBAGGAGE_CRASH_TODOS` to cause the application to crash whenever a TODO context is still in use somewhere, making it easy to diagnose and avoid breaking context propagation by accidentally leaving in a `TODO` context in production.
 
 Please refer to the respective functions documentation for details.
 
@@ -464,7 +464,7 @@ func makeDinner(context: LoggingContext) async throws -> Meal {
 
 ## Library/Framework developers: Instrumenting your software
 
-### Extracting & injecting Baggage
+### Extracting & injecting ServiceContext
 
 When hitting boundaries like an outgoing HTTP request you call out to the [configured instrument(s)](#Bootstrapping-the-Instrumentation-System):
 
@@ -549,7 +549,7 @@ Creating an instrument means adopting the `Instrument` protocol (or `Tracer` in
 The two methods will be called by instrumented libraries/frameworks at asynchronous boundaries, giving you a chance to
 act on the provided information or to add additional information to be carried across these boundaries.
 
-> Check out the [`Baggage` documentation](https://github.com/apple/swift-service-context) for more information on
+> Check out the [`ServiceContext` documentation](https://github.com/apple/swift-service-context) for more information on
 how to retrieve values from the `LoggingContext` and how to set values on it.
 
 ### Creating a Tracer
@@ -561,16 +561,16 @@ When creating a tracer you need to create two types:
 
 > The `Span` conforms to the standard rules defined in [OpenTelemetry](https://github.com/open-telemetry/opentelemetry-specification/blob/v0.7.0/specification/trace/api.md#span), so if unsure about usage patterns, you can refer to this specification and examples referring to it.
 
-### Defining, injecting and extracting Baggage
+### Defining, injecting and extracting ServiceContext
 
 ```swift
 import Tracing
 
-private enum TraceIDKey: BaggageKey {
+private enum TraceIDKey: ServiceContextKey {
   typealias Value = String
 }
 
-extension Baggage {
+extension ServiceContext {
   var traceID: String? {
     get {
       return self[TraceIDKey.self]

Sources/Instrumentation/Instrument.swift

@@ -56,17 +56,17 @@ public protocol Instrument: _SwiftInstrumentationSendable {
     ///
     /// - Parameters:
     ///   - carrier: The `Carrier` that was used to propagate values across boundaries.
-    ///   - baggage: The `ServiceContext` into which these values should be injected.
+    ///   - context: The `ServiceContext` into which these values should be injected.
     ///   - extractor: The ``Extractor`` that extracts values from the given `Carrier`.
-    func extract<Carrier, Extract>(_ carrier: Carrier, into baggage: inout ServiceContext, using extractor: Extract)
+    func extract<Carrier, Extract>(_ carrier: Carrier, into context: inout ServiceContext, using extractor: Extract)
         where Extract: Extractor, Extract.Carrier == Carrier
 
     /// Extract values from a `ServiceContext` and inject them into the given `Carrier` using the given ``Injector``.
     ///
     /// - Parameters:
-    ///   - baggage: The `ServiceContext` from which relevant information will be extracted.
+    ///   - context: The `ServiceContext` from which relevant information will be extracted.
     ///   - carrier: The `Carrier` into which this information will be injected.
     ///   - injector: The ``Injector`` used to inject extracted `ServiceContext` into the given `Carrier`.
-    func inject<Carrier, Inject>(_ baggage: ServiceContext, into carrier: inout Carrier, using injector: Inject)
+    func inject<Carrier, Inject>(_ context: ServiceContext, into carrier: inout Carrier, using injector: Inject)
         where Inject: Injector, Inject.Carrier == Carrier
 }

Sources/Instrumentation/MultiplexInstrument.swift

@@ -35,15 +35,15 @@ extension MultiplexInstrument {
 }
 
 extension MultiplexInstrument: Instrument {
-    public func inject<Carrier, Inject>(_ baggage: ServiceContext, into carrier: inout Carrier, using injector: Inject)
+    public func inject<Carrier, Inject>(_ context: ServiceContext, into carrier: inout Carrier, using injector: Inject)
         where Inject: Injector, Carrier == Inject.Carrier
     {
-        self.instruments.forEach { $0.inject(baggage, into: &carrier, using: injector) }
+        self.instruments.forEach { $0.inject(context, into: &carrier, using: injector) }
     }
 
-    public func extract<Carrier, Extract>(_ carrier: Carrier, into baggage: inout ServiceContext, using extractor: Extract)
+    public func extract<Carrier, Extract>(_ carrier: Carrier, into context: inout ServiceContext, using extractor: Extract)
         where Extract: Extractor, Carrier == Extract.Carrier
     {
-        self.instruments.forEach { $0.extract(carrier, into: &baggage, using: extractor) }
+        self.instruments.forEach { $0.extract(carrier, into: &context, using: extractor) }
     }
 }

Sources/Instrumentation/NoOpInstrument.swift

@@ -18,13 +18,13 @@ import ServiceContextModule
 public struct NoOpInstrument: Instrument {
     public init() {}
 
-    public func inject<Carrier, Inject>(_ baggage: ServiceContext, into carrier: inout Carrier, using injector: Inject)
+    public func inject<Carrier, Inject>(_ context: ServiceContext, into carrier: inout Carrier, using injector: Inject)
         where Inject: Injector, Carrier == Inject.Carrier
     {
         // no-op
     }
 
-    public func extract<Carrier, Extract>(_ carrier: Carrier, into baggage: inout ServiceContext, using extractor: Extract)
+    public func extract<Carrier, Extract>(_ carrier: Carrier, into context: inout ServiceContext, using extractor: Extract)
         where Extract: Extractor, Carrier == Extract.Carrier
     {
         // no-op

Sources/Tracing/Docs.docc/Guides/ImplementATracer.md

@@ -39,13 +39,13 @@ When creating a tracer you will need to implement two types:
 ### Defining, injecting and extracting ServiceContext
 
 In order to be able to extract and inject values into the `ServiceContext` which is the value that is "carried around" across asynchronous contexts,
-we need to declare a `BaggageKey`. ServiceContext generally acts as a type-safe dictionary and declaring the keys this way allows us to perform lookups 
+we need to declare a `ServiceContextKey`. ServiceContext generally acts as a type-safe dictionary and declaring the keys this way allows us to perform lookups 
 returning the expected type of values:
 
 ```swift
 import Tracing
 
-private enum TraceIDKey: BaggageKey {
+private enum TraceIDKey: ServiceContextKey {
   typealias Value = String
 }
 
@@ -148,7 +148,7 @@ When creating a tracer you need to create two types:
 ```swift
 import Tracing
 
-private enum TraceIDKey: BaggageKey {
+private enum TraceIDKey: ServiceContextKey {
   typealias Value = String
 }
 

Sources/Tracing/NoOpTracer.swift

@@ -17,39 +17,39 @@ import Dispatch
 @_exported import ServiceContextModule
 
 /// Tracer that ignores all operations, used when no tracing is required.
-@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) // for TaskLocal Baggage
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) // for TaskLocal ServiceContext
 public struct NoOpTracer: LegacyTracer {
     public typealias Span = NoOpSpan
 
     public init() {}
 
     public func startAnySpan<Instant: TracerInstant>(_ operationName: String,
-                                                     baggage: @autoclosure () -> Baggage,
+                                                     context: @autoclosure () -> ServiceContext,
                                                      ofKind kind: SpanKind,
                                                      at instant: @autoclosure () -> Instant,
                                                      function: String,
                                                      file fileID: String,
                                                      line: UInt) -> any Tracing.Span
     {
-        NoOpSpan(baggage: baggage())
+        NoOpSpan(context: context())
     }
 
     public func forceFlush() {}
 
-    public func inject<Carrier, Inject>(_ baggage: Baggage, into carrier: inout Carrier, using injector: Inject)
+    public func inject<Carrier, Inject>(_ context: ServiceContext, into carrier: inout Carrier, using injector: Inject)
         where Inject: Injector, Carrier == Inject.Carrier
     {
         // no-op
     }
 
-    public func extract<Carrier, Extract>(_ carrier: Carrier, into baggage: inout Baggage, using extractor: Extract)
+    public func extract<Carrier, Extract>(_ carrier: Carrier, into context: inout ServiceContext, using extractor: Extract)
         where Extract: Extractor, Carrier == Extract.Carrier
     {
         // no-op
     }
 
     public struct NoOpSpan: Tracing.Span {
-        public let baggage: Baggage
+        public let context: ServiceContext
         public var isRecording: Bool {
             false
         }
@@ -63,8 +63,8 @@ public struct NoOpTracer: LegacyTracer {
             }
         }
 
-        public init(baggage: Baggage) {
-            self.baggage = baggage
+        public init(context: ServiceContext) {
+            self.context = context
         }
 
         public func setStatus(_ status: SpanStatus) {}
@@ -94,7 +94,7 @@ public struct NoOpTracer: LegacyTracer {
 extension NoOpTracer: Tracer {
     public func startSpan<Instant: TracerInstant>(
         _ operationName: String,
-        baggage: @autoclosure () -> Baggage,
+        context: @autoclosure () -> ServiceContext,
         ofKind kind: SpanKind,
         at instant: @autoclosure () -> Instant,
         function: String,