Customized LoggerKit

Package.swift

@@ -7,16 +7,10 @@ let package = Package(
     name: "LoggerKit",
     platforms: [.iOS(.v13), .watchOS(.v6), .macOS(.v10_15), .tvOS(.v13)],
     products: [
-        // Products define the executables and libraries a package produces, and make them visible to other packages.
         .library(name: "LoggerKit", targets: ["LoggerKit"]),
     ],
-    dependencies: [
-        // Dependencies declare other packages that this package depends on.
-        // .package(url: /* package url */, from: "1.0.0"),
-    ],
+    dependencies: [],
     targets: [
-        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
-        // Targets can depend on other targets in this package, and on products in packages this package depends on.
         .target(name: "LoggerKit", dependencies: []),
         .testTarget(name: "LoggerKitTests", dependencies: ["LoggerKit"]),
     ]

Sources/LoggerKit/Loggable+Extension.swift

@@ -0,0 +1,20 @@
+//
+//  Loggable+Extension.swift
+//  
+//
+//  Created by Vishweshwaran on 19/02/23.
+//
+
+import Foundation
+
+extension Loggable {
+
+    public static var logTag: String {
+        return String(describing: self)
+    }
+
+    public static var logConfig: LoggerKit.LoggerConfig {
+        get { return Self.logConfig }
+        set { Self.logConfig = newValue }
+    }
+}

Sources/LoggerKit/LoggerKit.swift

@@ -7,11 +7,15 @@
 
 import Foundation
 
-public enum Logger: Loggable {
+public protocol Loggable {
+    static var logTag: String { get }
+    static var logConfig: LoggerKit.LoggerConfig { get set }
+}
+
+public struct LoggerKit {
 
-    enum LogLevel {
-
-        case verbose, info, debug, warning, error
+    enum LogLevel: Int {
+        case verbose = 0, info, debug, warning, error
         case `init`, `deinit`
 
         fileprivate var prefix: String {
@@ -33,34 +37,150 @@ public enum Logger: Loggable {
         let line: Int
 
         var description: String {
-            guard let file else { return "\(line)" }
+            guard let file = file else { return "\(line)" }
             return "\((file as NSString).lastPathComponent): \(line)"
         }
     }
 
-    static func handleLog(level: LogLevel, message: Any?..., shouldLogContext: Bool, context: Context) {
-        var logComponents: [String] = []
+    public struct LoggerConfig {
 
-        if shouldLogContext {
-            if level == .`init` || level == .deinit {
-                logComponents.append("\t\t\t \(level.prefix)")
-            } else {
-                logComponents.append(level.prefix)
-            }
+        let enable: Bool
+        let severity: LoggerKit.LogLevel
+
+        init(enable: Bool, severity: LoggerKit.LogLevel = .info) {
+            self.enable = enable
+            self.severity = severity
+        }
+
+        func shouldLog(_ level: LoggerKit.LogLevel) -> Bool {
+            return level.rawValue >= self.severity.rawValue
         }
+    }
+}
 
-        logComponents.append("\(context.description) -")
+public extension Loggable {
+
+    static func info(_ message: Any..., shouldLogContext: Bool = true, file: String = #file, line: Int = #line) {
+        let context = LoggerKit.Context(file: file, line: line)
+        handleLog(
+            level: .info,
+            message: formatLogMessage(message),
+            shouldLogContext: shouldLogContext,
+            context: context,
+            logTag: logTag,
+            logConfig: logConfig
+        )
+    }
+
+    static func verbose(_ message: Any..., shouldLogContext: Bool = true, file: String = #file, line: Int = #line) {
+        let context = LoggerKit.Context(file: file, line: line)
+        handleLog(
+            level: .verbose,
+            message: formatLogMessage(message),
+            shouldLogContext: shouldLogContext,
+            context: context,
+            logTag: logTag,
+            logConfig: logConfig
+        )
+    }
+
+    static func debug(_ message: Any..., shouldLogContext: Bool = true, file: String = #file, line: Int = #line) {
+        let context = LoggerKit.Context(file: file, line: line)
+        handleLog(
+            level: .debug,
+            message: formatLogMessage(message),
+            shouldLogContext: shouldLogContext,
+            context: context,
+            logTag: logTag,
+            logConfig: logConfig
+        )
+    }
+
+    static func warning(_ message: Any..., shouldLogContext: Bool = true, file: String = #file, line: Int = #line) {
+        let context = LoggerKit.Context(file: file, line: line)
+        handleLog(
+            level: .warning,
+            message: formatLogMessage(message),
+            shouldLogContext: shouldLogContext,
+            context: context,
+            logTag: logTag,
+            logConfig: logConfig
+        )
+    }
+
+    static func error(_ message: Any..., shouldLogContext: Bool = true, file: String = #file, line: Int = #line) {
+        let context = LoggerKit.Context(file: file, line: line)
+        handleLog(
+            level: .error,
+            message: formatLogMessage(message),
+            shouldLogContext: shouldLogContext,
+            context: context,
+            logTag: logTag,
+            logConfig: logConfig
+        )
+    }
+
+    static func initialize(_ message: Any..., shouldLogContext: Bool = false, file: String = #file, line: Int = #line) {
+        let context = LoggerKit.Context(file: file, line: line)
+        handleLog(
+            level: .`init`,
+            message: formatLogMessage(message),
+            shouldLogContext: shouldLogContext,
+            context: context,
+            logTag: logTag,
+            logConfig: logConfig
+        )
+    }
+
+    static func teardown(_ message: Any..., shouldLogContext: Bool = false, file: String = #file, line: Int = #line) {
+        let context = LoggerKit.Context(file: file, line: line)
+        handleLog(
+            level: .deinit,
+            message: formatLogMessage(message),
+            shouldLogContext: shouldLogContext,
+            context: context,
+            logTag: logTag,
+            logConfig: logConfig
+        )
+    }
+}
+
+extension Loggable {
+
+    private static func handleLog(
+        level: LoggerKit.LogLevel,
+        message: String,
+        shouldLogContext: Bool,
+        context: LoggerKit.Context,
+        logTag: String,
+        logConfig: LoggerKit.LoggerConfig
+    ) {
+        guard logConfig.enable else { return }
+        guard logConfig.shouldLog(level) else { return }
 
-        message.forEach { message in
-            if let message {
-                logComponents.append(String(describing: message))
-            }
+        var logComponents: [String] = []
+
+        let logFormat = "\(level.prefix) [\(logTag)]"
+
+        switch level {
+        case .`init`, .deinit:
+            logComponents.append("\t\t\t \(logFormat):")
+        default:
+            logComponents.append(logFormat)
         }
 
+        if shouldLogContext { logComponents.append("\(context.description) -") }
+
+        logComponents.append(message)
+
         let fullString = logComponents.joined(separator: " ")
 
         #if DEBUG
         print(fullString)
         #endif
     }
+
+    private static func formatLogMessage(_ message: Any...) -> String {
+        message.map { String(describing: $0) }.joined(separator: " ")
+    }
 }

Tests/LoggerKitTests/LoggerKitTests.swift

@@ -3,6 +3,11 @@ import XCTest
 
 final class LogKitTests: XCTestCase {
 
+    struct Logger: Loggable {
+        static var logTag: String = "LoggerKitTests"
+        static var logConfig: LoggerKit.LoggerConfig = .init(enable: true)
+    }
+
     func testInitLog() {
         Logger.initialize("LogKitTest Init")
     }
@@ -16,7 +21,7 @@ final class LogKitTests: XCTestCase {
     }
 
     func testDebugLog() {
-        Logger.debug("Debug mode enabled")
+        Logger.debug("Debug Mode")
     }
 
     func testWarningLog() {
@@ -49,14 +54,6 @@ final class LogKitTests: XCTestCase {
         Logger.verbose("Something went wrong! \(errorMessage)")
     }
 
-    func testLogWithoutParameter() {
-        Logger.error()
-        Logger.info()
-        Logger.debug()
-        Logger.warning()
-        Logger.verbose()
-    }
-
     func testWithComplexObjects() {
 
         struct LogTest {