Added OTLP-HTTP Exporter for the Stable metrics (#476)

jhoongo · web-flow · commit f7061def9c4d · 2023-10-26T17:34:28.000+02:00
diff --git a/Sources/Exporters/OpenTelemetryProtocolCommon/metric/MetricsAdapter.swift b/Sources/Exporters/OpenTelemetryProtocolCommon/metric/MetricsAdapter.swift
@@ -103,8 +103,9 @@ public enum MetricsAdapter {
         var protoDataPoint = Opentelemetry_Proto_Metrics_V1_NumberDataPoint()
         injectPointData(protoNumberPoint: &protoDataPoint, pointData: gaugeData)
         protoDataPoint.value = .asInt(Int64(gaugeData.value))
-        protoMetric.sum.aggregationTemporality = .cumulative
+        protoMetric.sum.aggregationTemporality = stableMetric.data.aggregationTemporality.convertToProtoEnum()
         protoMetric.sum.dataPoints.append(protoDataPoint)
+        protoMetric.sum.isMonotonic = stableMetric.isMonotonic
       case .DoubleGauge:
         guard let gaugeData = $0 as? DoublePointData else {
           break
@@ -120,8 +121,9 @@ public enum MetricsAdapter {
         var protoDataPoint = Opentelemetry_Proto_Metrics_V1_NumberDataPoint()
         injectPointData(protoNumberPoint: &protoDataPoint, pointData: gaugeData)
         protoDataPoint.value = .asDouble(gaugeData.value)
-        protoMetric.sum.aggregationTemporality = .cumulative
+        protoMetric.sum.aggregationTemporality = stableMetric.data.aggregationTemporality.convertToProtoEnum()
         protoMetric.sum.dataPoints.append(protoDataPoint)
+        protoMetric.sum.isMonotonic = stableMetric.isMonotonic
       case .Summary:
         guard let summaryData = $0 as? SummaryPointData else {
           break
@@ -147,7 +149,7 @@ public enum MetricsAdapter {
         protoDataPoint.count = UInt64(histogramData.count)
         protoDataPoint.explicitBounds = histogramData.boundaries.map { Double($0) }
         protoDataPoint.bucketCounts = histogramData.counts.map { UInt64($0) }
-        protoMetric.histogram.aggregationTemporality = .cumulative
+        protoMetric.histogram.aggregationTemporality = stableMetric.data.aggregationTemporality.convertToProtoEnum()
         protoMetric.histogram.dataPoints.append(protoDataPoint)
       case .ExponentialHistogram:
         // TODO: implement
@@ -394,3 +396,14 @@ public enum MetricsAdapter {
     return protoMetric
   }
 }
+
+extension AggregationTemporality {
+  func convertToProtoEnum() -> Opentelemetry_Proto_Metrics_V1_AggregationTemporality {
+    switch self {
+    case .cumulative:
+      return .cumulative
+    case .delta:
+      return .delta
+    }
+  }
+}
diff --git a/Sources/Exporters/OpenTelemetryProtocolHttp/StableOtlpHTTPExporterBase.swift b/Sources/Exporters/OpenTelemetryProtocolHttp/StableOtlpHTTPExporterBase.swift
@@ -0,0 +1,49 @@
+//
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+import SwiftProtobuf
+import OpenTelemetryProtocolExporterCommon
+
+public class StableOtlpHTTPExporterBase {
+  let endpoint: URL
+  let httpClient: HTTPClient
+  let envVarHeaders: [(String, String)]?
+  let config: OtlpConfiguration
+  
+  // MARK: - Init
+  
+  public init(endpoint: URL, config: OtlpConfiguration = OtlpConfiguration(), useSession: URLSession? = nil, envVarHeaders: [(String, String)]? = EnvVarHeaders.attributes) {
+    self.envVarHeaders = envVarHeaders
+    self.endpoint = endpoint
+    self.config = config
+    if let providedSession = useSession {
+      self.httpClient = HTTPClient(session: providedSession)
+    } else {
+      self.httpClient = HTTPClient()
+    }
+  }
+  
+  public func createRequest(body: Message, endpoint: URL) -> URLRequest {
+    var request = URLRequest(url: endpoint)
+    
+    for header in config.headers ?? [] {
+      request.addValue(header.1, forHTTPHeaderField: header.0)
+    }
+    
+    do {
+      request.httpMethod = "POST"
+      request.httpBody = try body.serializedData()
+      request.setValue(Headers.getUserAgentHeader(), forHTTPHeaderField: Constants.HTTP.userAgent)
+      request.setValue("application/x-protobuf", forHTTPHeaderField: "Content-Type")
+    } catch {
+      print("Error serializing body: \(error)")
+    }
+    
+    return request
+  }
+  
+  public func shutdown(explicitTimeout: TimeInterval? = nil) { }
+}
diff --git a/Sources/Exporters/OpenTelemetryProtocolHttp/metric/StableOtlpHTTPMetricExporter.swift b/Sources/Exporters/OpenTelemetryProtocolHttp/metric/StableOtlpHTTPMetricExporter.swift
@@ -0,0 +1,95 @@
+//
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+import OpenTelemetrySdk
+import OpenTelemetryProtocolExporterCommon
+
+public func defaultStableOtlpHTTPMetricsEndpoint() -> URL {
+  URL(string: "http://localhost:4318/v1/metrics")!
+}
+
+public class StableOtlpHTTPMetricExporter: StableOtlpHTTPExporterBase, StableMetricExporter {
+  var aggregationTemporalitySelector: AggregationTemporalitySelector
+  var defaultAggregationSelector: DefaultAggregationSelector
+  
+  var pendingMetrics: [StableMetricData] = []
+  
+  // MARK: - Init
+  
+  public init(endpoint: URL, config: OtlpConfiguration = OtlpConfiguration(), aggregationTemporalitySelector: AggregationTemporalitySelector = AggregationTemporality.alwaysCumulative(), defaultAggregationSelector: DefaultAggregationSelector = AggregationSelector.instance, useSession: URLSession? = nil, envVarHeaders: [(String, String)]? = EnvVarHeaders.attributes) {
+    
+    self.aggregationTemporalitySelector = aggregationTemporalitySelector
+    self.defaultAggregationSelector = defaultAggregationSelector
+    
+    super.init(endpoint: endpoint, config: config, useSession: useSession, envVarHeaders: envVarHeaders)
+  }
+  
+  
+  // MARK: - StableMetricsExporter
+  
+  public func export(metrics : [StableMetricData]) -> ExportResult {
+    pendingMetrics.append(contentsOf: metrics)
+    let sendingMetrics = pendingMetrics
+    pendingMetrics = []
+    let body = Opentelemetry_Proto_Collector_Metrics_V1_ExportMetricsServiceRequest.with {
+      $0.resourceMetrics = MetricsAdapter.toProtoResourceMetrics(stableMetricData: sendingMetrics)
+    }
+    
+    let request = createRequest(body: body, endpoint: endpoint)
+    httpClient.send(request: request) { [weak self] result in
+      switch result {
+      case .success(_):
+        break
+      case .failure(let error):
+        self?.pendingMetrics.append(contentsOf: sendingMetrics)
+        print(error)
+      }
+    }
+    
+    return .success
+  }
+  
+  public func flush() -> ExportResult {
+    var exporterResult: ExportResult = .success
+    
+    if !pendingMetrics.isEmpty {
+      let body = Opentelemetry_Proto_Collector_Metrics_V1_ExportMetricsServiceRequest.with {
+        $0.resourceMetrics = MetricsAdapter.toProtoResourceMetrics(stableMetricData: pendingMetrics)
+      }
+      let semaphore = DispatchSemaphore(value: 0)
+      let request = createRequest(body: body, endpoint: endpoint)
+      httpClient.send(request: request) { result in
+        switch result {
+        case .success(_):
+          break
+        case .failure(let error):
+          print(error)
+          exporterResult = .failure
+        }
+        semaphore.signal()
+      }
+      semaphore.wait()
+    }
+    
+    return exporterResult
+  }
+  
+  public func shutdown() -> ExportResult {
+    return .success
+  }
+  
+  // MARK: - AggregationTemporalitySelectorProtocol
+  
+  public func getAggregationTemporality(for instrument: OpenTelemetrySdk.InstrumentType) -> OpenTelemetrySdk.AggregationTemporality {
+    return aggregationTemporalitySelector.getAggregationTemporality(for: instrument)
+  }
+  
+  // MARK: - DefaultAggregationSelector
+  
+  public func getDefaultAggregation(for instrument: OpenTelemetrySdk.InstrumentType) -> OpenTelemetrySdk.Aggregation {
+    return defaultAggregationSelector.getDefaultAggregation(for: instrument)
+  }
+}
diff --git a/Sources/OpenTelemetrySdk/Metrics/Stable/Aggregation/AggregationTemporality.swift b/Sources/OpenTelemetrySdk/Metrics/Stable/Aggregation/AggregationTemporality.swift
@@ -14,7 +14,7 @@ public class AggregationTemporalitySelector : AggregationTemporalitySelectorProt
         return aggregationTemporalitySelector(instrument)
     }
     
-    init(aggregationTemporalitySelector: @escaping (InstrumentType) -> AggregationTemporality) {
+    public init(aggregationTemporalitySelector: @escaping (InstrumentType) -> AggregationTemporality) {
         self.aggregationTemporalitySelector = aggregationTemporalitySelector
     }
     
@@ -31,6 +31,12 @@ public enum AggregationTemporality {
         }
         
     }
+  
+    public static func alwaysDelta() -> AggregationTemporalitySelector {
+        return AggregationTemporalitySelector() { (type) in
+            .delta
+        }
+    }
     
     public static func deltaPreferred() -> AggregationTemporalitySelector {
         return  AggregationTemporalitySelector() { type in
diff --git a/Sources/OpenTelemetrySdk/Metrics/Stable/Aggregation/DoubleSumAggregator.swift b/Sources/OpenTelemetrySdk/Metrics/Stable/Aggregation/DoubleSumAggregator.swift
@@ -22,7 +22,7 @@ public class DoubleSumAggregator: SumAggregator, StableAggregator {
     }
     
     public func toMetricData(resource: Resource, scope: InstrumentationScopeInfo, descriptor: MetricDescriptor, points: [PointData], temporality: AggregationTemporality) -> StableMetricData {
-        StableMetricData.createDoubleSum(resource: resource, instrumentationScopeInfo: scope, name: descriptor.instrument.name, description: descriptor.instrument.description, unit: descriptor.instrument.unit, data: StableSumData(aggregationTemporality: temporality, points: points as! [DoublePointData]))
+        StableMetricData.createDoubleSum(resource: resource, instrumentationScopeInfo: scope, name: descriptor.instrument.name, description: descriptor.instrument.description, unit: descriptor.instrument.unit, isMonotonic: self.isMonotonic, data: StableSumData(aggregationTemporality: temporality, points: points as! [DoublePointData]))
     }
     
     init(instrumentDescriptor: InstrumentDescriptor, reservoirSupplier: @escaping () -> ExemplarReservoir) {
diff --git a/Sources/OpenTelemetrySdk/Metrics/Stable/Aggregation/LongSumAggregator.swift b/Sources/OpenTelemetrySdk/Metrics/Stable/Aggregation/LongSumAggregator.swift
@@ -27,7 +27,7 @@ public class LongSumAggregator: SumAggregator, StableAggregator {
     }
     
     public func toMetricData(resource: Resource, scope: InstrumentationScopeInfo, descriptor: MetricDescriptor, points: [PointData], temporality: AggregationTemporality) -> StableMetricData {
-        StableMetricData.createLongSum(resource: resource, instrumentationScopeInfo: scope, name: descriptor.instrument.name, description: descriptor.instrument.description, unit: descriptor.instrument.unit, data: StableSumData(aggregationTemporality: temporality, points: points as! [LongPointData]))
+        StableMetricData.createLongSum(resource: resource, instrumentationScopeInfo: scope, name: descriptor.instrument.name, description: descriptor.instrument.description, unit: descriptor.instrument.unit, isMonotonic: self.isMonotonic, data: StableSumData(aggregationTemporality: temporality, points: points as! [LongPointData]))
     }
     
     private class Handle: AggregatorHandle {
diff --git a/Sources/OpenTelemetrySdk/Metrics/Stable/Data/StableMetricData.swift b/Sources/OpenTelemetrySdk/Metrics/Stable/Data/StableMetricData.swift
@@ -23,29 +23,33 @@ public struct StableMetricData: Equatable {
     public private(set) var description: String
     public private(set) var unit: String
     public private(set) var type: MetricDataType
+    public private(set) var isMonotonic: Bool
     public private(set) var data: Data
 
-    public static let empty = StableMetricData(resource: Resource.empty, instrumentationScopeInfo: InstrumentationScopeInfo(), name: "", description: "", unit: "", type: .Summary, data: StableMetricData.Data(points: [PointData]()))
+    public static let empty = StableMetricData(resource: Resource.empty, instrumentationScopeInfo: InstrumentationScopeInfo(), name: "", description: "", unit: "", type: .Summary, isMonotonic: false, data: StableMetricData.Data(aggregationTemporality: .cumulative, points: [PointData]()))
 
     public class Data: Equatable {
         public private(set) var points: [PointData]
+        public private(set) var aggregationTemporality: AggregationTemporality
 
-        internal init(points: [PointData]) {
+        internal init(aggregationTemporality: AggregationTemporality, points: [PointData]) {
+            self.aggregationTemporality = aggregationTemporality
             self.points = points
         }
 
         public static func == (lhs: StableMetricData.Data, rhs: StableMetricData.Data) -> Bool {
-            return lhs.points == rhs.points
+            return lhs.points == rhs.points && lhs.aggregationTemporality == rhs.aggregationTemporality
         }
     }
 
-    internal init(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, type: MetricDataType, data: StableMetricData.Data) {
+    internal init(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, type: MetricDataType, isMonotonic: Bool, data: StableMetricData.Data) {
         self.resource = resource
         self.instrumentationScopeInfo = instrumentationScopeInfo
         self.name = name
         self.description = description
         self.unit = unit
         self.type = type
+        self.isMonotonic = isMonotonic
         self.data = data
     }
 
@@ -56,33 +60,34 @@ public struct StableMetricData: Equatable {
             lhs.description == rhs.description &&
             lhs.unit == rhs.unit &&
             lhs.type == rhs.type &&
-            lhs.data.points == rhs.data.points
+            lhs.isMonotonic == rhs.isMonotonic &&
+            lhs.data == rhs.data
     }
 }
 
 extension StableMetricData {
     static func createExponentialHistogram(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableExponentialHistogramData) -> StableMetricData {
-        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .ExponentialHistogram, data: data)
+        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .ExponentialHistogram, isMonotonic: false, data: data)
     }
 
     static func createDoubleGauge(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableGaugeData) -> StableMetricData {
-        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .DoubleGauge, data: data)
+        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .DoubleGauge, isMonotonic: false, data: data)
     }
 
     static func createLongGauge(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableGaugeData) -> StableMetricData {
-        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .LongGauge, data: data)
+        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .LongGauge, isMonotonic: false, data: data)
     }
 
-    static func createDoubleSum(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableSumData) -> StableMetricData {
-        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .DoubleSum, data: data)
+    static func createDoubleSum(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, isMonotonic: Bool, data: StableSumData) -> StableMetricData {
+        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .DoubleSum, isMonotonic: isMonotonic, data: data)
     }
 
-    static func createLongSum(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableSumData) -> StableMetricData {
-        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .LongSum, data: data)
+    static func createLongSum(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, isMonotonic: Bool, data: StableSumData) -> StableMetricData {
+        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .LongSum, isMonotonic: isMonotonic, data: data)
     }
 
     static func createHistogram(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableHistogramData) -> StableMetricData {
-        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .Histogram, data: data)
+        StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .Histogram, isMonotonic: false, data: data)
     }
 
     func isEmpty() -> Bool {
@@ -99,41 +104,31 @@ extension StableMetricData {
 }
 
 public class StableHistogramData: StableMetricData.Data {
-    public private(set) var aggregationTemporality: AggregationTemporality
     init(aggregationTemporality: AggregationTemporality, points: [HistogramPointData]) {
-        self.aggregationTemporality = aggregationTemporality
-        super.init(points: points)
+        super.init(aggregationTemporality: aggregationTemporality, points: points)
     }
 }
 
 public class StableExponentialHistogramData: StableMetricData.Data {
-    public private(set) var aggregationTemporality: AggregationTemporality
-    init(aggregationTemporality: AggregationTemporality, points: [PointData]) {
-        self.aggregationTemporality = aggregationTemporality
-        super.init(points: points)
+    override init(aggregationTemporality: AggregationTemporality, points: [PointData]) {
+        super.init(aggregationTemporality: aggregationTemporality, points: points)
     }
 }
 
 public class StableGaugeData: StableMetricData.Data {
-    public private(set) var aggregationTemporality: AggregationTemporality
-    init(aggregationTemporality: AggregationTemporality, points: [PointData]) {
-        self.aggregationTemporality = aggregationTemporality
-        super.init(points: points)
+    override init(aggregationTemporality: AggregationTemporality, points: [PointData]) {
+        super.init(aggregationTemporality: aggregationTemporality, points: points)
     }
 }
 
 public class StableSumData: StableMetricData.Data {
-    public private(set) var aggregationTemporality: AggregationTemporality
-    init(aggregationTemporality: AggregationTemporality, points: [PointData]) {
-        self.aggregationTemporality = aggregationTemporality
-        super.init(points: points)
+    override init(aggregationTemporality: AggregationTemporality, points: [PointData]) {
+        super.init(aggregationTemporality: aggregationTemporality, points: points)
     }
 }
 
 public class StableSummaryData: StableMetricData.Data {
-    public private(set) var aggregationTemporality: AggregationTemporality
-    init(aggregationTemporality: AggregationTemporality, points: [PointData]) {
-        self.aggregationTemporality = aggregationTemporality
-        super.init(points: points)
+    override init(aggregationTemporality: AggregationTemporality, points: [PointData]) {
+        super.init(aggregationTemporality: aggregationTemporality, points: points)
     }
 }
diff --git a/Tests/ExportersTests/OpenTelemetryProtocol/MetricsAdapterTest.swift b/Tests/ExportersTests/OpenTelemetryProtocol/MetricsAdapterTest.swift
diff --git a/Tests/ExportersTests/OpenTelemetryProtocol/StableOtlpHTTPMetricsExporterTest.swift b/Tests/ExportersTests/OpenTelemetryProtocol/StableOtlpHTTPMetricsExporterTest.swift
diff --git a/Tests/OpenTelemetrySdkTests/Metrics/StableMetrics/Data/StableMetricDataTests.swift b/Tests/OpenTelemetrySdkTests/Metrics/StableMetrics/Data/StableMetricDataTests.swift

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public class AggregationTemporalitySelector : AggregationTemporalitySelectorProt`
`14`	`14`	`return aggregationTemporalitySelector(instrument)`
`15`	`15`	`}`
`16`	`16`
`17`		`- init(aggregationTemporalitySelector: @escaping (InstrumentType) -> AggregationTemporality) {`
	`17`	`+ public init(aggregationTemporalitySelector: @escaping (InstrumentType) -> AggregationTemporality) {`
`18`	`18`	`self.aggregationTemporalitySelector = aggregationTemporalitySelector`
`19`	`19`	`}`
`20`	`20`
`@@ -31,6 +31,12 @@ public enum AggregationTemporality {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`}`
	`34`	`+`
	`35`	`+ public static func alwaysDelta() -> AggregationTemporalitySelector {`
	`36`	`+ return AggregationTemporalitySelector() { (type) in`
	`37`	`+ .delta`
	`38`	`+ }`
	`39`	`+ }`
`34`	`40`
`35`	`41`	`public static func deltaPreferred() -> AggregationTemporalitySelector {`
`36`	`42`	`return AggregationTemporalitySelector() { type in`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public class DoubleSumAggregator: SumAggregator, StableAggregator {`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`public func toMetricData(resource: Resource, scope: InstrumentationScopeInfo, descriptor: MetricDescriptor, points: [PointData], temporality: AggregationTemporality) -> StableMetricData {`
`25`		`- StableMetricData.createDoubleSum(resource: resource, instrumentationScopeInfo: scope, name: descriptor.instrument.name, description: descriptor.instrument.description, unit: descriptor.instrument.unit, data: StableSumData(aggregationTemporality: temporality, points: points as! [DoublePointData]))`
	`25`	`+ StableMetricData.createDoubleSum(resource: resource, instrumentationScopeInfo: scope, name: descriptor.instrument.name, description: descriptor.instrument.description, unit: descriptor.instrument.unit, isMonotonic: self.isMonotonic, data: StableSumData(aggregationTemporality: temporality, points: points as! [DoublePointData]))`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`init(instrumentDescriptor: InstrumentDescriptor, reservoirSupplier: @escaping () -> ExemplarReservoir) {`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public class LongSumAggregator: SumAggregator, StableAggregator {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`public func toMetricData(resource: Resource, scope: InstrumentationScopeInfo, descriptor: MetricDescriptor, points: [PointData], temporality: AggregationTemporality) -> StableMetricData {`
`30`		`- StableMetricData.createLongSum(resource: resource, instrumentationScopeInfo: scope, name: descriptor.instrument.name, description: descriptor.instrument.description, unit: descriptor.instrument.unit, data: StableSumData(aggregationTemporality: temporality, points: points as! [LongPointData]))`
	`30`	`+ StableMetricData.createLongSum(resource: resource, instrumentationScopeInfo: scope, name: descriptor.instrument.name, description: descriptor.instrument.description, unit: descriptor.instrument.unit, isMonotonic: self.isMonotonic, data: StableSumData(aggregationTemporality: temporality, points: points as! [LongPointData]))`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`private class Handle: AggregatorHandle {`
Original file line number	Diff line number	Diff line change
`@@ -23,29 +23,33 @@ public struct StableMetricData: Equatable {`
`23`	`23`	`public private(set) var description: String`
`24`	`24`	`public private(set) var unit: String`
`25`	`25`	`public private(set) var type: MetricDataType`
	`26`	`+ public private(set) var isMonotonic: Bool`
`26`	`27`	`public private(set) var data: Data`
`27`	`28`
`28`		`- public static let empty = StableMetricData(resource: Resource.empty, instrumentationScopeInfo: InstrumentationScopeInfo(), name: "", description: "", unit: "", type: .Summary, data: StableMetricData.Data(points: [PointData]()))`
	`29`	`+ public static let empty = StableMetricData(resource: Resource.empty, instrumentationScopeInfo: InstrumentationScopeInfo(), name: "", description: "", unit: "", type: .Summary, isMonotonic: false, data: StableMetricData.Data(aggregationTemporality: .cumulative, points: [PointData]()))`
`29`	`30`
`30`	`31`	`public class Data: Equatable {`
`31`	`32`	`public private(set) var points: [PointData]`
	`33`	`+ public private(set) var aggregationTemporality: AggregationTemporality`
`32`	`34`
`33`		`- internal init(points: [PointData]) {`
	`35`	`+ internal init(aggregationTemporality: AggregationTemporality, points: [PointData]) {`
	`36`	`+ self.aggregationTemporality = aggregationTemporality`
`34`	`37`	`self.points = points`
`35`	`38`	`}`
`36`	`39`
`37`	`40`	`public static func == (lhs: StableMetricData.Data, rhs: StableMetricData.Data) -> Bool {`
`38`		`- return lhs.points == rhs.points`
	`41`	`+ return lhs.points == rhs.points && lhs.aggregationTemporality == rhs.aggregationTemporality`
`39`	`42`	`}`
`40`	`43`	`}`
`41`	`44`
`42`		`- internal init(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, type: MetricDataType, data: StableMetricData.Data) {`
	`45`	`+ internal init(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, type: MetricDataType, isMonotonic: Bool, data: StableMetricData.Data) {`
`43`	`46`	`self.resource = resource`
`44`	`47`	`self.instrumentationScopeInfo = instrumentationScopeInfo`
`45`	`48`	`self.name = name`
`46`	`49`	`self.description = description`
`47`	`50`	`self.unit = unit`
`48`	`51`	`self.type = type`
	`52`	`+ self.isMonotonic = isMonotonic`
`49`	`53`	`self.data = data`
`50`	`54`	`}`
`51`	`55`
`@@ -56,33 +60,34 @@ public struct StableMetricData: Equatable {`
`56`	`60`	`lhs.description == rhs.description &&`
`57`	`61`	`lhs.unit == rhs.unit &&`
`58`	`62`	`lhs.type == rhs.type &&`
`59`		`- lhs.data.points == rhs.data.points`
	`63`	`+ lhs.isMonotonic == rhs.isMonotonic &&`
	`64`	`+ lhs.data == rhs.data`
`60`	`65`	`}`
`61`	`66`	`}`
`62`	`67`
`63`	`68`	`extension StableMetricData {`
`64`	`69`	`static func createExponentialHistogram(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableExponentialHistogramData) -> StableMetricData {`
`65`		`- StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .ExponentialHistogram, data: data)`
	`70`	`+ StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .ExponentialHistogram, isMonotonic: false, data: data)`
`66`	`71`	`}`
`67`	`72`
`68`	`73`	`static func createDoubleGauge(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableGaugeData) -> StableMetricData {`
`69`		`- StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .DoubleGauge, data: data)`
	`74`	`+ StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .DoubleGauge, isMonotonic: false, data: data)`
`70`	`75`	`}`
`71`	`76`
`72`	`77`	`static func createLongGauge(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableGaugeData) -> StableMetricData {`
`73`		`- StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .LongGauge, data: data)`
	`78`	`+ StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .LongGauge, isMonotonic: false, data: data)`
`74`	`79`	`}`
`75`	`80`
`76`		`- static func createDoubleSum(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableSumData) -> StableMetricData {`
`77`		`- StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .DoubleSum, data: data)`
	`81`	`+ static func createDoubleSum(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, isMonotonic: Bool, data: StableSumData) -> StableMetricData {`
	`82`	`+ StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .DoubleSum, isMonotonic: isMonotonic, data: data)`
`78`	`83`	`}`
`79`	`84`
`80`		`- static func createLongSum(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableSumData) -> StableMetricData {`
`81`		`- StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .LongSum, data: data)`
	`85`	`+ static func createLongSum(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, isMonotonic: Bool, data: StableSumData) -> StableMetricData {`
	`86`	`+ StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .LongSum, isMonotonic: isMonotonic, data: data)`
`82`	`87`	`}`
`83`	`88`
`84`	`89`	`static func createHistogram(resource: Resource, instrumentationScopeInfo: InstrumentationScopeInfo, name: String, description: String, unit: String, data: StableHistogramData) -> StableMetricData {`
`85`		`- StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .Histogram, data: data)`
	`90`	`+ StableMetricData(resource: resource, instrumentationScopeInfo: instrumentationScopeInfo, name: name, description: description, unit: unit, type: .Histogram, isMonotonic: false, data: data)`
`86`	`91`	`}`
`87`	`92`
`88`	`93`	`func isEmpty() -> Bool {`
`@@ -99,41 +104,31 @@ extension StableMetricData {`
`99`	`104`	`}`
`100`	`105`
`101`	`106`	`public class StableHistogramData: StableMetricData.Data {`
`102`		`- public private(set) var aggregationTemporality: AggregationTemporality`
`103`	`107`	`init(aggregationTemporality: AggregationTemporality, points: [HistogramPointData]) {`
`104`		`- self.aggregationTemporality = aggregationTemporality`
`105`		`- super.init(points: points)`
	`108`	`+ super.init(aggregationTemporality: aggregationTemporality, points: points)`
`106`	`109`	`}`
`107`	`110`	`}`
`108`	`111`
`109`	`112`	`public class StableExponentialHistogramData: StableMetricData.Data {`
`110`		`- public private(set) var aggregationTemporality: AggregationTemporality`
`111`		`- init(aggregationTemporality: AggregationTemporality, points: [PointData]) {`
`112`		`- self.aggregationTemporality = aggregationTemporality`
`113`		`- super.init(points: points)`
	`113`	`+ override init(aggregationTemporality: AggregationTemporality, points: [PointData]) {`
	`114`	`+ super.init(aggregationTemporality: aggregationTemporality, points: points)`
`114`	`115`	`}`
`115`	`116`	`}`
`116`	`117`
`117`	`118`	`public class StableGaugeData: StableMetricData.Data {`
`118`		`- public private(set) var aggregationTemporality: AggregationTemporality`
`119`		`- init(aggregationTemporality: AggregationTemporality, points: [PointData]) {`
`120`		`- self.aggregationTemporality = aggregationTemporality`
`121`		`- super.init(points: points)`
	`119`	`+ override init(aggregationTemporality: AggregationTemporality, points: [PointData]) {`
	`120`	`+ super.init(aggregationTemporality: aggregationTemporality, points: points)`
`122`	`121`	`}`
`123`	`122`	`}`
`124`	`123`
`125`	`124`	`public class StableSumData: StableMetricData.Data {`
`126`		`- public private(set) var aggregationTemporality: AggregationTemporality`
`127`		`- init(aggregationTemporality: AggregationTemporality, points: [PointData]) {`
`128`		`- self.aggregationTemporality = aggregationTemporality`
`129`		`- super.init(points: points)`
	`125`	`+ override init(aggregationTemporality: AggregationTemporality, points: [PointData]) {`
	`126`	`+ super.init(aggregationTemporality: aggregationTemporality, points: points)`
`130`	`127`	`}`
`131`	`128`	`}`
`132`	`129`
`133`	`130`	`public class StableSummaryData: StableMetricData.Data {`
`134`		`- public private(set) var aggregationTemporality: AggregationTemporality`
`135`		`- init(aggregationTemporality: AggregationTemporality, points: [PointData]) {`
`136`		`- self.aggregationTemporality = aggregationTemporality`
`137`		`- super.init(points: points)`
	`131`	`+ override init(aggregationTemporality: AggregationTemporality, points: [PointData]) {`
	`132`	`+ super.init(aggregationTemporality: aggregationTemporality, points: points)`
`138`	`133`	`}`
`139`	`134`	`}`