<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta name="generator" content="HTML Tidy, see www.w3.org" />

    <title>Manual Page: rotatelogs - Apache HTTP Server</title>
  </head>
  <!-- Background white, links blue (unvisited), navy (visited), red (active) -->

  <body bgcolor="#ffffff" text="#000000" link="#0000ff"
  vlink="#000080" alink="#ff0000">
    <!--#include virtual="header.html" -->

    <h1 align="center">Manual Page: rotatelogs</h1>
    <!-- This document was autogenerated from the man page -->
<pre>
<strong>NAME</strong>
     rotatelogs - rotate Apache logs without having to  kill  the
     server

<strong>SYNOPSIS</strong>
     <strong>rotatelogs</strong> <em>logfile rotationtime</em> [ <em>offset</em> ]

<strong>DESCRIPTION</strong>
     <strong>rotatelogs</strong> is a simple program for use in  conjunction  with
     Apache's piped logfile feature which can be used like this:

        TransferLog "|rotatelogs /path/to/logs/access_log 86400"

     This creates the files  /path/to/logs/access_log.nnnn  where
     nnnn  is  the  system time at which the log nominally starts
     (this time will always be a multiple of the  rotation  time,
     so you can synchronize cron scripts with it).  At the end of
     each rotation time (here  after  24  hours)  a  new  log  is
     started.

<strong>OPTIONS</strong>
     <em>logfile</em>
          The path plus basename of the logfile. The suffix .nnnn
          is automatically added.

     <em>rotationtime</em>
          The rotation time in seconds.

     <em>offset</em>
          The number of minutes offset from UTC. If omitted, zero
          is assumed and UTC is used.  For example, to use local
          time in the zone UTC -5 hours, specify a value of -300
          for this argument.

<strong>SEE ALSO</strong>
     <strong>httpd(8)</strong>

</pre>
    <!--#include virtual="footer.html" -->
  </body>
</html>

