=logging remove LoggerWithSource, keep allowing config via passing in

logger

Author: ktoso

Package.swift

@@ -258,8 +258,7 @@ var dependencies: [Package.Dependency] = [
 
     // ~~~ SSWG APIs ~~~
 
-    // .package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
-    .package(url: "https://github.com/weissi/swift-log.git", .branch("jw-source")),
+    .package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
     // swift-metrics 1.x and 2.x are almost API compatible, so most clients should use
     .package(url: "https://github.com/apple/swift-metrics.git", "1.0.0" ..< "3.0.0"),
 

Sources/DistributedActors/ActorLogging.swift

@@ -74,7 +74,7 @@ internal final class LoggingContext {
 /// The preferred way of obtaining a logger for an actor or system is `context.log` or `system.log`, rather than creating new ones.
 public struct ActorLogger {
     public static func make<T>(context: ActorContext<T>) -> Logger {
-        var log = context.system.log.logger
+        var log = context.system.log
         log[metadataKey: "actor/path"] = Logger.MetadataValue.stringConvertible(context.path)
         return log
     }
@@ -116,7 +116,7 @@ public struct ActorOriginLogHandler: LogHandler {
     public init(_ system: ActorSystem, identifier: String? = nil) {
         self.init(
             LoggingContext(
-                logger: system.log.logger,
+                logger: system.log,
                 identifier: identifier ?? system.name,
                 useBuiltInFormatter: system.settings.logging.useBuiltInFormatter,
                 dispatcher: { () in _hackyPThreadThreadId() }

Sources/DistributedActors/ActorSystem.swift

@@ -109,7 +109,7 @@ public final class ActorSystem {
     // MARK: Logging
 
     /// Root logger of this actor system, as configured in `LoggingSettings`.
-    public let log: LoggerWithSource
+    public let log: Logger
 
     // ==== ----------------------------------------------------------------------------------------------------------------
     // MARK: Shutdown
@@ -190,7 +190,7 @@ public final class ActorSystem {
             rootLogger[metadataKey: "actor/node"] = "\(settings.cluster.uniqueBindNode)"
         }
         rootLogger[metadataKey: "actor/nodeName"] = "\(self.name)"
-        self.log = rootLogger.withSource("ActorSystem(\(self.name))")
+        self.log = rootLogger
 
         // vvv~~~~~~~~~~~~~~~~~~~ all properties initialized, self can be shared ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~vvv //
 

Sources/DistributedActors/ActorSystemSettings.swift

@@ -64,8 +64,12 @@ extension Array where Element == ActorTransport {
 public struct LoggingSettings {
     public static let `default` = LoggingSettings()
 
-    /// At what level should the library actually log and print logs // TODO: We'd want to replace this by proper log handlers which allow config by labels
-    public var logLevel: Logger.Level { // TODO: deprecate
+    /// Customize the default log level of the `system.log` (and `context.log`) loggers.
+    ///
+    /// This this modifies the current "base" logger which is `LoggingSettings.logger`,
+    /// it is also possible to change the logger itself, e.g. if you care about reusing a specific logger
+    /// or need to pass metadata through all loggers in the actor system.
+    public var logLevel: Logger.Level {
         get {
             self.logger.logLevel
         }
@@ -77,13 +81,9 @@ public struct LoggingSettings {
     public var logger: Logger = LoggingSettings.makeDefaultLogger()
 
     static func makeDefaultLogger() -> Logger {
-        Logger(label: "<<ActorSystem>>")
+        Logger(label: "<<ActorSystem>>") // replaced by specific system name during startup
     }
 
-//    /// Optionally override Logger that shall be offered to actors and the system.
-//    /// This is used instead of globally configured `Logging.Logger()` factories by the actor system.
-//    public var overrideLoggerFactory: ((String) -> Logger)?
-
     // TODO: hope to remove this once a StdOutLogHandler lands that has formatting support;
     // logs are hard to follow with not consistent order of metadata etc (like system address etc).
     public var useBuiltInFormatter: Bool = true

Sources/DistributedActors/Cluster/Transport/TransportPipelines.swift

@@ -35,11 +35,11 @@ private final class InitiatingHandshakeHandler: ChannelInboundHandler, Removable
     typealias InboundOut = ByteBuffer
     typealias OutboundOut = ByteBuffer
 
-    private let log: LoggerWithSource
+    private let log: Logger
     private let handshakeOffer: Wire.HandshakeOffer
     private let cluster: ClusterShell.Ref
 
-    init(log: LoggerWithSource, handshakeOffer: Wire.HandshakeOffer, cluster: ClusterShell.Ref) {
+    init(log: Logger, handshakeOffer: Wire.HandshakeOffer, cluster: ClusterShell.Ref) {
         self.log = log
         self.handshakeOffer = handshakeOffer
         self.cluster = cluster
@@ -112,11 +112,11 @@ final class ReceivingHandshakeHandler: ChannelInboundHandler, RemovableChannelHa
     typealias InboundIn = ByteBuffer
     typealias InboundOut = Never
 
-    private let log: LoggerWithSource
+    private let log: Logger
     private let cluster: ClusterShell.Ref
     private let localNode: UniqueNode
 
-    init(log: LoggerWithSource, cluster: ClusterShell.Ref, localNode: UniqueNode) {
+    init(log: Logger, cluster: ClusterShell.Ref, localNode: UniqueNode) {
         self.log = log
         self.cluster = cluster
         self.localNode = localNode
@@ -251,9 +251,9 @@ private final class WireEnvelopeHandler: ChannelDuplexHandler {
     typealias InboundIn = ByteBuffer
     typealias InboundOut = Wire.Envelope
 
-    let log: LoggerWithSource
+    let log: Logger
 
-    init(log: LoggerWithSource) {
+    init(log: Logger) {
         self.log = log
     }
 
@@ -290,10 +290,10 @@ final class OutboundSerializationHandler: ChannelOutboundHandler {
     typealias OutboundIn = TransportEnvelope
     typealias OutboundOut = Wire.Envelope
 
-    let log: LoggerWithSource
+    let log: Logger
     let serializationPool: SerializationPool
 
-    init(log: LoggerWithSource, serializationPool: SerializationPool) {
+    init(log: Logger, serializationPool: SerializationPool) {
         self.log = log
         self.serializationPool = serializationPool
     }
@@ -353,7 +353,7 @@ internal final class SystemMessageRedeliveryHandler: ChannelDuplexHandler {
     typealias InboundIn = Wire.Envelope // we handle deserialization in case it is about a system message (since message == system message envelope)
     typealias InboundOut = Wire.Envelope // we pass along user messages; all system messages are handled in-place here (ack, nack), or delivered directly to the recipient from this handler
 
-    private let log: LoggerWithSource
+    private let log: Logger
     private let system: ActorSystem
     private let clusterShell: ClusterShell.Ref
 
@@ -366,7 +366,7 @@ internal final class SystemMessageRedeliveryHandler: ChannelDuplexHandler {
     private var redeliveryScheduled: Scheduled<RedeliveryTick>?
 
     init(
-        log: LoggerWithSource,
+        log: Logger,
         system: ActorSystem,
         cluster: ClusterShell.Ref,
         serializationPool: SerializationPool,
@@ -602,12 +602,12 @@ private final class UserMessageHandler: ChannelInboundHandler {
     typealias InboundIn = Wire.Envelope
     typealias InboundOut = Never // we terminate here, by sending messages off to local actors
 
-    let log: LoggerWithSource
+    let log: Logger
 
     let system: ActorSystem
     let serializationPool: SerializationPool
 
-    init(log: LoggerWithSource, system: ActorSystem, serializationPool: SerializationPool) {
+    init(log: Logger, system: ActorSystem, serializationPool: SerializationPool) {
         self.log = log
         self.system = system
         self.serializationPool = serializationPool
@@ -649,9 +649,9 @@ private final class DumpRawBytesDebugHandler: ChannelInboundHandler {
     typealias InboundIn = ByteBuffer
 
     let role: HandlerRole
-    var log: LoggerWithSource
+    var log: Logger
 
-    init(role: HandlerRole, log: LoggerWithSource) {
+    init(role: HandlerRole, log: Logger) {
         self.role = role
         self.log = log
     }
@@ -708,7 +708,8 @@ extension ClusterShell {
                     }
                 }
 
-                let log = LoggerWithSource(system.log.logger, source: "/system/transport.server")
+                var log = system.log
+                log[metadataKey: "actor/path"] = "/system/transport.server" // TODO: this is a fake path, we could use log source: here if it gets merged
 
                 // FIXME: PASS IN FROM ASSOCIATION SINCE MUST SURVIVE CONNECTIONS! // TODO: tests about killing connections the hard way
                 let outboundSysMsgs = OutboundSystemMessageRedelivery(settings: .default)
@@ -771,7 +772,8 @@ extension ClusterShell {
                     }
                 }
 
-                let log = LoggerWithSource(system.log.logger, source: "/system/transport.client")
+                var log = system.log
+                log[metadataKey: "actor/path"] = "/system/transport.client" // TODO: this is a fake path, we could use log source: here if it gets merged
 
                 // FIXME: PASS IN FROM ASSOCIATION SINCE MUST SURVIVE CONNECTIONS !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                 let outboundSysMsgs = OutboundSystemMessageRedelivery(settings: .default)

Sources/DistributedActors/DeadLetters.swift

@@ -71,7 +71,7 @@ extension ActorSystem {
             ///
             /// We don't apply the special /dead path, as to not complicate diagnosing who actually terminated or if we were accidentally sent
             /// a remote actor ref that was dead(!)
-            return ActorRef(.deadLetters(.init(self.log.logger, address: recipient, system: self))).adapt(from: Message.self)
+            return ActorRef(.deadLetters(.init(self.log, address: recipient, system: self))).adapt(from: Message.self)
         }
 
         let localRecipient: ActorAddress
@@ -82,7 +82,7 @@ extension ActorSystem {
             // drop the node from the address; and prepend it as known-to-be-dead
             localRecipient = ActorAddress(path: ActorPath._dead.appending(segments: recipient.segments), incarnation: recipient.incarnation)
         }
-        return ActorRef(.deadLetters(.init(self.log.logger, address: localRecipient, system: self))).adapt(from: Message.self)
+        return ActorRef(.deadLetters(.init(self.log, address: localRecipient, system: self))).adapt(from: Message.self)
     }
 
     /// Anonymous `/dead/letters` reference, which may be used for messages which have no logical recipient.
@@ -140,11 +140,11 @@ extension ActorSystem {
 /// but not for anything more -- users shall assume that their communication is correct and only debug why a dead reference appeared if it indeed does happen.
 public final class DeadLetterOffice {
     let _address: ActorAddress
-    let log: LoggerWithSource
+    let log: Logger
     weak var system: ActorSystem?
 
     init(_ log: Logger, address: ActorAddress, system: ActorSystem?) {
-        self.log = log.withSource("DeadLetters")
+        self.log = log
         self._address = address
         self.system = system
     }

Sources/DistributedActors/Serialization/Serialization+Context.swift

@@ -25,7 +25,7 @@ extension Serialization {
     ///
     /// Context MAY be accessed concurrently be encoders/decoders.
     public struct Context {
-        public let log: LoggerWithSource
+        public let log: Logger
         public let system: ActorSystem
 
         public var serialization: Serialization {
@@ -40,7 +40,7 @@ extension Serialization {
             self.system.cluster.node
         }
 
-        internal init(log: LoggerWithSource, system: ActorSystem, allocator: NIO.ByteBufferAllocator) {
+        internal init(log: Logger, system: ActorSystem, allocator: NIO.ByteBufferAllocator) {
             self.log = log
             self.system = system
             self.allocator = allocator

Sources/DistributedActors/Serialization/Serialization.swift

@@ -35,7 +35,7 @@ import Foundation // for Codable
 /// for any kind of Message type that is possible to be received by any spawned `Actor`, sub-receive, `Gossip` instance etc.
 ///
 public class Serialization {
-    private let log: LoggerWithSource
+    private let log: Logger
     internal let settings: Serialization.Settings
     @usableFromInline
     internal let metrics: ActorSystemMetrics // TODO: rather, do this via instrumentation
@@ -180,9 +180,10 @@ public class Serialization {
 
         self.allocator = self.settings.allocator
 
-        var log = system.log.logger.withSource("serialization")
+        var log = system.log
         // TODO: Dry up setting this metadata
         log[metadataKey: "node"] = .stringConvertible(systemSettings.cluster.uniqueBindNode)
+        log[metadataKey: "actor/path"] = "/system/serialization" // TODO: this is a fake path, we could use log source: here if it gets merged
         log.logLevel = systemSettings.logging.logLevel
         self.log = log
 

Sources/DistributedActorsTestKit/LogCapture.swift

@@ -109,10 +109,12 @@ extension LogCapture {
                     actorPath = "[\(path)]"
                 }
 
+                metadata.removeValue(forKey: "label")
                 if !metadata.isEmpty {
                     metadataString = "\n// metadata:\n"
-                    for key in metadata.keys.sorted() where key != "label" {
-                        let valueDescription = self.prettyPrint(metadata: metadata[key]!)
+                    for key in metadata.keys.sorted() {
+                        let value: Logger.MetadataValue = metadata[key]!
+                        let valueDescription = self.prettyPrint(metadata: value)
 
                         var allString = "\n// \"\(key)\": \(valueDescription)"
                         if allString.contains("\n") {
@@ -167,7 +169,6 @@ public struct CapturedLogMessage {
     let level: Logger.Level
     var message: Logger.Message
     var metadata: Logger.Metadata?
-    let source: String
     let file: String
     let function: String
     let line: UInt
@@ -185,7 +186,7 @@ struct LogCaptureLogHandler: LogHandler {
         self.capture = capture
     }
 
-    public func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, source: String, file: String, function: String, line: UInt) {
+    public func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt) {
         guard self.capture.settings.filterActorPaths.contains(where: { path in self.label.starts(with: path) }) else {
             return // ignore this actor's logs, it was filtered out
         }
@@ -203,7 +204,7 @@ struct LogCaptureLogHandler: LogHandler {
         var _metadata: Logger.Metadata = metadata ?? [:]
         _metadata["label"] = "\(self.label)"
 
-        self.capture.append(CapturedLogMessage(date: date, level: level, message: message, metadata: _metadata, source: source, file: file, function: function, line: line))
+        self.capture.append(CapturedLogMessage(date: date, level: level, message: message, metadata: _metadata, file: file, function: function, line: line))
     }
 
     public subscript(metadataKey _: String) -> Logger.Metadata.Value? {

Sources/DistributedActorsXPC/ActorCell/XPCServiceCellDelegate.swift

@@ -77,7 +77,7 @@ internal final class XPCServiceCellDelegate<Message: ActorMessage>: CellDelegate
         master.tell(.xpcRegisterService(self.peer, myself.asAddressable())) // TODO: do we really need it?
 
         xpc_connection_set_event_handler(self.peer) { (xdict: xpc_object_t) in
-            var log = system.log.logger.withSource("XPCService:\(myself.address.name)")
+            var log = system.log
             log[metadataKey: "actor/path"] = "\(address)"
             // TODO: connection id?