mod_log_rotate.c

/* Copyright 1999-2004 The Apache Software Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* Adds RotateLogs and supporting directives that allow logs to be rotated by
 * the server without having to pipe them through rotatelogs.
 *
 * RotateLogs On|Off    Enable / disable automatic log rotation. Once enabled
 *                      mod_log_rotate takes responsibility for all log output
 *                      server wide even if RotateLogs Off is subsequently
 *                      used. That means that the BufferedLogs directive that
 *                      is implemented by mod_log_config will be ignored.
 *
 * RotateLogsLocalTime  Normally the log rotation interval is based on UTC.
 *                      For example an interval of 86400 (one day) will cause
 *                      the logs to rotate at UTC 00:00. When this option is
 *                      on, log rotation is timed relative to the local time.
 *
 * RotateInterval       Set the interval in seconds for log rotation. The
 *                      default is 86400 (one day). The shortest interval that
 *                      can be specified is 60 seconds. An optional second
 *                      argument specifies an offset in minutes which is
 *                      applied to UTC (or local time if RotateLogsLocalTime
 *                      is on). For example RotateInterval 86400 60 will
 *                      cause logs to be rotated at 23:00 UTC.
 *
 * The current version of this module is available at:
 *   http://www.hexten.net/sw/mod_log_rotate/index.mhtml
 */

/* 2004/12/02 1.00      andya@apache.org    Initial release.
 */
#include "apr_anylock.h"
#include "apr_file_io.h"
#include "apr_pools.h"
#include "apr_strings.h"
#include "apr_time.h"

#include "httpd.h"
#include "http_config.h"
#include "http_log.h"
#include "ap_mpm.h"

#include "mod_log_config.h"

#ifndef APR_LARGEFILE
#define APR_LARGEFILE 0
#endif

#define INTERVAL_DEFAULT    (APR_USEC_PER_SEC * APR_TIME_C(3600) * APR_TIME_C(24))
#define INTERVAL_MIN        (APR_USEC_PER_SEC * APR_TIME_C(60))

static int xfer_flags = (APR_WRITE | APR_APPEND | APR_CREATE | APR_LARGEFILE);
static apr_fileperms_t xfer_perms = APR_OS_DEFAULT;

module AP_MODULE_DECLARE_DATA log_rotate_module;

typedef struct {
    int             enabled;        /* Rotation enabled                     */
    apr_time_t      interval;       /* Rotation interval                    */
    apr_time_t      offset;         /* Offset from midnight                 */
    int             localt;         /* Use local time instead of GMT        */
} log_options;

typedef struct {
    apr_pool_t      *pool;          /* Our working pool                     */
    const char      *fname;         /* Basename for logs without extension  */
    apr_file_t      *fd;            /* Current open log file                */
    apr_time_t      logtime;        /* Quantised time of current log file   */
    apr_anylock_t   mutex;

    log_options     st;             /* Embedded config options              */
} rotated_log;

static const char *ap_pstrftime(apr_pool_t *p, const char *format, apr_time_exp_t *tm) {
    size_t got, len = strlen(format) + 1;
    const char *fp = strchr(format, '%');
    char *buf = NULL;
    while (NULL != fp) {
        len += 10;   /* approx only, will fail if anything generates a huge expansion */
        fp = strchr(fp + 1, '%');
    }

    buf = apr_palloc(p, len);
    apr_strftime(buf, &got, len, format, tm);
    return buf;
}

static apr_file_t *ap_open_log(apr_pool_t *p, server_rec *s, const char *base, log_options *ls, apr_time_t tm) {
    if (*base == '|') {
        /* We have piped log handling here because once log rotation has been
         * enabled we become responsible for /all/ transfer log output server
         * wide. That's a consequence of the way the log output hooks in
         * mod_log_config are implemented. Unfortunately this means we have to
         * duplicate functionality from mod_log_config. Note that we don't
         * support the buffered logging mode that mlc implements.
         */
        piped_log *pl;

        if (ls->enabled) {
            /* Can't rotate a piped log */
            ls->enabled = 0;
            ap_log_error(APLOG_MARK, APLOG_WARNING, APR_SUCCESS, s,
                            "disabled log rotation for piped log %s.", base);
        }

        if (pl = ap_open_piped_log(p, base + 1), NULL == pl) {
           return NULL;
        }

        return ap_piped_log_write_fd(pl);
    } else {
        apr_file_t *fd;
        apr_status_t rv;
        const char *name = ap_server_root_relative(p, base);

        if (NULL == name) {
            ap_log_error(APLOG_MARK, APLOG_ERR, APR_EBADPATH, s,
                            "invalid transfer log path %s.", base);
            return NULL;
        }

        if (ls->enabled) {
            apr_time_t log_time = tm - ls->offset;
            if (strchr(base, '%') != NULL) {
                apr_time_exp_t e;

                apr_time_exp_gmt(&e, log_time);
                name = ap_pstrftime(p, name, &e);
            } else {
                /* Synthesize the log name using the specified time in seconds as a
                 * suffix.  We subtract the offset here because it was added when
                 * quantizing the time but we want the name to reflect the actual
                 * time when the log rotated. We don't reverse the local time
                 * adjustment because, presumably, if you've specified local time
                 * logging you want the filenames to use local time.
                 */
                name = apr_psprintf(p, "%s.%" APR_TIME_T_FMT, name, apr_time_sec(log_time));
            }
        }

        if (rv = apr_file_open(&fd, name, xfer_flags, xfer_perms, p), APR_SUCCESS != rv) {
            ap_log_error(APLOG_MARK, APLOG_ERR, rv, s,
                            "could not open transfer log file %s.", name);
            return NULL;
        }

        return fd;
    }
}

static apr_status_t ap_close_log(server_rec *s, apr_file_t *fd) {
    apr_status_t rv;

    if (rv = apr_file_close(fd), APR_SUCCESS != rv) {
        ap_log_error(APLOG_MARK, APLOG_ERR, rv, s,
                        "error closing transfer log file.");
    }

    return rv;
}

/* Quantize the supplied time to the log rotation interval applying offsets as
 * specified in the config.
 */
static apr_time_t ap_get_quantized_time(rotated_log *rl, apr_time_t tm) {
    apr_time_t localadj = 0;

    if (rl->st.localt) {
        apr_time_exp_t lt;
        apr_time_exp_lt(&lt, tm);
        localadj = (apr_time_t) lt.tm_gmtoff * APR_USEC_PER_SEC;
    }

    return ((tm + rl->st.offset + localadj) / rl->st.interval) * rl->st.interval;
}

/* Called by mod_log_config to write a log file line.
 */
static apr_status_t ap_rotated_log_writer(request_rec *r, void *handle,
                                          const char **strs, int *strl,
                                          int nelts, apr_size_t len) {
    char *str;
    char *s;
    int i;
    apr_status_t rv = 0;
    rotated_log *rl = (rotated_log *) handle;

    if (NULL != rl && NULL != rl->fd) {
        if (rl->st.enabled) {
            apr_time_t logt = ap_get_quantized_time(rl, r->request_time);
            /*ap_log_error(APLOG_MARK, APLOG_DEBUG, rv, r->server, "New: %lu, old: %lu",
            (unsigned long) logt, (unsigned long) rl->logtime);*/
            /* Decide if the quantized time has rolled over into a new slot. */
            if (logt != rl->logtime) {
                /* Get the mutex */
                if (rv = APR_ANYLOCK_LOCK(&rl->mutex), APR_SUCCESS != rv) {
                    return rv;
                }

                /* Now check again in case someone else rotated the log while we waited
                 * for the mutex.
                 */
                if (logt != rl->logtime) {
                    apr_file_t *ofd = rl->fd;
                    apr_pool_t *par, *np;
                    rl->logtime = logt;

                    /* Create a new pool to provide storage for the new file.
                     * Once we have the new file open we'll destroy the old
                     * pool and make this one current.
                     */
                    par = apr_pool_parent_get(rl->pool);
                    if (rv = apr_pool_create(&np, par), APR_SUCCESS != rv) {
                        APR_ANYLOCK_UNLOCK(&rl->mutex);
                        return rv;
                    }

                    /* Atomically replace the current log file because other
                     * threads, perhaps those responsible for a long lived
                     * request, won't have blocked on the mutex.
                     */
                    if (rl->fd = ap_open_log(np, r->server, rl->fname, &rl->st, logt), NULL == rl->fd) {
                        /* Open failed so keep going with the old log... */
                        rl->fd = ofd;
                        /* ...and destroy the new pool. */
                        apr_pool_destroy(np);
                    } else {
                        /* Close the old log... */
                        ap_close_log(r->server, ofd);
                        /* ...and switch to the new pool. */
                        apr_pool_destroy(rl->pool);
                        rl->pool = np;
                    }
                }

                APR_ANYLOCK_UNLOCK(&rl->mutex);
            }
        }

        str = apr_palloc(r->pool, len + 1);

        for (i = 0, s = str; i < nelts; ++i) {
            memcpy(s, strs[i], strl[i]);
            s += strl[i];
        }

        rv = apr_file_write(rl->fd, str, &len);

        return rv;
    } else {
        return APR_SUCCESS; /* Should we complain? */
    }
}

/* Called my mod_log_config to initialise a log writer.
 */
static void *ap_rotated_log_writer_init(apr_pool_t *p, server_rec *s, const char* name) {
    rotated_log *rl;
    apr_status_t rv;
    log_options *ls = ap_get_module_config(s->module_config, &log_rotate_module);

    rl = apr_palloc(p, sizeof(rotated_log));
    rl->fname = apr_pstrdup(p, name);

    if (rv = apr_pool_create(&rl->pool, p), APR_SUCCESS != rv) {
        ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, "can't make log rotation pool.");
        return NULL;
    }

    rl->mutex.type = apr_anylock_none;

#if APR_HAS_THREADS
    {
        int mpm_threads;

        ap_mpm_query(AP_MPMQ_MAX_THREADS, &mpm_threads);
        if (mpm_threads > 1) {
            apr_status_t rv;

            rl->mutex.type = apr_anylock_threadmutex;
            rv = apr_thread_mutex_create(&rl->mutex.lock.tm, APR_THREAD_MUTEX_DEFAULT, p);
            if (rv != APR_SUCCESS) {
                ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s,
                        "could not initialize log rotation mutex, "
                        "transfer log may become corrupted");
                rl->mutex.type = apr_anylock_none;
            }
        }
    }
#endif

    rl->st          = *ls;
    rl->logtime     = ap_get_quantized_time(rl, apr_time_now());

    if (rl->fd = ap_open_log(rl->pool, s, rl->fname, &rl->st, rl->logtime), NULL == rl->fd) {
        return NULL;
    }

    return rl;
}

static const char *set_rotated_logs(cmd_parms *cmd, void *dummy, int flag) {
    log_options *ls = ap_get_module_config(cmd->server->module_config, &log_rotate_module);
    if (flag) {
        /* Always hook the writer functions when we're enabled even if we've
         * done it already. We can't unhook which means that once we've been
         * enabled we become responsible for all transfer log output. Note that
         * a subsequent BufferedLogs On in conf will clobber these hooks and
         * disable us.
         */
        APR_OPTIONAL_FN_TYPE(ap_log_set_writer_init) *set_writer_init;
        APR_OPTIONAL_FN_TYPE(ap_log_set_writer)      *set_writer;

        set_writer_init = APR_RETRIEVE_OPTIONAL_FN(ap_log_set_writer_init);
        set_writer      = APR_RETRIEVE_OPTIONAL_FN(ap_log_set_writer);

        if (NULL != set_writer_init && NULL != set_writer) {
            set_writer_init(ap_rotated_log_writer_init);
            set_writer(ap_rotated_log_writer);
            ls->enabled = 1;
        } else {
            ap_log_error(APLOG_MARK, APLOG_ERR, APR_SUCCESS, cmd->server,
                    "can't install log rotator - ap_log_set_writer not available");
            ls->enabled = 0;
        }
    } else {
        ls->enabled = 0;
    }

    return NULL;
}

static const char *set_localtime(cmd_parms *cmd, void *dummy, int flag) {
    log_options *ls = ap_get_module_config(cmd->server->module_config, &log_rotate_module);
    ls->localt = flag;
    return NULL;
}

static const char *set_interval(cmd_parms *cmd, void *dummy,
                                const char *inte, const char *offs) {
    log_options *ls = ap_get_module_config(cmd->server->module_config, &log_rotate_module);
    if (NULL != inte) {
        /* Interval in seconds */
        ls->interval = APR_USEC_PER_SEC * (apr_time_t) atol(inte);
        if (ls->interval < INTERVAL_MIN) {
            ls->interval = INTERVAL_MIN;
        }
    }

    if (NULL != offs) {
        /* Offset in minutes */
        ls->offset = APR_USEC_PER_SEC * 60 * (apr_time_t) atol(offs);
    }

    return NULL;
}

static const command_rec rotate_log_cmds[] = {
    AP_INIT_FLAG(  "RotateLogs", set_rotated_logs, NULL, RSRC_CONF,
                   "Enable rotated logging"),
    AP_INIT_FLAG(  "RotateLogsLocalTime", set_localtime, NULL, RSRC_CONF,
                   "Rotate relative to local time"),
    AP_INIT_TAKE12("RotateInterval", set_interval, NULL, RSRC_CONF,
                   "Set rotation interval in seconds with"
                   " optional offset in minutes"),
    {NULL}
};

static void *make_log_options(apr_pool_t *p, server_rec *s) {
    log_options *ls;

    ls = (log_options *) apr_palloc(p, sizeof(log_options));
    ls->enabled     = 1;
    ls->interval    = INTERVAL_DEFAULT;
    ls->offset      = 0;
    ls->localt      = 0;

    return ls;
}

static void *merge_log_options(apr_pool_t *p, void *basev, void *addv) {
    log_options *base = (log_options *) basev;
    log_options *add  = (log_options *) addv;

    *add = *base;

    return add;
}

module AP_MODULE_DECLARE_DATA log_rotate_module = {
    STANDARD20_MODULE_STUFF,
    NULL,                       /* create per-dir config */
    NULL,                       /* merge per-dir config */
    make_log_options,           /* server config */
    merge_log_options,          /* merge server config */
    rotate_log_cmds,            /* command apr_table_t */
    NULL                        /* register hooks */
};