Add launched environment SpanContext to TracerSharedState, it allows automatic trace context propagation to child processes

Also fix tracestate propagation header in W3CTraceContextPropagation
Fixes #78

Author: Ignacio Bonafonte

Sources/OpenTelemetryApi/Trace/Propagation/W3CTraceContextPropagator.swift

@@ -33,7 +33,7 @@ public struct W3CTraceContextPropagator: TextMapPropagator {
     private static let traceparentLengthV0 = versionAndTraceIdAndSpanIdLength + optionsLength
 
     static let traceparent = "traceparent"
-    static let traceState = "traceState"
+    static let traceState = "tracestate"
 
     public init() {}
 

Sources/OpenTelemetrySdk/Trace/Propagation/EnvironmentContextPropagator.swift

@@ -0,0 +1,45 @@
+// 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
+import OpenTelemetryApi
+
+/**
+ * Implementation of a EnvironmentContextPropagation propagation, using W3CTraceContextPropagator
+ */
+
+public struct EnvironmentContextPropagator: TextMapPropagator {
+    static let traceParent = "OTEL_TRACE_PARENT"
+    static let traceState = "OTEL_TRACE_STATE"
+    let w3cPropagator = W3CTraceContextPropagator()
+
+    public let fields: Set<String> = [traceState, traceParent]
+
+    public init() {}
+
+    public func inject<S>(spanContext: SpanContext, carrier: inout [String: String], setter: S) where S: Setter {
+        var auxCarrier = [String: String]()
+        w3cPropagator.inject(spanContext: spanContext, carrier: &auxCarrier, setter: setter)
+        carrier[EnvironmentContextPropagator.traceParent] = auxCarrier["traceparent"]
+        carrier[EnvironmentContextPropagator.traceState] = auxCarrier["tracestate"]
+    }
+
+    public func extract<G>(carrier: [String: String], getter: G) -> SpanContext? where G: Getter {
+        var auxCarrier = [String: String]()
+        auxCarrier["traceparent"] = carrier[EnvironmentContextPropagator.traceParent]
+        auxCarrier["tracestate"] = carrier[EnvironmentContextPropagator.traceState]
+        return w3cPropagator.extract(carrier: auxCarrier, getter: getter)
+    }
+}

Sources/OpenTelemetrySdk/Trace/SpanBuilderSdk.swift

@@ -166,16 +166,20 @@ class SpanBuilderSdk: SpanBuilder {
 
     private func getParentContext(parentType: ParentType, explicitParent: Span?, remoteParent: SpanContext?) -> SpanContext? {
         let currentSpan = OpenTelemetry.instance.contextProvider.activeSpan
+
+        var parentContext: SpanContext?
         switch parentType {
         case .noParent:
-            return nil
+            parentContext = nil
         case .currentSpan:
-            return currentSpan?.context
+            parentContext = currentSpan?.context
         case .explicitParent:
-            return explicitParent?.context
+            parentContext = explicitParent?.context
         case .explicitRemoteParent:
-            return remoteParent
+            parentContext = remoteParent
         }
+
+        return parentContext ?? tracerSharedState.launchEnvironmentContext
     }
 
     private static func getParentSpan(parentType: ParentType, explicitParent: Span?) -> Span? {

Sources/OpenTelemetrySdk/Trace/TracerSharedState.swift

@@ -14,6 +14,7 @@
 //
 
 import Foundation
+import OpenTelemetryApi
 
 /// Represents the shared state/config between all Tracers created by the same TracerProvider.
 class TracerSharedState {
@@ -25,6 +26,7 @@ class TracerSharedState {
     var sampler: Sampler
     var activeSpanProcessor: SpanProcessor
     var hasBeenShutdown = false
+    var launchEnvironmentContext: SpanContext?
 
     var registeredSpanProcessors = [SpanProcessor]()
 
@@ -49,6 +51,11 @@ class TracerSharedState {
         } else {
             activeSpanProcessor = NoopSpanProcessor()
         }
+
+        /// Recovers explicit parent context from process environment variables, it allows to automatic
+        /// trace context propagation to child processes
+        let environmentPropagator = EnvironmentContextPropagator()
+        self.launchEnvironmentContext = environmentPropagator.extract(carrier: ProcessInfo.processInfo.environment, getter: EnvironmentGetter())
     }
 
     /// Adds a new SpanProcessor
@@ -89,4 +96,13 @@ class TracerSharedState {
             return setSampler(Samplers.traceIdRatio(ratio: samplerProbability))
         }
     }
+
+    private struct EnvironmentGetter: Getter {
+        func get(carrier: [String: String], key: String) -> [String]? {
+            if let value = carrier[key] {
+                return [value]
+            }
+            return nil
+        }
+    }
 }

Tests/OpenTelemetryApiTests/Trace/Propagation/W3CTraceContextPropagatorTest.swift

@@ -187,7 +187,7 @@ class W3CTraceContextPropagatorTest: XCTestCase {
 
     func testHeaderNames() {
         XCTAssertEqual(W3CTraceContextPropagator.traceparent, "traceparent")
-        XCTAssertEqual(W3CTraceContextPropagator.traceState, "traceState")
+        XCTAssertEqual(W3CTraceContextPropagator.traceState, "tracestate")
     }
 
     func testExtract_EmptyCarrier() {

Tests/OpenTelemetrySdkTests/Trace/SpanBuilderSdkTests.swift

@@ -249,6 +249,20 @@ class SpanBuilderSdkTest: XCTestCase {
         span.end()
     }
 
+    func testParentEnvironmentContext() {
+        setenv("OTEL_TRACE_PARENT", "00-ff000000000000000000000000000041-ff00000000000041-01", 1)
+        let providerWithEnv = TracerProviderSdk()
+        let tracerAux = providerWithEnv.get(instrumentationName: "SpanBuilderWithEnvTest")
+        let parent = tracerAux.spanBuilder(spanName: spanName).setNoParent().startSpan()
+        OpenTelemetry.instance.contextProvider.setActiveSpan(parent)
+        let span = tracerAux.spanBuilder(spanName: spanName).setParent(parent).startSpan()
+        XCTAssertEqual(span.context.traceId, parent.context.traceId)
+        XCTAssertEqual(parent.context.traceId.hexString, "ff000000000000000000000000000041")
+        span.end()
+        parent.end()
+        unsetenv("OTEL_TRACE_PARENT")
+    }
+
     func testParent_timestampConverter() {
         let parent = tracerSdk.spanBuilder(spanName: spanName).startSpan()
         let span = tracerSdk.spanBuilder(spanName: spanName).setParent(parent).startSpan() as! RecordEventsReadableSpan