version 0.1.0

Author: crspybits

Package.resolved

@@ -9,6 +9,15 @@
           "revision": "173f567a2dfec11d74588eea82cecea555bdc0bc",
           "version": "1.4.0"
         }
+      },
+      {
+        "package": "XCGLogger",
+        "repositoryURL": "https://github.com/DaveWoodCom/XCGLogger.git",
+        "state": {
+          "branch": null,
+          "revision": "a9c4667b247928a29bdd41be2ec2c8d304215a54",
+          "version": "7.0.1"
+        }
       }
     ]
   },

Package.swift

@@ -12,15 +12,20 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
+        .package(url: "https://github.com/DaveWoodCom/XCGLogger.git", from: "7.0.0")
     ],
     targets: [
         .target(
             name: "FileLogging",
             dependencies: [
+                "XCGLogger",
                 .product(name: "Logging", package: "swift-log")
             ]),
         .testTarget(
             name: "swift-log-fileTests",
-            dependencies: ["FileLogging"]),
+            dependencies: [
+                "FileLogging",
+                "XCGLogger"
+            ]),
     ]
 )

README.md

@@ -30,4 +30,33 @@ let logger = Logger(label: "Test")
 
 Note in that last example, if you use `LoggingSystem.bootstrap`, make sure to create your `Logger` *after* the  `LoggingSystem.bootstrap` usage (or you won't get the effects of the `LoggingSystem.bootstrap`).
 
+## Example: Using XCGLogger
+
+[XCGLogger](https://github.com/DaveWoodCom/XCGLogger.git) supports rotating file logs amongst other features.
+
+```swift
+let logFileURL = URL(/* your local log file here */)
+let xcgLogger = /* Make your XCGLogger, using logFileURL */
+let logger = XCGLogging.logger(label: "Test", logger: xcgLogger)
+logger.error("Test Test Test")
+```
+
+## Example: Logging to both the standard output (Xcode console if using Xcode) and a file using XCGLogger.
+
+```swift
+let logFileURL = try getDocumentsDirectory().appendingPathComponent(logFileName)
+let xcgLogger = /* Make your XCGLogger, using logFileURL */
+
+LoggingSystem.bootstrap { label in
+    let handlers:[LogHandler] = [
+        XCGLoggerHandler(label: label, logger: xcgLogger),
+        StreamLogHandler.standardOutput(label: label)
+    ]
+
+    return MultiplexLogHandler(handlers)
+}
+
+let logger = Logger(label: "Test")
+```
+
 For more examples, see the unit tests and refer to [apple/swift-log's README](https://github.com/apple/swift-log#the-core-concepts)

Sources/FileLogging/swift_log_xcglogger.swift

@@ -0,0 +1,84 @@
+
+import Logging
+import Foundation
+import XCGLogger
+
+public struct XCGLogging {
+    let logger:XCGLogger
+    
+    public init(logger:XCGLogger) {
+        self.logger = logger
+    }
+    
+    public func handler(label: String) -> XCGLoggerHandler {
+        return XCGLoggerHandler(label: label, logger: logger)
+    }
+    
+    public static func logger(label: String, logger:XCGLogger) -> Logger {
+        let logging = XCGLogging(logger: logger)
+        return Logger(label: label, factory: logging.handler)
+    }
+}
+
+/// `XCGLoggerHandler` is an implementation of `LogHandler` that makes use of the XCGLogger.
+public struct XCGLoggerHandler: LogHandler {
+    private var xcgLogger:XCGLogger
+    private var label: String
+    
+    public var logLevel: Logger.Level = .info
+
+    public var metadata = Logger.Metadata()
+
+    public subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
+        get {
+            return self.metadata[metadataKey]
+        }
+        set {
+            self.metadata[metadataKey] = newValue
+        }
+    }
+
+    public init(label: String, logger:XCGLogger) {
+        self.label = label
+        self.xcgLogger = logger
+    }
+    
+    public func log(level: Logger.Level,
+                    message: Logger.Message,
+                    metadata: Logger.Metadata?,
+                    source: String,
+                    file: String = #file,
+                    function: String = #function,
+                    line: UInt = #line) {
+
+        let xcgLoggerLevel = convert(level: level)
+        xcgLogger.logln(xcgLoggerLevel, functionName: function, fileName: file, lineNumber: Int(line), userInfo: metadata ?? self.metadata) {
+            return message
+        }
+    }
+    
+    func convert(level: Logger.Level) -> XCGLogger.Level {
+        switch level {
+        case .trace:
+            return .verbose
+            
+        case .debug:
+            return .debug
+            
+        case .info:
+            return .info
+            
+        case .notice:
+            return .notice
+            
+        case .warning:
+            return .warning
+            
+        case .error:
+            return .error
+            
+        case .critical:
+            return .severe
+        }
+    }
+}

Tests/swift-log-fileTests/Utilities.swift

@@ -0,0 +1,30 @@
+
+import Foundation
+
+enum TestError: Error {
+    case noDocumentDirectory
+    case cannotGetFileSize
+}
+    
+protocol Utilities {
+}
+
+extension Utilities {
+    func getDocumentsDirectory() throws -> URL {
+        let paths = FileManager.default.urls(for: .downloadsDirectory, in: .userDomainMask)
+        guard paths.count > 0 else {
+            throw TestError.noDocumentDirectory
+        }
+        
+        return paths[0]
+    }
+    
+    func getFileSize(file: URL) throws -> UInt64 {
+        let attr = try FileManager.default.attributesOfItem(atPath: file.path)
+        guard let fileSize = attr[FileAttributeKey.size] as? UInt64 else {
+            throw TestError.cannotGetFileSize
+        }
+
+        return fileSize
+    }
+}

Tests/swift-log-fileTests/swift_log_fileTests.swift

@@ -2,12 +2,7 @@ import XCTest
 @testable import FileLogging
 @testable import Logging
 
-enum TestError: Error {
-    case noDocumentDirectory
-    case cannotGetFileSize
-}
-
-final class swift_log_fileTests: XCTestCase {
+final class swift_log_fileTests: XCTestCase, Utilities {
     let logFileName = "LogFile.txt"
 
     func testLogToFileUsingBootstrap() throws {
@@ -21,6 +16,8 @@ final class swift_log_fileTests: XCTestCase {
 
         // Not really an error.
         logger.error("Test Test Test")
+        
+        try? FileManager.default.removeItem(at: logFileURL)
     }
 
     func testLogToFileAppendsAcrossLoggerCalls() throws {
@@ -39,6 +36,7 @@ final class swift_log_fileTests: XCTestCase {
         let fileSize2 = try getFileSize(file: logFileURL)
 
         XCTAssert(fileSize2 > fileSize1)
+        try? FileManager.default.removeItem(at: logFileURL)
     }
 
     func testLogToFileAppendsAcrossConstructorCalls() throws {
@@ -55,6 +53,7 @@ final class swift_log_fileTests: XCTestCase {
         let fileSize2 = try getFileSize(file: logFileURL)
 
         XCTAssert(fileSize2 > fileSize1)
+        try? FileManager.default.removeItem(at: logFileURL)
     }
 
     // Adapted from https://nshipster.com/swift-log/
@@ -75,6 +74,7 @@ final class swift_log_fileTests: XCTestCase {
 
         // TODO: Manually check that the output also shows up in the Xcode console.
         logger.error("Test Test Test")
+        try? FileManager.default.removeItem(at: logFileURL)
     }
 
     func testLoggingUsingLoggerFactoryConstructor() throws {
@@ -90,6 +90,7 @@ final class swift_log_fileTests: XCTestCase {
         let fileSize2 = try getFileSize(file: logFileURL)
 
         XCTAssert(fileSize2 > fileSize1)
+        try? FileManager.default.removeItem(at: logFileURL)
     }
 
     func testLoggingUsingConvenienceMethod() throws {
@@ -104,25 +105,6 @@ final class swift_log_fileTests: XCTestCase {
         let fileSize2 = try getFileSize(file: logFileURL)
 
         XCTAssert(fileSize2 > fileSize1)
-    }
-    
-    // MARK: Helpers
-    
-    func getDocumentsDirectory() throws -> URL {
-        let paths = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)
-        guard paths.count > 0 else {
-            throw TestError.noDocumentDirectory
-        }
-        
-        return paths[0]
-    }
-    
-    func getFileSize(file: URL) throws -> UInt64 {
-        let attr = try FileManager.default.attributesOfItem(atPath: file.path)
-        guard let fileSize = attr[FileAttributeKey.size] as? UInt64 else {
-            throw TestError.noDocumentDirectory
-        }
-
-        return fileSize
+        try? FileManager.default.removeItem(at: logFileURL)
     }
 }