Add TracingInstrument (#62)

Co-authored-by: Konrad `ktoso` Malawski <[email protected]>
Co-authored-by: Konrad `ktoso` Malawski <[email protected]>

Author: slashmo

Package.swift

@@ -3,6 +3,9 @@ import PackageDescription
 
 let package = Package(
     name: "gsoc-swift-tracing",
+    platforms: [
+        .macOS(.v10_15)
+    ],
     products: [
         .library(name: "BaggageLogging", targets: ["BaggageLogging"]),
         .library(name: "Instrumentation", targets: ["Instrumentation"]),
@@ -44,6 +47,7 @@ let package = Package(
             name: "InstrumentationTests",
             dependencies: [
                 "Instrumentation",
+                "BaggageLogging"
             ]
         ),
 

Sources/Instrumentation/Instrument.swift

@@ -66,3 +66,15 @@ public protocol Instrument {
         Injector: InjectorProtocol,
         Injector.Carrier == Carrier
 }
+
+public struct NoOpInstrument: Instrument {
+    public func inject<Carrier, Injector>(_ baggage: BaggageContext, into carrier: inout Carrier, using injector: Injector)
+        where
+        Injector: InjectorProtocol,
+        Carrier == Injector.Carrier {}
+
+    public func extract<Carrier, Extractor>(_ carrier: Carrier, into baggage: inout BaggageContext, using extractor: Extractor)
+        where
+        Extractor: ExtractorProtocol,
+        Carrier == Extractor.Carrier {}
+}

Sources/Instrumentation/InstrumentationSystem.swift

@@ -19,7 +19,8 @@ import Baggage
 /// - Note: If you need to use more that one cross-cutting tool you can do so by using `MultiplexInstrument`.
 public enum InstrumentationSystem {
     private static let lock = ReadWriteLock()
-    private static var _instrument: Instrument = NOOPInstrument.instance
+    private static var _instrument: Instrument = NoOpInstrument()
+    private static var _tracer: TracingInstrument?
     private static var isInitialized = false
 
     /// Globally select the desired `Instrument` implementation.
@@ -34,27 +35,36 @@ public enum InstrumentationSystem {
                 you need to use multiple instruments.
                 """
             )
+            if let tracer = instrument as? TracingInstrument {
+                self._tracer = tracer
+            }
             self._instrument = instrument
+
             self.isInitialized = true
         }
     }
 
+    // for our testing we want to allow multiple bootstrapping
+    internal static func bootstrapInternal(_ instrument: Instrument) {
+        self.lock.withWriterLock {
+            if let tracer = instrument as? TracingInstrument {
+                self._tracer = tracer
+            }
+            self._instrument = instrument
+        }
+    }
+
     /// Returns the globally configured `Instrument`. Defaults to a no-op `Instrument` if `boostrap` wasn't called before.
     public static var instrument: Instrument {
         self.lock.withReaderLock { self._instrument }
     }
-}
-
-private final class NOOPInstrument: Instrument {
-    static let instance = NOOPInstrument()
-
-    func inject<Carrier, Injector>(_ baggage: BaggageContext, into carrier: inout Carrier, using injector: Injector)
-        where
-        Injector: InjectorProtocol,
-        Carrier == Injector.Carrier {}
 
-    func extract<Carrier, Extractor>(_ carrier: Carrier, into baggage: inout BaggageContext, using extractor: Extractor)
-        where
-        Extractor: ExtractorProtocol,
-        Carrier == Extractor.Carrier {}
+    // FIXME: smarter impl
+    public static var tracer: TracingInstrument {
+        self.lock.withReaderLock {
+            let tracer: TracingInstrument? = self._tracer
+            let res: TracingInstrument = tracer ?? NoOpTracingInstrument()
+            return res
+        }
+    }
 }

Sources/Instrumentation/Tracing/NoOpTracing.swift

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift Distributed Tracing open source project
+//
+// Copyright (c) 2020 Moritz Lang and the Swift Tracing project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import Baggage
+import Dispatch
+
+/// No operation TracingInstrument, used when no tracing is required.
+public struct NoOpTracingInstrument: TracingInstrument {
+    public var currentSpan: Span? = nil
+
+    public func startSpan(named operationName: String, context: BaggageContext, at timestamp: DispatchTime?) -> Span {
+        NoOpSpan()
+    }
+
+    public func inject<Carrier, Injector>(_ context: BaggageContext, into carrier: inout Carrier, using injector: Injector)
+        where
+        Injector: InjectorProtocol,
+        Carrier == Injector.Carrier {}
+
+    public func extract<Carrier, Extractor>(_ carrier: Carrier, into baggage: inout BaggageContext, using extractor: Extractor)
+        where
+        Extractor: ExtractorProtocol,
+        Carrier == Extractor.Carrier {}
+
+    public struct NoOpSpan: Span {
+        public var operationName: String = ""
+        public var status: SpanStatus?
+
+        public var startTimestamp: DispatchTime {
+            .now()
+        }
+
+        public var endTimestamp: DispatchTime? = nil
+
+        public var baggage: BaggageContext {
+            .init()
+        }
+
+        public var events: [SpanEvent] {
+            []
+        }
+
+        public mutating func addEvent(_ event: SpanEvent) {}
+
+        public var attributes: SpanAttributes {
+            get {
+                [:]
+            }
+            set {
+                // ignore
+            }
+        }
+
+        public let isRecording = false
+
+        public mutating func end(at timestamp: DispatchTime) {
+            // ignore
+        }
+    }
+}