feat: App life cycle logging (#48)

App life cycle logging

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Adds app lifecycle auto-logging and refactors log building/queuing via
AppLogBuilder and LDLogRecordBuilder; removes flush APIs and updates
memory/crash handling.
> 
> - **Auto-instrumentation**:
> - **App lifecycle logging**: New `AppLifecycleLogger` emits
`device.app.lifecycle` logs; integrated in `ObservabilityClientFactory`.
> - **Memory warnings**: `MemoryPressureMonitor` now builds logs with
`AppLogBuilder` and yields `ReadableLogRecord` to queue.
> - **Logging pipeline**:
> - Introduce `AppLogBuilder` to construct logs (adds session id, scope,
resource) and `LoggerDecorator` now enqueues built `ReadableLogRecord`.
> - `LDLogRecordBuilder` decoupled from queue; returns
`ReadableLogRecord` via `readableLogRecord()` and removes `emit()`.
> - **API changes**:
> - Remove `flush()` from `Observe`, `LogsApi`, `TracesApi` and
corresponding implementations in `LDObserve`, `ObservabilityClient`, and
usage in `LDCrashFilter`.
> - **Crash reporting**:
> - `LDCrashFilter` now completes without forcing a flush after logging.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
6eb1749. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: abelonogov-ld

Sources/LaunchDarklyObservability/LDObserve.swift

@@ -46,10 +46,6 @@ extension LDObserve: Observe {
         client.recordUpDownCounter(metric: metric)
     }
 
-    public func flush() -> Bool {
-        client.flush()
-    }
-    
     public func recordLog(message: String, severity: Severity, attributes: [String : AttributeValue]) {
         client.recordLog(message: message, severity: severity, attributes: attributes)
     }

Sources/Observability/Api/Observe.swift

@@ -25,9 +25,6 @@ public protocol MetricsApi {
     /// Record an up/down counter metric.
     /// - metric The up/down counter metric to record
     func recordUpDownCounter(metric: Metric)
-    /// Flushes all pending telemetry data (traces, logs, metrics).
-    /// - true if all flush operations succeeded, false otherwise
-    func flush() -> Bool
 }
 
 public protocol LogsApi {
@@ -36,9 +33,6 @@ public protocol LogsApi {
     /// - severity The severity of the log message
     /// - attributes The attributes to record with the log message
     func recordLog(message: String, severity: Severity, attributes: [String : AttributeValue])
-    /// Flushes all pending telemetry data (traces, logs, metrics).
-    /// - true if all flush operations succeeded, false otherwise
-    func flush() -> Bool
 }
 
 public protocol TracesApi {
@@ -50,7 +44,4 @@ public protocol TracesApi {
     /// - name The name of the span
     /// - attributes The attributes to record with the span
     func startSpan(name: String, attributes: [String : AttributeValue]) -> Span
-    /// Flushes all pending telemetry data (traces, logs, metrics).
-    /// - true if all flush operations succeeded, false otherwise
-    func flush() -> Bool
 }

Sources/Observability/AutoInstrumentation/Memory/MemoryPressureMonitor.swift

@@ -1,13 +1,16 @@
 import Foundation
+import OpenTelemetrySdk
 
 final class MemoryPressureMonitor: AutoInstrumentation {
     private let options: Options
-    private let logsApi: LogsApi
+    private let appLogBuilder: AppLogBuilder
+    private let yield: (ReadableLogRecord) async -> Void
     private var source: DispatchSourceMemoryPressure?
 
-    init(options: Options, logsApi: LogsApi) {
+    init(options: Options, appLogBuilder: AppLogBuilder, yield: @escaping (ReadableLogRecord) async -> Void) {
         self.options = options
-        self.logsApi = logsApi
+        self.appLogBuilder = appLogBuilder
+        self.yield = yield
     }
 
     func start() {
@@ -23,20 +26,22 @@ final class MemoryPressureMonitor: AutoInstrumentation {
             eventMask: [.critical, .warning],
             queue: .global(qos: .background)
         )
+        let localYield = yield
         source?.setEventHandler { [weak self] in
             Task {
                 guard let self, let event = self.source?.data else { return }
                 /// Report only if memory pressure is warning or critical
                 guard [DispatchSource.MemoryPressureEvent.warning, .critical].contains(event) else {
                     return
                 }
-                self.logsApi.recordLog(
-                    message: "applicationDidReceiveMemoryWarning",
-                    severity: .warn,
-                    attributes: [
-                        SemanticConvention.systemMemoryWarning: .string(event.name)
-                    ]
-                )
+                
+                guard let log = self.appLogBuilder.buildLog(message: "applicationDidReceiveMemoryWarning",
+                                                            severity: .warn,
+                                                            attributes: [SemanticConvention.systemMemoryWarning: .string(event.name)]) else {
+                    return
+                }
+                
+                await localYield(log)
             }
         }
         source?.activate()

Sources/Observability/Client/ObservabilityClient.swift

@@ -62,10 +62,4 @@ extension ObservabilityClient: Observe {
     func startSpan(name: String, attributes: [String : AttributeValue]) -> any Span {
         tracer.startSpan(name: name, attributes: attributes)
     }
-    
-    func flush() -> Bool {
-        tracer.flush() &&
-        meter.flush() &&
-        logger.flush()
-    }
 }

Sources/Observability/Client/ObservabilityClientFactory.swift

@@ -46,15 +46,25 @@ public struct ObservabilityClientFactory {
         }
 
         if options.logs == .enabled {
-            logger = LoggerDecorator(options: options, sessionManager: sessionManager, eventQueue: eventQueue, sampler: sampler)
+            let appLogBuilder = AppLogBuilder(options: options, sessionManager: sessionManager, sampler: sampler)
+            logger = LoggerDecorator(eventQueue: eventQueue, appLogBuilder: appLogBuilder)
             let logExporter = OtlpLogExporter(endpoint: url)
             Task {
                 await batchWorker.addExporter(logExporter)
             }
             if options.autoInstrumentation.contains(.memoryWarnings) {
-                let memoryWarningMonitor = MemoryPressureMonitor(options: options, logsApi: logger)
+                let memoryWarningMonitor = MemoryPressureMonitor(options: options, appLogBuilder: appLogBuilder) { log in
+                    await eventQueue.send(EventQueueItem(payload: LogItem(log: log)))
+                }
                 autoInstrumentation.append(memoryWarningMonitor)
             }
+            
+            let appLifecycleLogger = AppLifecycleLogger(appLifecycleManager: appLifecycleManager, appLogBuilder: appLogBuilder) { log in
+                Task {
+                    await eventQueue.send(EventQueueItem(payload: LogItem(log: log)))
+                }
+            }
+            autoInstrumentation.append(appLifecycleLogger)
         } else {
             logger = NoOpLogger()
         }
@@ -124,6 +134,7 @@ public struct ObservabilityClientFactory {
                     }
                 )
             }
+            
             if options.autoInstrumentation.contains(.cpu) {
                 autoInstrumentation.append(
                     MeasurementTask(metricsApi: meter, samplingInterval: autoInstrumentationSamplingInterval) { api in

Sources/Observability/CrashReports/LDCrashFilter.swift

@@ -66,14 +66,7 @@ final class LDCrashFilter: NSObject, CrashReportFilter {
                     attributes: attributes
                 )
             }
-            
-            Task { [weak self] in
-                guard self?.logsApi.flush() == true else {
-                    onCompletion?(reports, LaunchDarklyCrashFilterError.flushFailed)
-                    return
-                }
-                onCompletion?(reports, nil)
-            }
+            onCompletion?(reports, nil)
         } catch let error {
             onCompletion?(reports, error)
         }

Sources/Observability/Logs/LDLogRecordBuilder.swift

@@ -2,7 +2,7 @@ import Foundation
 import OpenTelemetryApi
 import OpenTelemetrySdk
 
-class LDLogRecordBuilder: EventBuilder {
+final class LDLogRecordBuilder {
     private var limits: LogLimits
     private var instrumentationScope: InstrumentationScopeInfo
     private var includeSpanContext: Bool
@@ -14,16 +14,13 @@ class LDLogRecordBuilder: EventBuilder {
     private var spanContext: SpanContext?
     private var resource: Resource
     private var clock: Clock
-    private var queue: EventQueuing
     private let sampler: ExportSampler
 
-    init(queue: EventQueuing,
-                sampler: ExportSampler,
-                resource: Resource,
-                clock: Clock,
-                instrumentationScope: InstrumentationScopeInfo,
-                includeSpanContext: Bool) {
-        self.queue = queue
+    init(sampler: ExportSampler,
+         resource: Resource,
+         clock: Clock,
+         instrumentationScope: InstrumentationScopeInfo,
+         includeSpanContext: Bool) {
         self.sampler = sampler
         self.resource = resource
         self.clock = clock
@@ -33,6 +30,32 @@ class LDLogRecordBuilder: EventBuilder {
         self.instrumentationScope = instrumentationScope
         self.attributes = AttributesDictionary(capacity: logLimits.maxAttributeCount,
                                                valueLengthLimit: logLimits.maxAttributeLength)
+        
+    }
+    
+    public func readableLogRecord() -> ReadableLogRecord? {
+        if spanContext == nil, includeSpanContext {
+            spanContext = OpenTelemetry.instance.contextProvider.activeSpan?.context
+        }
+        
+        let attrs = attributes.reduce(into: [String: OpenTelemetryApi.AttributeValue]()) { result, element in
+            result[element.0] = element.1
+        }
+        
+        let log = ReadableLogRecord(resource: resource,
+                                    instrumentationScopeInfo: instrumentationScope,
+                                    timestamp: timestamp ?? clock.now,
+                                    observedTimestamp: observedTimestamp,
+                                    spanContext: spanContext,
+                                    severity: severity,
+                                    body: body,
+                                    attributes: attrs)
+        
+        guard let sampledLog = sampler.sampledLog(log) else {
+            return nil
+        }
+        
+        return sampledLog
     }
 
     public func setTimestamp(_ timestamp: Date) -> Self {
@@ -69,31 +92,4 @@ class LDLogRecordBuilder: EventBuilder {
         self.attributes["event.data"] = OpenTelemetryApi.AttributeValue(AttributeSet(labels: attributes))
         return self
     }
-    
-    public func emit() {
-        if spanContext == nil, includeSpanContext {
-            spanContext = OpenTelemetry.instance.contextProvider.activeSpan?.context
-        }
-    
-        Task {
-            let attrs = attributes.reduce(into: [String: OpenTelemetryApi.AttributeValue]()) { result, element in
-                result[element.0] = element.1
-            }
-        
-            let log = ReadableLogRecord(resource: resource,
-                                        instrumentationScopeInfo: instrumentationScope,
-                                        timestamp: timestamp ?? clock.now,
-                                        observedTimestamp: observedTimestamp,
-                                        spanContext: spanContext,
-                                        severity: severity,
-                                        body: body,
-                                        attributes: attrs)
-            
-            guard let sampledLog = sampler.sampledLog(log) else {
-                return
-            }
-            
-            await queue.send(EventQueueItem(payload: LogItem(log: sampledLog)))
-        }
-    }
 }

Sources/Observability/Logs/LoggerDecorator.swift

@@ -1,22 +1,18 @@
 import Foundation
 import OpenTelemetrySdk
 
-final class LoggerDecorator: Logger {
+final class AppLogBuilder {
     private let options: Options
-    private var logger: any Logger { self }
     private let sessionManager: SessionManager
-    private let eventQueue: EventQueue
     private let sampler: ExportSampler
 
     init(
         options: Options,
         sessionManager: SessionManager,
-        eventQueue: EventQueue,
         sampler: ExportSampler
     ) {
         self.options = options
         self.sessionManager = sessionManager
-        self.eventQueue = eventQueue
         self.sampler = sampler
     }
 
@@ -25,13 +21,38 @@ final class LoggerDecorator: Logger {
         DefaultLoggerProvider.instance.get(instrumentationScopeName: "").eventBuilder(name: name)
     }
 
-    func logRecordBuilder() -> LogRecordBuilder {
-        LDLogRecordBuilder(queue: eventQueue,
-                           sampler: sampler,
-                           resource: Resource(attributes: options.resourceAttributes),
-                           clock: MillisClock(),
-                           instrumentationScope: .init(name: options.serviceName),
-                           includeSpanContext: true)
+    public func buildLog(message: String,
+                         severity: Severity,
+                         attributes: [String: AttributeValue]) -> ReadableLogRecord? {
+        var attributes = attributes
+        let sessionId = sessionManager.sessionInfo.id
+        if !sessionId.isEmpty {
+            attributes[SemanticConvention.highlightSessionId] = .string(sessionId)
+        }
+        
+        let logBuilder = LDLogRecordBuilder(
+            sampler: sampler,
+            resource: Resource(attributes: options.resourceAttributes),
+            clock: MillisClock(),
+            instrumentationScope: .init(name: options.serviceName),
+            includeSpanContext: true)
+        
+        logBuilder.setBody(.string(message))
+        logBuilder.setTimestamp(Date())
+        logBuilder.setSeverity(severity)
+        logBuilder.setAttributes(attributes)
+        
+        return logBuilder.readableLogRecord()
+    }
+}
+
+final class LoggerDecorator {
+    private let eventQueue: EventQueue
+    private let appLogBuilder: AppLogBuilder
+    
+    init(eventQueue: EventQueue, appLogBuilder: AppLogBuilder) {
+        self.eventQueue = eventQueue
+        self.appLogBuilder = appLogBuilder
     }
 }
 
@@ -41,22 +62,14 @@ extension LoggerDecorator: LogsApi {
         severity: Severity,
         attributes: [String: AttributeValue]
     ) {
-        var attributes = attributes
-        let sessionId = sessionManager.sessionInfo.id
-        if !sessionId.isEmpty {
-            attributes[SemanticConvention.highlightSessionId] = .string(sessionId)
+        Task {
+            guard let log = appLogBuilder.buildLog(message: message,
+                                                   severity: severity,
+                                                   attributes: attributes) else {
+                return
+            }
+            
+            await eventQueue.send(EventQueueItem(payload: LogItem(log: log)))
         }
-        logRecordBuilder()
-            .setBody(.string(message))
-            .setTimestamp(Date())
-            .setSeverity(severity)
-            .setAttributes(attributes)
-            .emit()
-    }
-    
-    public func flush() -> Bool {
-        // TODO: Implement flush API since we are using LDLogRecordBuilder now.
-//        logRecordProcessor.forceFlush(explicitTimeout: CommonOTelConfiguration.flushTimeout) == .success
-        true
     }
 }