srcjar/org/apache/log4j/DailyRollingFileAppender.java

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one or more
   3  * contributor license agreements.  See the NOTICE file distributed with
   4  * this work for additional information regarding copyright ownership.
   5  * The ASF licenses this file to You under the Apache License, Version 2.0
   6  * (the "License"); you may not use this file except in compliance with
   7  * the License.  You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18
  19
  20 package org.apache.log4j;
  21
  22 import java.io.IOException;
  23 import java.io.File;
  24 import java.io.InterruptedIOException;
  25 import java.text.SimpleDateFormat;
  26 import java.util.Date;
  27 import java.util.GregorianCalendar;
  28 import java.util.Calendar;
  29 import java.util.TimeZone;
  30 import java.util.Locale;
  31
  32 import org.apache.log4j.helpers.LogLog;
  33 import org.apache.log4j.spi.LoggingEvent;
  34
  35 /**
  36    DailyRollingFileAppender extends {@link FileAppender} so that the
  37    underlying file is rolled over at a user chosen frequency.
  38
  39    DailyRollingFileAppender has been observed to exhibit
  40    synchronization issues and data loss.  The log4j extras
  41    companion includes alternatives which should be considered
  42    for new deployments and which are discussed in the documentation
  43    for org.apache.log4j.rolling.RollingFileAppender.
  44
  45    <p>The rolling schedule is specified by the <b>DatePattern</b>
  46    option. This pattern should follow the {@link SimpleDateFormat}
  47    conventions. In particular, you <em>must</em> escape literal text
  48    within a pair of single quotes. A formatted version of the date
  49    pattern is used as the suffix for the rolled file name.
  50
  51    <p>For example, if the <b>File</b> option is set to
  52    <code>/foo/bar.log</code> and the <b>DatePattern</b> set to
  53    <code>'.'yyyy-MM-dd</code>, on 2001-02-16 at midnight, the logging
  54    file <code>/foo/bar.log</code> will be copied to
  55    <code>/foo/bar.log.2001-02-16</code> and logging for 2001-02-17
  56    will continue in <code>/foo/bar.log</code> until it rolls over
  57    the next day.
  58
  59    <p>Is is possible to specify monthly, weekly, half-daily, daily,
  60    hourly, or minutely rollover schedules.
  61
  62    <p><table border="1" cellpadding="2">
  63    <tr>
  64    <th>DatePattern</th>
  65    <th>Rollover schedule</th>
  66    <th>Example</th>
  67
  68    <tr>
  69    <td><code>'.'yyyy-MM</code>
  70    <td>Rollover at the beginning of each month</td>
  71
  72    <td>At midnight of May 31st, 2002 <code>/foo/bar.log</code> will be
  73    copied to <code>/foo/bar.log.2002-05</code>. Logging for the month
  74    of June will be output to <code>/foo/bar.log</code> until it is
  75    also rolled over the next month.
  76
  77    <tr>
  78    <td><code>'.'yyyy-ww</code>
  79
  80    <td>Rollover at the first day of each week. The first day of the
  81    week depends on the locale.</td>
  82
  83    <td>Assuming the first day of the week is Sunday, on Saturday
  84    midnight, June 9th 2002, the file <i>/foo/bar.log</i> will be
  85    copied to <i>/foo/bar.log.2002-23</i>.  Logging for the 24th week
  86    of 2002 will be output to <code>/foo/bar.log</code> until it is
  87    rolled over the next week.
  88
  89    <tr>
  90    <td><code>'.'yyyy-MM-dd</code>
  91
  92    <td>Rollover at midnight each day.</td>
  93
  94    <td>At midnight, on March 8th, 2002, <code>/foo/bar.log</code> will
  95    be copied to <code>/foo/bar.log.2002-03-08</code>. Logging for the
  96    9th day of March will be output to <code>/foo/bar.log</code> until
  97    it is rolled over the next day.
  98
  99    <tr>
 100    <td><code>'.'yyyy-MM-dd-a</code>
 101
 102    <td>Rollover at midnight and midday of each day.</td>
 103
 104    <td>At noon, on March 9th, 2002, <code>/foo/bar.log</code> will be
 105    copied to <code>/foo/bar.log.2002-03-09-AM</code>. Logging for the
 106    afternoon of the 9th will be output to <code>/foo/bar.log</code>
 107    until it is rolled over at midnight.
 108
 109    <tr>
 110    <td><code>'.'yyyy-MM-dd-HH</code>
 111
 112    <td>Rollover at the top of every hour.</td>
 113
 114    <td>At approximately 11:00.000 o'clock on March 9th, 2002,
 115    <code>/foo/bar.log</code> will be copied to
 116    <code>/foo/bar.log.2002-03-09-10</code>. Logging for the 11th hour
 117    of the 9th of March will be output to <code>/foo/bar.log</code>
 118    until it is rolled over at the beginning of the next hour.
 119
 120
 121    <tr>
 122    <td><code>'.'yyyy-MM-dd-HH-mm</code>
 123
 124    <td>Rollover at the beginning of every minute.</td>
 125
 126    <td>At approximately 11:23,000, on March 9th, 2001,
 127    <code>/foo/bar.log</code> will be copied to
 128    <code>/foo/bar.log.2001-03-09-10-22</code>. Logging for the minute
 129    of 11:23 (9th of March) will be output to
 130    <code>/foo/bar.log</code> until it is rolled over the next minute.
 131
 132    </table>
 133
 134    <p>Do not use the colon ":" character in anywhere in the
 135    <b>DatePattern</b> option. The text before the colon is interpeted
 136    as the protocol specificaion of a URL which is probably not what
 137    you want.
 138
 139
 140    @author Eirik Lygre
 141    @author Ceki G&uuml;lc&uuml;*/
 142 public class DailyRollingFileAppender extends FileAppender {
 143
 144
 145   // The code assumes that the following constants are in a increasing
 146   // sequence.
 147   static final int TOP_OF_TROUBLE=-1;
 148   static final int TOP_OF_MINUTE = 0;
 149   static final int TOP_OF_HOUR   = 1;
 150   static final int HALF_DAY      = 2;
 151   static final int TOP_OF_DAY    = 3;
 152   static final int TOP_OF_WEEK   = 4;
 153   static final int TOP_OF_MONTH  = 5;
 154
 155
 156   /**
 157      The date pattern. By default, the pattern is set to
 158      "'.'yyyy-MM-dd" meaning daily rollover.
 159    */
 160   private String datePattern = "'.'yyyy-MM-dd";
 161
 162   /**
 163      The log file will be renamed to the value of the
 164      scheduledFilename variable when the next interval is entered. For
 165      example, if the rollover period is one hour, the log file will be
 166      renamed to the value of "scheduledFilename" at the beginning of
 167      the next hour.
 168
 169      The precise time when a rollover occurs depends on logging
 170      activity.
 171   */
 172   private String scheduledFilename;
 173
 174   /**
 175      The next time we estimate a rollover should occur. */
 176   private long nextCheck = System.currentTimeMillis () - 1;
 177
 178   Date now = new Date();
 179
 180   SimpleDateFormat sdf;
 181
 182   RollingCalendar rc = new RollingCalendar();
 183
 184   int checkPeriod = TOP_OF_TROUBLE;
 185
 186   // The gmtTimeZone is used only in computeCheckPeriod() method.
 187   static final TimeZone gmtTimeZone = TimeZone.getTimeZone("GMT");
 188
 189
 190   /**
 191      The default constructor does nothing. */
 192   public DailyRollingFileAppender() {
 193   }
 194
 195   /**
 196     Instantiate a <code>DailyRollingFileAppender</code> and open the
 197     file designated by <code>filename</code>. The opened filename will
 198     become the ouput destination for this appender.
 199
 200     */
 201   public DailyRollingFileAppender (Layout layout, String filename,
 202                                    String datePattern) throws IOException {
 203     super(layout, filename, true);
 204     this.datePattern = datePattern;
 205     activateOptions();
 206   }
 207
 208   /**
 209      The <b>DatePattern</b> takes a string in the same format as
 210      expected by {@link SimpleDateFormat}. This options determines the
 211      rollover schedule.
 212    */
 213   public void setDatePattern(String pattern) {
 214     datePattern = pattern;
 215   }
 216
 217   /** Returns the value of the <b>DatePattern</b> option. */
 218   public String getDatePattern() {
 219     return datePattern;
 220   }
 221
 222   public void activateOptions() {
 223     super.activateOptions();
 224     if(datePattern != null && fileName != null) {
 225       now.setTime(System.currentTimeMillis());
 226       sdf = new SimpleDateFormat(datePattern);
 227       int type = computeCheckPeriod();
 228       printPeriodicity(type);
 229       rc.setType(type);
 230       File file = new File(fileName);
 231       scheduledFilename = fileName+sdf.format(new Date(file.lastModified()));
 232
 233     } else {
 234       LogLog.error("Either File or DatePattern options are not set for appender ["
 235                    +name+"].");
 236     }
 237   }
 238
 239   void printPeriodicity(int type) {
 240     switch(type) {
 241     case TOP_OF_MINUTE:
 242       LogLog.debug("Appender ["+name+"] to be rolled every minute.");
 243       break;
 244     case TOP_OF_HOUR:
 245       LogLog.debug("Appender ["+name
 246                    +"] to be rolled on top of every hour.");
 247       break;
 248     case HALF_DAY:
 249       LogLog.debug("Appender ["+name
 250                    +"] to be rolled at midday and midnight.");
 251       break;
 252     case TOP_OF_DAY:
 253       LogLog.debug("Appender ["+name
 254                    +"] to be rolled at midnight.");
 255       break;
 256     case TOP_OF_WEEK:
 257       LogLog.debug("Appender ["+name
 258                    +"] to be rolled at start of week.");
 259       break;
 260     case TOP_OF_MONTH:
 261       LogLog.debug("Appender ["+name
 262                    +"] to be rolled at start of every month.");
 263       break;
 264     default:
 265       LogLog.warn("Unknown periodicity for appender ["+name+"].");
 266     }
 267   }
 268
 269
 270   // This method computes the roll over period by looping over the
 271   // periods, starting with the shortest, and stopping when the r0 is
 272   // different from from r1, where r0 is the epoch formatted according
 273   // the datePattern (supplied by the user) and r1 is the
 274   // epoch+nextMillis(i) formatted according to datePattern. All date
 275   // formatting is done in GMT and not local format because the test
 276   // logic is based on comparisons relative to 1970-01-01 00:00:00
 277   // GMT (the epoch).
 278
 279   int computeCheckPeriod() {
 280     RollingCalendar rollingCalendar = new RollingCalendar(gmtTimeZone, Locale.getDefault());
 281     // set sate to 1970-01-01 00:00:00 GMT
 282     Date epoch = new Date(0);
 283     if(datePattern != null) {
 284       for(int i = TOP_OF_MINUTE; i <= TOP_OF_MONTH; i++) {
 285         SimpleDateFormat simpleDateFormat = new SimpleDateFormat(datePattern);
 286         simpleDateFormat.setTimeZone(gmtTimeZone); // do all date formatting in GMT
 287         String r0 = simpleDateFormat.format(epoch);
 288         rollingCalendar.setType(i);
 289         Date next = new Date(rollingCalendar.getNextCheckMillis(epoch));
 290         String r1 =  simpleDateFormat.format(next);
 291         //System.out.println("Type = "+i+", r0 = "+r0+", r1 = "+r1);
 292         if(r0 != null && r1 != null && !r0.equals(r1)) {
 293           return i;
 294         }
 295       }
 296     }
 297     return TOP_OF_TROUBLE; // Deliberately head for trouble...
 298   }
 299
 300   /**
 301      Rollover the current file to a new file.
 302   */
 303   void rollOver() throws IOException {
 304
 305     /* Compute filename, but only if datePattern is specified */
 306     if (datePattern == null) {
 307       errorHandler.error("Missing DatePattern option in rollOver().");
 308       return;
 309     }
 310
 311     String datedFilename = fileName+sdf.format(now);
 312     // It is too early to roll over because we are still within the
 313     // bounds of the current interval. Rollover will occur once the
 314     // next interval is reached.
 315     if (scheduledFilename.equals(datedFilename)) {
 316       return;
 317     }
 318
 319     // close current file, and rename it to datedFilename
 320     this.closeFile();
 321
 322     File target  = new File(scheduledFilename);
 323     if (target.exists()) {
 324       target.delete();
 325     }
 326
 327     File file = new File(fileName);
 328     boolean result = file.renameTo(target);
 329     if(result) {
 330       LogLog.debug(fileName +" -> "+ scheduledFilename);
 331     } else {
 332       LogLog.error("Failed to rename ["+fileName+"] to ["+scheduledFilename+"].");
 333     }
 334
 335     try {
 336       // This will also close the file. This is OK since multiple
 337       // close operations are safe.
 338       this.setFile(fileName, true, this.bufferedIO, this.bufferSize);
 339     }
 340     catch(IOException e) {
 341       errorHandler.error("setFile("+fileName+", true) call failed.");
 342     }
 343     scheduledFilename = datedFilename;
 344   }
 345
 346   /**
 347    * This method differentiates DailyRollingFileAppender from its
 348    * super class.
 349    *
 350    * <p>Before actually logging, this method will check whether it is
 351    * time to do a rollover. If it is, it will schedule the next
 352    * rollover time and then rollover.
 353    * */
 354   protected void subAppend(LoggingEvent event) {
 355     long n = System.currentTimeMillis();
 356     if (n >= nextCheck) {
 357       now.setTime(n);
 358       nextCheck = rc.getNextCheckMillis(now);
 359       try {
 360         rollOver();
 361       }
 362       catch(IOException ioe) {
 363           if (ioe instanceof InterruptedIOException) {
 364               Thread.currentThread().interrupt();
 365           }
 366               LogLog.error("rollOver() failed.", ioe);
 367       }
 368     }
 369     super.subAppend(event);
 370    }
 371 }
 372
 373 /**
 374  *  RollingCalendar is a helper class to DailyRollingFileAppender.
 375  *  Given a periodicity type and the current time, it computes the
 376  *  start of the next interval.
 377  * */
 378 class RollingCalendar extends GregorianCalendar {
 379   private static final long serialVersionUID = -3560331770601814177L;
 380
 381   int type = DailyRollingFileAppender.TOP_OF_TROUBLE;
 382
 383   RollingCalendar() {
 384     super();
 385   }
 386
 387   RollingCalendar(TimeZone tz, Locale locale) {
 388     super(tz, locale);
 389   }
 390
 391   void setType(int type) {
 392     this.type = type;
 393   }
 394
 395   public long getNextCheckMillis(Date now) {
 396     return getNextCheckDate(now).getTime();
 397   }
 398
 399   public Date getNextCheckDate(Date now) {
 400     this.setTime(now);
 401
 402     switch(type) {
 403     case DailyRollingFileAppender.TOP_OF_MINUTE:
 404         this.set(Calendar.SECOND, 0);
 405         this.set(Calendar.MILLISECOND, 0);
 406         this.add(Calendar.MINUTE, 1);
 407         break;
 408     case DailyRollingFileAppender.TOP_OF_HOUR:
 409         this.set(Calendar.MINUTE, 0);
 410         this.set(Calendar.SECOND, 0);
 411         this.set(Calendar.MILLISECOND, 0);
 412         this.add(Calendar.HOUR_OF_DAY, 1);
 413         break;
 414     case DailyRollingFileAppender.HALF_DAY:
 415         this.set(Calendar.MINUTE, 0);
 416         this.set(Calendar.SECOND, 0);
 417         this.set(Calendar.MILLISECOND, 0);
 418         int hour = get(Calendar.HOUR_OF_DAY);
 419         if(hour < 12) {
 420           this.set(Calendar.HOUR_OF_DAY, 12);
 421         } else {
 422           this.set(Calendar.HOUR_OF_DAY, 0);
 423           this.add(Calendar.DAY_OF_MONTH, 1);
 424         }
 425         break;
 426     case DailyRollingFileAppender.TOP_OF_DAY:
 427         this.set(Calendar.HOUR_OF_DAY, 0);
 428         this.set(Calendar.MINUTE, 0);
 429         this.set(Calendar.SECOND, 0);
 430         this.set(Calendar.MILLISECOND, 0);
 431         this.add(Calendar.DATE, 1);
 432         break;
 433     case DailyRollingFileAppender.TOP_OF_WEEK:
 434         this.set(Calendar.DAY_OF_WEEK, getFirstDayOfWeek());
 435         this.set(Calendar.HOUR_OF_DAY, 0);
 436         this.set(Calendar.MINUTE, 0);
 437         this.set(Calendar.SECOND, 0);
 438         this.set(Calendar.MILLISECOND, 0);
 439         this.add(Calendar.WEEK_OF_YEAR, 1);
 440         break;
 441     case DailyRollingFileAppender.TOP_OF_MONTH:
 442         this.set(Calendar.DATE, 1);
 443         this.set(Calendar.HOUR_OF_DAY, 0);
 444         this.set(Calendar.MINUTE, 0);
 445         this.set(Calendar.SECOND, 0);
 446         this.set(Calendar.MILLISECOND, 0);
 447         this.add(Calendar.MONTH, 1);
 448         break;
 449     default:
 450         throw new IllegalStateException("Unknown periodicity type.");
 451     }
 452     return getTime();
 453   }
 454 }