Allows to "pass in a logger" rather than using the customizable String->Logger func

.swiftformat

@@ -1,11 +1,12 @@
 # file options
 
---swiftversion 5.1
+--swiftversion 5.2
 --exclude .build
 --exclude "**/*.pb.swift"
 --exclude "**/*+GenActor.swift"
 --exclude "**/*+GenCodable.swift"
 --exclude "**/*+XPCProtocolStub.swift"
+--disable redundantParens # https://github.com/nicklockwood/SwiftFormat/issues/638
 
 # format options
 

IntegrationTests/tests_02_process_isolated/it_ProcessIsolated_backoffRespawn/main.swift

@@ -21,7 +21,7 @@ import Glibc
 import DistributedActors
 
 let isolated = ProcessIsolated { boot in
-    boot.settings.logging.defaultLevel = .info
+    boot.settings.logging.logLevel = .info
     boot.runOn(role: .servant) {
         boot.settings.failure.onGuardianFailure = .systemExit(-1)
     }

IntegrationTests/tests_02_process_isolated/it_ProcessIsolated_escalatingWorkers/main.swift

@@ -21,7 +21,7 @@ import Glibc
 import DistributedActors
 
 let isolated = ProcessIsolated { boot in
-    boot.settings.logging.defaultLevel = .info
+    boot.settings.logging.logLevel = .info
     boot.runOn(role: .servant) {
         boot.settings.failure.onGuardianFailure = .systemExit(-1)
     }

IntegrationTests/tests_02_process_isolated/it_ProcessIsolated_noLeaking/main.swift

@@ -22,7 +22,7 @@ import DistributedActors
 
 let isolated = ProcessIsolated { boot in
     // create actor system (for each process this will run a new since this is the beginning of the program)
-    boot.settings.logging.defaultLevel = .info
+    boot.settings.logging.logLevel = .info
     return ActorSystem(settings: boot.settings)
 }
 

IntegrationTests/tests_02_process_isolated/it_ProcessIsolated_respawnsServants/main.swift

@@ -22,7 +22,7 @@ import DistributedActors
 
 let isolated = ProcessIsolated { boot in
     // create a new actor system (for each process this will run a new since this is the beginning of the program)
-    boot.settings.logging.defaultLevel = .info
+    boot.settings.logging.logLevel = .info
     return ActorSystem(settings: boot.settings)
 }
 

IntegrationTests/tests_04_cluster/it_Clustered_swim_suspension_reachability/main.swift

@@ -26,7 +26,7 @@ guard args.count >= 1 else {
 }
 
 let system = ActorSystem("System") { settings in
-    settings.logging.defaultLevel = .info
+    settings.logging.logLevel = .info
 
     settings.cluster.enabled = true
     settings.cluster.bindPort = Int(args[0])!

Sources/DistributedActors/ActorLogging.swift

@@ -16,14 +16,18 @@ import DistributedActorsConcurrencyHelpers
 import Foundation
 import Logging
 
+/// :nodoc:
 /// - Warning: NOT thread safe! Only use from Actors, properly synchronize access, or create multiple instances for each execution context.
-public class LoggingContext {
+// TODO: deprecate, we should not need this explicit type
+internal final class LoggingContext {
     let identifier: String
 
     // TODO: want to eventually not have this; also move to more structured logging perhaps...
     /// If `true` the built-in "pretty" formatter should be used, rather than passing verbatim to underlying `LogHandler`
     let useBuiltInFormatter: Bool
 
+    let logger: Logger
+
     @usableFromInline
     internal var _storage: Logger.Metadata = [:]
 
@@ -36,7 +40,8 @@ public class LoggingContext {
         }
     }
 
-    public init(identifier: String, useBuiltInFormatter: Bool, dispatcher: (() -> String)?) {
+    public init(logger: Logger, identifier: String, useBuiltInFormatter: Bool, dispatcher: (() -> String)?) {
+        self.logger = logger
         self.identifier = identifier
         self.useBuiltInFormatter = useBuiltInFormatter
         if let makeDispatcherName = dispatcher {
@@ -69,40 +74,8 @@ public 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 {
-        if let overriddenLoggerFactory = context.system.settings.logging.overrideLoggerFactory { return overriddenLoggerFactory("\(context.path)")
-        }
-
-        var proxyHandler = ActorOriginLogHandler(context)
-        proxyHandler.metadata["actorPath"] = "\(context.path)"
-        if context.system.settings.cluster.enabled {
-            proxyHandler.metadata["node"] = "\(context.system.settings.cluster.node)"
-        } else {
-            proxyHandler.metadata["nodeName"] = "\(context.system.name)"
-        }
-
-        var log = Logger(label: "\(context.path)", factory: { _ in proxyHandler })
-        log.logLevel = context.system.settings.logging.defaultLevel
-        return log
-    }
-
-    public static func make(system: ActorSystem, identifier: String? = nil) -> Logger {
-        if let overriddenLoggerFactory = system.settings.logging.overrideLoggerFactory {
-            return overriddenLoggerFactory(identifier ?? system.name)
-        }
-
-        // we need to add our own storage, and can't do so to Logger since it is a struct...
-        // so we need to make such "proxy log handler", that does out actor specific things.
-        var proxyHandler = ActorOriginLogHandler(system)
-        if system.settings.cluster.enabled {
-            proxyHandler.metadata["node"] = .lazyStringConvertible { () in
-                system.settings.cluster.node
-            }
-        } else {
-            proxyHandler.metadata["nodeName"] = .string(system.name)
-        }
-
-        var log = Logger(label: identifier ?? system.name, factory: { _ in proxyHandler })
-        log.logLevel = system.settings.logging.defaultLevel
+        var log = context.system.log
+        log[metadataKey: "actor/path"] = Logger.MetadataValue.stringConvertible(context.path)
         return log
     }
 }
@@ -119,19 +92,20 @@ public struct ActorOriginLogHandler: LogHandler {
 
     private let context: LoggingContext
 
-    private var loggingSystemSelectedLogger: Logger
+    private var targetLogger: Logger
 
-    public init(_ context: LoggingContext) {
+    internal init(_ context: LoggingContext) {
         self.context = context
 
-        self.loggingSystemSelectedLogger = Logger(label: context.identifier)
-        self.loggingSystemSelectedLogger.logLevel = self.logLevel
+        self.targetLogger = context.logger
+        self.targetLogger.logLevel = self.logLevel
     }
 
-    public init<T>(_ context: ActorContext<T>) {
+    internal init<T>(_ context: ActorContext<T>) {
         let dispatcherName = context.props.dispatcher.name
         self.init(
             LoggingContext(
+                logger: context.log,
                 identifier: context.path.description,
                 useBuiltInFormatter: context.system.settings.logging.useBuiltInFormatter,
                 dispatcher: { () in dispatcherName } // beware of closing over the context here (!)
@@ -142,6 +116,7 @@ public struct ActorOriginLogHandler: LogHandler {
     public init(_ system: ActorSystem, identifier: String? = nil) {
         self.init(
             LoggingContext(
+                logger: system.log,
                 identifier: identifier ?? system.name,
                 useBuiltInFormatter: system.settings.logging.useBuiltInFormatter,
                 dispatcher: { () in _hackyPThreadThreadId() }
@@ -169,70 +144,74 @@ public struct ActorOriginLogHandler: LogHandler {
     internal func invokeConfiguredLoggingInfra(_ logMessage: LogMessage) {
         // TODO: here we can either log... or dispatch to actor... or invoke Logging. etc
 
-        if self.context.useBuiltInFormatter {
-            var l = logMessage
+        guard self.context.useBuiltInFormatter else {
+            self.targetLogger.log(level: logMessage.level, logMessage.message, metadata: self.metadata, file: logMessage.file, function: logMessage.function, line: logMessage.line)
+            return
+        }
 
-            let dispatcherPart: String
-            if let d = l.effectiveMetadata?.removeValue(forKey: "dispatcher") {
-                dispatcherPart = "[\(d)]"
-            } else {
-                dispatcherPart = ""
-            }
-            let actorPathPart: String
-            if let d = l.effectiveMetadata?.removeValue(forKey: "actorPath") {
-                actorPathPart = "[\(d)]"
-            } else {
-                actorPathPart = ""
-            }
+        var l = logMessage
 
-            let actorSystemIdentity: String
-            if let d = l.effectiveMetadata?.removeValue(forKey: "node") {
-                actorSystemIdentity = "[\(d)]"
+        let dispatcherPart: String
+        if let d = l.effectiveMetadata?.removeValue(forKey: "dispatcher") {
+            dispatcherPart = "[\(d)]"
+        } else {
+            dispatcherPart = ""
+        }
+
+        let actorPathPart: String
+        if let d = l.effectiveMetadata?.removeValue(forKey: "actor/path") {
+            actorPathPart = "[\(d)]"
+        } else {
+            actorPathPart = ""
+        }
+
+        let actorSystemIdentity: String
+        if let d = l.effectiveMetadata?.removeValue(forKey: "actor/node") {
+            actorSystemIdentity = "[\(d)]"
+        } else {
+            if let name = l.effectiveMetadata?.removeValue(forKey: "actor/nodeName") {
+                actorSystemIdentity = "[\(name)]"
             } else {
-                if let name = l.effectiveMetadata?.removeValue(forKey: "nodeName") {
-                    actorSystemIdentity = "[\(name)]"
-                } else {
-                    actorSystemIdentity = ""
-                }
+                actorSystemIdentity = ""
             }
+        }
+
+        var msg = ""
+        msg += "\(actorSystemIdentity)"
+        msg += "[\(l.file.description.split(separator: "/").last ?? "<unknown-file>"):\(l.line)]" // we only print "file" rather than full path
+        msg += "\(dispatcherPart)"
+        msg += "\(actorPathPart)"
+        msg += " \(l.message)"
+
+        guard ProcessInfo.processInfo.environment["SACT_PRETTY_LOG"] != nil else {
+            // no "pretty" logging
+            self.targetLogger.log(level: logMessage.level, Logger.Message(stringLiteral: msg), metadata: l.effectiveMetadata, file: logMessage.file, function: logMessage.function, line: logMessage.line)
+            return
+        }
 
-            var msg = ""
-            msg += "\(actorSystemIdentity)"
-            msg += "[\(l.file.description.split(separator: "/").last ?? "<unknown-file>"):\(l.line)]"
-            msg += "\(dispatcherPart)"
-            msg += "\(actorPathPart)"
-            msg += " \(l.message)"
-
-            if ProcessInfo.processInfo.environment["SACT_PRETTY_LOG"] != nil {
-                if let metadata = l.effectiveMetadata, !metadata.isEmpty {
-                    var metadataString = "\n// metadata:\n"
-                    for key in metadata.keys.sorted() where key != "label" {
-                        var allString = "\n// \"\(key)\": \(metadata[key]!)"
-                        if allString.contains("\n") {
-                            allString = String(
-                                allString.split(separator: "\n").map { valueLine in
-                                    if valueLine.starts(with: "// ") {
-                                        return "\(valueLine)\n"
-                                    } else {
-                                        return "// \(valueLine)\n"
-                                    }
-                                }.joined(separator: "")
-                            )
-                        }
-                        metadataString.append(allString)
-                    }
-                    metadataString = String(metadataString.dropLast(1))
-
-                    msg += metadataString
+        // "pretty" logging
+        if let metadata = l.effectiveMetadata, !metadata.isEmpty {
+            var metadataString = "\n// metadata:\n"
+            for key in metadata.keys.sorted() where key != "label" {
+                var allString = "\n// \"\(key)\": \(metadata[key]!)"
+                if allString.contains("\n") {
+                    allString = String(
+                        allString.split(separator: "\n").map { valueLine in
+                            if valueLine.starts(with: "// ") {
+                                return "\(valueLine)\n"
+                            } else {
+                                return "// \(valueLine)\n"
+                            }
+                        }.joined(separator: "")
+                    )
                 }
-                self.loggingSystemSelectedLogger.log(level: logMessage.level, Logger.Message(stringLiteral: msg), metadata: [:], file: logMessage.file, function: logMessage.function, line: logMessage.line)
-            } else {
-                self.loggingSystemSelectedLogger.log(level: logMessage.level, Logger.Message(stringLiteral: msg), metadata: l.effectiveMetadata, file: logMessage.file, function: logMessage.function, line: logMessage.line)
+                metadataString.append(allString)
             }
+            metadataString = String(metadataString.dropLast(1))
 
-        } else {
-            self.loggingSystemSelectedLogger.log(level: logMessage.level, logMessage.message, metadata: self.metadata, file: logMessage.file, function: logMessage.function, line: logMessage.line)
+            msg += metadataString
         }
+        self.targetLogger.log(level: logMessage.level, Logger.Message(stringLiteral: msg), metadata: [:], file: logMessage.file, function: logMessage.function, line: logMessage.line)
     }
 
     // TODO: hope to remove this one
@@ -245,15 +224,12 @@ public struct ActorOriginLogHandler: LogHandler {
         }
     }
 
-    private var _logLevel: Logger.Level = .info
-
     public var logLevel: Logger.Level {
         get {
-            self._logLevel
+            self.targetLogger.logLevel
         }
         set {
-            self._logLevel = newValue
-            self.loggingSystemSelectedLogger.logLevel = newValue
+            self.targetLogger.logLevel = newValue
         }
     }
 
@@ -300,8 +276,21 @@ public struct LogMessage {
 
 // MARK: Extend logging metadata storage capabilities
 
+extension Logger.Metadata {
+    public static func pretty<T>(_ value: T) -> Logger.Metadata.Value where T: CustomPrettyStringConvertible {
+        .string(value.prettyDescription)
+    }
+
+    public static func pretty<T>(_ value: T) -> Logger.Metadata.Value {
+        if let pretty = value as? CustomPrettyStringConvertible {
+            return .string(pretty.prettyDescription)
+        } else {
+            return .string("\(value)")
+        }
+    }
+}
+
 extension Optional where Wrapped == Logger.MetadataValue {
-    /// Delays rendering of value by boxing it in a `LazyMetadataBox`
     public static func lazyStringConvertible(_ makeValue: @escaping () -> CustomStringConvertible) -> Logger.Metadata.Value {
         .stringConvertible(LazyMetadataBox { makeValue() })
     }

Sources/DistributedActors/ActorSystem.swift

@@ -108,11 +108,8 @@ public final class ActorSystem {
     // ==== ----------------------------------------------------------------------------------------------------------------
     // MARK: Logging
 
-    public var log: Logger {
-        var l = ActorLogger.make(system: self)
-        l.logLevel = self.settings.logging.defaultLevel
-        return l
-    }
+    /// Root logger of this actor system, as configured in `LoggingSettings`.
+    public let log: Logger
 
     // ==== ----------------------------------------------------------------------------------------------------------------
     // MARK: Shutdown
@@ -188,29 +185,22 @@ public final class ActorSystem {
         let initializationLock = ReadWriteLock()
         self.lazyInitializationLock = initializationLock
 
+        var rootLogger = settings.logging.logger
+        if settings.cluster.enabled {
+            rootLogger[metadataKey: "actor/node"] = "\(settings.cluster.uniqueBindNode)"
+        }
+        rootLogger[metadataKey: "actor/nodeName"] = "\(self.name)"
+        self.log = rootLogger
+
+        // vvv~~~~~~~~~~~~~~~~~~~ all properties initialized, self can be shared ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~vvv //
+
         // serialization
         initializationLock.withWriterLockVoid {
             self._serialization = Serialization(settings: settings, system: self)
         }
 
-        // vvv~~~~~~~~~~~~~~~~~~~ all properties initialized, self can be shared ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~vvv
-
         // dead letters init
-        let overrideLogger: Logger? = settings.logging.overrideLoggerFactory.map { f in f("\(ActorPath._deadLetters)") }
-        var deadLogger = overrideLogger ?? Logger(
-            label: "\(ActorPath._deadLetters)",
-            factory: {
-                let context = LoggingContext(identifier: $0, useBuiltInFormatter: settings.logging.useBuiltInFormatter, dispatcher: nil)
-                if settings.cluster.enabled {
-                    context[metadataKey: "node"] = .stringConvertible(settings.cluster.uniqueBindNode)
-                }
-                context[metadataKey: "nodeName"] = .stringConvertible(name)
-                return ActorOriginLogHandler(context)
-            }
-        )
-        deadLogger.logLevel = settings.logging.defaultLevel
-
-        self._deadLetters = ActorRef(.deadLetters(.init(deadLogger, address: ActorAddress._deadLetters, system: self)))
+        self._deadLetters = ActorRef(.deadLetters(.init(rootLogger, address: ActorAddress._deadLetters, system: self)))
 
         // actor providers
         let localUserProvider = LocalActorRefProvider(root: Guardian(parent: theOne, name: "user", system: self))