Merge branch 'main' into Context-handling-rework

Author: Ignacio Bonafonte

Sources/OpenTelemetryApi/Baggage/Propagation/JaegerBaggagePropagator.swift

@@ -0,0 +1,68 @@
+// Copyright 2020, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+/**
+ * Implementation of the Jaeger propagation protocol. See
+ * https://www.jaegertracing.io/docs/client-libraries/#propagation-format
+ */
+
+public class JaegerBaggagePropagator: TextMapBaggagePropagator {
+    public static let baggageHeader = "jaeger-baggage"
+    public static let baggagePrefix = "uberctx-"
+
+    public var fields: Set<String> = [baggageHeader]
+
+    public init() {}
+
+    public func inject<S>(baggage: Baggage, carrier: inout [String: String], setter: S) where S: Setter {
+        baggage.getEntries().forEach {
+            setter.set(carrier: &carrier, key: JaegerBaggagePropagator.baggagePrefix + $0.key.name, value: $0.value.string)
+        }
+    }
+
+    public func extract<G>(carrier: [String: String], getter: G) -> Baggage? where G: Getter {
+        let builder = OpenTelemetry.instance.baggageManager.baggageBuilder()
+
+        carrier.forEach {
+            if $0.key.hasPrefix(JaegerBaggagePropagator.baggagePrefix) {
+                if $0.key.count == JaegerBaggagePropagator.baggagePrefix.count {
+                    return
+                }
+
+                if let key = EntryKey(name: String($0.key.dropFirst(JaegerBaggagePropagator.baggagePrefix.count))),
+                   let value = EntryValue(string: $0.value)
+                {
+                    builder.put(key: key, value: value, metadata: nil)
+                }
+            } else if $0.key == JaegerBaggagePropagator.baggageHeader {
+                $0.value.split(separator: ",").forEach { entry in
+                    let keyValue = entry.split(separator: "=")
+                    if keyValue.count != 2 {
+                        return
+                    }
+                    if let key = EntryKey(name: String(keyValue[0])),
+                       let value = EntryValue(string: String(keyValue[1]))
+                    {
+                        builder.put(key: key, value: value, metadata: nil)
+                    }
+                }
+            }
+        }
+
+        return builder.build()
+    }
+}

Sources/OpenTelemetryApi/Trace/Propagation/B3Propagator.swift

@@ -20,13 +20,13 @@ import Foundation
  * https://github.com/openzipkin/b3-propagation
  */
 public class B3Propagator: TextMapPropagator {
-    public static let traceIdHeader = "X-B3-TraceId"
-    public static let spanIdHeader = "X-B3-SpanId"
-    public static let sampledHeader = "X-B3-Sampled"
-    public static let trueInt = "1"
-    public static let falseInt = "0"
-    public static let combinedHeader = "b3"
-    public static let combinedHeaderDelimiter = "-"
+    static let traceIdHeader = "X-B3-TraceId"
+    static let spanIdHeader = "X-B3-SpanId"
+    static let sampledHeader = "X-B3-Sampled"
+    static let trueInt = "1"
+    static let falseInt = "0"
+    static let combinedHeader = "b3"
+    static let combinedHeaderDelimiter = "-"
 
     public let fields: Set<String> = [traceIdHeader, spanIdHeader, sampledHeader]
 

Sources/OpenTelemetryApi/Trace/Propagation/JaegerPropagator.swift

@@ -0,0 +1,117 @@
+// Copyright 2020, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+/**
+ * Implementation of the Jaeger propagation protocol. See
+ * https://www.jaegertracing.io/docs/client-libraries/#propagation-format
+ */
+
+public class JaegerPropagator: TextMapPropagator {
+    static let propagationHeader = "uber-trace-id"
+    // Parent span has been deprecated but Jaeger propagation protocol requires it
+    static let deprecatedParentSpan = "0"
+    static let propagationHeaderDelimiter: Character = ":"
+
+    private static let maxTraceIdLength = 2 * TraceId.size
+    private static let maxSpanIdLength = 2 * SpanId.size
+    private static let maxFlagsLength = 2
+
+    private static let isSampledChar = "1"
+    private static let notSampledChar = "0"
+
+    private static let sampledFlags = TraceFlags().settingIsSampled(true)
+    private static let notSampledFlags = TraceFlags().settingIsSampled(false)
+
+    public var fields: Set<String> = [propagationHeader]
+
+    public init() {}
+
+    public func inject<S>(spanContext: SpanContext, carrier: inout [String: String], setter: S) where S: Setter {
+        guard spanContext.traceId.isValid, spanContext.spanId.isValid else {
+            return
+        }
+        var propagation = ""
+        propagation += spanContext.traceId.hexString
+        propagation += String(JaegerPropagator.propagationHeaderDelimiter)
+        propagation += spanContext.spanId.hexString
+        propagation += String(JaegerPropagator.propagationHeaderDelimiter)
+        propagation += JaegerPropagator.deprecatedParentSpan
+        propagation += String(JaegerPropagator.propagationHeaderDelimiter)
+        propagation += spanContext.isSampled ? JaegerPropagator.isSampledChar : JaegerPropagator.notSampledChar
+        setter.set(carrier: &carrier, key: JaegerPropagator.propagationHeader, value: propagation)
+    }
+
+    public func extract<G>(carrier: [String: String], getter: G) -> SpanContext? where G: Getter {
+        guard let headerValue = getter.get(carrier: carrier, key: JaegerPropagator.propagationHeader), headerValue.count >= 1 else {
+            return nil
+        }
+
+        var header = headerValue[0]
+        if header.lastIndex(of: JaegerPropagator.propagationHeaderDelimiter) == nil {
+            guard let decodedHeader = header.removingPercentEncoding,
+                  let _ = decodedHeader.lastIndex(of: JaegerPropagator.propagationHeaderDelimiter)
+            else {
+                return nil
+            }
+            header = decodedHeader
+        }
+
+        let parts = header.split(separator: JaegerPropagator.propagationHeaderDelimiter)
+        guard parts.count == 4 else {
+            return nil
+        }
+
+        let traceId = String(parts[0])
+        if !isTraceIdValid(traceId) {
+            return nil
+        }
+
+        let spanId = String(parts[1])
+        if !isSpanIdValid(spanId) {
+            return nil
+        }
+
+        let flags = String(parts[3])
+        if !isFlagValid(flags) {
+            return nil
+        }
+
+        return buildSpanContext(traceId: traceId, spanId: spanId, flags: flags)
+    }
+
+    private func buildSpanContext(traceId: String, spanId: String, flags: String) -> SpanContext? {
+        let flagsInt = Int(flags) ?? 0
+        let traceFlags = ((flagsInt & 1) == 1) ? JaegerPropagator.sampledFlags : JaegerPropagator.notSampledFlags
+        let context = SpanContext.createFromRemoteParent(traceId: TraceId(fromHexString: traceId),
+                                                  spanId: SpanId(fromHexString: spanId),
+                                                  traceFlags: traceFlags,
+                                                  traceState: TraceState())
+        return context.isValid ? context : nil
+    }
+
+    private func isTraceIdValid(_ traceId: String) -> Bool {
+        return !(traceId.isEmpty || traceId.count > JaegerPropagator.maxTraceIdLength)
+    }
+
+    private func isSpanIdValid(_ spanId: String) -> Bool {
+        return !(spanId.isEmpty || spanId.count > JaegerPropagator.maxSpanIdLength)
+    }
+
+    private func isFlagValid(_ flags: String) -> Bool {
+        return !(flags.isEmpty || flags.count > JaegerPropagator.maxFlagsLength)
+    }
+}

Sources/OpenTelemetrySdk/Resources/EnvVarResource.swift

@@ -24,7 +24,7 @@ public struct EnvVarResource {
 
     ///  This resource information is loaded from the OC_RESOURCE_LABELS
     ///  environment variable.
-    public static let resource = Resource(attributes: parseResourceAttributes(rawEnvAttributes: ProcessInfo.processInfo.environment[otelResourceAttributesEnv]))
+    public static let resource = Resource(attributes: parseResourceAttributes(rawEnvAttributes: ProcessInfo.processInfo.environment[otelResourceAttributesEnv])).merging(other: Resource())
 
     private init() {}
 

Sources/OpenTelemetrySdk/Trace/NoopSpanProcessor.swift

@@ -16,17 +16,17 @@
 import Foundation
 import OpenTelemetryApi
 
-public struct NoopSpanProcessor: SpanProcessor {
-    public init() {}
+struct NoopSpanProcessor: SpanProcessor {
+    init() {}
 
-    public let isStartRequired = false
-    public let isEndRequired = false
+    let isStartRequired = false
+    let isEndRequired = false
 
-    public func onStart(parentContext: SpanContext?, span: ReadableSpan) {}
+    func onStart(parentContext: SpanContext?, span: ReadableSpan) {}
 
-    public func onEnd(span: ReadableSpan) {}
+    func onEnd(span: ReadableSpan) {}
 
-    public func shutdown() {}
+    func shutdown() {}
 
-    public func forceFlush() {}
+    func forceFlush() {}
 }

Sources/OpenTelemetrySdk/Trace/TracerProviderSdk.swift

@@ -20,19 +20,35 @@ import OpenTelemetryApi
 public class TracerProviderSdk: TracerProvider {
     private var tracerProvider = [InstrumentationLibraryInfo: TracerSdk]()
     internal var sharedState: TracerSharedState
+    internal static let emptyName = "unknown"
 
     /// Returns a new TracerProviderSdk with default Clock, IdGenerator and Resource.
     public init(clock: Clock = MillisClock(),
                 idGenerator: IdGenerator = RandomIdGenerator(),
-                resource: Resource = EnvVarResource.resource)
+                resource: Resource = EnvVarResource.resource,
+                spanLimits: SpanLimits = SpanLimits(),
+                sampler: Sampler = Samplers.parentBased(root: Samplers.alwaysOn),
+                spanProcessors: [SpanProcessor] = [])
     {
-        sharedState = TracerSharedState(clock: clock, idGenerator: idGenerator, resource: resource)
+        sharedState = TracerSharedState(clock: clock,
+                                        idGenerator: idGenerator,
+                                        resource: resource,
+                                        spanLimits: spanLimits,
+                                        sampler: sampler,
+                                        spanProcessors: spanProcessors)
     }
 
     public func get(instrumentationName: String, instrumentationVersion: String? = nil) -> Tracer {
         if sharedState.hasBeenShutdown {
             return DefaultTracer.instance
         }
+
+        var instrumentationName = instrumentationName
+        if instrumentationName.isEmpty {
+            // Per the spec, empty is "invalid"
+            print("Tracer requested without instrumentation name.")
+            instrumentationName = TracerProviderSdk.emptyName
+        }
         let instrumentationLibraryInfo = InstrumentationLibraryInfo(name: instrumentationName, version: instrumentationVersion ?? "")
         if let tracer = tracerProvider[instrumentationLibraryInfo] {
             return tracer

Sources/OpenTelemetrySdk/Trace/TracerSharedState.swift

@@ -21,24 +21,45 @@ class TracerSharedState {
     var idGenerator: IdGenerator
     var resource: Resource
 
-    var sampler: Sampler = ParentBasedSampler(root: Samplers.alwaysOn)
-    var activeSpanLimits = SpanLimits()
-    var activeSpanProcessor: SpanProcessor = NoopSpanProcessor()
+    var activeSpanLimits: SpanLimits
+    var sampler: Sampler
+    var activeSpanProcessor: SpanProcessor
     var hasBeenShutdown = false
 
     var registeredSpanProcessors = [SpanProcessor]()
 
-    init(clock: Clock, idGenerator: IdGenerator, resource: Resource) {
+    init(clock: Clock,
+         idGenerator: IdGenerator,
+         resource: Resource,
+         spanLimits: SpanLimits,
+         sampler: Sampler,
+         spanProcessors: [SpanProcessor])
+    {
         self.clock = clock
         self.idGenerator = idGenerator
         self.resource = resource
+        self.activeSpanLimits = spanLimits
+        self.sampler = sampler
+        if spanProcessors.count > 1 {
+            self.activeSpanProcessor = MultiSpanProcessor(spanProcessors: spanProcessors)
+            registeredSpanProcessors = spanProcessors
+        } else if spanProcessors.count == 1 {
+            self.activeSpanProcessor = spanProcessors[0]
+            registeredSpanProcessors = spanProcessors
+        } else {
+            activeSpanProcessor = NoopSpanProcessor()
+        }
     }
 
     /// Adds a new SpanProcessor
     /// - Parameter spanProcessor:  the new SpanProcessor to be added.
     func addSpanProcessor(_ spanProcessor: SpanProcessor) {
         registeredSpanProcessors.append(spanProcessor)
-        activeSpanProcessor = MultiSpanProcessor(spanProcessors: registeredSpanProcessors)
+        if registeredSpanProcessors.count > 1 {
+            activeSpanProcessor = MultiSpanProcessor(spanProcessors: registeredSpanProcessors)
+        } else {
+            activeSpanProcessor = registeredSpanProcessors[0]
+        }
     }
 
     /// Stops tracing, including shutting down processors and set to true isStopped.