日志记录与 logrotate 兼容

Question

我正在编写一个 Linux 守护程序来写入日志。我希望日志由 logrotate 旋转。程序是用C写的。

通常，我的程序会在启动时打开日志文件，然后根据需要写入条目，最后在退出时关闭日志文件。

为了使用 logrotate 支持日志轮换，我需要做哪些不同的事情？据我所知，我的程序应该能够在每次 logrotate 完成其工作时重新打开日志文件。然而，我用谷歌搜索的来源并没有具体说明重新打开日志文件的确切含义。我需要对旧文件做些什么吗？我可以创建另一个同名文件吗？我更喜欢非常具体的说明，比如一些简单的示例代码。

我还了解到应该有一种方法可以告诉我的程序何时该重新打开。我的程序已经有一个 D-Bus 接口，我想将它用于那些通知。

注意：我不需要有关如何配置 logrotate 的说明。这个问题只是关于如何让自己的软件兼容它。

Answer 1

Normally, my program would open the log file when it starts, then write entries as needed and then, finally, close the log file on exit.

What do I need to do differently in order to support log rotation using logrotate?

不，您的程序应该像对 logrotate 一无所知一样工作。

Do I need to do something about the old file and can I just create another file with the same name?

没有。应该只有一个日志文件可以打开和写入。 Logrotate 将检查该文件，如果它变得太大，它会 copy/save 旧部分，并截断当前日志文件。因此，您的程序应该完全透明地工作——它不需要知道任何关于 logrotate 的信息。

Answer 2

常用的有几种方式：

您使用 logrotate 并且您的程序应该能够捕获一个信号（通常是 SIGHUP）作为关闭和重新打开其日志文件的请求。然后 logrotate 在后旋转脚本中发送信号
您使用 logrotate 并且您的程序不知道它，但可以重新启动。然后 logrotate 在后旋转脚本中重新启动您的程序。缺点：如果程序的启动代价高昂，这可能是次优的
您使用 logrotate 并且您的程序不知道它，但您将 copytruncate 选项传递给 logrotate。然后 logrotate 复制文件，然后截断它。缺点：在竞争条件下，您可能会丢失消息。来自 rotatelog.conf 联机帮助页

... Note that there is a very small time slice between copying the file and truncating it, so some logging data might be lost...
您使用 rotatelogs，一个用于 httpd Apache 的实用程序。您的程序不是直接写入文件，而是将其日志通过管道传输到 rotatelogs。然后 rotatelogs 管理不同的日志文件。缺点：您的程序应该能够登录到管道，否则您将需要安装一个命名的 fifo。

但请注意，对于关键日志，在每条消息后关闭文件可能会很有趣，因为它可以确保在应用程序崩溃时所有内容都已到达磁盘。

Answer 3

虽然 man logrotate 示例使用 HUP 信号，但我建议使用 USR1 或 USR2，因为 "reload configuration" 使用 HUP 很常见。因此，在 logrotate 配置文件中，例如

/var/log/yourapp/log {
    rotate 7
    weekly
    postrotate
        /usr/bin/killall -USR1 yourapp
    endscript
}

棘手的一点是处理信号在记录中间到达的情况。 none 的锁定原语（除了 sem_post()，这在这里没有帮助）是 async-signal safe 的事实使它成为一个有趣的问题。

最简单的方法是使用专用线程，在 sigwaitinfo() 中等待，并在所有线程中阻塞信号。在退出时，进程自己发送信号，并加入专用线程。例如，

#define  ROTATE_SIGNAL  SIGUSR1

static pthread_t        log_thread;
static pthread_mutex_t  log_lock = PTHREAD_MUTEX_INITIALIZER;
static char            *log_path = NULL;
static FILE *volatile   log_file = NULL;

int log(const char *format, ...)
{
    va_list  args;
    int      retval;

    if (!format)
        return -1;
    if (!*format)
        return 0;

    va_start(args, format);
    pthread_mutex_lock(&log_lock);
    if (!log_file)
        return -1;
    retval = vfprintf(log_file, format, args);
    pthread_mutex_unlock(&log_lock);
    va_end(args);

    return retval;
}

void *log_sighandler(void *unused)
{
    siginfo_t info;
    sigset_t  sigs;
    int       signum;

    sigemptyset(&sigs);
    sigaddset(&sigs, ROTATE_SIGNAL);

    while (1) {

        signum = sigwaitinfo(&sigs, &info);
        if (signum != ROTATE_SIGNAL)
            continue;

        /* Sent by this process itself, for exiting? */
        if (info.si_pid == getpid())
            break;

        pthread_mutex_lock(&log_lock);
        if (log_file) {
            fflush(log_file);
            fclose(log_file);
            log_file = NULL;
        }
        if (log_path) {
            log_file = fopen(log_path, "a");
        }
        pthread_mutex_unlock(&log_lock);
    }

    /* Close time. */
    pthread_mutex_lock(&log_lock);
    if (log_file) {
        fflush(log_file);
        fclose(log_file);
        log_file = NULL;
    }
    pthread_mutex_unlock(&log_lock);

    return NULL;
}

/* Initialize logging to the specified path.
   Returns 0 if successful, errno otherwise. */
int log_init(const char *path)
{
    sigset_t          sigs;
    pthread_attr_t    attrs;
    int               retval;

    /* Block the rotate signal in all threads. */
    sigemptyset(&sigs);
    sigaddset(&sigs, ROTATE_SIGNAL);
    pthread_sigmask(SIG_BLOCK, &sigs, NULL);

    /* Open the log file. Since this is in the main thread,
       before the rotate signal thread, no need to use log_lock. */
    if (log_file) {
        /* You're using this wrong. */
        fflush(log_file);
        fclose(log_file);
    }
    log_file = fopen(path, "a");
    if (!log_file)
        return errno;

    log_path = strdup(path);

    /* Create a thread to handle the rotate signal, with a tiny stack. */
    pthread_attr_init(&attrs);
    pthread_attr_setstacksize(65536);
    retval = pthread_create(&log_thread, &attrs, log_sighandler, NULL);
    pthread_attr_destroy(&attrs);
    if (retval)
        return errno = retval;

    return 0;       
}

void log_done(void)
{
    pthread_kill(log_thread, ROTATE_SIGNAL);
    pthread_join(log_thread, NULL);
    free(log_path);
    log_path = NULL;
}

想法是在 main() 中，在记录或创建任何其他线程之前，您调用 log_init(path-to-log-file)，注意保存日志文件路径的副本。它设置信号掩码（由您可能创建的任何线程继承），并创建辅助线程。在退出之前，您调用 log_done()。要将某些内容记录到日志文件中，请像使用 printf().

一样使用 log()

我个人也会在 vfprintf() 行之前自动添加一个时间戳：

    struct timespec  ts;
    struct tm        tm;

    if (clock_gettime(CLOCK_REALTIME, &ts) == 0 &&
        localtime_r(&(ts.tv_sec), &tm) == &tm)
        fprintf(log_file, "%04d-%02d-%02d %02d:%02d:%02d.%03ld: ",
                          tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
                          tm.tm_hour, tm.tm_min, tm.tm_sec,
                          ts.tv_nsec / 1000000L);

这种 YYYY-MM-DD HH:MM:SS.sss 格式的好处是它接近世界标准 (ISO 8601) 并且排序正确。

日志记录与 logrotate 兼容

Logging compatibly with logrotate

c

linux

logrotate