🔍 Logger

Features

Why Logger?

Logging format:

Logger.debug("Network.connect - connection established successfully", tag: .net)
// Output: [🔵 Debug] [2023年12月24日 22:00:45] ➞ 📡 Network.connect: connection established successfully
Logger.warning("Network.connect \(error.localizedDescription)", tag: .net)
// Output: [🟠 Warning] [2023年12月24日 22:00:45] ➞ 📡 Network.connect: Wi-Fi is not turned on
Logger.error("Network.processData \(error.localizedDescription)", tag: .net)
// Output: [🔴 Error] [2023年12月24日 22:00:45] ➞ 📡 Network.processData: Decoding was unsuccessful. Nothing was saved

Configure:

// Configure the logger output format
Logger.config = .plain // Options: .plain (no date), .full (includes date and verbose level)
// Set the output transport method
Logger.type = .console // Options: .console, .file(filePath: String), .custom(onLog: LogType.OnLog)
// Define the logging mode for levels and tags
Logger.mode = .everything // Options: .everything (all logs), .nothing (disable logging), .essential (warnings and errors only)
// Convenient one-liner setup
Logger.setup(config: .full, mode: .essential, type: .console)

Add custom log end-point like GA or Firebase crashalytics

// Define a custom logging function
let onLog: LogType.OnLog = { msg, level, tag in
 // Only send warnings and errors to the custom endpoint
 if [.error, .warning].contains(level) {
 sendToAnalytics(msg, level: level, tag: tag)
 }
}
// Set the logger to use the custom output
Logger.type = .custom(onLog)
Logger.warn("User session expired", tag: .security) // This will be sent to the custom endpoint
Logger.error("Failed to save data", tag: .db) // This will be sent to the custom endpoint
Logger.info("User opened settings", tag: .ui) // This will not be sent

Note

Since iOS14+ Target apples own Logger class, write: os.Logger

Logging to Console.app

import os // Need to import os.Logger
let logger = os.Logger(subsystem: "co.acme.ExampleApp", category: "ExampleApp")
let onLog: LogType.OnLog = { msg, level, _ in
 logger.log("\(msg, privacy: .public)") // Reveals the redacted text from the message
}
Logger.type = .custom(onLog) // Add the custom output closure to the logger
Logger.info("Something happened") // Prints to Console.app (filter by category or subsystem)

Tracing

class Test {
 func myFunction() {
 Trace.trace("This msg")
 }
}
Test().myFunction() // Prints "This msg is called from function: myFunction in class: Test on line: 13"

Trace + Logger

Logger.warn("\(Trace.trace() - error occured", tag: .net) - error occured") // Called inside NetManager.connect
// Prints: [️🟠 Warning] [23-12-24 22:00:45] ➞ 📡 NetManager.connect - error occured

Gotchas

Installation

.package(url: "https://github.com/sentryco/Logger", branch: "main")

.target(
 name: "MyTarget",
 dependencies: [
 .product(name: "Logger", package: "Logger"),
 ]
),

Todo:

protocol LoggerProtocol {
 func log(message: String, level: LogLevel, tag: LogTag)
}
// Implementations
class ConsoleLogger: LoggerProtocol {
 func log(message: String, level: LogLevel, tag: LogTag) {
 Swift.print(message)
 }
}
class FileLogger: LoggerProtocol {
 // File logging implementation...
}

extension String {
 enum ConsoleColor: String {
 case red = "\u{001B}[0;31m"
 case orange = "\u{001B}[0;33m"
 case blue = "\u{001B}[0;34m"
 case purple = "\u{001B}[0;35m"
 case reset = "\u{001B}[0;0m"
 }
 func colored(_ color: ConsoleColor) -> String {
 return "\(color.rawValue)\(self)\(ConsoleColor.reset.rawValue)"
 }
}
// Apply Colors in Logging:
extension Logger {
 fileprivate static func formatMessage(_ msg: String, level: LogLevel, tag: LogTag) -> String {
 // Existing formatting code...
 var text = "[\(levelText)]"
 if config.showDate {
 let date = config.dateFormatter.string(from: Date())
 text += " [\(date)]"
 }
 text += " ➞ \(tag.rawValue)\(msg)"
 // Apply color based on log level
 switch level {
 case .error:
 text = text.colored(.red)
 case .warning:
 text = text.colored(.orange)
 case .debug:
 text = text.colored(.blue)
 case .info:
 text = text.colored(.purple)
 }
 return text
 }
}

import os
public enum LogType {
 // Existing cases...
 case osLog(OSLog = .default)
}
extension LogType {
 internal func log(msg: String, level: LogLevel, tag: LogTag) {
 switch self {
 // Existing cases...
 case let .osLog(logger):
 if #available(iOS 14.0, macOS 11.0, *) {
 logger.log("\(msg, privacy: .public)")
 } else {
 os_log("%{public}@", log: logger, type: .default, msg)
 }
 }
 }
}
// Configure logger to use osLog
Logger.type = .osLog()
// Log messages
Logger.info("Application started", tag: .system)

// Set Up Exception Handler:
func setUpExceptionHandler() {
 NSSetUncaughtExceptionHandler { exception in
 Logger.error("Uncaught exception: \(exception)", tag: .system)
 }
}
// Set Up Signal Handler:
import Darwin
func setUpSignalHandler() {
 signal(SIGABRT) { _ in
 Logger.error("Received SIGABRT signal", tag: .system)
 }
 signal(SIGILL) { _ in
 Logger.error("Received SIGILL signal", tag: .system)
 }
 // Add handlers for other signals as needed
}
// Call Handlers at App Launch:
// In AppDelegate or main entry point
func applicationDidFinishLaunching(_ application: UIApplication) {
 setUpExceptionHandler()
 setUpSignalHandler()
 // Other initialization code...
}
// Extend LogType:
public enum LogType {
 // Existing cases...
 case crashlytics
}
// Implement Crashlytics Logging:
extension LogType {
 internal func log(msg: String, level: LogLevel, tag: LogTag) {
 switch self {
 // Existing cases...
 case .crashlytics:
 Crashlytics.crashlytics().log(msg)
 if level == .error {
 let error = NSError(domain: Bundle.main.bundleIdentifier ?? "Logger", code: 0, userInfo: [NSLocalizedDescriptionKey: msg])
 Crashlytics.crashlytics().record(error: error)
 }
 }
 }
}
// Usage Example:
Logger.type = .crashlytics
Logger.error("Critical failure", tag: .system)

public enum LogLevel: String, CaseIterable {
 // Existing cases...
 case important = "🟢"
}

extension LogLevel {
 var title: String {
 switch self {
 // Existing cases...
 case .important:
 return "Important"
 }
 }
}

extension Logger {
 public static func important(_ msg: String, tag: LogTag = .other) {
 log(msg, level: .important, tag: tag)
 }
}

Logger.important("User achieved a significant milestone", tag: .achievement)

public protocol LoggerProtocol {
 func log(_ msg: String, level: LogLevel, tag: LogTag)
}

public class ConsoleLogger: LoggerProtocol {
 public func log(_ msg: String, level: LogLevel, tag: LogTag) {
 print(msg)
 }
}
public class FileLogger: LoggerProtocol {
 private let filePath: String
 public init(filePath: String) {
 self.filePath = filePath
 }
 public func log(_ msg: String, level: LogLevel, tag: LogTag) {
 // Implement file writing logic here
 }
}

public final class Logger {
 public static var logger: LoggerProtocol = ConsoleLogger()
 // Modify log methods to use `logger.log(...)`
}

Logger.logger = FileLogger(filePath: "/path/to/log.txt")
Logger.info("This will be logged to a file")

extension Logger {
 public static func logAsync(_ msg: String, level: LogLevel, tag: LogTag) async {
 await withCheckedContinuation { continuation in
 DispatchQueue.global(qos: .utility).async {
 log(msg, level: level, tag: tag)
 continuation.resume()
 }
 }
 }
}
Task {
 await Logger.logAsync("Asynchronous log message", level: .info, tag: .system)
}

extension LogType {
 private static let fileWriteQueue = DispatchQueue(label: "com.logger.fileWriteQueue")
 static func writeToFile(string: String, filePath: String) {
 fileWriteQueue.async {
 // File writing code...
 }
 }
}