优化iOS日志管理：构建高效的日志体系

胖虎1

已于 2024-09-30 09:31:36 修改

阅读量1.3k

点赞数 11

分类专栏： # 开发经验分享文章标签： ios 日志

于 2024-09-27 16:26:31 首次发布

本文链接：https://blog.csdn.net/weixin_39339407/article/details/142585516

版权

开发经验分享专栏收录该内容

66 篇文章

订阅专栏

引言

在现代应用程序开发中，日志记录不仅仅是调试工具，它也是性能监控和安全审计的关键组成部分。有效的日志管理能够帮助开发者快速识别和理解问题，同时提供系统运行状态的深刻洞察。在这篇博客中，我们将深入讨论日志的重要性，分享在写日志时需要注意的事项，并介绍在iOS项目中基于SwiftyBeaver构建的高效日志体系。让我们一起探索如何提升日志记录的安全性与性能。

日志的重要性

日志的作用主要体现在以下几个方面：

调试与问题追踪：日志记录可以帮助开发者快速定位错误和异常，使问题解决更高效。
性能监控：通过记录应用性能数据，开发者可以识别性能瓶颈，进行优化，确保用户体验流畅。
安全审计：日志为应用提供了审计轨迹，有助于检测和分析潜在的安全威胁，确保数据安全。
用户行为分析：记录用户操作可以帮助团队理解用户行为，从而改进产品功能和用户体验。

注意事项

我们在构建日志管理系统和写入日志时有一些具体的注意事项：

日志级别的选择：根据重要性选择合适的日志级别，避免过多的无关信息。
一致的日志合适：确保日志格式统一，便于后期分析和排查问题。
敏感信息处理：避免在日志中记录敏感信息，保护用户隐私。
线程安全：在多线程环境中，确保日志写入的线程安全，防止数据竞争和混乱。可以使用锁配合队列
或者其他的同步机制来实现安全的写入，确保日志记录的准确性和一致性。

实现方案

在此日志方案致力于构建一个高效的日志记录系统，主要由两部分组成：一个线程安全的缓存队列和一个后台写入队列。首先，所有日志消息会先被放入线程安全的缓存队列中，这样可以确保在多线程环境写日志的安全性，避免数据竞争。接着，从缓存队列中读取数据并将其传递到后台写入队列，后台线程负责将日志实际写入存储。这种设计不仅确保了日志记录的准确性，还避免了在主线程中执行写入操作，减少了CPU资源的占用，从而提升了整体应用性能。

日志类型枚举

在此日志方案中，首先定义了一个枚举类型ZMLogLevel，用于表示日志的不同级别。这有助开发者根据消息的重要性进行分类，从而优化日志管理。该枚举包含四个级别：

debug：用于调试信息，通常用于开发阶段，帮助开发者跟踪代码执行过程。
info：表示常规信息，记录系统的正常运行状态。
warning：用来警告潜在的问题，提示开发者关注，但不一定是错误。
error：表示发生了错误，通常需要开发者及时处理。

ZMLogDefine.swift

/// 日志级别
enum ZMLogLevel {
    /// debug
    case debug
    /// info
    case info
    /// warning
    case warning
    /// error
    case error
}

通过使用ZMLogLevel，开发者可以灵活控制日志的输出，确保日志信息的清晰和有效。

日志数据

为了更好地管理和记录日志，我们定义了一个结构体ZMLogData。该结构体包含多个属性，用于详细描述日志信息：

level：类型为ZMLogLevel，表示日志的级别，帮助开发者区分信息的重要性。
module：一个字符串，表示生成该日志的模块或组件，便于追踪来源。
message：用户存储日志内容，可以是任何类型的消息，提供灵活性。
fileName：记录日志产生的文件名，帮助开发者快速定位问题。
funcName：表示生成日志的函数名，进一步提高追踪的准确性。
line：记录生产日志的代码行号，为调试提供精确参考。

ZMLogData

struct ZMLogData {
    /// 日志级别
    var level: ZMLogLevel
    /// 模块
    var module: String
    /// 日志
    var message: Any
    /// 文件名
    var fileName: String
    /// 方法名
    var funcName: String
    /// 行号
    var line: Int
    
}

通过使用ZMLogData结构体，我们能够系统化地组织日志信息，提升日志的可读性和可追溯性。

日志缓存队列

为了实现日志的高效缓存，我们需要创建一个线程安全的缓存队列ZMLogQueue类，该类负责管理日志数据的进出队列，以下是该类的主要功能和实现细节：

锁机制：为了确保在多线程环境中对日志数据的写入安全，我们使用了NSLock来进行线程同步。每次操作队列都会加锁，确保数据的完整性。
日志数据数组：logDataArray数组用户存储日志数据，类型为[ZMLogData]，确保所有日志信息按照顺序存储。
进队：enqueue(_:)方法允许将新的日志数据添加到队列中。在添加日志之前，会加锁以避免并发写入导致数据竞争。
出队：dequeue()方法用户从队列中取出日志数据。取出后会自动移除队首日志，同时在操作前加锁，以保证安全性。
是否为空：isEmpty()方法用于检查队列是否为空，方便调用者判断是否有待处理的日志。
清空：clear()方法用于清空队列中的所有日志数据，便于重置或清理状态。

ZMLogQueue

class ZMLogQueue: NSObject {
    
    /// 锁
    private let lock = NSLock()

    /// 日志数据
    private var logDataArray:[ZMLogData] = []
    
    /// 进队
    func enqueue(_ logData: ZMLogData) {
        lock.lock()
        logDataArray.append(logData)
        lock.unlock()
    }
    
    /// 出队
    func dequeue() -> ZMLogData? {
        lock.lock()
        let logData = logDataArray.first
        logDataArray.removeFirst()
        lock.unlock()
        return logData
    }
    
    /// 是否为空
    func isEmpty() -> Bool {
        return logDataArray.isEmpty
    }
    
    /// 清空
    func clear() {
        logDataArray.removeAll()
    }
   
}

通过这个缓存队列的设计，我能够高效、安全地管理日志数据，确保在多线程环境下的可靠性。

日志管理

为了简化日志记录的使用和管理，我们还需要实现一个ZMLogHelper类，该类采用了单利的模式，确保在应用的任何地方都能方便地方法和使用日志功能。以下是该类的注意特点：

单利模式：使用static let shared定义了一个共享实例，使得整个应用可以统一使用这个日志助手，避免多次实例化。
日志记录：通过集成SwiftyBeaver，ZMLogHelper提供了多种日志级别的记录功能，包括debug、info、warning和error。每个方法都接受日志消息及相关的上下文信息（如模块、文件名、函数名和行号），并将这些信息封装为ZMLogData实例。
队列管理：内部使用ZMLogQueue类来缓存日志数据，确保在多线程环境中安全地处理日志信息。
后台线程处理：日志的实际写入操作在另外一个后台线程中进行，这样可以避免主线程的阻塞，提升应用的相应速度。
处理流程：每当记录日志时，ZMLogHelper会将日志数据添加到缓存队列中，并启动后台线程进行处理，确保所有日志信息都能及时且高效地写入。

ZMLogHelper

import SwiftyBeaver

class ZMLogHelper: NSObject {
    
    /// 日志
    static private let log = SwiftyBeaver.self
    /// 队列
    static private let logDataQueue = ZMLogQueue()
    /// 创建一个后台线程
    static private let logQueue = DispatchQueue(label: "com.zm.log.queue", qos: .background)
    
    static func startLog() {
        let console = ConsoleDestination()
        // 年月日时分秒
        console.format = "$Dyyyy-MM-dd HH:mm:ss.SSS$d $C$L$c $N.$F:$l - $M"
        log.addDestination(console)
    }
    
    /// debug日志
    static func debug(_ message: Any, module: String = "", fileName: String = #file, funcName: String = #function, line: Int = #line) {
        let logData = ZMLogData(level: .debug, module: module, message: message, fileName: fileName, funcName: funcName, line: line)
        logDataQueue.enqueue(logData)
        startProcessLog()
    }
    
    static private func logDebug(_ message: Any, module: String = "", fileName: String = #file, funcName: String = #function, line: Int = #line) {
        log.debug(module + " " + "\(message)", file: fileName, function: funcName, line: line)
    }
    
    /// info日志
    static func info(_ message: Any, module: String = "", fileName: String = #file, funcName: String = #function, line: Int = #line) {
        let logData = ZMLogData(level: .info, module: module, message: message, fileName: fileName, funcName: funcName, line: line)
        logDataQueue.enqueue(logData)
        startProcessLog()
    }
    
    static private func logInfo(_ message: Any, module: String = "", fileName: String = #file, funcName: String = #function, line: Int = #line) {
        log.info(module + " " + "\(message)", file: fileName, function: funcName, line: line)
    }
    
    /// warning日志
    static func warning(_ message: Any, module: String = "", fileName: String = #file, funcName: String = #function, line: Int = #line) {
        let logData = ZMLogData(level: .warning, module: module, message: message, fileName: fileName, funcName: funcName, line: line)
        logDataQueue.enqueue(logData)
        startProcessLog()
    }
    
    static private func logWarning(_ message: Any, module: String = "", fileName: String = #file, funcName: String = #function, line: Int = #line) {
        log.warning(module + " " + "\(message)", file: fileName, function: funcName, line: line)
    }
    
    /// error日志
    static func error(_ message: Any, module: String = "", fileName: String = #file, funcName: String = #function, line: Int = #line) {
        let logData = ZMLogData(level: .error, module: module, message: message, fileName: fileName, funcName: funcName, line: line)
        logDataQueue.enqueue(logData)
        startProcessLog()
    }
    
    static private func logError(_ message: Any, module: String = "", fileName: String = #file, funcName: String = #function, line: Int = #line) {
        log.error(module + " " + "\(message)", file: fileName, function: funcName, line: line)
    }
    
    /// 开始处理日志
    static private func startProcessLog() {
        logQueue.async {
            while !self.logDataQueue.isEmpty() {
                self.processLog()
            }
        }
    }
    
    /// 处理日志
    static private func processLog() {
        guard let logData = logDataQueue.dequeue() else {
            return
        }
        switch logData.level {
        case .debug:
            logDebug(logData.message, module: logData.module, fileName: logData.fileName, funcName: logData.funcName, line: logData.line)
        case .info:
            logInfo(logData.message, module: logData.module, fileName: logData.fileName, funcName: logData.funcName, line: logData.line)
        case .warning:
            logWarning(logData.message, module: logData.module, fileName: logData.fileName, funcName: logData.funcName, line: logData.line)
        case .error:
            logError(logData.message, module: logData.module, fileName: logData.fileName, funcName: logData.funcName, line: logData.line)
        }
    }
}

通过ZMLogHelper，开发者可以轻松地记录和管理日志，提升调试和问题追踪的效率。

结语

在这篇博客中，我们深入探讨了日志的重要性以及在iOS项目中构建高效日志体系的方法。从定义日志级别到实现线程安全的日志缓存队列，再到使用ZMLogHelpler类简化日志记录的流程，这些设计思路旨在提升日志管理的效率和安全性。希望这个设计思路能够为大家的工作提供启发让你在面对复杂问题时能够高效地进行调试和追踪。也欢迎大家分享自己的日志管理经验！让我们一起提升开发效率！