Merge pull request #213 from bryce-b/otlp-exporter-config

Add functionality for Exporter headers env-var #204

Author: Ignacio Bonafonte

Sources/Exporters/OpenTelemetryProtocol/common/EnvVarHeaders.swift

@@ -0,0 +1,39 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import Foundation
+import OpenTelemetryApi
+
+/// Provides a framework for detection of resource information from the environment variable
+public struct EnvVarHeaders {
+    private static let otelAttributesEnv = "OTEL_EXPORTER_OTLP_HEADERS"
+    private static let labelListSplitter = Character(",")
+    private static let labelKeyValueSplitter = Character("=")
+
+    ///  This resource information is loaded from the 
+    ///  environment variable.
+    public static let attributes : [(String,String)]? = parseAttributes(rawEnvAttributes: ProcessInfo.processInfo.environment[otelAttributesEnv])
+
+    private init() {}
+
+    /// Creates a label map from the environment variable string.
+    /// - Parameter rawEnvLabels: the comma-separated list of labels
+    private static func parseAttributes(rawEnvAttributes: String?) -> [(String, String)]? {
+        guard let rawEnvLabels = rawEnvAttributes else { return nil }
+
+        var labels = [(String, String)]()
+
+        rawEnvLabels.split(separator: labelListSplitter).forEach {
+            let split = $0.split(separator: labelKeyValueSplitter)
+            if split.count != 2 {
+                return
+            }
+            let key = split[0].trimmingCharacters(in: .whitespaces)
+            let value = split[1].trimmingCharacters(in: CharacterSet(charactersIn: "^\"|\"$"))
+            labels.append((key,value))
+        }
+        return labels
+    }
+}

Sources/Exporters/OpenTelemetryProtocol/common/OtlpConfiguration.swift

@@ -0,0 +1,33 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import Foundation
+
+
+
+public struct OtlpConfiguration {
+    public static let DefaultTimeoutInterval : TimeInterval = TimeInterval(10)
+
+
+    /*
+     * This is a first pass addition to satisfy the OTLP Configuration specification:
+     * https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md
+     * It's possible to satisfy a few of these configuration options through the configuration of the GRPC channel
+     * It's worth considering re-factoring the initialization of the OTLP exporters to collect all the configuration
+     * in one locations.
+     *
+     * I've left several of the configuration options stubbed in comments, so that may be implemented in the future.
+     */
+    // let endpoint : URL? = URL(string: "https://localhost:4317")
+    // let certificateFile
+    // let compression
+    let headers : [(String,String)]?
+    let timeout : TimeInterval
+
+    public init(timeout : TimeInterval  = OtlpConfiguration.DefaultTimeoutInterval, headers: [(String,String)]? = nil) {
+        self.headers = headers
+        self.timeout = timeout
+    }
+}

Sources/Exporters/OpenTelemetryProtocol/metric/OtelpMetricExporter.swift renamed to Sources/Exporters/OpenTelemetryProtocol/metric/OtlpMetricExporter.swift

@@ -6,18 +6,28 @@
 import Foundation
 import GRPC
 import NIO
+import NIOHPACK
 import OpenTelemetryApi
 import OpenTelemetrySdk
 
-public class OtelpMetricExporter: MetricExporter {
+public class OtlpMetricExporter: MetricExporter {
     let channel: GRPCChannel
     let metricClient: Opentelemetry_Proto_Collector_Metrics_V1_MetricsServiceClient
-    let timeoutNanos: Int64
+    let config : OtlpConfiguration
+    var callOptions : CallOptions? = nil
 
-    public init(channel: GRPCChannel, timeoutNanos: Int64 = 0) {
+
+
+    public init(channel: GRPCChannel, config: OtlpConfiguration = OtlpConfiguration()) {
         self.channel = channel
-        self.timeoutNanos = timeoutNanos
+        self.config = config
         self.metricClient = Opentelemetry_Proto_Collector_Metrics_V1_MetricsServiceClient(channel: self.channel)
+
+        if let headers = EnvVarHeaders.attributes {
+            callOptions = CallOptions(customMetadata: HPACKHeaders(headers))
+        } else if let headers = config.headers {
+            callOptions = CallOptions(customMetadata: HPACKHeaders(headers))
+        }
     }
 
     public func export(metrics: [Metric], shouldCancel: (() -> Bool)?) -> MetricExporterResultCode {
@@ -26,11 +36,11 @@ public class OtelpMetricExporter: MetricExporter {
                 $0.resourceMetrics = MetricsAdapter.toProtoResourceMetrics(metricDataList: metrics)
             }
 
-        if timeoutNanos > 0 {
-            metricClient.defaultCallOptions.timeLimit = TimeLimit.timeout(TimeAmount.nanoseconds(timeoutNanos))
+        if config.timeout > 0 {
+            metricClient.defaultCallOptions.timeLimit = TimeLimit.timeout(TimeAmount.nanoseconds(Int64(config.timeout.toNanoseconds)))
         }
 
-        let export = metricClient.export(exportRequest)
+        let export = metricClient.export(exportRequest, callOptions: callOptions)
 
         do {
             _ = try export.response.wait()

Sources/Exporters/OpenTelemetryProtocol/trace/OtlpTraceExporter.swift

@@ -6,30 +6,37 @@
 import Foundation
 import GRPC
 import NIO
+import NIOHPACK
 import OpenTelemetryApi
 import OpenTelemetrySdk
 
 public class OtlpTraceExporter: SpanExporter {
     let channel: GRPCChannel
     let traceClient: Opentelemetry_Proto_Collector_Trace_V1_TraceServiceClient
-    let timeoutNanos: Int64
+    let config : OtlpConfiguration
+    var callOptions : CallOptions? = nil
 
-    public init(channel: GRPCChannel, timeoutNanos: Int64 = 0) {
+    public init(channel: GRPCChannel, config: OtlpConfiguration = OtlpConfiguration()) {
         self.channel = channel
         traceClient = Opentelemetry_Proto_Collector_Trace_V1_TraceServiceClient(channel: channel)
-        self.timeoutNanos = timeoutNanos
+        self.config = config
+        if let headers = EnvVarHeaders.attributes {
+            callOptions = CallOptions(customMetadata: HPACKHeaders(headers))
+        } else if let headers = config.headers {
+            callOptions = CallOptions(customMetadata: HPACKHeaders(headers))
+        }
     }
 
     public func export(spans: [SpanData]) -> SpanExporterResultCode {
         let exportRequest = Opentelemetry_Proto_Collector_Trace_V1_ExportTraceServiceRequest.with {
             $0.resourceSpans = SpanAdapter.toProtoResourceSpans(spanDataList: spans)
         }
 
-        if timeoutNanos > 0 {
-            traceClient.defaultCallOptions.timeLimit = TimeLimit.timeout(TimeAmount.nanoseconds(timeoutNanos))
+        if config.timeout > 0 {
+            traceClient.defaultCallOptions.timeLimit = TimeLimit.timeout(TimeAmount.nanoseconds(Int64(config.timeout.toNanoseconds)))
         }
 
-        let export = traceClient.export(exportRequest)
+        let export = traceClient.export(exportRequest, callOptions: callOptions)
 
         do {
             // wait() on the response to stop the program from exiting before the response is received.

Sources/OpenTelemetrySdk/Metrics/MeterProviderBuilder.swift

@@ -0,0 +1,41 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import Foundation
+
+import OpenTelemetryApi
+
+public class MeterProviderBuilder {
+    public private(set) var resource : Resource = Resource()
+    public private(set) var metricExporter : MetricExporter = NoopMetricExporter()
+    public private(set) var metricPushInterval : TimeInterval = MeterProviderSdk.defaultPushInterval
+    public private(set) var metricProcessor : MetricProcessor = NoopMetricProcessor()
+
+    public init() {}
+
+    public func with(processor: MetricProcessor) -> Self {
+        self.metricProcessor = processor
+        return self
+    }
+
+    public func with(exporter: MetricExporter) -> Self {
+        self.metricExporter = exporter
+        return self
+    }
+
+    public func with(pushInterval: TimeInterval) -> Self {
+        self.metricPushInterval = pushInterval
+        return self
+    }
+
+    public func with(resource: Resource) -> Self {
+        self.resource = resource
+        return self
+    }
+
+    public func build() -> MeterProvider {
+        return MeterProviderSdk(metricProcessor:metricProcessor, metricExporter: metricExporter, metricPushInterval: metricPushInterval, resource: resource)
+    }
+}
+

Sources/OpenTelemetrySdk/Trace/TracerProviderBuilder.swift

@@ -0,0 +1,56 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import Foundation
+import OpenTelemetryApi
+
+public class TracerProviderBuilder {
+    public private(set) var clock : Clock = MillisClock()
+    public private(set) var idGenerator : IdGenerator = RandomIdGenerator()
+    public private(set) var resource : Resource = Resource()
+    public private(set) var spanLimits : SpanLimits = SpanLimits()
+    public private(set) var sampler : Sampler = Samplers.parentBased(root: Samplers.alwaysOn)
+    public private(set) var spanProcessors : [SpanProcessor] = []
+
+    public init() {}
+
+    public func with(clock: Clock) -> Self {
+        self.clock = clock
+        return self
+    }
+
+    public func with(idGenerator: IdGenerator) -> Self {
+        self.idGenerator = idGenerator
+        return self
+    }
+
+    public func with(resource: Resource) -> Self {
+        self.resource = resource
+        return self
+    }
+    public func with(spanLimits: SpanLimits) -> Self {
+        self.spanLimits = spanLimits
+        return self
+    }
+
+    public func with(sampler: Sampler) -> Self {
+        self.sampler = sampler
+        return self
+    }
+
+    public func add(spanProcessor: SpanProcessor) -> Self {
+        spanProcessors.append(spanProcessor)
+        return self
+    }
+
+    public func add(spanProcessors: [SpanProcessor]) -> Self {
+        self.spanProcessors.append(contentsOf: spanProcessors)
+        return self
+    }
+
+    public func build() -> TracerProviderSdk {
+        return TracerProviderSdk(clock: clock, idGenerator: idGenerator, resource: resource, spanLimits: spanLimits, sampler: sampler, spanProcessors: spanProcessors)
+    }
+}

Tests/ExportersTests/OpenTelemetryProtocol/OtlpMetricExporterTests.swift

@@ -28,7 +28,7 @@ class OtlpMetricExproterTests: XCTestCase {
 
     func testExport() {
         let metric = generateSumMetric()
-        let exporter = OtelpMetricExporter(channel: channel)
+        let exporter = OtlpMetricExporter(channel: channel)
         let result = exporter.export(metrics: [metric]) { () -> Bool in
             false
         }
@@ -39,7 +39,7 @@ class OtlpMetricExproterTests: XCTestCase {
 
     func testGaugeExport() {
         let metric = generateGaugeMetric()
-        let exporter = OtelpMetricExporter(channel: channel)
+        let exporter = OtlpMetricExporter(channel: channel)
 
         let result = exporter.export(metrics: [metric]) { () -> Bool in
             false
@@ -62,7 +62,7 @@ class OtlpMetricExproterTests: XCTestCase {
         for _ in 0 ..< 10 {
             metrics.append(generateSumMetric())
         }
-        let exporter = OtelpMetricExporter(channel: channel)
+        let exporter = OtlpMetricExporter(channel: channel)
         let result = exporter.export(metrics: metrics) { () -> Bool in
             false
         }
@@ -73,7 +73,7 @@ class OtlpMetricExproterTests: XCTestCase {
 
     func testExportAfterShutdown() {
         let metric = generateSumMetric()
-        let exporter = OtelpMetricExporter(channel: channel)
+        let exporter = OtlpMetricExporter(channel: channel)
         exporter.shutdown()
         let result = exporter.export(metrics: [metric]) { () -> Bool in
             false
@@ -83,7 +83,7 @@ class OtlpMetricExproterTests: XCTestCase {
 
     func testExportCancelled() {
         fakeCollector.returnedStatus = GRPCStatus(code: .cancelled, message: nil)
-        let exporter = OtelpMetricExporter(channel: channel)
+        let exporter = OtlpMetricExporter(channel: channel)
         let metric = generateSumMetric()
         let result = exporter.export(metrics: [metric]) { () -> Bool in
             false