Adopt ServiceContext 1.0

**Motivation:**
The baggage type ended up more useful than anticipated and we're
renaming it to ServiceContext for the 1.0 release.

Many libraries and production systems and up passing context around
which may not necessarily be related to tracing, which made us make this
naming change. Functionally ServiceContext and Baggage are the same, but
the way we talk about context propagation in general makes more sense if
we call this a context stype.

**Modifications:**

Use the new type; The `Baggage` still exists in the
`InstrumentationBaggage` module so people can still use it if they
wanted to but it is a TYPEALIAS to the ServiceContext.

Author: ktoso

IntegrationTests/tests_01_performance/test_01_resources/shared.swift

@@ -27,7 +27,7 @@
 //===----------------------------------------------------------------------===//
 
 import Foundation
-import InstrumentationBaggage
+import ServiceContextModule
 
 @inline(never)
 func take1(context: BaggageContext) -> Int {

IntegrationTests/tests_01_performance/test_01_resources/test_001_pass_around_static_strings_small.swift

@@ -26,7 +26,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import InstrumentationBaggage
+import ServiceContextModule
 
 func run(identifier: String) {
     measure(identifier: identifier) {

IntegrationTests/tests_01_performance/test_01_resources/test_002_pass_around_static_strings_large.swift

@@ -26,7 +26,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import InstrumentationBaggage
+import ServiceContextModule
 
 func run(identifier: String) {
     measure(identifier: identifier) {

Package.swift

@@ -14,7 +14,7 @@ let package = Package(
         .library(name: "Tracing", targets: ["Tracing"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-distributed-tracing-baggage.git", .upToNextMinor(from: "0.4.1")),
+        .package(url: "https://github.com/apple/swift-service-context.git", .upToNextMinor(from: "1.0.0")),
         .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
     ],
     targets: [
@@ -24,7 +24,7 @@ let package = Package(
         .target(
             name: "Instrumentation",
             dependencies: [
-                .product(name: "InstrumentationBaggage", package: "swift-distributed-tracing-baggage"),
+                .product(name: "ServiceContextModule", package: "swift-service-context"),
             ]
         ),
         .testTarget(
@@ -56,7 +56,7 @@ let package = Package(
         .executableTarget(
             name: "_TracingBenchmarks",
             dependencies: [
-                .product(name: "InstrumentationBaggage", package: "swift-distributed-tracing-baggage"),
+                .product(name: "ServiceContextModule", package: "swift-service-context"),
                 .target(name: "Tracing"),
                 .target(name: "_TracingBenchmarkTools"),
             ]

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-distributed-tracing-baggage](https://github.com/apple/swift-distributed-tracing-baggage) -- [`Baggage`](https://apple.github.io/swift-distributed-tracing-baggage/docs/current/InstrumentationBaggage/Structs/Baggage.html) (zero dependencies)
+- 🧳 [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)
 
 ---
 
@@ -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-distributed-tracing-baggage).
+> `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).
 > 
 > It _also_ is used for tracing, by tracers reaching in to read or modify the carried baggage. 
 
@@ -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-distributed-tracing-baggage/blob/main/Sources/Baggage/LoggingContext.swift) or [`Baggage.topLevel`](https://github.com/apple/swift-distributed-tracing-baggage-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-distributed-tracing-baggage/blob/main/Sources/Baggage/LoggingContext.swift) or [`Baggage.TODO`](https://github.com/apple/swift-distributed-tracing-baggage-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/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.
 
 Please refer to the respective functions documentation for details.
 
@@ -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-distributed-tracing-baggage) for more information on
+> Check out the [`Baggage` 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

Sources/Instrumentation/Instrument.swift

@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import InstrumentationBaggage
+import ServiceContextModule
 
 /// Typealias used to simplify Support of old Swift versions which do not have `Sendable` defined.
 #if swift(>=5.6.0)
@@ -51,22 +51,22 @@ public protocol Injector: _SwiftInstrumentationSendable {
 /// Conforming types are usually cross-cutting tools like tracers. They are agnostic of what specific `Carrier` is used
 /// to propagate metadata across boundaries, but instead just specify what values to use for which keys.
 public protocol Instrument: _SwiftInstrumentationSendable {
-    /// Extract values from a `Carrier` by using the given extractor and inject them into the given `Baggage`.
+    /// Extract values from a `Carrier` by using the given extractor and inject them into the given `ServiceContext`.
     /// It's quite common for `Instrument`s to come up with new values if they weren't passed along in the given `Carrier`.
     ///
     /// - Parameters:
     ///   - carrier: The `Carrier` that was used to propagate values across boundaries.
-    ///   - baggage: The `Baggage` into which these values should be injected.
+    ///   - baggage: 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 Baggage, using extractor: Extract)
+    func extract<Carrier, Extract>(_ carrier: Carrier, into baggage: inout ServiceContext, using extractor: Extract)
         where Extract: Extractor, Extract.Carrier == Carrier
 
-    /// Extract values from a `Baggage` and inject them into the given `Carrier` using the given ``Injector``.
+    /// Extract values from a `ServiceContext` and inject them into the given `Carrier` using the given ``Injector``.
     ///
     /// - Parameters:
-    ///   - baggage: The `Baggage` from which relevant information will be extracted.
+    ///   - baggage: 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 `Baggage` into the given `Carrier`.
-    func inject<Carrier, Inject>(_ baggage: Baggage, into carrier: inout Carrier, using injector: Inject)
+    ///   - 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)
         where Inject: Injector, Inject.Carrier == Carrier
 }

Sources/Instrumentation/InstrumentationSystem.swift

@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import InstrumentationBaggage
+import ServiceContextModule
 
 /// `InstrumentationSystem` is a global facility where the default cross-cutting tool can be configured.
 /// It is set up just once in a given program to select the desired ``Instrument`` implementation.
@@ -22,7 +22,7 @@ import InstrumentationBaggage
 ///
 /// # Access the Instrument
 /// ``instrument``: Returns whatever you passed to ``bootstrap(_:)`` as an ``Instrument``.
-@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 enum InstrumentationSystem {
     private static let lock = ReadWriteLock()
     private static var _instrument: Instrument = NoOpInstrument()
@@ -62,7 +62,7 @@ public enum InstrumentationSystem {
     }
 }
 
-@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
 extension InstrumentationSystem {
     /// :nodoc: INTERNAL API: Do Not Use
     public static func _findInstrument(where predicate: (Instrument) -> Bool) -> Instrument? {

Sources/Instrumentation/MultiplexInstrument.swift

@@ -12,17 +12,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-import InstrumentationBaggage
+import ServiceContextModule
 
 /// A pseudo-``Instrument`` that may be used to instrument using multiple other ``Instrument``s across a
-/// common `Baggage`.
+/// common `ServiceContext`.
 public struct MultiplexInstrument {
     private var instruments: [Instrument]
 
     /// Create a ``MultiplexInstrument``.
     ///
     /// - Parameter instruments: An array of ``Instrument``s, each of which will be used to ``Instrument/inject(_:into:using:)`` or ``Instrument/extract(_:into:using:)``
-    /// through the same `Baggage`.
+    /// through the same `ServiceContext`.
     public init(_ instruments: [Instrument]) {
         self.instruments = instruments
     }
@@ -35,13 +35,13 @@ extension MultiplexInstrument {
 }
 
 extension MultiplexInstrument: Instrument {
-    public func inject<Carrier, Inject>(_ baggage: Baggage, into carrier: inout Carrier, using injector: Inject)
+    public func inject<Carrier, Inject>(_ baggage: ServiceContext, into carrier: inout Carrier, using injector: Inject)
         where Inject: Injector, Carrier == Inject.Carrier
     {
         self.instruments.forEach { $0.inject(baggage, into: &carrier, using: injector) }
     }
 
-    public func extract<Carrier, Extract>(_ carrier: Carrier, into baggage: inout Baggage, using extractor: Extract)
+    public func extract<Carrier, Extract>(_ carrier: Carrier, into baggage: inout ServiceContext, using extractor: Extract)
         where Extract: Extractor, Carrier == Extract.Carrier
     {
         self.instruments.forEach { $0.extract(carrier, into: &baggage, using: extractor) }

Sources/Instrumentation/NoOpInstrument.swift

@@ -12,19 +12,19 @@
 //
 //===----------------------------------------------------------------------===//
 
-import InstrumentationBaggage
+import ServiceContextModule
 
 /// A "no op" implementation of an ``Instrument``.
 public struct NoOpInstrument: Instrument {
     public init() {}
 
-    public func inject<Carrier, Inject>(_ baggage: Baggage, into carrier: inout Carrier, using injector: Inject)
+    public func inject<Carrier, Inject>(_ baggage: 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 baggage: inout ServiceContext, using extractor: Extract)
         where Extract: Extractor, Carrier == Extract.Carrier
     {
         // no-op