用 C 创建健壮的日志系统

创建强大的软件需要做出深思熟虑的设计选择，以简化代码维护和扩展功能。其中一个示例是在 C 应用程序中实现日志记录功能。日志记录不仅仅是打印错误消息；它是关于构建一个支持调试、分析甚至跨平台兼容性的结构化系统。

在本文中，我们将受现实场景的启发，探索如何使用设计模式和最佳实践逐步构建日志系统。最后，您将对用 C 语言创建灵活且可扩展的日志系统有深入的了解。

目录

1. 日志记录的需要
2. 组织日志文件
3. 创建中央日志功能
4. 实现软件模块过滤器
5. 添加条件日志记录
6. 正确管理资源
7. 确保线程安全
8. 外部和动态配置
9. 自定义日志格式
10. 内部错误处理
11. 性能和效率
12. 安全最佳实践
13. 与日志记录工具集成
14. 测试和验证
15. 跨平台文件记录
16. 把一切都包起来
17. 额外

---

日志记录的需要

想象一下维护部署在远程站点的软件系统。每当出现问题时，您必须亲自出差来调试问题。随着部署在地理上的扩展，这种设置很快就会变得不切实际。记录可以挽救局面。

日志记录提供了执行过程中关键点的系统内部状态的详细记录。通过检查日志文件，开发人员可以诊断和解决问题，而无需直接重现问题。这对于难以在受控环境中重新创建的偶发错误特别有用。

日志记录的价值在多线程应用程序中变得更加明显，其中错误可能取决于时间和竞争条件。在没有日志的情况下调试这些问题需要大量的努力和专门的工具，而这些工具可能并不总是可用。日志提供了所发生事件的快照，有助于查明根本原因。

然而，日志记录不仅仅是一个简单的功能——它是一个系统。实施不当的日志记录机制可能会导致性能问题、安全漏洞和不可维护的代码。因此，在设计日志系统时，遵循结构化方法和模式至关重要。

组织记录文件

正确的文件组织对于保持代码库在增长时的可维护性至关重要。日志记录作为一项独特的功能，应该隔离到自己的模块中，以便轻松定位和修改，而不影响代码的不相关部分。

头文件（logger.h）：

#ifndef LOGGER_H
#define LOGGER_H

#include <stdio.h>
#include <time.h>

// Function prototypes
void log_message(const char* text);

#endif // LOGGER_H
</time.h></stdio.h>

实现文件（logger.c）：

#include "logger.h"

void log_message(const char* text) {
    if (!text) {
        fprintf(stderr, "Invalid log message\n");
        return;
    }
    time_t now = time(NULL);
    printf("[%s] %s\n", ctime(&now), text);
}

用法（main.c）：

#include "logger.h"

int main() {
    log_message("Application started");
    log_message("Performing operation...");
    log_message("Operation completed.");
    return 0;
}

编译并运行：

要编译并运行该示例，请在终端中使用以下命令：

gcc -o app main.c logger.c
./app

预期输出：

[Mon Sep 27 14:00:00 2021
] Application started
[Mon Sep 27 14:00:00 2021
] Performing operation...
[Mon Sep 27 14:00:00 2021
] Operation completed.

第一步是创建一个用于日志记录的专用目录。该目录应包含所有相关的实现文件。例如，logger.c 可以包含日志系统的核心逻辑，而 logger_test.c 可以保存单元测试。将相关文件放在一起可以提高开发团队内的清晰度和协作性。

此外，日志记录接口应通过头文件（例如 logger.h）公开，并放置在适当的目录中，例如 include/ 或与源文件相同的目录。这确保了需要日志记录功能的其他模块可以轻松访问它。将头文件与实现文件分开还支持封装，向日志记录 API 的用户隐藏实现细节。

最后，对目录和文件采用一致的命名约定可以进一步增强可维护性。例如，使用 logger.h 和 logger.c 可以清楚地表明这些文件属于日志记录模块。避免将不相关的代码混合到日志记录模块中，因为这违背了模块化的目的。

创建中央日志记录功能

任何日志系统的核心都有一个处理核心操作的核心功能：记录日志消息。此功能的设计应考虑简单性和可扩展性，以支持未来的增强功能，而无需进行重大更改。

实现（logger.c）：

#include "logger.h"
#include <stdio.h>
#include <time.h>
#include <assert.h>

#define BUFFER_SIZE 256
static_assert(BUFFER_SIZE >= 64, "Buffer size is too small");

void log_message(const char* text) {
    char buffer[BUFFER_SIZE];
    time_t now = time(NULL);

    if (!text) {
        fprintf(stderr, "Error: Null message passed to log_message\n");
        return;
    }

    snprintf(buffer, BUFFER_SIZE, "[%s] %s", ctime(&now), text);
    printf("%s", buffer);
}
</assert.h></time.h></stdio.h>

注意：使用 static_assert 需要 C11 或更高版本。确保您的编译器支持此标准。

基本的日志记录功能可以通过将消息打印到标准输出来启动。向每个日志条目添加时间戳可以通过提供时间上下文来提高其实用性。例如，日志可以帮助识别特定错误何时发生或事件如何随着时间的推移展开。

为了保持日志记录模块无状态，请避免在函数调用之间保留任何内部状态。这种设计选择简化了实现，并确保模块在多线程环境中无缝工作。无状态模块也更容易测试和调试，因为它们的行为不依赖于先前的交互。

设计日志记录功能时考虑错误处理。例如，如果将 NULL 指针作为日志消息传递，会发生什么情况？遵循“武士原则”，该函数应该要么优雅地处理这个问题，要么立即失败，从而使调试更容易。

实施软件模块过滤器

随着应用程序变得越来越复杂，它们的日志输出可能会变得难以承受。如果没有过滤器，来自不相关模块的日志可能会淹没控制台，从而难以关注相关信息。实施过滤器可确保仅记录所需的日志。

为了实现这一点，引入一种机制来跟踪启用的模块。这可以像全局列表一样简单，也可以像动态分配的哈希表一样复杂。该列表存储模块名称，并且仅处理来自这些模块的日志。

过滤是通过在日志记录函数中添加模块参数来实现的。在写入日志之前，该函数会检查模块是否已启用。如果不是，它会跳过日志条目。这种方法使日志记录输出简洁并集中于感兴趣的领域。这是过滤的示例实现：

头文件（logger.h）：

#ifndef LOGGER_H
#define LOGGER_H

#include <stdio.h>
#include <time.h>

// Function prototypes
void log_message(const char* text);

#endif // LOGGER_H
</time.h></stdio.h>

实现文件（logger.c）：

#include "logger.h"

void log_message(const char* text) {
    if (!text) {
        fprintf(stderr, "Invalid log message\n");
        return;
    }
    time_t now = time(NULL);
    printf("[%s] %s\n", ctime(&now), text);
}

此实现在简单性和功能性之间取得了平衡，为特定于模块的日志记录提供了坚实的起点。

添加条件日志记录

条件日志记录对于创建适应不同环境或运行时条件的灵活系统至关重要。例如，在开发过程中，您可能需要详细的调试日志来跟踪应用程序行为。在生产中，您可能更愿意仅记录警告和错误，以最大限度地减少性能开销。

实现此目的的一种方法是引入日志级别。常见级别包括调试、信息、警告和错误。日志记录功能可以为日志级别添加一个附加参数，只有当日志级别达到或超过当前阈值时才会记录日志。这种方法可确保过滤掉不相关的消息，从而保持日志简洁且有用。

为了使其可配置，您可以使用全局变量来存储日志级别阈值。然后，应用程序可以动态调整此阈值，例如通过配置文件或运行时命令。

头文件（logger.h）：

#include "logger.h"

int main() {
    log_message("Application started");
    log_message("Performing operation...");
    log_message("Operation completed.");
    return 0;
}

实现文件（logger.c）：

gcc -o app main.c logger.c
./app

此实现可以轻松控制日志记录的详细程度。例如，您可以在故障排除会话期间将日志级别设置为 DEBUG，并在生产中将其恢复为 WARNING。

正确管理资源

适当的资源管理至关重要，尤其是在处理文件操作或多个日志记录目的地时。未能关闭文件或释放分配的内存可能会导致资源泄漏，随着时间的推移会降低系统性能。

确保为记录而打开的任何文件在不再需要时正确关闭。这可以通过实现初始化和关闭日志系统的函数来实现。

实现（logger.c）：

#ifndef LOGGER_H
#define LOGGER_H

#include <stdio.h>
#include <time.h>

// Function prototypes
void log_message(const char* text);

#endif // LOGGER_H
</time.h></stdio.h>

用法（main.c）：

#include "logger.h"

void log_message(const char* text) {
    if (!text) {
        fprintf(stderr, "Invalid log message\n");
        return;
    }
    time_t now = time(NULL);
    printf("[%s] %s\n", ctime(&now), text);
}

编译并运行：

#include "logger.h"

int main() {
    log_message("Application started");
    log_message("Performing operation...");
    log_message("Operation completed.");
    return 0;
}

这会将日志消息写入 application.log。通过提供 init_logging 和 close_logging 函数，您可以让应用程序控制日志记录资源的生命周期，防止泄漏和访问问题。

确保线程安全

在多线程应用程序中，日志记录函数必须是线程安全的，以防止竞争条件并确保日志消息不会交错或损坏。

实现线程安全的一种方法是使用互斥体或其他同步机制。

实现（logger.c）：

gcc -o app main.c logger.c
./app

多线程环境中的使用（main.c）：

[Mon Sep 27 14:00:00 2021
] Application started
[Mon Sep 27 14:00:00 2021
] Performing operation...
[Mon Sep 27 14:00:00 2021
] Operation completed.

编译并运行：

#include "logger.h"
#include <stdio.h>
#include <time.h>
#include <assert.h>

#define BUFFER_SIZE 256
static_assert(BUFFER_SIZE >= 64, "Buffer size is too small");

void log_message(const char* text) {
    char buffer[BUFFER_SIZE];
    time_t now = time(NULL);

    if (!text) {
        fprintf(stderr, "Error: Null message passed to log_message\n");
        return;
    }

    snprintf(buffer, BUFFER_SIZE, "[%s] %s", ctime(&now), text);
    printf("%s", buffer);
}
</assert.h></time.h></stdio.h>

这可以确保来自不同线程的日志不会相互干扰，从而保持日志消息的完整性。

外部和动态配置

允许在外部设置日志配置增强了灵活性。日志级别、启用的模块和目标等配置可以从配置文件加载或通过命令行参数设置。

配置文件（config.cfg）：

#ifndef LOGGER_H
#define LOGGER_H

#include <stdbool.h>

void enable_module(const char* module);
void disable_module(const char* module);
void log_message(const char* module, const char* text);

#endif // LOGGER_H
</stdbool.h>

实现（logger.c）：

#include "logger.h"
#include <stdio.h>
#include <string.h>

#define MAX_MODULES 10
#define MODULE_NAME_LENGTH 20

static char enabled_modules[MAX_MODULES][MODULE_NAME_LENGTH];

void enable_module(const char* module) {
    for (int i = 0; i #ifndef LOGGER_H
#define LOGGER_H

typedef enum { DEBUG, INFO, WARNING, ERROR } LogLevel;

void set_log_level(LogLevel level);
void log_message(LogLevel level, const char* module, const char* text);

#endif // LOGGER_H
</string.h></stdio.h>

') { strncpy(enabled_modules[i], module, MODULE_NAME_LENGTH - 1); enabled_modules[i][MODULE_NAME_LENGTH - 1] = '

#include "logger.h"
#include <stdio.h>
#include <time.h>
#include <string.h>

static LogLevel current_log_level = INFO;

void set_log_level(LogLevel level) {
    current_log_level = level;
}

void log_message(LogLevel level, const char* module, const char* text) {
    if (level ';
            break;
        }
    }
}

void disable_module(const char* module) {
    for (int i = 0; i #include "logger.h"
#include <stdio.h>
#include <stdlib.h>

static FILE* log_file = NULL;

void init_logging(const char* filename) {
    if (filename) {
        log_file = fopen(filename, "a");
        if (!log_file) {
            fprintf(stderr, "Failed to open log file: %s\n", filename);
            exit(EXIT_FAILURE);
        }
    } else {
        log_file = stdout; // Default to standard output
    }
}

void close_logging() {
    if (log_file && log_file != stdout) {
        fclose(log_file);
        log_file = NULL;
    }
}

void log_message(const char* text) {
    if (!log_file) {
        fprintf(stderr, "Logging not initialized.\n");
        return;
    }
    time_t now = time(NULL);
    fprintf(log_file, "[%s] %s\n", ctime(&now), text);
    fflush(log_file); // Ensure the message is written immediately
}
</stdlib.h></stdio.h></string.h></time.h></stdio.h>

'; break; } } } static int is_module_enabled(const char* module) { for (int i = 0; i

用法（main.c）：

#include "logger.h"

int main() {
    init_logging("application.log");

    log_message("Application started");
    log_message("Performing operation...");
    log_message("Operation completed.");

    close_logging();
    return 0;
}

编译并运行：

gcc -o app main.c logger.c
./app

通过实现动态配置，您可以调整日志记录行为而无需重新编译应用程序，这在生产环境中特别有用。

自定义日志格式

自定义日志消息的格式可以使其信息更丰富且更易于解析，尤其是在与日志分析工具集成时。

实现（logger.c）：

#include "logger.h"
#include <pthread.h>

static pthread_mutex_t log_mutex = PTHREAD_MUTEX_INITIALIZER;

void log_message(const char* text) {
    pthread_mutex_lock(&log_mutex);
    // Existing logging code
    if (!log_file) {
        fprintf(stderr, "Logging not initialized.\n");
        pthread_mutex_unlock(&log_mutex);
        return;
    }
    time_t now = time(NULL);
    fprintf(log_file, "[%s] %s\n", ctime(&now), text);
    fflush(log_file);
    pthread_mutex_unlock(&log_mutex);
}
</pthread.h>

示例输出：

#include "logger.h"
#include <pthread.h>

void* thread_function(void* arg) {
    char* thread_name = (char*)arg;
    for (int i = 0; i 



<p>对于结构化日志记录，请考虑以 JSON 格式输出日志：<br>
</p>

<pre class="brush:php;toolbar:false">gcc -pthread -o app main.c logger.c
./app

这种格式适合日志管理工具解析。

内部错误处理

日志系统本身可能会遇到错误，例如无法打开文件或资源分配问题。妥善处理这些错误并向开发人员提供反馈非常重要。

实现（logger.c）：

#ifndef LOGGER_H
#define LOGGER_H

#include <stdio.h>
#include <time.h>

// Function prototypes
void log_message(const char* text);

#endif // LOGGER_H
</time.h></stdio.h>

通过在使用前检查资源状态并提供有意义的错误消息，您可以防止崩溃并帮助排除日志系统本身的问题。

性能和效率

日志记录会影响应用程序性能，尤其是在日志记录范围广泛或同步执行的情况下。为了缓解这种情况，请考虑缓冲日志或异步执行日志记录操作等技术。

异步日志实现（logger.c）：

#include "logger.h"

void log_message(const char* text) {
    if (!text) {
        fprintf(stderr, "Invalid log message\n");
        return;
    }
    time_t now = time(NULL);
    printf("[%s] %s\n", ctime(&now), text);
}

用法（main.c）：

#include "logger.h"

int main() {
    log_message("Application started");
    log_message("Performing operation...");
    log_message("Operation completed.");
    return 0;
}

使用异步日志记录可以减少主应用程序线程在日志记录上花费的时间，从而提高整体性能。

安全最佳实践

日志可能会无意中暴露敏感信息，例如密码或个人数据。避免记录此类信息并保护日志文件免遭未经授权的访问至关重要。

实现（logger.c）：

gcc -o app main.c logger.c
./app

设置文件权限：

[Mon Sep 27 14:00:00 2021
] Application started
[Mon Sep 27 14:00:00 2021
] Performing operation...
[Mon Sep 27 14:00:00 2021
] Operation completed.

推荐：

• 清理输入：确保日志消息中不包含敏感数据。
• 访问控制：对日志文件设置适当的权限以限制访问。
• 加密：如果日志文件包含敏感信息，请考虑对其进行加密。
• 日志轮换：实施日志轮换以防止日志无限增长并管理暴露。

通过遵循这些做法，您可以增强应用程序的安全性并遵守数据保护法规。

与日志记录工具集成

现代应用程序通常与外部日志记录工具和服务集成，以实现更好的日志管理和分析。

系统日志集成（logger.c）：

#include "logger.h"
#include <stdio.h>
#include <time.h>
#include <assert.h>

#define BUFFER_SIZE 256
static_assert(BUFFER_SIZE >= 64, "Buffer size is too small");

void log_message(const char* text) {
    char buffer[BUFFER_SIZE];
    time_t now = time(NULL);

    if (!text) {
        fprintf(stderr, "Error: Null message passed to log_message\n");
        return;
    }

    snprintf(buffer, BUFFER_SIZE, "[%s] %s", ctime(&now), text);
    printf("%s", buffer);
}
</assert.h></time.h></stdio.h>

用法（main.c）：

#ifndef LOGGER_H
#define LOGGER_H

#include <stdbool.h>

void enable_module(const char* module);
void disable_module(const char* module);
void log_message(const char* module, const char* text);

#endif // LOGGER_H
</stdbool.h>

远程记录服务：

要将日志发送到 Graylog 或 Elasticsearch 等远程服务，您可以使用网络套接字或专用库。

使用套接字的示例（logger.c）：

#include "logger.h"
#include <stdio.h>
#include <string.h>

#define MAX_MODULES 10
#define MODULE_NAME_LENGTH 20

static char enabled_modules[MAX_MODULES][MODULE_NAME_LENGTH];

void enable_module(const char* module) {
    for (int i = 0; i #ifndef LOGGER_H
#define LOGGER_H

typedef enum { DEBUG, INFO, WARNING, ERROR } LogLevel;

void set_log_level(LogLevel level);
void log_message(LogLevel level, const char* module, const char* text);

#endif // LOGGER_H
</string.h></stdio.h>

') { strncpy(enabled_modules[i], module, MODULE_NAME_LENGTH - 1); enabled_modules[i][MODULE_NAME_LENGTH - 1] = '

#include "logger.h"
#include <stdio.h>
#include <time.h>
#include <string.h>

static LogLevel current_log_level = INFO;

void set_log_level(LogLevel level) {
    current_log_level = level;
}

void log_message(LogLevel level, const char* module, const char* text) {
    if (level ';
            break;
        }
    }
}

void disable_module(const char* module) {
    for (int i = 0; i #include "logger.h"
#include <stdio.h>
#include <stdlib.h>

static FILE* log_file = NULL;

void init_logging(const char* filename) {
    if (filename) {
        log_file = fopen(filename, "a");
        if (!log_file) {
            fprintf(stderr, "Failed to open log file: %s\n", filename);
            exit(EXIT_FAILURE);
        }
    } else {
        log_file = stdout; // Default to standard output
    }
}

void close_logging() {
    if (log_file && log_file != stdout) {
        fclose(log_file);
        log_file = NULL;
    }
}

void log_message(const char* text) {
    if (!log_file) {
        fprintf(stderr, "Logging not initialized.\n");
        return;
    }
    time_t now = time(NULL);
    fprintf(log_file, "[%s] %s\n", ctime(&now), text);
    fflush(log_file); // Ensure the message is written immediately
}
</stdlib.h></stdio.h></string.h></time.h></stdio.h>

'; break; } } } static int is_module_enabled(const char* module) { for (int i = 0; i

用法（main.c）：

#include "logger.h"

int main() {
    init_logging("application.log");

    log_message("Application started");
    log_message("Performing operation...");
    log_message("Operation completed.");

    close_logging();
    return 0;
}

与外部工具集成可以提供集中日志管理、实时监控和警报等高级功能。

测试和验证

彻底的测试确保日志系统在各种条件下都能正常运行。

单元测试示例（test_logger.c）：

gcc -o app main.c logger.c
./app

编译并运行测试：

#include "logger.h"
#include <pthread.h>

static pthread_mutex_t log_mutex = PTHREAD_MUTEX_INITIALIZER;

void log_message(const char* text) {
    pthread_mutex_lock(&log_mutex);
    // Existing logging code
    if (!log_file) {
        fprintf(stderr, "Logging not initialized.\n");
        pthread_mutex_unlock(&log_mutex);
        return;
    }
    time_t now = time(NULL);
    fprintf(log_file, "[%s] %s\n", ctime(&now), text);
    fflush(log_file);
    pthread_mutex_unlock(&log_mutex);
}
</pthread.h>

测试策略：

• 单元测试：验证各个函数。
• 压力测试：模拟高频日志记录。
• 多线程测试： 同时从多个线程记录。
• 故障注入：模拟磁盘已满或网络故障等错误。

通过严格测试日志系统，您可以在问题影响生产环境之前识别并修复问题。

跨平台文件记录

跨平台兼容性是现代软件的必要条件。虽然前面的示例在基于 Unix 的系统上运行良好，但由于文件处理 API 的差异，它们可能无法在 Windows 上运行。为了解决这个问题，您需要一个跨平台的日志机制。

实现（logger.c）：

#ifndef LOGGER_H
#define LOGGER_H

#include <stdio.h>
#include <time.h>

// Function prototypes
void log_message(const char* text);

#endif // LOGGER_H
</time.h></stdio.h>

用法（logger.c）：

#include "logger.h"

void log_message(const char* text) {
    if (!text) {
        fprintf(stderr, "Invalid log message\n");
        return;
    }
    time_t now = time(NULL);
    printf("[%s] %s\n", ctime(&now), text);
}

通过隔离特定于平台的详细信息，您可以确保主要日志记录逻辑保持干净且一致。

总结一切

设计日志系统乍一看似乎是一项简单的任务，但正如我们所见，它涉及许多影响功能、性能和可维护性的决策。通过使用设计模式和结构化方法，您可以创建一个健壮、可扩展且易于集成的日志系统。

从组织文件到实现跨平台兼容性，每一步都建立在前一步的基础上，形成一个有凝聚力的整体。系统可以按模块过滤日志，通过日志级别调整详细程度，支持多个目的地，并正确处理资源。它确保线程安全，允许外部配置，支持自定义格式，并遵守安全最佳实践。

通过采用无状态设计、动态接口和抽象层等模式，您可以避免常见的陷阱并使您的代码库面向未来。无论您是在开发小型实用程序还是大型应用程序，这些原则都是非常宝贵的。

您在构建精心设计的日志系统方面投入的精力会得到回报，减少调试时间，更好地洞察应用程序行为，并提高利益相关者的满意度。有了这个基础，您现在就可以处理最复杂项目的日志记录需求。

额外：增强日志系统

在这个额外的部分中，我们将解决之前确定的一些需要改进的领域，以增强我们构建的日志系统。我们将专注于改进代码一致性、改进错误处理、阐明复杂概念以及扩展测试和验证。每个主题都包含介绍性文字、可编译的实际示例以及供进一步学习的外部参考资料。

1. 代码一致性和格式

一致的代码格式和命名约定提高了可读性和可维护性。我们将使用 Snake_case 标准化变量和函数名称，这在 C 编程中很常见。

更新的实现 (logger.h)：

#ifndef LOGGER_H
#define LOGGER_H

#include <stdio.h>
#include <time.h>

// Function prototypes
void log_message(const char* text);

#endif // LOGGER_H
</time.h></stdio.h>

更新的实现 (logger.c)：

#include "logger.h"

void log_message(const char* text) {
    if (!text) {
        fprintf(stderr, "Invalid log message\n");
        return;
    }
    time_t now = time(NULL);
    printf("[%s] %s\n", ctime(&now), text);
}

更新用法（main.c）：

#include "logger.h"

int main() {
    log_message("Application started");
    log_message("Performing operation...");
    log_message("Operation completed.");
    return 0;
}

编译并运行：

gcc -o app main.c logger.c
./app

外部参考：

• GNU 编码标准：命名约定
• Linux 内核编码风格

2. 改进的错误处理

强大的错误处理功能确保应用程序能够优雅地处理意外情况。

增强的错误检查（logger.c）：

[Mon Sep 27 14:00:00 2021
] Application started
[Mon Sep 27 14:00:00 2021
] Performing operation...
[Mon Sep 27 14:00:00 2021
] Operation completed.

外部参考：

• C 中的错误处理
• C 语言的断言

3. 澄清异步日志记录

异步日志记录通过将日志记录过程与主应用程序流程分离来提高性能。这里有一个实际例子的详细解释。

实现（logger.c）：

#include "logger.h"
#include <stdio.h>
#include <time.h>
#include <assert.h>

#define BUFFER_SIZE 256
static_assert(BUFFER_SIZE >= 64, "Buffer size is too small");

void log_message(const char* text) {
    char buffer[BUFFER_SIZE];
    time_t now = time(NULL);

    if (!text) {
        fprintf(stderr, "Error: Null message passed to log_message\n");
        return;
    }

    snprintf(buffer, BUFFER_SIZE, "[%s] %s", ctime(&now), text);
    printf("%s", buffer);
}
</assert.h></time.h></stdio.h>

用法（main.c）：

#ifndef LOGGER_H
#define LOGGER_H

#include <stdbool.h>

void enable_module(const char* module);
void disable_module(const char* module);
void log_message(const char* module, const char* text);

#endif // LOGGER_H
</stdbool.h>

编译并运行：

#include "logger.h"
#include <stdio.h>
#include <string.h>

#define MAX_MODULES 10
#define MODULE_NAME_LENGTH 20

static char enabled_modules[MAX_MODULES][MODULE_NAME_LENGTH];

void enable_module(const char* module) {
    for (int i = 0; i #ifndef LOGGER_H
#define LOGGER_H

typedef enum { DEBUG, INFO, WARNING, ERROR } LogLevel;

void set_log_level(LogLevel level);
void log_message(LogLevel level, const char* module, const char* text);

#endif // LOGGER_H
</string.h></stdio.h>

') { strncpy(enabled_modules[i], module, MODULE_NAME_LENGTH - 1); enabled_modules[i][MODULE_NAME_LENGTH - 1] = '

#include "logger.h"
#include <stdio.h>
#include <time.h>
#include <string.h>

static LogLevel current_log_level = INFO;

void set_log_level(LogLevel level) {
    current_log_level = level;
}

void log_message(LogLevel level, const char* module, const char* text) {
    if (level ';
            break;
        }
    }
}

void disable_module(const char* module) {
    for (int i = 0; i #include "logger.h"
#include <stdio.h>
#include <stdlib.h>

static FILE* log_file = NULL;

void init_logging(const char* filename) {
    if (filename) {
        log_file = fopen(filename, "a");
        if (!log_file) {
            fprintf(stderr, "Failed to open log file: %s\n", filename);
            exit(EXIT_FAILURE);
        }
    } else {
        log_file = stdout; // Default to standard output
    }
}

void close_logging() {
    if (log_file && log_file != stdout) {
        fclose(log_file);
        log_file = NULL;
    }
}

void log_message(const char* text) {
    if (!log_file) {
        fprintf(stderr, "Logging not initialized.\n");
        return;
    }
    time_t now = time(NULL);
    fprintf(log_file, "[%s] %s\n", ctime(&now), text);
    fflush(log_file); // Ensure the message is written immediately
}
</stdlib.h></stdio.h></string.h></time.h></stdio.h>

'; break; } } } static int is_module_enabled(const char* module) { for (int i = 0; i

说明：

• 生产者-消费者模型：主线程生成日志消息并将它们添加到队列中。日志工作线程消耗队列中的消息并将其写入日志文件。
• 线程同步：互斥体和条件变量确保对共享资源的线程安全访问。
• 正常关闭：logging_active 标志和条件变量会在日志记录关闭时通知工作线程退出。

外部参考：

• 生产者-消费者问题
• POSIX 线程编程

4. 扩大测试和验证

测试对于确保日志系统在各种条件下正常运行至关重要。

使用 Unity 测试框架：

Unity 是一个轻量级的 C 测试框架。

设置：

1. 从官方存储库下载Unity：GitHub 上的Unity
2. 在您的测试文件中包含 unity.h。

测试文件（test_logger.c）：

#include "logger.h"

int main() {
    init_logging("application.log");

    log_message("Application started");
    log_message("Performing operation...");
    log_message("Operation completed.");

    close_logging();
    return 0;
}

编译并运行测试：

gcc -o app main.c logger.c
./app

说明：

• setUp 和tearDown： 在每次设置和清理测试之前和之后运行的函数。
• 断言： 使用 TEST_ASSERT_* 宏来验证条件。
• 测试用例：测试涵盖记录到标准输出和文件。

外部参考：

• 统一测试框架
• C 语言的单元测试

5. 安全增强

确保日志系统的安全至关重要，尤其是在处理敏感数据时。

使用 TLS 安全传输：

要通过网络安全地发送日志，请使用 TLS 加密。

使用 OpenSSL 实现（logger.c）：

#ifndef LOGGER_H
#define LOGGER_H

#include <stdio.h>
#include <time.h>

// Function prototypes
void log_message(const char* text);

#endif // LOGGER_H
</time.h></stdio.h>

外部参考：

• OpenSSL 文档
• 使用 OpenSSL 进行安全编程

遵守数据保护法规：

记录个人数据时，确保遵守 GDPR 等法规。

推荐：

• 匿名化：删除或掩盖日志中的个人标识符。
• 访问控制：限制对日志文件的访问。
• 数据保留策略：定义日志的存储时间。

外部参考：

• 欧盟 GDPR 合规性
• HIPAA 安全规则

6.利用现有的日志库

有时，使用完善的日志库可以节省时间并提供额外的功能。

zlog简介：

zlog 是一个可靠、线程安全且高度可配置的 C 日志库。

特点：

• 通过文件进行配置。
• 支持多种日志类别和级别。
• 异步日志记录功能。

使用示例：

1. 安装：

#include "logger.h"

void log_message(const char* text) {
    if (!text) {
        fprintf(stderr, "Invalid log message\n");
        return;
    }
    time_t now = time(NULL);
    printf("[%s] %s\n", ctime(&now), text);
}

1. 配置文件（zlog.conf）：

#include "logger.h"

int main() {
    log_message("Application started");
    log_message("Performing operation...");
    log_message("Operation completed.");
    return 0;
}

1. 实现（main.c）：

gcc -o app main.c logger.c
./app

1. 编译并运行：

[Mon Sep 27 14:00:00 2021
] Application started
[Mon Sep 27 14:00:00 2021
] Performing operation...
[Mon Sep 27 14:00:00 2021
] Operation completed.

外部参考：

• zlog官方网站
• log4c 项目

与自定义实现的比较：

• 使用图书馆的优点：

  • 节省开发时间。
  • 提供高级功能。
  • 经过充分测试和维护。

• 缺点：

  • 可能包含不必要的功能。
  • 添加外部依赖项。
  • 对内部运作的控制较少。

7. 加强结论

最后，让我们强化关键要点并鼓励进一步探索。

最后的想法：

构建强大的日志系统是软件开发的一个关键方面。通过关注代码一致性、错误处理、清晰度、测试、安全性并在适当的时候利用现有工具，您可以为增强应用程序的可维护性和可靠性奠定基础。

号召性用语：

• 应用概念：将这些增强功能集成到您的项目中。
• 进一步探索： 研究更高级的日志记录功能，例如日志轮换、过滤和分析工具。
• 保持更新：及时了解日志记录和软件开发方面的最佳实践和新兴技术。

其他资源：

• 日志记录的艺术

以上是用 C 创建健壮的日志系统的详细内容。更多信息请关注PHP中文网其他相关文章！