The version of Apache log4j used by SoundHelix.

[[ 🗃 ^aEp6o apache-log4j ]] :: [📥 Inbox] [📤 Outbox] [🐤 Followers] [🤝 Collaborators] [🛠 Commits]

Clone

HTTPS: git clone https://vervis.peers.community/repos/aEp6o

SSH: git clone USERNAME@vervis.peers.community:aEp6o

Branches

Tags

v1.3alpha8 :: src / java / org / apache / log4j /

DailyRollingFileAppender.java

/*
 * Copyright 1999,2005 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.
 */

package org.apache.log4j;

import org.apache.log4j.rolling.TimeBasedRollingPolicy;
import org.apache.log4j.spi.Filter;
import org.apache.log4j.spi.LoggerRepository;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.OptionHandler;

import java.io.IOException;


/**
  * org.apache.log4j.DailyRollingFileAppender emulates earlier implementations
  * by delegating to general purpose org.apache.log4j.rollling.RollingFileAppender
  * introduced in log4j 1.3.  This class is provided for compatibility with
  * existing configuration files but is not intended to be compatible with
  * existing extensions of the prior RollingFileAppender and is marked final
  * to prevent such use.
  *
  *  @author Curt Arnold
  * @deprecated Replaced by {@link org.apache.log4j.rolling.RollingFileAppender}
*/
public final class DailyRollingFileAppender implements Appender, OptionHandler {

  /**
   * It is assumed and enforced that errorHandler is never null.
   * 
   * @deprecated as of 1.3
   */
  private final org.apache.log4j.spi.ErrorHandler errorHandler = new org.apache.log4j.helpers.OnlyOnceErrorHandler();

  /**
     The date pattern used to initiate rollover.
  */
  private String datePattern = "'.'yyyy-MM-dd";

  /**
   *  Nested new rolling file appender.
   */
  private final org.apache.log4j.rolling.RollingFileAppender rfa =
    new org.apache.log4j.rolling.RollingFileAppender();

  /**
     The default constructor simply calls its {@link
     FileAppender#FileAppender parents constructor}.  */
  public DailyRollingFileAppender() {
  }

  /**
    Instantiate a DailyRollingFileAppender and open the file designated by
    <code>filename</code>. The opened filename will become the ouput
    destination for this appender.

  */
  public DailyRollingFileAppender(
    final Layout layout, final String filename, final String datePattern)
    throws IOException {
    rfa.setLayout(layout);
    rfa.setFile(filename);
    this.datePattern = datePattern;
    activateOptions();
  }

  /**
     The <b>DatePattern</b> takes a string in the same format as
     expected by {@link java.text.SimpleDateFormat}. This options determines the
     rollover schedule.
   */
  public void setDatePattern(String pattern) {
    datePattern = pattern;
  }

  /** 
   * Returns the value of the <b>DatePattern</b> option. 
   * By default, the pattern is set to ".yyyy-MM-dd" meaning daily rollover.
   */
  public String getDatePattern() {
    return datePattern;
  }

  /**
   * Prepares DailyRollingFileAppender for use.
   */
  public void activateOptions() {
    TimeBasedRollingPolicy policy = new TimeBasedRollingPolicy();
    StringBuffer pattern = new StringBuffer(rfa.getFile());
    boolean inLiteral = false;
    boolean inPattern = false;

    for (int i = 0; i < datePattern.length(); i++) {
      if (datePattern.charAt(i) == '\'') {
        inLiteral = !inLiteral;

        if (inLiteral && inPattern) {
          pattern.append("}");
          inPattern = false;
        }
      } else {
        if (!inLiteral && !inPattern) {
          pattern.append("%d{");
          inPattern = true;
        }

        pattern.append(datePattern.charAt(i));
      }
    }

    if (inPattern) {
      pattern.append("}");
    }

    policy.setFileNamePattern(pattern.toString());
    policy.activateOptions();
    rfa.setTriggeringPolicy(policy);
    rfa.setRollingPolicy(policy);

    rfa.activateOptions();
  }


  /**
   * Add a filter to the end of the filter list.
   *
   * @since 0.9.0
   */
  public void addFilter(final Filter newFilter) {
    rfa.addFilter(newFilter);
  }

  /**
   * Returns the head Filter. The Filters are organized in a linked list and
   * so all Filters on this Appender are available through the result.
   *
   * @return the head Filter or null, if no Filters are present
   *
   * @since 1.1
   */
  public Filter getFilter() {
    return rfa.getFilter();
  }

  /**
   * Clear the list of filters by removing all the filters in it.
   *
   * @since 0.9.0
   */
  public void clearFilters() {
    rfa.clearFilters();
  }

  /**
   * Release any resources allocated within the appender such as file handles,
   * network connections, etc.
   *
   * <p>
   * It is a programming error to append to a closed appender.
   * </p>
   *
   * @since 0.8.4
   */
  public void close() {
    rfa.close();
  }

  /**
   * Is this appender closed?
   *
   * @since 1.3
   */
  public boolean isClosed() {
    return rfa.isClosed();
  }

  /**
   * Is this appender in working order?
   *
   * @since 1.3
   */
  public boolean isActive() {
    return rfa.isActive();
  }

  /**
   * Log in <code>Appender</code> specific way. When appropriate, Loggers will
   * call the <code>doAppend</code> method of appender implementations in
   * order to log.
   */
  public void doAppend(final LoggingEvent event) {
    rfa.doAppend(event);
  }

  /**
   * Get the name of this appender. The name uniquely identifies the appender.
   */
  public String getName() {
    return rfa.getName();
  }

  /**
   * Set the {@link Layout} for this appender.
   *
   * @since 0.8.1
   */
  public void setLayout(final Layout layout) {
    rfa.setLayout(layout);
  }

  /**
   * Returns this appenders layout.
   *
   * @since 1.1
   */
  public Layout getLayout() {
    return rfa.getLayout();
  }

  /**
   * Set the name of this appender. The name is used by other components to
   * identify this appender.
   *
   * @since 0.8.1
   */
  public void setName(final String name) {
    rfa.setName(name);
  }

  public void setLoggerRepository(final LoggerRepository repository)
    throws IllegalStateException {
    rfa.setLoggerRepository(repository);
  }

  /**
     The <b>File</b> property takes a string value which should be the
     name of the file to append to.

     <p><font color="#DD0044"><b>Note that the special values
     "System.out" or "System.err" are no longer honored.</b></font>

     <p>Note: Actual opening of the file is made when {@link
     #activateOptions} is called, not when the options are set.  */
  public void setFile(final String file) {
    rfa.setFile(file);
  }

  /**
      Returns the value of the <b>Append</b> option.
   */
  public boolean getAppend() {
    return rfa.getAppend();
  }

  /** Returns the value of the <b>File</b> option. */
  public String getFile() {
    return rfa.getFile();
  }

  /**
     Get the value of the <b>BufferedIO</b> option.

     <p>BufferedIO will significatnly increase performance on heavily
     loaded systems.

  */
  public boolean getBufferedIO() {
    return rfa.getBufferedIO();
  }

  /**
     Get the size of the IO buffer.
  */
  public int getBufferSize() {
    return rfa.getBufferSize();
  }

  /**
     The <b>Append</b> option takes a boolean value. It is set to
     <code>true</code> by default. If true, then <code>File</code>
     will be opened in append mode by {@link #setFile setFile} (see
     above). Otherwise, {@link #setFile setFile} will open
     <code>File</code> in truncate mode.

     <p>Note: Actual opening of the file is made when {@link
     #activateOptions} is called, not when the options are set.
   */
  public void setAppend(final boolean flag) {
    rfa.setAppend(flag);
  }

  /**
     The <b>BufferedIO</b> option takes a boolean value. It is set to
     <code>false</code> by default. If true, then <code>File</code>
     will be opened and the resulting {@link java.io.Writer} wrapped
     around a {@link java.io.BufferedWriter}.

     BufferedIO will significatnly increase performance on heavily
     loaded systems.

  */
  public void setBufferedIO(final boolean bufferedIO) {
    rfa.setBufferedIO(bufferedIO);
  }

  /**
     Set the size of the IO buffer.
  */
  public void setBufferSize(final int bufferSize) {
    rfa.setBufferSize(bufferSize);
  }

  /**
   * Return the hardcoded <code>OnlyOnceErrorHandler</code> for this Appender.
   * <code>ErrorHandler</code>'s are no longer utilized as of version 1.3.
   *
   * @since 0.9.0
   * @deprecated As of 1.3
   */
  public final org.apache.log4j.spi.ErrorHandler getErrorHandler() {
    return this.errorHandler;
  }

  /**
   * Ignored as of 1.3
   *
   * @since 0.9.0
   * @deprecated As of 1.3
   */
  public final void setErrorHandler(org.apache.log4j.spi.ErrorHandler eh) {
    ; //ignore
  }

    /**
     * Gets whether appender requires a layout.
     * @return false
     */
  public boolean requiresLayout() {
      return true;
  }


}
[See repo JSON]