Ilyas Hallak
03cd32dd4d
- Add guard checks in AppViewModel to prevent sync when hasFinishedSetup is false - Share Extension now shows friendly UI when app not configured or session expired - Check token existence via KeychainHelper instead of attempting API calls - Improve 401 error messages: "Session expired. Please log in via the Readeck app." - Replace #if DEBUG with BuildEnvironment.isDebugBuild for runtime checks - Enable Debug Menu in both DEBUG and TestFlight builds - Replace print() statements with Logger.sync/Logger.viewModel
304 lines
11 KiB
Swift
304 lines
11 KiB
Swift
//
|
||
// Logger.swift
|
||
// readeck
|
||
//
|
||
// Created by Ilyas Hallak on 16.08.25.
|
||
//
|
||
|
||
import Foundation
|
||
import os
|
||
|
||
// MARK: - Log Configuration
|
||
|
||
enum LogLevel: Int, CaseIterable, Codable {
|
||
case debug = 0
|
||
case info = 1
|
||
case notice = 2
|
||
case warning = 3
|
||
case error = 4
|
||
case critical = 5
|
||
|
||
var emoji: String {
|
||
switch self {
|
||
case .debug: return "🔍"
|
||
case .info: return "ℹ️"
|
||
case .notice: return "📢"
|
||
case .warning: return "⚠️"
|
||
case .error: return "❌"
|
||
case .critical: return "💥"
|
||
}
|
||
}
|
||
}
|
||
|
||
enum LogCategory: String, CaseIterable, Codable {
|
||
case network = "Network"
|
||
case ui = "UI"
|
||
case data = "Data"
|
||
case auth = "Authentication"
|
||
case performance = "Performance"
|
||
case general = "General"
|
||
case manual = "Manual"
|
||
case viewModel = "ViewModel"
|
||
case sync = "Sync"
|
||
}
|
||
|
||
class LogConfiguration: ObservableObject {
|
||
static let shared = LogConfiguration()
|
||
|
||
@Published private var categoryLevels: [LogCategory: LogLevel] = [:]
|
||
@Published var globalMinLevel: LogLevel = .debug
|
||
@Published var showPerformanceLogs = true
|
||
@Published var showTimestamps = true
|
||
@Published var includeSourceLocation = true
|
||
@Published var isLoggingEnabled = false
|
||
|
||
private init() {
|
||
// First time setup: Enable logging in DEBUG builds with sensible defaults
|
||
if Bundle.main.isDebugBuild {
|
||
if UserDefaults.standard.object(forKey: "LogConfigurationInitialized") == nil {
|
||
isLoggingEnabled = true
|
||
showPerformanceLogs = true
|
||
showTimestamps = true
|
||
includeSourceLocation = true
|
||
globalMinLevel = .debug
|
||
UserDefaults.standard.set(true, forKey: "LogConfigurationInitialized")
|
||
saveConfiguration()
|
||
}
|
||
}
|
||
|
||
loadConfiguration()
|
||
}
|
||
|
||
func setLevel(_ level: LogLevel, for category: LogCategory) {
|
||
categoryLevels[category] = level
|
||
saveConfiguration()
|
||
}
|
||
|
||
func getLevel(for category: LogCategory) -> LogLevel {
|
||
return categoryLevels[category] ?? globalMinLevel
|
||
}
|
||
|
||
func shouldLog(_ level: LogLevel, for category: LogCategory) -> Bool {
|
||
guard isLoggingEnabled else { return false }
|
||
let categoryLevel = getLevel(for: category)
|
||
return level.rawValue >= categoryLevel.rawValue
|
||
}
|
||
|
||
private func loadConfiguration() {
|
||
// Load from UserDefaults
|
||
if let data = UserDefaults.standard.data(forKey: "LogConfiguration"),
|
||
let config = try? JSONDecoder().decode([String: Int].self, from: data) {
|
||
for (categoryString, levelInt) in config {
|
||
if let category = LogCategory(rawValue: categoryString),
|
||
let level = LogLevel(rawValue: levelInt) {
|
||
categoryLevels[category] = level
|
||
}
|
||
}
|
||
}
|
||
|
||
globalMinLevel = LogLevel(rawValue: UserDefaults.standard.integer(forKey: "LogGlobalLevel")) ?? .debug
|
||
|
||
// Load boolean settings with defaults
|
||
if UserDefaults.standard.object(forKey: "LogShowPerformance") != nil {
|
||
showPerformanceLogs = UserDefaults.standard.bool(forKey: "LogShowPerformance")
|
||
}
|
||
if UserDefaults.standard.object(forKey: "LogShowTimestamps") != nil {
|
||
showTimestamps = UserDefaults.standard.bool(forKey: "LogShowTimestamps")
|
||
}
|
||
if UserDefaults.standard.object(forKey: "LogIncludeSourceLocation") != nil {
|
||
includeSourceLocation = UserDefaults.standard.bool(forKey: "LogIncludeSourceLocation")
|
||
}
|
||
if UserDefaults.standard.object(forKey: "LogIsEnabled") != nil {
|
||
isLoggingEnabled = UserDefaults.standard.bool(forKey: "LogIsEnabled")
|
||
}
|
||
}
|
||
|
||
private func saveConfiguration() {
|
||
let config = categoryLevels.mapKeys { $0.rawValue }.mapValues { $0.rawValue }
|
||
if let data = try? JSONEncoder().encode(config) {
|
||
UserDefaults.standard.set(data, forKey: "LogConfiguration")
|
||
}
|
||
|
||
UserDefaults.standard.set(globalMinLevel.rawValue, forKey: "LogGlobalLevel")
|
||
UserDefaults.standard.set(showPerformanceLogs, forKey: "LogShowPerformance")
|
||
UserDefaults.standard.set(showTimestamps, forKey: "LogShowTimestamps")
|
||
UserDefaults.standard.set(includeSourceLocation, forKey: "LogIncludeSourceLocation")
|
||
UserDefaults.standard.set(isLoggingEnabled, forKey: "LogIsEnabled")
|
||
}
|
||
}
|
||
|
||
struct Logger {
|
||
private let logger: os.Logger
|
||
private let category: LogCategory
|
||
private let config = LogConfiguration.shared
|
||
|
||
init(subsystem: String = Bundle.main.bundleIdentifier ?? "com.romm.app", category: LogCategory) {
|
||
self.logger = os.Logger(subsystem: subsystem, category: category.rawValue)
|
||
self.category = category
|
||
}
|
||
|
||
// MARK: - Log Levels
|
||
|
||
func debug(_ message: String, file: String = #file, function: String = #function, line: Int = #line) {
|
||
guard config.shouldLog(.debug, for: category) else { return }
|
||
let formattedMessage = formatMessage(message, level: .debug, file: file, function: function, line: line)
|
||
logger.debug("\(formattedMessage)")
|
||
storeLog(message: message, level: .debug, file: file, function: function, line: line)
|
||
}
|
||
|
||
func info(_ message: String, file: String = #file, function: String = #function, line: Int = #line) {
|
||
guard config.shouldLog(.info, for: category) else { return }
|
||
let formattedMessage = formatMessage(message, level: .info, file: file, function: function, line: line)
|
||
logger.info("\(formattedMessage)")
|
||
storeLog(message: message, level: .info, file: file, function: function, line: line)
|
||
}
|
||
|
||
func notice(_ message: String, file: String = #file, function: String = #function, line: Int = #line) {
|
||
guard config.shouldLog(.notice, for: category) else { return }
|
||
let formattedMessage = formatMessage(message, level: .notice, file: file, function: function, line: line)
|
||
logger.notice("\(formattedMessage)")
|
||
storeLog(message: message, level: .notice, file: file, function: function, line: line)
|
||
}
|
||
|
||
func warning(_ message: String, file: String = #file, function: String = #function, line: Int = #line) {
|
||
guard config.shouldLog(.warning, for: category) else { return }
|
||
let formattedMessage = formatMessage(message, level: .warning, file: file, function: function, line: line)
|
||
logger.warning("\(formattedMessage)")
|
||
storeLog(message: message, level: .warning, file: file, function: function, line: line)
|
||
}
|
||
|
||
func error(_ message: String, file: String = #file, function: String = #function, line: Int = #line) {
|
||
guard config.shouldLog(.error, for: category) else { return }
|
||
let formattedMessage = formatMessage(message, level: .error, file: file, function: function, line: line)
|
||
logger.error("\(formattedMessage)")
|
||
storeLog(message: message, level: .error, file: file, function: function, line: line)
|
||
}
|
||
|
||
func critical(_ message: String, file: String = #file, function: String = #function, line: Int = #line) {
|
||
guard config.shouldLog(.critical, for: category) else { return }
|
||
let formattedMessage = formatMessage(message, level: .critical, file: file, function: function, line: line)
|
||
logger.critical("\(formattedMessage)")
|
||
storeLog(message: message, level: .critical, file: file, function: function, line: line)
|
||
}
|
||
|
||
// MARK: - Store Log
|
||
|
||
private func storeLog(message: String, level: LogLevel, file: String, function: String, line: Int) {
|
||
guard Bundle.main.isDebugBuild else { return }
|
||
guard config.isLoggingEnabled else { return }
|
||
let entry = LogEntry(
|
||
level: level,
|
||
category: category,
|
||
message: message,
|
||
file: file,
|
||
function: function,
|
||
line: line
|
||
)
|
||
Task {
|
||
await LogStore.shared.addEntry(entry)
|
||
}
|
||
}
|
||
|
||
// MARK: - Convenience Methods
|
||
|
||
func logNetworkRequest(method: String, url: String, statusCode: Int? = nil) {
|
||
guard config.shouldLog(.info, for: category) else { return }
|
||
if let statusCode = statusCode {
|
||
info("🌐 \(method) \(url) - Status: \(statusCode)")
|
||
} else {
|
||
info("🌐 \(method) \(url)")
|
||
}
|
||
}
|
||
|
||
func logNetworkError(method: String, url: String, error: Error) {
|
||
guard config.shouldLog(.error, for: category) else { return }
|
||
self.error("❌ \(method) \(url) - Error: \(error.localizedDescription)")
|
||
}
|
||
|
||
func logPerformance(_ operation: String, duration: TimeInterval) {
|
||
guard config.showPerformanceLogs && config.shouldLog(.info, for: category) else { return }
|
||
info("⏱️ \(operation) completed in \(String(format: "%.3f", duration))s")
|
||
}
|
||
|
||
// MARK: - Private Helpers
|
||
|
||
private func formatMessage(_ message: String, level: LogLevel, file: String, function: String, line: Int) -> String {
|
||
var components: [String] = []
|
||
|
||
if config.showTimestamps {
|
||
let timestamp = DateFormatter.logTimestamp.string(from: Date())
|
||
components.append(timestamp)
|
||
}
|
||
|
||
components.append(level.emoji)
|
||
components.append("[\(category.rawValue)]")
|
||
|
||
if config.includeSourceLocation {
|
||
components.append("[\(sourceFileName(filePath: file)):\(line)]")
|
||
components.append(function)
|
||
}
|
||
|
||
components.append("-")
|
||
components.append(message)
|
||
|
||
return components.joined(separator: " ")
|
||
}
|
||
|
||
private func sourceFileName(filePath: String) -> String {
|
||
return URL(fileURLWithPath: filePath).lastPathComponent.replacingOccurrences(of: ".swift", with: "")
|
||
}
|
||
}
|
||
|
||
// MARK: - Category-specific Loggers
|
||
|
||
extension Logger {
|
||
static let network = Logger(category: .network)
|
||
static let ui = Logger(category: .ui)
|
||
static let data = Logger(category: .data)
|
||
static let auth = Logger(category: .auth)
|
||
static let performance = Logger(category: .performance)
|
||
static let general = Logger(category: .general)
|
||
static let manual = Logger(category: .manual)
|
||
static let viewModel = Logger(category: .viewModel)
|
||
static let sync = Logger(category: .sync)
|
||
}
|
||
|
||
// MARK: - Performance Measurement Helper
|
||
|
||
struct PerformanceMeasurement {
|
||
private let startTime = CFAbsoluteTimeGetCurrent()
|
||
private let operation: String
|
||
private let logger: Logger
|
||
|
||
init(operation: String, logger: Logger = .performance) {
|
||
self.operation = operation
|
||
self.logger = logger
|
||
logger.debug("🚀 Starting \(operation)")
|
||
}
|
||
|
||
func end() {
|
||
let duration = CFAbsoluteTimeGetCurrent() - startTime
|
||
logger.logPerformance(operation, duration: duration)
|
||
}
|
||
}
|
||
|
||
// MARK: - DateFormatter Extension
|
||
|
||
extension DateFormatter {
|
||
static let logTimestamp: DateFormatter = {
|
||
let formatter = DateFormatter()
|
||
formatter.dateFormat = "HH:mm:ss.SSS"
|
||
|
||
return formatter
|
||
}()
|
||
}
|
||
|
||
// MARK: - Dictionary Extension
|
||
|
||
extension Dictionary {
|
||
func mapKeys<T>(_ transform: (Key) throws -> T) rethrows -> [T: Value] {
|
||
return try Dictionary<T, Value>(uniqueKeysWithValues: map { (try transform($0.key), $0.value) })
|
||
}
|
||
}
|
||
|