Fix thread race conditions in new metrics (#871)

* Updated SDK locks to use a more similar to Mutex approach, which allows being used in the future when we transition to Swift 6
* Removed inout to properties that dont need it.
* Updated some properties to constants when mutability is not needed
* Cleaned also most warnings

Author: nachoBonafonte

Examples/OTLP HTTP Exporter/main.swift

@@ -75,20 +75,20 @@
   createSpans()
 
 // Metrics
-let otlpMetricExporter = StableOtlpHTTPMetricExporter(endpoint: defaultStableOtlpHTTPMetricsEndpoint())
-let meterProvider = StableMeterProviderSdk.builder()
+let otlpMetricExporter = OtlpHttpMetricExporter(endpoint: defaultOtlpHttpMetricsEndpoint())
+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")]
 

Sources/Importers/SwiftMetricsShim/Locks.swift

@@ -200,3 +200,29 @@ extension ReadWriteLock {
     try withWriterLock(body)
   }
 }
+
+public final class Locked<Value> : @unchecked Sendable {
+    
+    private var internalValue: Value
+    
+    private let lock = Lock()
+    
+    public var protectedValue: Value {
+        get {
+            lock.withLock { internalValue }
+        }
+        _modify {
+            lock.lock()
+            defer { lock.unlock() }
+            yield &internalValue
+        }
+    }
+    
+    public init(initialValue: Value) {
+        self.internalValue = initialValue
+    }
+    
+    public func locking<T>(_ block: (inout Value) throws -> T) rethrows -> T {
+        try lock.withLock { try block(&internalValue) }
+    }
+}

Sources/Importers/SwiftMetricsShim/MetricHandlers.swift

@@ -9,21 +9,21 @@ import OpenTelemetryApi
 class SwiftCounterMetric: CounterHandler, SwiftMetric {
   let metricName: String
   let metricType: MetricType = .counter
-  var counter: LongCounter
+  let counter: Locked<LongCounter>
   let labels: [String: AttributeValue]
 
   required init(name: String,
                 labels: [String: String],
                 meter: any OpenTelemetryApi.Meter) {
     metricName = name
-    counter = meter.counterBuilder(name: name).build()
+    counter = .init(initialValue: meter.counterBuilder(name: name).build())
     self.labels = labels.mapValues { value in
       return AttributeValue.string(value)
     }
   }
 
   func increment(by: Int64) {
-    counter.add(value: Int(by), attributes: labels)
+    counter.protectedValue.add(value: Int(by), attributes: labels)
   }
 
   func reset() {}

Sources/OpenTelemetrySdk/Common/ComponentRegistry.swift

@@ -12,7 +12,7 @@ class ComponentRegistry<T> {
   private var componentByNameVersion = [String: [String: T]]()
   private var componentByNameSchema = [String: [String: T]]()
   private var componentByNameVersionSchema = [String: [String: [String: T]]]()
-  private var allComponents = [T]()
+  private let allComponents = ReadWriteLocked<[T]>(initialValue: [])
 
   private let builder: (InstrumentationScopeInfo) -> T
 
@@ -84,11 +84,13 @@ class ComponentRegistry<T> {
 
   private func buildComponent(_ scope: InstrumentationScopeInfo) -> T {
     let component = builder(scope)
-    allComponents.append(component)
+    allComponents.writeLocking {
+      $0.append(component)
+    }
     return component
   }
 
   public func getComponents() -> [T] {
-    return [T](allComponents)
+    return [T](allComponents.protectedValue)
   }
 }

Sources/OpenTelemetrySdk/Internal/Locks.swift

@@ -163,7 +163,7 @@ extension ReadWriteLock {
   /// - Parameter body: The block to execute while holding the lock.
   /// - Returns: The value returned by the block.
   @inlinable
-  func withReaderLock<T>(_ body: () throws -> T) rethrows -> T {
+  public func withReaderLock<T>(_ body: () throws -> T) rethrows -> T {
     lockRead()
     defer {
       self.unlock()
@@ -180,7 +180,7 @@ extension ReadWriteLock {
   /// - Parameter body: The block to execute while holding the lock.
   /// - Returns: The value returned by the block.
   @inlinable
-  func withWriterLock<T>(_ body: () throws -> T) rethrows -> T {
+  public func withWriterLock<T>(_ body: () throws -> T) rethrows -> T {
     lockWrite()
     defer {
       self.unlock()
@@ -200,3 +200,61 @@ extension ReadWriteLock {
     try withWriterLock(body)
   }
 }
+
+public final class Locked<Value> : @unchecked Sendable {
+    
+    private var internalValue: Value
+    
+    private let lock = Lock()
+    
+    public var protectedValue: Value {
+        get {
+            lock.withLock { internalValue }
+        }
+        _modify {
+            lock.lock()
+            defer { lock.unlock() }
+            yield &internalValue
+        }
+    }
+    
+    public init(initialValue: Value) {
+        self.internalValue = initialValue
+    }
+    
+    public func locking<T>(_ block: (inout Value) throws -> T) rethrows -> T {
+        try lock.withLock { try block(&internalValue) }
+    }
+}
+
+public final class ReadWriteLocked<Value> : @unchecked Sendable {
+    
+    private var internalValue: Value
+    
+    private let rwlock = ReadWriteLock()
+    
+    public var protectedValue: Value {
+        get {
+            rwlock.withReaderLock { internalValue }
+        }
+        _modify {
+            rwlock.lockWrite()
+            defer { rwlock.unlock() }
+            yield &internalValue
+        }
+    }
+    
+    public init(initialValue: Value) {
+        self.internalValue = initialValue
+    }
+    
+    public func readLocking<T>(_ block: (Value) throws -> T) rethrows -> T {
+        try rwlock.withReaderLock{ try block(internalValue) }
+    }
+    
+    public func writeLocking<T>(_ block: (inout Value) throws -> T) rethrows -> T {
+        try rwlock.withWriterLock{ try block(&internalValue) }
+    }
+    
+    
+}

Sources/OpenTelemetrySdk/Logs/LoggerBuilderSdk.swift

@@ -7,8 +7,8 @@ import Foundation
 import OpenTelemetryApi
 
 public class LoggerBuilderSdk: LoggerBuilder {
-  private var registry: ComponentRegistry<LoggerSdk>
-  private var instrumentationScopeName: String
+  private let registry: ComponentRegistry<LoggerSdk>
+  private let instrumentationScopeName: String
   private var eventDomain: String?
   private var schemaUrl: String?
   private var attributes: [String: AttributeValue]?

Sources/OpenTelemetrySdk/Logs/LoggerProviderSdk.swift

@@ -8,7 +8,7 @@ import OpenTelemetryApi
 
 public class LoggerProviderSdk: LoggerProvider {
   private var sharedState: LoggerSharedState
-  private var loggerRegistry: ComponentRegistry<LoggerSdk>
+  private let loggerRegistry: ComponentRegistry<LoggerSdk>
   public init(clock: Clock = MillisClock(),
               resource: Resource = EnvVarResource.get(),
               logLimits: LogLimits = LogLimits(),

Sources/OpenTelemetrySdk/Metrics/DoubleCounterMeterBuilderSdk.swift

@@ -7,14 +7,14 @@ import Foundation
 import OpenTelemetryApi
 
 public class DoubleCounterMeterBuilderSdk: InstrumentBuilder, DoubleCounterBuilder {
-  init(meterProviderSharedState: inout MeterProviderSharedState,
-       meterSharedState: inout MeterSharedState,
+  init(meterProviderSharedState: MeterProviderSharedState,
+       meterSharedState: MeterSharedState,
        name: String,
        description: String,
        unit: String) {
     super.init(
-      meterProviderSharedState: &meterProviderSharedState,
-      meterSharedState: &meterSharedState,
+      meterProviderSharedState: meterProviderSharedState,
+      meterSharedState: meterSharedState,
       type: .counter,
       valueType: .double,
       description: description,

Sources/OpenTelemetrySdk/Metrics/DoubleGaugeBuilderSdk.swift

@@ -7,10 +7,10 @@ import Foundation
 import OpenTelemetryApi
 
 public class DoubleGaugeBuilderSdk: InstrumentBuilder, DoubleGaugeBuilder {
-  init(meterProviderSharedState: inout MeterProviderSharedState, meterSharedState: inout MeterSharedState, name: String) {
+  init(meterProviderSharedState: MeterProviderSharedState, meterSharedState: MeterSharedState, name: String) {
     super.init(
-      meterProviderSharedState: &meterProviderSharedState,
-      meterSharedState: &meterSharedState,
+      meterProviderSharedState: meterProviderSharedState,
+      meterSharedState: meterSharedState,
       type: .observableGauge,
       valueType: .double,
       description: "",

Sources/OpenTelemetrySdk/Metrics/DoubleHistogramMeterBuilderSdk.swift

@@ -7,14 +7,14 @@ import Foundation
 import OpenTelemetryApi
 
 public class DoubleHistogramMeterBuilderSdk: InstrumentBuilder, DoubleHistogramBuilder {
-  init(meterProviderSharedState: inout MeterProviderSharedState,
-       meterSharedState: inout MeterSharedState,
+  init(meterProviderSharedState: MeterProviderSharedState,
+       meterSharedState: MeterSharedState,
        name: String,
        description: String = "",
        unit: String = "") {
     super.init(
-      meterProviderSharedState: &meterProviderSharedState,
-      meterSharedState: &meterSharedState,
+      meterProviderSharedState: meterProviderSharedState,
+      meterSharedState: meterSharedState,
       type: .histogram,
       valueType: .double,
       description: description,