Added MetricSdkProcessor

Author: bryce-b

Sources/Exporters/OpenTelemetryProtocol/metric/MetricsAdapter.swift

@@ -127,8 +127,7 @@ struct MetricsAdapter {
                 var protoDataPoint = Opentelemetry_Proto_Metrics_V1_IntHistogramDataPoint()
                 protoDataPoint.sum = Int64(summaryData.sum)
                 protoDataPoint.count = UInt64(summaryData.count)
-//                protoDataPoint.explicitBounds = [summaryData.min, summaryData.max]
-                
+                protoDataPoint.bucketCounts = [UInt64(summaryData.min), UInt64(summaryData.max)]
                 protoDataPoint.startTimeUnixNano = summaryData.startTimestamp.timeIntervalSince1970.toNanoseconds
                 protoDataPoint.timeUnixNano = summaryData.timestamp.timeIntervalSince1970.toNanoseconds
 

Sources/OpenTelemetrySdk/Metrics/Configuration/MeterSdkProvider.swift

@@ -35,10 +35,7 @@ public class MeterSdkProvider: MeterProvider {
                 metricExporter: MetricExporter,
                 metricPushInterval: TimeInterval = MeterSdkProvider.defaultPushInterval,
                 resource: Resource = EnvVarResource.resource) {
-       self.meterSharedState = MeterSharedState(metricProcessor: metricProcessor,
-                                                metricExporter: metricExporter,
-                                                metricPushInterval: metricPushInterval,
-                                                resource: resource)
+        self.meterSharedState = MeterSharedState(metricProcessor:metricProcessor, metricPushInterval: metricPushInterval, resource: resource)
 
         defaultMeter = MeterSdk(meterSharedState: self.meterSharedState, instrumentationLibraryInfo: InstrumentationLibraryInfo())
 

Sources/OpenTelemetrySdk/Metrics/Configuration/MeterSharedState.swift

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

Sources/OpenTelemetrySdk/Metrics/Export/MetricSdkProcessor.swift

@@ -0,0 +1,54 @@
+// 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
+
+public class MetricSdkProcessor : MetricProcessor {
+    private let lock : Lock
+    var metrics : [Metric]
+    
+    public init() {
+        metrics = [Metric]()
+        lock = Lock()
+    }
+    
+    /// 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.
+    public func finishCollectionCycle() -> [Metric] {
+        lock.lock()
+        defer {
+            lock.unlock()
+        }
+        return metrics
+    }
+    
+    /// Process the metric. This method is called once every collection interval.
+    /// - Parameters:
+    ///   - metric: the metric record.
+    public func process(metric: Metric) {
+        lock.lock()
+        defer {
+            lock.unlock()
+        }
+
+        metrics.append(metric)
+        
+    }
+
+    
+}

Tests/OpenTelemetrySdkTests/Metrics/PushControllerTests.swift

@@ -38,7 +38,7 @@ final class PushControllerTests: XCTestCase {
         // Setup 2 meters whose Collect will increment the collect count.
         var meter1CollectCount = 0
         var meter2CollectCount = 0
-        let meterSharedState = MeterSharedState(metricProcessor: testProcessor, metricExporter: NoopMetricExporter(), metricPushInterval: MeterSdkProvider.defaultPushInterval, resource: Resource())
+        let meterSharedState = MeterSharedState(metricProcessor: testProcessor, metricPushInterval: MeterSdkProvider.defaultPushInterval, resource: Resource())
 
         let meterInstrumentationLibrary1 = InstrumentationLibraryInfo(name:"meter1")