SLG-0003: Error parameter implementation

Sources/InMemoryLogging/InMemoryLogHandler.swift

@@ -46,6 +46,8 @@ public struct InMemoryLogHandler: LogHandler {
         public var level: Logger.Level
         /// The message which was logged.
         public var message: Logger.Message
+        /// The error which was logged.
+        public var error: (any Error)?
         /// The metadata which was logged.
         public var metadata: Logger.Metadata
 
@@ -54,18 +56,49 @@ public struct InMemoryLogHandler: LogHandler {
             self.message = message
             self.metadata = metadata
         }
+
+        public init(level: Logger.Level, message: Logger.Message, error: (any Error)?, metadata: Logger.Metadata) {
+            self.level = level
+            self.message = message
+            self.error = error
+            self.metadata = metadata
+        }
+
+        public static func == (lhs: InMemoryLogHandler.Entry, rhs: InMemoryLogHandler.Entry) -> Bool {
+            lhs.level == rhs.level
+                && lhs.message == rhs.message
+                && errorsEqual(lhs.error, rhs.error)
+                && lhs.metadata == rhs.metadata
+        }
+
+        private static func errorsEqual(_ lhs: (any Error)?, _ rhs: (any Error)?) -> Bool {
+            switch (lhs, rhs) {
+            case (nil, nil):
+                return true
+            case let (l?, r?):
+                return "\(l)" == "\(r)" && String(reflecting: type(of: l)) == String(reflecting: type(of: r))
+            default:
+                return false
+            }
+        }
     }
 
     private final class LogStore: @unchecked Sendable {
         private var _entries: [Entry] = []
         private let lock = Lock()
 
-        fileprivate func append(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata) {
+        fileprivate func append(
+            level: Logger.Level,
+            message: Logger.Message,
+            error: (any Error)?,
+            metadata: Logger.Metadata
+        ) {
             self.lock.withLockVoid {
                 self._entries.append(
                     Entry(
                         level: level,
                         message: message,
+                        error: error,
                         metadata: metadata
                     )
                 )
@@ -99,8 +132,9 @@ public struct InMemoryLogHandler: LogHandler {
         mergedMetadata = mergedMetadata.merging(self.metadata) { $1 }
         // ..merge in metadata from this log call, overwriting existing keys
         mergedMetadata = mergedMetadata.merging(event.metadata ?? [:]) { $1 }
+        // ..merge in error as metadata, overwriting existing keys
 
-        self.logStore.append(level: event.level, message: event.message, metadata: mergedMetadata)
+        self.logStore.append(level: event.level, message: event.message, error: event.error, metadata: mergedMetadata)
     }
 
     @available(*, deprecated, renamed: "log(event:)")

Sources/Logging/Docs.docc/Proposals/SLG-0003.md

@@ -6,7 +6,7 @@ Add standardized way of attaching data from `Error` instances to log entries.
 
 - Proposal: SLG-0003
 - Author(s): [Samuel Murray](https://github.com/samuelmurray)
-- Status: **Ready for Implementation**
+- Status: **Approved**
 - Issue: [apple/swift-log#291](https://github.com/apple/swift-log/issues/291)
 - Implementation:
     - [apple/swift-log#425](https://github.com/apple/swift-log/pull/425)

Sources/Logging/LogEvent.swift

@@ -26,6 +26,9 @@ public struct LogEvent: Sendable {
     /// The message of this event.
     public var message: Logger.Message
 
+    /// The error associated with this event, if any.
+    public var error: (any Error)?
+
     /// The metadata associated with this event, if any.
     public var metadata: Logger.Metadata? {
         get { self._metadata }
@@ -75,9 +78,44 @@ public struct LogEvent: Sendable {
         file: String,
         function: String,
         line: UInt
+    ) {
+        self.init(
+            level: level,
+            message: message,
+            error: nil,
+            metadata: metadata,
+            source: source,
+            file: file,
+            function: function,
+            line: line
+        )
+    }
+
+    /// Creates a new log event.
+    ///
+    /// - Parameters:
+    ///   - level: The log level of this event.
+    ///   - message: The message of this event.
+    ///   - error: The error associated with this event, if any.
+    ///   - metadata: The metadata associated with this event, if any.
+    ///   - source: The source where this log event originated. When `nil`, ``source`` is derived lazily
+    ///     from ``file`` on first access so handlers that never read it pay no allocation cost.
+    ///   - file: The file this log event originates from.
+    ///   - function: The function this log event originates from.
+    ///   - line: The line this log event originates from.
+    public init(
+        level: Logger.Level,
+        message: Logger.Message,
+        error: (any Error)?,
+        metadata: Logger.Metadata?,
+        source: String?,
+        file: String,
+        function: String,
+        line: UInt
     ) {
         self.level = level
         self.message = message
+        self.error = error
         self._metadata = metadata
         self._source = source
         self.file = file