Refactored metric APIs

- Made MeterSdkProvider init mimic the TraceProvider init

        I decided to change the MetricSdkProvider.init method to take shared state objects as parameters,
        since this is how the TraceProvider operates. Alternatively, I could have move the default values
        into the MeterSharedState construction, but that would require making the NoopMetricProcessor &
        NoopMetricExporter public, which I'm not against, but seemed intentionally private.

- replaced MeterRegisteryKey with InstrumentationLibraryInfo

- Injected Resource into the MetricSdk stack
        I followed the same pattern as with the Trace Sdk.

Author: bryce-b

Examples/Datadog Sample/main.swift

@@ -81,8 +81,7 @@ func childSpan() {
 func testMetrics() {
     let processor = UngroupedBatcher()
 
-    let state = MeterSharedState(metricProcessor: processor, metricExporter: datadogExporter, metricPushInterval: 0.1)
-    let meterProvider = MeterSdkProvider(meterSharedState: state)
+    let meterProvider = MeterSdkProvider(metricProcessor: processor, metricExporter: datadogExporter, metricPushInterval: 0.1)
 
     let meter = meterProvider.get(instrumentationName: "MyMeter")
 

Examples/Prometheus Sample/main.swift

@@ -34,8 +34,8 @@ DispatchQueue.global(qos: .default).async {
 
 let processor = UngroupedBatcher()
 
-let state = MeterSharedState(metricProcessor: processor, metricExporter: promExporter, metricPushInterval: 0.1)
-let meterProvider = MeterSdkProvider(meterSharedState: state)
+
+let meterProvider = MeterSdkProvider(metricProcessor: processor, metricExporter: promExporter, metricPushInterval: 0.1)
 
 var meter = meterProvider.get(instrumentationName: "MyMeter")
 

Sources/OpenTelemetrySdk/Metrics/Configuration/MeterSdkProvider.swift

@@ -18,41 +18,40 @@ import OpenTelemetryApi
 
 public class MeterSdkProvider: MeterProvider {
     private let lock = Lock()
-    private let defaultPushInterval: TimeInterval = 60
+    static public let defaultPushInterval: TimeInterval = 60
 
-    var meterRegistry = [MeterRegistryKey: MeterSdk]()
+    var meterRegistry = [InstrumentationLibraryInfo: MeterSdk]()
 
-    let metricProcessor: MetricProcessor
-    let metricExporter: MetricExporter
+    var meterSharedState : MeterSharedState
     var pushMetricController: PushMetricController!
     var defaultMeter: MeterSdk
 
     public convenience init() {
-        self.init(meterSharedState: MeterSharedState())
+        self.init(metricProcessor: NoopMetricProcessor(),
+                  metricExporter: NoopMetricExporter())
     }
+    
+    public init(metricProcessor: MetricProcessor,
+                metricExporter: MetricExporter,
+                metricPushInterval: TimeInterval = MeterSdkProvider.defaultPushInterval,
+                resource: Resource = EnvVarResource.resource) {
+       self.meterSharedState = MeterSharedState(metricProcessor: metricProcessor,
+                                                metricExporter: metricExporter,
+                                                metricPushInterval: metricPushInterval,
+                                                resource: resource)
 
-    public init(meterSharedState: MeterSharedState) {
-        metricProcessor = meterSharedState.metricProcessor ?? NoopMetricProcessor()
-        metricExporter = meterSharedState.metricExporter ?? NoopMetricExporter()
+        defaultMeter = MeterSdk(meterSharedState: self.meterSharedState, instrumentationLibraryInfo: InstrumentationLibraryInfo())
 
-        defaultMeter = MeterSdk(meterName: "", metricProcessor: metricProcessor)
-
-        let defaultPushInterval = self.defaultPushInterval
         pushMetricController = PushMetricController(
             meterProvider: self,
             metricProcessor: metricProcessor,
             metricExporter: metricExporter,
-            pushInterval: meterSharedState.metricPushInterval ?? defaultPushInterval) {
+            pushInterval: meterSharedState.metricPushInterval) {
             false
         }
     }
 
-    public static func create(configure: (MeterSharedState) -> Void) -> MeterSdkProvider {
-        let builder = MeterSharedState()
-        configure(builder)
 
-        return MeterSdkProvider(meterSharedState: builder)
-    }
 
     public func get(instrumentationName: String, instrumentationVersion: String? = nil) -> Meter {
         if instrumentationName.isEmpty {
@@ -63,16 +62,16 @@ public class MeterSdkProvider: MeterProvider {
         defer {
             lock.unlock()
         }
-        let key = MeterRegistryKey(name: instrumentationName, version: instrumentationVersion)
-        var meter: MeterSdk! = meterRegistry[key]
+        let instrumentationLibraryInfo  = InstrumentationLibraryInfo(name: instrumentationName, version: instrumentationVersion)
+        var meter: MeterSdk! = meterRegistry[instrumentationLibraryInfo]
         if meter == nil {
-            meter = MeterSdk(meterName: instrumentationName, metricProcessor: metricProcessor)
-            meterRegistry[key] = meter!
+            meter = MeterSdk(meterSharedState: self.meterSharedState, instrumentationLibraryInfo: instrumentationLibraryInfo)
+            meterRegistry[instrumentationLibraryInfo] = meter!
         }
         return meter!
     }
 
-    func getMeters() -> [MeterRegistryKey: MeterSdk] {
+    func getMeters() -> [InstrumentationLibraryInfo: MeterSdk] {
         lock.lock()
         defer {
             lock.unlock()
@@ -88,8 +87,3 @@ public class MeterSdkProvider: MeterProvider {
         return labels
     }
 }
-
-struct MeterRegistryKey: Hashable {
-    var name: String
-    var version: String?
-}

Sources/OpenTelemetrySdk/Metrics/Configuration/MeterSharedState.swift

@@ -17,15 +17,20 @@ import Foundation
 
 public struct MeterSharedState {
     /// Configures metric processor. (aka batcher).
-    public private(set) var metricProcessor: MetricProcessor?
+    public private(set) var metricProcessor: MetricProcessor
     /// Configures Metric Exporter.
-    public private(set) var metricExporter: MetricExporter?
+    public private(set) var metricExporter: MetricExporter
     /// Sets the push interval.
-    public private(set) var metricPushInterval: TimeInterval?
+    public private(set) var metricPushInterval: TimeInterval
+    public private(set) var resource: Resource
 
-    public init(metricProcessor: MetricProcessor? = nil, metricExporter: MetricExporter? = nil, metricPushInterval: TimeInterval? = nil) {
+    public init(metricProcessor: MetricProcessor,
+                metricExporter: MetricExporter,
+                metricPushInterval: TimeInterval ,
+                resource: Resource) {
         self.metricProcessor = metricProcessor
         self.metricExporter = metricExporter
         self.metricPushInterval = metricPushInterval
+        self.resource = resource
     }
 }

Sources/OpenTelemetrySdk/Metrics/Export/Metric.swift

@@ -17,15 +17,17 @@ import Foundation
 
 public struct Metric {
     public private(set) var namespace: String
+    public private(set) var resource: Resource
     public private(set) var name: String
     public private(set) var description: String
     public private(set) var aggregationType: AggregationType
     public internal(set) var data = [MetricData]()
 
-    init(namespace: String, name: String, desc: String, type: AggregationType) {
+    init(namespace: String, name: String, desc: String, type: AggregationType, resource: Resource) {
         self.namespace = namespace
         self.name = name
         description = desc
         aggregationType = type
+        self.resource = resource
     }
 }

Sources/OpenTelemetrySdk/Metrics/Export/MetricProcessor.swift

@@ -15,20 +15,20 @@
 
 import Foundation
 
-public protocol MetricProcessor: AnyObject {
+public protocol MetricProcessor {
     /// Finish the current collection cycle and return the metrics it holds.
     /// This is called at the end of one collection cycle by the Controller.
     /// MetricProcessor can use this to clear its Metrics (in case of stateless).
     /// - Returns: The list of metrics from this cycle, which are to be exported.
     func finishCollectionCycle() -> [Metric]
 
     /// Process the metric. This method is called once every collection interval.
-    /// - PArameters:
+    /// - Parameters:
     ///   - metric: the metric record.
     func process(metric: Metric)
 }
 
-class NoopMetricProcessor: MetricProcessor {
+struct NoopMetricProcessor: MetricProcessor {
     func finishCollectionCycle() -> [Metric] {
         return [Metric]()
     }

Sources/OpenTelemetrySdk/Metrics/MeterSdk.swift

@@ -20,6 +20,7 @@ class MeterSdk: Meter {
     fileprivate let collectLock = Lock()
     let meterName: String
     var metricProcessor: MetricProcessor
+    var resource: Resource
 
     var intCounters = [String: CounterMetricSdk<Int>]()
     var doubleCounters = [String: CounterMetricSdk<Double>]()
@@ -28,9 +29,10 @@ class MeterSdk: Meter {
     var intObservers = [String: IntObserverMetricSdk]()
     var doubleObservers = [String: DoubleObserverMetricSdk]()
 
-    init(meterName: String, metricProcessor: MetricProcessor) {
-        self.meterName = meterName
-        self.metricProcessor = metricProcessor
+    init(meterSharedState: MeterSharedState, instrumentationLibraryInfo: InstrumentationLibraryInfo) {
+        self.meterName = instrumentationLibraryInfo.name
+        self.resource = meterSharedState.resource
+        self.metricProcessor = meterSharedState.metricProcessor
     }
 
     func getLabelSet(labels: [String: String]) -> LabelSet {
@@ -45,7 +47,7 @@ class MeterSdk: Meter {
                 let metricName = counter.key
                 let counterInstrument = counter.value
 
-                var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.intSum)
+                var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.intSum, resource: resource)
 
                 counterInstrument.boundInstruments.forEach { boundInstrument in
                     let labelSet = boundInstrument.key
@@ -80,7 +82,7 @@ class MeterSdk: Meter {
                 let metricName = counter.key
                 let counterInstrument = counter.value
 
-                var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.doubleSum)
+                var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.doubleSum, resource: resource)
 
                 counterInstrument.boundInstruments.forEach { boundInstrument in
                     let labelSet = boundInstrument.key
@@ -115,7 +117,7 @@ class MeterSdk: Meter {
             intMeasures.forEach { measure in
                 let metricName = measure.key
                 let measureInstrument = measure.value
-                var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.intSummary)
+            var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.intSummary, resource:resource)
                 measureInstrument.boundInstruments.forEach { boundInstrument in
                     let labelSet = boundInstrument.key
                     let aggregator = boundInstrument.value.getAggregator()
@@ -130,7 +132,7 @@ class MeterSdk: Meter {
             doubleMeasures.forEach { measure in
                 let metricName = measure.key
                 let measureInstrument = measure.value
-                var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.doubleSummary)
+                var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.doubleSummary, resource: resource)
                 measureInstrument.boundInstruments.forEach { boundInstrument in
                     let labelSet = boundInstrument.key
                     let aggregator = boundInstrument.value.getAggregator()
@@ -145,7 +147,7 @@ class MeterSdk: Meter {
             intObservers.forEach { observer in
                 let metricName = observer.key
                 let observerInstrument = observer.value
-                var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.intSum)
+                var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.intSum, resource: resource)
                 observerInstrument.invokeCallback()
 
                 observerInstrument.observerHandles.forEach { handle in
@@ -162,7 +164,7 @@ class MeterSdk: Meter {
             doubleObservers.forEach { observer in
                 let metricName = observer.key
                 let observerInstrument = observer.value
-                var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.doubleSum)
+                var metric = Metric(namespace: meterName, name: metricName, desc: meterName + metricName, type: AggregationType.doubleSum, resource: resource)
                 observerInstrument.invokeCallback()
 
                 observerInstrument.observerHandles.forEach { handle in

Tests/ExportersTests/DatadogExporter/DatadogExporterTests.swift

@@ -130,8 +130,10 @@ class DatadogExporterTests: XCTestCase {
 
         let datadogExporter = try! DatadogExporter(config: exporterConfiguration)
 
-        let state = MeterSharedState(metricProcessor: UngroupedBatcher(), metricExporter: datadogExporter, metricPushInterval: 0.1)
-        let meter = MeterSdkProvider(meterSharedState: state).get(instrumentationName: "MyMeter")
+
+        let meter = MeterSdkProvider(metricProcessor: UngroupedBatcher(),
+                                     metricExporter: datadogExporter,
+                                     metricPushInterval: 0.1).get(instrumentationName: "MyMeter")
 
         let testCounter = meter.createIntCounter(name: "MyCounter")
 

Tests/ExportersTests/Prometheus/PrometheusExporterTests.swift

@@ -70,9 +70,8 @@ class PrometheusExporterTests: XCTestCase {
     }
 
     private func collectMetrics(simpleProcessor: UngroupedBatcher, exporter: MetricExporter) {
-        let state = MeterSharedState(metricProcessor: simpleProcessor, metricExporter: exporter, metricPushInterval: metricPushIntervalSec)
 
-        let meterProvider = MeterSdkProvider(meterSharedState: state)
+        let meterProvider = MeterSdkProvider(metricProcessor: simpleProcessor, metricExporter: exporter, metricPushInterval: metricPushIntervalSec)
 
         let meter = meterProvider.get(instrumentationName: "library1")
 

Tests/OpenTelemetrySdkTests/Metrics/CounterTests.swift

@@ -21,8 +21,7 @@ final class CounterTests: XCTestCase {
     public func testIntCounterBoundInstrumentsStatusUpdatedCorrectlySingleThread() {
         let testProcessor = TestMetricProcessor()
 
-        let meterSharedState = MeterSharedState(metricProcessor: testProcessor)
-        let meter = MeterSdkProvider(meterSharedState: meterSharedState).get(instrumentationName: "library1") as! MeterSdk
+        let meter = MeterSdkProvider(metricProcessor: testProcessor, metricExporter: NoopMetricExporter()).get(instrumentationName: "library1") as! MeterSdk
         let testCounter = meter.createIntCounter(name: "testCounter").internalCounter as! CounterMetricSdk<Int>
 
         let labels1 = ["dim1": "value1"]
@@ -82,8 +81,7 @@ final class CounterTests: XCTestCase {
 
     public func testDoubleCounterBoundInstrumentsStatusUpdatedCorrectlySingleThread() {
         let testProcessor = TestMetricProcessor()
-        let meterSharedState = MeterSharedState(metricProcessor: testProcessor)
-        let meter = MeterSdkProvider(meterSharedState: meterSharedState).get(instrumentationName: "library1") as! MeterSdk
+        let meter = MeterSdkProvider(metricProcessor: testProcessor, metricExporter: NoopMetricExporter()).get(instrumentationName: "library1") as! MeterSdk
         let testCounter = meter.createDoubleCounter(name: "testCounter").internalCounter as! CounterMetricSdk<Double>
 
         let labels1 = ["dim1": "value1"]
@@ -143,8 +141,7 @@ final class CounterTests: XCTestCase {
 
     public func testIntCounterBoundInstrumentsStatusUpdatedCorrectlyMultiThread() {
         let testProcessor = TestMetricProcessor()
-        let meterSharedState = MeterSharedState(metricProcessor: testProcessor)
-        let meter = MeterSdkProvider(meterSharedState: meterSharedState).get(instrumentationName: "library1") as! MeterSdk
+        let meter = MeterSdkProvider(metricProcessor: testProcessor, metricExporter: NoopMetricExporter()).get(instrumentationName: "library1") as! MeterSdk
         let testCounter = meter.createIntCounter(name: "testCounter").internalCounter as! CounterMetricSdk<Int>
 
         let labels1 = ["dim1": "value1"]