added unit tests and fixed bugs

Author: bryce-b

Sources/OpenTelemetrySdk/Common/ComponentRegistry.swift

@@ -0,0 +1,81 @@
+//
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+// 
+
+import Foundation
+import OpenTelemetryApi
+
+class ComponentRegistry<T> {
+    private var lock = Lock()
+    private var componentByName = [String: 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 builder : (InstrumentationScopeInfo) -> T
+    
+    init(_ builder : @escaping (InstrumentationScopeInfo) -> T){
+        self.builder = builder
+        
+    }
+    
+    public func get(name: String, version: String? = nil, schemaUrl : String? = nil) -> T {
+        lock.lock()
+        defer {
+            lock.unlock()
+        }
+        if let version = version, let schemaUrl = schemaUrl {
+            if componentByNameVersionSchema[name] == nil {
+                componentByNameVersionSchema[name] = [String: [String: T]]()
+            }
+            
+            if componentByNameVersionSchema[name]![version] == nil {
+                componentByNameVersionSchema[name]![version] = [String:T]()
+            }
+            
+            if componentByNameVersionSchema[name]![version]![schemaUrl] == nil {
+                componentByNameVersionSchema[name]![version]![schemaUrl] = buildComponent(InstrumentationScopeInfo(name: name, version:version, schemaUrl: schemaUrl))
+            }
+            return componentByNameVersionSchema[name]![version]![schemaUrl]!
+        } else if let version = version {
+            if componentByNameVersion[name] == nil {
+                componentByNameVersion[name] = [String: T]()
+            }
+            
+            if componentByNameVersion[name]![version] == nil {
+                componentByNameVersion[name]![version] = buildComponent(InstrumentationScopeInfo(name:name, version:version))
+            }
+            
+            return componentByNameVersion[name]![version]!
+            
+        } else if let schemaUrl = schemaUrl {
+            if componentByNameSchema[name] == nil {
+                componentByNameSchema[name] = [String:T]()
+            }
+            
+            if componentByNameSchema[name]![schemaUrl] == nil {
+                componentByNameSchema[name]![schemaUrl] = buildComponent(InstrumentationScopeInfo(name: name, schemaUrl: schemaUrl))
+            }
+            
+            return componentByNameSchema[name]![schemaUrl]!
+            
+        } else {
+            if componentByName[name] == nil {
+               componentByName[name] = buildComponent(InstrumentationScopeInfo(name: name))
+            }
+            return componentByName[name]!
+        }
+    }
+    
+    private func buildComponent(_ scope: InstrumentationScopeInfo) -> T {
+        let component = builder(scope)
+        allComponents.append(component)
+        return component
+    }
+    
+    public func getComponents() -> [T] {
+        return [T](allComponents)
+    }
+}

Sources/OpenTelemetrySdk/Logs/ComponentRegistry.swift

@@ -9,6 +9,10 @@ public class InMemoryLogRecordExporter : LogRecordExporter {
     private var finishedLogRecords = [ReadableLogRecord]()
     private var isRunning = true
 
+    public func getFinishedLogRecords() -> [ReadableLogRecord] {
+        return finishedLogRecords
+    }
+    
     public func export(logRecords: [ReadableLogRecord]) -> ExportResult {
         guard isRunning else {
             return .failure

Sources/OpenTelemetrySdk/Logs/Export/InMemoryLogRecordExporter.swift

@@ -0,0 +1,38 @@
+//
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+// 
+
+import Foundation
+
+public class MultiLogRecordExporter : LogRecordExporter {
+    var logRecordExporters : [LogRecordExporter]
+
+    public init(logRecordExporters: [LogRecordExporter]) {
+        self.logRecordExporters = logRecordExporters
+    }
+    
+    public func export(logRecords: [ReadableLogRecord]) -> ExportResult {
+        var result = ExportResult.success
+        logRecordExporters.forEach {
+            result.mergeResultCode(newResultCode: $0.export(logRecords: logRecords))
+        }
+        return result
+    }
+    
+    public func shutdown() {
+        logRecordExporters.forEach {
+            $0.shutdown()
+        }
+    }
+    
+    public func forceFlush() -> ExportResult {
+        var result = ExportResult.success
+        logRecordExporters.forEach {
+            result.mergeResultCode(newResultCode: $0.forceFlush())
+        }
+        return result
+    }
+    
+    
+}

Sources/OpenTelemetrySdk/Logs/Export/MultiLogRecordExporter.swift

@@ -8,8 +8,8 @@ import Foundation
 public struct LogLimits {
     static public let defaultMaxAttributeCount = 128
     static public let defaultMaxAtributeLength = Int.max
-    private let maxAttributeCount : Int
-    private let maxAttributeLength : Int
+    public let maxAttributeCount : Int
+    public let maxAttributeLength : Int
 
     public init(maxAttributeCount: Int = Self.defaultMaxAttributeCount , maxAttributeLength: Int = Self.defaultMaxAtributeLength) {
         self.maxAttributeCount = maxAttributeCount

Sources/OpenTelemetrySdk/Logs/LogLimits.swift

@@ -19,7 +19,7 @@ public class LogRecordBuilderSdk : EventBuilder {
     private var observedTimestamp : Date?
     private var body : String?
     private var severity: Severity?
-    private var attributes = [String:AttributeValue]()
+    private var attributes : AttributesDictionary
     private var spanContext : SpanContext?
 
 
@@ -29,6 +29,7 @@ public class LogRecordBuilderSdk : EventBuilder {
         limits = sharedState.logLimits
         self.includeSpanContext = includeSpanContext
         self.instrumentationScope = instrumentationScope
+        attributes = AttributesDictionary(capacity: sharedState.logLimits.maxAttributeCount, valueLengthLimit: sharedState.logLimits.maxAttributeLength)
     }
 
     public func setObservedTimestamp(_ observed: Date) -> Self {
@@ -37,7 +38,7 @@ public class LogRecordBuilderSdk : EventBuilder {
     }
 
     public func setSpanContext(_ context: OpenTelemetryApi.SpanContext) -> Self {
-        self.spanContext = spanContext
+        self.spanContext = context
 
         return self
     }
@@ -53,7 +54,7 @@ public class LogRecordBuilderSdk : EventBuilder {
     }
 
     public func setAttributes(_ attributes: [String : OpenTelemetryApi.AttributeValue]) -> Self {
-        self.attributes = attributes
+        self.attributes.updateValues(attributes: attributes)
         return self
     }
 
@@ -72,7 +73,7 @@ public class LogRecordBuilderSdk : EventBuilder {
                                                                                  spanContext: spanContext,
                                                                                  severity: severity,
                                                                                  body: body,
-                                                                                 attributes: attributes))
+                                                                                 attributes: attributes.attributes))
     }
 
 

Sources/OpenTelemetrySdk/Logs/LogRecordBuilderSdk.swift

@@ -23,7 +23,7 @@ public class LoggerSdk : OpenTelemetryApi.Logger {
     public func eventBuilder(name: String) -> OpenTelemetryApi.EventBuilder {
         guard let eventDomain = self.eventDomain else {
             os_log("Events cannot be emitted from Logger without an event domain. Use `LoggerBuilder.setEventDomain(_ domain: String) when obtaining a Logger.")
-            return DefaultLoggerProvider.instance.loggerBuilder(instrumentationScopeName: "unused").setEventDomain("unused").setAttributes(["event.domain": AttributeValue.string("unused"), "event.name": AttributeValue.string(name)]) as! EventBuilder
+            return DefaultLoggerProvider.instance.loggerBuilder(instrumentationScopeName: "unused").setEventDomain("unused").setAttributes(["event.domain": AttributeValue.string("unused"), "event.name": AttributeValue.string(name)]).build().eventBuilder(name: "unused")
         }
         return LogRecordBuilderSdk(sharedState: sharedState, instrumentationScope: instrumentationScope, includeSpanContext: true).setAttributes(["event.domain": AttributeValue.string(eventDomain),
                                                                                                                                                   "event.name": AttributeValue.string(name)])

Sources/OpenTelemetrySdk/Logs/LoggerSdk.swift

@@ -12,12 +12,14 @@ public struct AttributesDictionary {
     var attributes: [String: AttributeValue]
     var keys: [String]
     private var capacity: Int
+    private var valueLengthLimit : Int
     private var recordedAttributes: Int
 
-    public init(capacity: Int) {
+    public init(capacity: Int, valueLengthLimit: Int = Int.max) {
         attributes = [String: AttributeValue]()
         keys = [String]()
         recordedAttributes = 0
+        self.valueLengthLimit = valueLengthLimit
         self.capacity = capacity
     }
 
@@ -35,7 +37,24 @@ public struct AttributesDictionary {
     }
 
     @discardableResult public mutating func updateValue(value: AttributeValue, forKey key: String) -> AttributeValue? {
-        let oldValue = attributes.updateValue(value, forKey: key)
+        var attributedValue = value
+        switch value {
+        case let .string(v):
+            if v.count > valueLengthLimit {
+                attributedValue = AttributeValue.string(String(v.prefix(valueLengthLimit)))
+            }
+            break
+        case let .stringArray(v):
+            var strArr = [String]()
+            v.forEach { string in
+                strArr.append(String(string.prefix(valueLengthLimit)))
+            }
+            attributedValue = AttributeValue.stringArray(strArr)
+            break
+        default:
+            break
+        }
+        let oldValue = attributes.updateValue(attributedValue, forKey: key)
         if oldValue == nil {
             recordedAttributes += 1
             keys.append(key)

Sources/OpenTelemetrySdk/Trace/AttributesDictionary.swift

@@ -0,0 +1,39 @@
+//
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+// 
+
+import Foundation
+@testable import OpenTelemetrySdk
+import XCTest
+
+class ComponentRegistryTests : XCTestCase {
+    
+    
+    func testComponentRegistry() {
+        let registry = ComponentRegistry<String> { instrumentationScope in
+            return instrumentationScope.name + (instrumentationScope.version ?? "") + (instrumentationScope.schemaUrl ?? "")
+        }
+        
+        let item1 = registry.get(name: "one")
+        let item2 = registry.get(name: "one", version: "1")
+        let item3 = registry.get(name:"one",version: "1", schemaUrl: "https://opentelemetry.io/schemas/1.15.0")
+        let item4 = registry.get(name: "one", schemaUrl: "https://opentelemetry.io/schemas/1.15.0")
+        
+        XCTAssertNotIdentical(item2 as AnyObject, item1 as AnyObject)
+        XCTAssertNotIdentical(item1 as AnyObject, item3 as AnyObject)
+        XCTAssertNotIdentical(item2 as AnyObject, item3 as AnyObject)
+        XCTAssertNotIdentical(item4 as AnyObject, item1 as AnyObject)
+        XCTAssertNotIdentical(item4 as AnyObject, item2 as AnyObject)
+        XCTAssertNotIdentical(item4 as AnyObject, item3 as AnyObject)
+        
+        XCTAssertIdentical(registry.get(name: "one") as AnyObject, item1 as AnyObject)
+        XCTAssertIdentical(registry.get(name: "one", version: "1") as AnyObject, item2 as AnyObject)
+        XCTAssertIdentical(registry.get(name:"one",version: "1", schemaUrl: "https://opentelemetry.io/schemas/1.15.0") as AnyObject, item3 as AnyObject)
+        XCTAssertIdentical(registry.get(name: "one", schemaUrl: "https://opentelemetry.io/schemas/1.15.0") as AnyObject, item4 as AnyObject)
+        
+        
+        
+        
+    }
+}