feat: support log events (#932)

* feat: support log event.name

* preserve log record data in session processor

* upgrade to swift-core 2.2.0

* remove event name

* use default logger

Author: williazz

Package.resolved

@@ -29,7 +29,7 @@ let package = Package(
     .executable(name: "StableMetricSample", targets: ["StableMetricSample"])
   ],
   dependencies: [
-    .package(url: "https://github.com/open-telemetry/opentelemetry-swift-core.git", from: "2.1.1"),
+    .package(url: "https://github.com/open-telemetry/opentelemetry-swift-core.git", from: "2.2.0"),
     .package(url: "https://github.com/apple/swift-nio.git", from: "2.86.0"),
     .package(url: "https://github.com/grpc/grpc-swift.git", exact: "1.26.1"),
     .package(url: "https://github.com/apple/swift-protobuf.git", from: "1.30.0"),

Package.swift

@@ -46,6 +46,10 @@ public class LogRecordAdapter {
 
     protoLogRecord.timeUnixNano = logRecord.timestamp.timeIntervalSince1970.toNanoseconds
 
+    if let eventName = logRecord.eventName {
+      protoLogRecord.eventName = eventName
+    }
+
     if let body = logRecord.body {
       protoLogRecord.body = CommonAdapter.toProtoAnyValue(attributeValue: body)
     }

Sources/Exporters/OpenTelemetryProtocolCommon/logs/LogRecordAdapter.swift

@@ -22,7 +22,7 @@ public class SessionLogRecordProcessor: LogRecordProcessor {
 
   /// Called when a log record is emitted - adds session attributes and forwards to next processor
   public func onEmit(logRecord: ReadableLogRecord) {
-    var newAttributes = logRecord.attributes
+    var enhancedRecord = logRecord
 
     // For session.start and session.end events, preserve existing session attributes
     if let body = logRecord.body,
@@ -33,23 +33,12 @@ public class SessionLogRecordProcessor: LogRecordProcessor {
     } else {
       // For other log records, add current session attributes
       let session = sessionManager.getSession()
-      newAttributes[SessionConstants.id] = AttributeValue.string(session.id)
+      enhancedRecord.setAttribute(key: SessionConstants.id, value: AttributeValue.string(session.id))
       if let previousId = session.previousId {
-        newAttributes[SessionConstants.previousId] = AttributeValue.string(previousId)
+        enhancedRecord.setAttribute(key: SessionConstants.previousId, value: AttributeValue.string(previousId))
       }
     }
 
-    let enhancedRecord = ReadableLogRecord(
-      resource: logRecord.resource,
-      instrumentationScopeInfo: logRecord.instrumentationScopeInfo,
-      timestamp: logRecord.timestamp,
-      observedTimestamp: logRecord.observedTimestamp,
-      spanContext: logRecord.spanContext,
-      severity: logRecord.severity,
-      body: logRecord.body,
-      attributes: newAttributes
-    )
-
     nextProcessor.onEmit(logRecord: enhancedRecord)
   }
 

Sources/Instrumentation/Sessions/SessionLogRecordProcessor.swift

@@ -42,7 +42,8 @@ class LogRecordAdapterTests: XCTestCase {
                                       spanContext: spanContext,
                                       severity: .fatal,
                                       body: AttributeValue.string("Hello, world"),
-                                      attributes: ["event.name": AttributeValue.string("name"), "event.domain": AttributeValue.string("domain")])
+                                      attributes: ["event.name": AttributeValue.string("name"), "event.domain": AttributeValue.string("domain")],
+                                      eventName: "session.start")
 
     let protoLog = LogRecordAdapter.toProtoLogRecord(logRecord: logRecord)
 
@@ -55,5 +56,6 @@ class LogRecordAdapterTests: XCTestCase {
     XCTAssertEqual(protoLog.traceID, Data(bytes: traceIdBytes, count: 16))
     XCTAssertEqual(protoLog.timeUnixNano, timestamp.timeIntervalSince1970.toNanoseconds)
     XCTAssertEqual(protoLog.attributes.count, 2)
+    XCTAssertEqual(protoLog.eventName, "session.start")
   }
 }

Tests/ExportersTests/OpenTelemetryProtocol/LogRecordAdapterTests.swift

@@ -204,6 +204,53 @@ final class SessionLogRecordProcessorTests: XCTestCase {
     }
   }
 
+  func testDataIsPreserved() {
+    let logRecordWithEventName = ReadableLogRecord(
+      resource: Resource(attributes: [:]),
+      instrumentationScopeInfo: InstrumentationScopeInfo(),
+      timestamp: Date(),
+      observedTimestamp: Date(),
+      spanContext: nil,
+      severity: .info,
+      body: AttributeValue.string("Test log message"),
+      attributes: ["test.key": AttributeValue.string("test.value")],
+      eventName: "user.login"
+    )
+
+    mockSessionManager.sessionId = "test-session-123"
+    logRecordProcessor.onEmit(logRecord: logRecordWithEventName)
+
+    XCTAssertEqual(mockNextProcessor.receivedLogRecords.count, 1)
+    let enhancedRecord = mockNextProcessor.receivedLogRecords[0]
+
+    // Verify all fields are preserved
+    XCTAssertEqual(enhancedRecord.eventName, "user.login", "EventName should be preserved")
+    XCTAssertEqual(enhancedRecord.resource.attributes, logRecordWithEventName.resource.attributes)
+    XCTAssertEqual(enhancedRecord.instrumentationScopeInfo.name, logRecordWithEventName.instrumentationScopeInfo.name)
+    XCTAssertEqual(enhancedRecord.timestamp, logRecordWithEventName.timestamp)
+    XCTAssertEqual(enhancedRecord.observedTimestamp, logRecordWithEventName.observedTimestamp)
+    XCTAssertEqual(enhancedRecord.severity, logRecordWithEventName.severity)
+    XCTAssertEqual(enhancedRecord.body?.description, logRecordWithEventName.body?.description)
+    XCTAssertEqual(enhancedRecord.spanContext, logRecordWithEventName.spanContext)
+    
+    // Verify session attributes were added
+    if case let .string(sessionId) = enhancedRecord.attributes[SessionConstants.id] {
+      XCTAssertEqual(sessionId, "test-session-123")
+    } else {
+      XCTFail("Expected session.id attribute to be added")
+    }
+    
+    // Verify original attributes preserved
+    if case let .string(testValue) = enhancedRecord.attributes["test.key"] {
+      XCTAssertEqual(testValue, "test.value")
+    } else {
+      XCTFail("Expected original attributes to be preserved")
+    }
+    
+    // Verify total attribute count (original + session attributes)
+    XCTAssertEqual(enhancedRecord.attributes.count, 2, "Should have original attribute + session.id")
+  }
+
   func testConcurrentOnEmitThreadSafety() {
     let mockNextProcessor = MockLogRecordProcessor()
     let expectation = XCTestExpectation(description: "Concurrent processing")