Log enhancements to allow for instances

Example/Tests/LogTests.swift

@@ -11,23 +11,55 @@ import XCTest
 
 class LogTests: XCTestCase {
 
+    final class Loggers {
+        static let userInterface = Log("UI", logLevel: .verbose)
+        static let app = Log("App")
+    }
+
+    class NetworkLog: Log {
+        static var networkLog = Log("Network")
+
+        override class var instance: Log {
+            return networkLog
+        }
+    }
+
     func testLogHandler() {
 
         var loggedStrings: [(level: Log.Level, string: String)] = []
-        Log.handler = { (level, string) in
+        Log.globalHandler = { (log, level, string) in
             loggedStrings.append((level: level, string: string))
         }
 
-        Log.logLevel = .warn
+        var networkStrings: [(level: Log.Level, string: String)] = []
+        NetworkLog.handler = { (level, string) in
+            networkStrings.append((level: level, string: string))
+        }
+
+        let localInstance = Log("Local Instance", logLevel: .verbose, useEmoji: true)
 
+        Log.logLevel = .info
+        Log.useEmoji = true
         Log.verbose("Ignore me")
         Log.error("Don't ignore me!")
 
+        NetworkLog.logLevel = .info
+        NetworkLog.verbose("network verbose")
+        NetworkLog.debug("network debug")
+        NetworkLog.info("network info")
+        NetworkLog.warn("network warning")
+        NetworkLog.error("network error")
+
+        localInstance.warn("Local Instance Warning")
+        Loggers.userInterface.info("Button Pressed")
+        Loggers.app.warn("Out of Memory")
+
         // Log messages include the date, which is not conducive to testing,
         // so we just check the end of the logged string.
-        XCTAssertEqual(loggedStrings.count, 1)
+        XCTAssertEqual(loggedStrings.count, 6)
         XCTAssertEqual(loggedStrings[0].level, .error)
         XCTAssertTrue(loggedStrings[0].string.hasSuffix("Don't ignore me!"))
+        XCTAssertTrue(loggedStrings[1].string.hasSuffix("network info"))
+        XCTAssertEqual(networkStrings.count, 3)
     }
-
 }

Pod/Classes/Logging/Log.swift

@@ -7,26 +7,30 @@
 //
 
 import Foundation
+import OSLog
 
 /**
-*  A simple log that outputs to the console via ```print()````
+*  A simple log that outputs to the console via ```print()```` and also logs to the console with OSLog (if available)
 */
 open class Log {
 
-    // MARK: Configuration
+    // MARK: Types
+
+    public typealias InstanceLogHandler = ((Level, String) -> Void)
+    public typealias GlobalLogHandler = ((Log, Level, String) -> Void)
 
     /**
      Represents a level of detail to be logged.
      */
-    public enum Level: Int {
+    public enum Level: Int, CaseIterable {
         case verbose
         case debug
         case info
         case warn
         case error
         case off
 
-        var name: String {
+        public var name: String {
             switch self {
             case .verbose: return "Verbose"
             case .debug: return "Debug"
@@ -37,7 +41,7 @@ open class Log {
             }
         }
 
-        var emoji: String {
+        public var emoji: String {
             switch self {
             case .verbose: return "📖"
             case .debug: return "🐝"
@@ -49,11 +53,38 @@ open class Log {
         }
     }
 
+    public static private(set) var standard = Log("", logLevel: .off)
+
+    /// Static instance used for helper methods.
+    open class var instance: Log {
+        return standard
+    }
+
+    /// Subsystem of the OSLog message when running on iOS 14 or later.
+    open var subsystem: String {
+        let bundleName = Bundle.main.object(forInfoDictionaryKey: "CFBundleDisplayName") as? String
+        return (bundleName ?? "com.rightpoint.swiftilities") + ".log"
+    }
+
+    /// If this is non-nil, we will call it with the same string that we
+    /// are going to print to the console. You can use this to pass log
+    /// messages along to your crash reporter, analytics service, etc.
+    /// - warning: Be mindful of private user data that might end up in
+    ///            your log statements! Use log levels appropriately
+    ///            to keep private data out of logs that are sent over
+    ///            the Internet.
+    public static var globalHandler: GlobalLogHandler?
+
+    // MARK: Configuration
+
+    /// Displayed name of the Log instance, also used as the Category in OSLog messages
+    public var name: String
+
     /// The log level, defaults to .Off
-    public static var logLevel: Level = .off
+    public var logLevel: Level = .off
 
     /// If true, prints emojis to signify log type, defaults to off
-    public static var useEmoji: Bool = false
+    public var useEmoji: Bool = false
 
     /// If this is non-nil, we will call it with the same string that we
     /// are going to print to the console. You can use this to pass log
@@ -62,7 +93,15 @@ open class Log {
     ///            your log statements! Use log levels appropriately
     ///            to keep private data out of logs that are sent over
     ///            the Internet.
-    public static var handler: ((Level, String) -> Void)?
+    public var handler: InstanceLogHandler?
+
+    // MARK: Initializer
+
+    required public init(_ name: String, logLevel: Level = .off, useEmoji: Bool = false) {
+        self.name = name
+        self.logLevel = logLevel
+        self.useEmoji = useEmoji
+    }
 
     // MARK: Private
 
@@ -74,37 +113,100 @@ open class Log {
     }()
 
     /// Generic log method
-    fileprivate static func log<T>(_ object: @autoclosure () -> T, level: Log.Level, _ fileName: String, _ functionName: String, _ line: Int) {
-        if logLevel.rawValue <= level.rawValue {
-            let date = Log.dateformatter.string(from: Date())
-            let components: [String] = fileName.components(separatedBy: "/")
-            let objectName = components.last ?? "Unknown Object"
-            let levelString = Log.useEmoji ? level.emoji : "|" + level.name.uppercased() + "|"
-            let logString = "\(levelString)\(date) \(objectName) \(functionName) line \(line):\n\(object())"
-            print(logString + "\n")
-            handler?(level, logString)
+    internal func log<T>(_ object: @autoclosure () -> T, level: Log.Level, _ fileName: String, _ functionName: String, _ line: Int) {
+        guard logLevel.rawValue <= level.rawValue else {return}
+
+        let date = Log.dateformatter.string(from: Date())
+        let components: [String] = fileName.components(separatedBy: "/")
+        let objectName = components.last ?? "Unknown Object"
+        let levelString = useEmoji ? level.emoji : "|" + level.name.uppercased() + "|"
+        let logString = "\(levelString)\(date) \(objectName) \(functionName) line \(line):\n\(object())"
+
+        if #available(iOS 14.0, *) {
+            let logger = Logger(subsystem: subsystem, category: name)
+            let objectString = "\(object())"
+            let logMessage = "\(objectName) \(functionName) line \(line)"
+            switch level {
+            case .verbose:
+                logger.trace("\(logMessage):\n\(objectString, privacy: .private)")
+            case .debug:
+                logger.debug("\(logMessage):\n\(objectString, privacy: .private)")
+            case .info:
+                logger.info("\(logMessage):\n\(objectString, privacy: .private)")
+            case .warn:
+                logger.warning("\(logMessage):\n\(objectString, privacy: .private)")
+            case .error:
+                logger.error("\(logMessage):\n\(objectString, privacy: .private)")
+            case .off:
+                break
+            }
+        }
+        else {
+            let nameString = name.count > 0 ? "[\(name)]]" : ""
+            print(nameString + logString + "\n")
         }
+        self.handler?(level, logString)
+        Log.globalHandler?(self, level, logString)
     }
 
-    // MARK: Log Methods
+    // MARK: Public
 
-    public static func error<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
+    public func error<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
         log(object(), level:.error, fileName, functionName, line)
     }
 
-    public static func warn<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
+    public func warn<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
         log(object(), level:.warn, fileName, functionName, line)
     }
 
-    public static func info<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
+    public func info<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
         log(object(), level:.info, fileName, functionName, line)
     }
 
-    public static func debug<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
+    public func debug<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
         log(object(), level:.debug, fileName, functionName, line)
     }
 
-    public static func verbose<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
+    public func verbose<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
         log(object(), level:.verbose, fileName, functionName, line)
     }
 }
+
+// MARK: Static Helper Methods
+extension Log {
+
+    public static var logLevel: Level {
+        get { instance.logLevel }
+        set { instance.logLevel = newValue }
+    }
+
+    public static var useEmoji: Bool {
+        get { instance.useEmoji }
+        set { instance.useEmoji = newValue }
+    }
+
+    public static var handler: InstanceLogHandler? {
+        get { instance.handler }
+        set { instance.handler = newValue }
+    }
+
+    public static func error<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
+        instance.log(object(), level:.error, fileName, functionName, line)
+    }
+
+    public static func warn<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
+        instance.log(object(), level:.warn, fileName, functionName, line)
+    }
+
+    public static func info<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
+        instance.log(object(), level:.info, fileName, functionName, line)
+    }
+
+    public static func debug<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
+        instance.log(object(), level:.debug, fileName, functionName, line)
+    }
+
+    public static func verbose<T>(_ object: @autoclosure () -> T, _ fileName: String = #file, _ functionName: String = #function, _ line: Int = #line) {
+        instance.log(object(), level:.verbose, fileName, functionName, line)
+    }
+}

Pod/Classes/Logging/README.md

@@ -23,12 +23,36 @@ Log levels (from highest to lowest priority):
 - error
 - off
 
+When running on iOS 14 or later, log messages will also be reported to OSLog.
+
 ## Advanced functionality
 
-You can include one custom handler that will get called for any string being logged. Assigning another handler will replace the first.
+You can include one global custom handler that will get called for any string being logged across all Log instances. Assigning another handler will replace the first.
+
+```swift
+Log.globalHandler = { (log, level, string) in
+    sendToAnalytics((key: level, string: string))
+}
+```
+
+Log messages may be categorized by defining separate instances of the Log class.
+
+```swift
+final class Loggers {
+    static let userInterface = Log("UI", logLevel: .verbose)
+    static let app = Log("App")
+    static let network = Log("Network", logLevel: .error)
+}
+
+Loggers.userInterface.info("Button Pressed")
+Loggers.network.error("Token Expired")
+Loggers.app.warn("Out of Memory")
+```
+
+You may also include one custom handler per Log instance. Messages will still be reported to the global handler as well.
 
 ```swift
-Log.handler = { (level, string) in
+Loggers.network.handler = { (level, string) in
     sendToAnalytics((key: level, string: string))
 }
 ```