removed 'stable' term from metrics, left deprecated typealiases (#852)

Author: bryce-b

.github/workflows/Create-Release-PR.yml

@@ -25,7 +25,7 @@ jobs:
        import Foundation
        
        extension Resource {
-         public static let OTEL_SWIFT_SDK_VERSION : String = "${{ inputs.new_version }}"
+         public static let OTEL_SWIFT_SDK_VERSION: String = "${{ inputs.new_version }}"
        }
        ' > Sources/OpenTelemetrySdk/Version.swift
     - name: update Podspec

Examples/OTLP Exporter/main.swift

@@ -82,20 +82,20 @@
   createSpans()
 
   // Metrics
-let otlpMetricExporter = StableOtlpMetricExporter(channel: client)
-let meterProvider = StableMeterProviderSdk.builder()
+let otlpMetricExporter = OtlpMetricExporter(channel: client)
+let meterProvider = MeterProviderSdk.builder()
   .registerMetricReader(
-    reader: StablePeriodicMetricReaderBuilder(
+    reader: PeriodicMetricReaderBuilder(
       exporter: otlpMetricExporter).setInterval(timeInterval: 60)
       .build()
   )
   .registerView(
     selector: InstrumentSelector.builder().setInstrument(name: ".*").build(),
-      view: StableView.builder().build()
+      view: View.builder().build()
     )
   .build()
 
-OpenTelemetry.registerStableMeterProvider(meterProvider: meterProvider)
+OpenTelemetry.registerMeterProvider(meterProvider: meterProvider)
 
 let labels1 = ["dim1": AttributeValue.string("value1")]
 

Examples/Prometheus Sample/main.swift

@@ -28,21 +28,21 @@ DispatchQueue.global(qos: .default).async {
   }
 }
 
-let meterProvider = StableMeterProviderSdk.builder()
+let meterProvider = MeterProviderSdk.builder()
   .registerView(
     selector: InstrumentSelector
       .builder()
       .setInstrument(type: .histogram).build(),
-    view: StableView.builder()
+    view: View.builder()
       .withAggregation(
         aggregation: ExplicitBucketHistogramAggregation(bucketBoundaries: [5, 10, 25])
       ).build()
   )
   .registerMetricReader(
-    reader: StablePeriodicMetricReaderBuilder(exporter: promExporter).build(
+    reader: PeriodicMetricReaderBuilder(exporter: promExporter).build(
     )).build()
 
-OpenTelemetry.registerStableMeterProvider(meterProvider: meterProvider)
+OpenTelemetry.registerMeterProvider(meterProvider: meterProvider)
 
 var meter = meterProvider.get(name: "MyMeter")
 

Examples/Stable Metric Sample/main.swift

@@ -39,27 +39,36 @@ func basicConfiguration() {
 
   // register view will process all instruments using `.*` regex
 
-  OpenTelemetry.registerStableMeterProvider(meterProvider: StableMeterProviderSdk.builder()
-    .registerView(selector: InstrumentSelector.builder().setInstrument(name: ".*").build(), view: StableView.builder().build())
-    .registerMetricReader(reader: StablePeriodicMetricReaderBuilder(exporter: StableOtlpMetricExporter(channel: exporterChannel)).build())
+  OpenTelemetry.registerMeterProvider(
+meterProvider: MeterProviderSdk.builder()
+  .registerView(
+    selector: InstrumentSelector.builder().setInstrument(name: ".*").build(),
+    view: View.builder().build()
+  )
+  .registerMetricReader(
+    reader: PeriodicMetricReaderBuilder(
+      exporter: OtlpMetricExporter(channel: exporterChannel)
+    )
+    .build()
+  )
     .build()
   )
 }
 
 func complexViewConfiguration() {
   let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-  let exporterChannel = ClientConnection.insecure(group: group)
+  _ = ClientConnection.insecure(group: group)
     .connect(host: "localhost", port: 8200)
 
   // The example registers a View that re-configures the Gauge instrument into a sum instrument named "GaugeSum"
 
-  OpenTelemetry.registerStableMeterProvider(
-    meterProvider: StableMeterProviderSdk.builder()
+  OpenTelemetry.registerMeterProvider(
+    meterProvider: MeterProviderSdk.builder()
       .registerView(
         selector: InstrumentSelector.builder()
           .setInstrument(name: "Gauge")
           .build(),
-        view: StableView.builder()
+        view: View.builder()
           .withName(name: "GaugeSum")
           .withAggregation(
             aggregation: Aggregations
@@ -69,7 +78,7 @@ func complexViewConfiguration() {
       )
       .setExemplarFilter(exemplarFilter: AlwaysOnFilter())
       .registerMetricReader(
-        reader: StablePeriodicMetricReaderBuilder(
+        reader: PeriodicMetricReaderBuilder(
           exporter: StdoutMetricExporter(isDebug: true)
         )
         .build()
@@ -81,15 +90,15 @@ func complexViewConfiguration() {
 basicConfiguration()
 
 // creating a new meter & instrument
-let meter = OpenTelemetry.instance.stableMeterProvider?.meterBuilder(name: "MyMeter").build()
-var gaugeBuilder = meter!.gaugeBuilder(name: "Gauge")
+let meter = OpenTelemetry.instance.meterProvider.meterBuilder(name: "MyMeter").build()
+var gaugeBuilder = meter.gaugeBuilder(name: "Gauge")
 
 // observable gauge
 var observableGauge = gaugeBuilder.buildWithCallback { ObservableDoubleMeasurement in
   ObservableDoubleMeasurement.record(value: 1.0, attributes: ["test": AttributeValue.bool(true)])
 }
 
-var gauge = (meter?.gaugeBuilder(name: "Gauge") as! DoubleGaugeBuilderSdk).buildWithCallback { _ in
+var gauge = meter.gaugeBuilder(name: "Gauge").buildWithCallback { _ in
   // noop
 }
 

Sources/Exporters/OpenTelemetryProtocolCommon/common/ExporterMetrics.swift

@@ -18,7 +18,7 @@ public class ExporterMetrics {
   public static let ATTRIBUTE_KEY_TYPE: String = "type"
   public static let ATTRIBUTE_KEY_SUCCESS: String = "success"
 
-  private let meterProvider: any StableMeterProvider
+  private let meterProvider: any MeterProvider
   private let exporterName: String
   private let transportName: String
   private var seenAttrs: [String: AttributeValue] = [:]
@@ -34,7 +34,7 @@ public class ExporterMetrics {
   ///    - exporterName: Could be `span`, `log` etc
   ///    - transportName: Kind of exporter defined by type `TransporterType`
   public init(type: String,
-              meterProvider: any StableMeterProvider,
+              meterProvider: any MeterProvider,
               exporterName: String,
               transportName: TransporterType) {
     self.meterProvider = meterProvider
@@ -72,14 +72,14 @@ public class ExporterMetrics {
    * Create an instance for recording exporter metrics under the meter
    * "io.opentelemetry.exporters." + exporterName + "-transporterType".
    **/
-  private var meter: any StableMeter {
+  private var meter: any Meter {
     meterProvider.get(name: "io.opentelemetry.exporters.\(exporterName)-\(transportName)")
   }
 
   // MARK: - Static function
 
   public static func makeExporterMetric(type: String,
-                                        meterProvider: any StableMeterProvider,
+                                        meterProvider: any MeterProvider,
                                         exporterName: String,
                                         transportName: TransporterType) -> ExporterMetrics {
     ExporterMetrics(type: type,

Sources/Exporters/OpenTelemetryProtocolCommon/metric/MetricsAdapter.swift

@@ -7,8 +7,8 @@ import OpenTelemetryApi
 import OpenTelemetrySdk
 
 public enum MetricsAdapter {
-  public static func toProtoResourceMetrics(stableMetricData: [StableMetricData]) -> [Opentelemetry_Proto_Metrics_V1_ResourceMetrics] {
-    let resourceAndScopeMap = groupByResourceAndScope(stableMetricData: stableMetricData)
+  public static func toProtoResourceMetrics(metricData: [MetricData]) -> [Opentelemetry_Proto_Metrics_V1_ResourceMetrics] {
+    let resourceAndScopeMap = groupByResourceAndScope(metricData: metricData)
 
     var resourceMetrics = [Opentelemetry_Proto_Metrics_V1_ResourceMetrics]()
     resourceAndScopeMap.forEach { resMap in
@@ -30,26 +30,26 @@ public enum MetricsAdapter {
     return resourceMetrics
   }
 
-  private static func groupByResourceAndScope(stableMetricData: [StableMetricData]) -> [Resource: [InstrumentationScopeInfo: [Opentelemetry_Proto_Metrics_V1_Metric]]] {
+  private static func groupByResourceAndScope(metricData: [MetricData]) -> [Resource: [InstrumentationScopeInfo: [Opentelemetry_Proto_Metrics_V1_Metric]]] {
     var results = [Resource: [InstrumentationScopeInfo: [Opentelemetry_Proto_Metrics_V1_Metric]]]()
 
-    stableMetricData.forEach {
-      if let metric = toProtoMetric(stableMetric: $0) {
+    metricData.forEach {
+      if let metric = toProtoMetric(metricData: $0) {
         results[$0.resource, default: [InstrumentationScopeInfo: [Opentelemetry_Proto_Metrics_V1_Metric]]()][$0.instrumentationScopeInfo, default: [Opentelemetry_Proto_Metrics_V1_Metric]()].append(metric)
       }
     }
     return results
   }
 
-  public static func toProtoMetric(stableMetric: StableMetricData) -> Opentelemetry_Proto_Metrics_V1_Metric? {
+  public static func toProtoMetric(metricData: MetricData) -> Opentelemetry_Proto_Metrics_V1_Metric? {
     var protoMetric = Opentelemetry_Proto_Metrics_V1_Metric()
-    protoMetric.name = stableMetric.name
-    protoMetric.unit = stableMetric.unit
-    protoMetric.description_p = stableMetric.description
-    if stableMetric.data.points.isEmpty { return nil }
+    protoMetric.name = metricData.name
+    protoMetric.unit = metricData.unit
+    protoMetric.description_p = metricData.description
+    if metricData.data.points.isEmpty { return nil }
 
-    stableMetric.data.points.forEach {
-      switch stableMetric.type {
+    metricData.data.points.forEach {
+      switch metricData.type {
       case .LongGauge:
         guard let gaugeData = $0 as? LongPointData else {
           break
@@ -65,9 +65,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 = stableMetric.data.aggregationTemporality.convertToProtoEnum()
+        protoMetric.sum.aggregationTemporality = metricData.data.aggregationTemporality.convertToProtoEnum()
         protoMetric.sum.dataPoints.append(protoDataPoint)
-        protoMetric.sum.isMonotonic = stableMetric.isMonotonic
+        protoMetric.sum.isMonotonic = metricData.isMonotonic
       case .DoubleGauge:
         guard let gaugeData = $0 as? DoublePointData else {
           break
@@ -83,9 +83,9 @@ public enum MetricsAdapter {
         var protoDataPoint = Opentelemetry_Proto_Metrics_V1_NumberDataPoint()
         injectPointData(protoNumberPoint: &protoDataPoint, pointData: gaugeData)
         protoDataPoint.value = .asDouble(gaugeData.value)
-        protoMetric.sum.aggregationTemporality = stableMetric.data.aggregationTemporality.convertToProtoEnum()
+        protoMetric.sum.aggregationTemporality = metricData.data.aggregationTemporality.convertToProtoEnum()
         protoMetric.sum.dataPoints.append(protoDataPoint)
-        protoMetric.sum.isMonotonic = stableMetric.isMonotonic
+        protoMetric.sum.isMonotonic = metricData.isMonotonic
       case .Summary:
         guard let summaryData = $0 as? SummaryPointData else {
           break
@@ -113,7 +113,7 @@ public enum MetricsAdapter {
         protoDataPoint.min = Double(histogramData.min)
         protoDataPoint.explicitBounds = histogramData.boundaries.map { Double($0) }
         protoDataPoint.bucketCounts = histogramData.counts.map { UInt64($0) }
-        protoMetric.histogram.aggregationTemporality = stableMetric.data.aggregationTemporality.convertToProtoEnum()
+        protoMetric.histogram.aggregationTemporality = metricData.data.aggregationTemporality.convertToProtoEnum()
         protoMetric.histogram.dataPoints.append(protoDataPoint)
       case .ExponentialHistogram:
         guard let exponentialHistogramData = $0 as? ExponentialHistogramPointData else {
@@ -139,7 +139,7 @@ public enum MetricsAdapter {
         protoDataPoint.positive = positiveBuckets
         protoDataPoint.negative = negativeBuckets
 
-        protoMetric.exponentialHistogram.aggregationTemporality = stableMetric.data.aggregationTemporality.convertToProtoEnum()
+        protoMetric.exponentialHistogram.aggregationTemporality = metricData.data.aggregationTemporality.convertToProtoEnum()
         protoMetric.exponentialHistogram.dataPoints.append(protoDataPoint)
       }
     }

Sources/Exporters/OpenTelemetryProtocolGrpc/metric/StableOtlpMetricExporter.swift renamed to Sources/Exporters/OpenTelemetryProtocolGrpc/metric/OtlpMetricExporter.swift

@@ -11,7 +11,7 @@ import NIOHPACK
 import OpenTelemetryProtocolExporterCommon
 import OpenTelemetrySdk
 
-public class StableOtlpMetricExporter: StableMetricExporter {
+public class OtlpMetricExporter: MetricExporter {
   public func getAggregationTemporality(for instrument: OpenTelemetrySdk.InstrumentType) -> OpenTelemetrySdk.AggregationTemporality {
     return aggregationTemporalitySelector.getAggregationTemporality(for: instrument)
   }
@@ -40,9 +40,9 @@ public class StableOtlpMetricExporter: StableMetricExporter {
     }
   }
 
-  public func export(metrics: [OpenTelemetrySdk.StableMetricData]) -> OpenTelemetrySdk.ExportResult {
+  public func export(metrics: [OpenTelemetrySdk.MetricData]) -> OpenTelemetrySdk.ExportResult {
     let exportRequest = Opentelemetry_Proto_Collector_Metrics_V1_ExportMetricsServiceRequest.with {
-      $0.resourceMetrics = MetricsAdapter.toProtoResourceMetrics(stableMetricData: metrics)
+      $0.resourceMetrics = MetricsAdapter.toProtoResourceMetrics(metricData: metrics)
     }
     if config.timeout > 0 {
       metricClient.defaultCallOptions.timeLimit = TimeLimit.timeout(TimeAmount.nanoseconds(Int64(config.timeout.toNanoseconds)))

Sources/Exporters/OpenTelemetryProtocolHttp/OtlpHttpExporterBase.swift

@@ -7,22 +7,24 @@
   import DataCompression
 #endif
 import Foundation
-import SwiftProtobuf
 import OpenTelemetryProtocolExporterCommon
+import SwiftProtobuf
 #if canImport(FoundationNetworking)
   import FoundationNetworking
 #endif
 
+@available(*, deprecated, renamed: "OtlpHttpExporterBase")
+public typealias StableOtlpHTTPExporterBase = OtlpHttpExporterBase
+
 public class OtlpHttpExporterBase {
   let endpoint: URL
   let httpClient: HTTPClient
   let envVarHeaders: [(String, String)]?
   let config: OtlpConfiguration
 
-  public init(endpoint: URL,
-              config: OtlpConfiguration = OtlpConfiguration(),
-              useSession: URLSession? = nil,
-              envVarHeaders: [(String, String)]? = EnvVarHeaders.attributes) {
+  // 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
@@ -36,6 +38,17 @@ public class OtlpHttpExporterBase {
   public func createRequest(body: Message, endpoint: URL) -> URLRequest {
     var request = URLRequest(url: endpoint)
 
+    if let headers = envVarHeaders {
+      headers.forEach { key, value in
+        request.addValue(value, forHTTPHeaderField: key)
+      }
+
+    } else if let headers = config.headers {
+      headers.forEach { key, value in
+        request.addValue(value, forHTTPHeaderField: key)
+      }
+    }
+
     do {
       let rawData = try body.serializedData()
       request.httpMethod = "POST"
@@ -62,13 +75,13 @@ public class OtlpHttpExporterBase {
           break
         }
       #endif
+
       // Apply final data. Could be compressed or raw
       // but it doesn't matter here
       request.httpBody = compressedData
     } catch {
       print("Error serializing body: \(error)")
     }
-
     return request
   }