LogRecord xref

View Javadoc

    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  package org.apache.log4j.lf5;
    18
    19  import java.io.IOException;
    20  import java.io.PrintWriter;
    21  import java.io.StringWriter;
    22
    23  /**
    24   * LogRecord.  A LogRecord encapsulates the details of your desired log
    25   * request.
    26   *
    27   * @author Michael J. Sikorsky
    28   * @author Robert Shaw
    29   */
    30
    31  // Contributed by ThoughtWorks Inc.
    32
    33  public abstract class LogRecord implements java.io.Serializable {
    34    //--------------------------------------------------------------------------
    35    //   Constants:
    36    //--------------------------------------------------------------------------
    37
    38    //--------------------------------------------------------------------------
    39    //   Protected Variables:
    40    //--------------------------------------------------------------------------
    41    protected static long _seqCount = 0;
    42
    43    protected LogLevel _level;
    44    protected String _message;
    45    protected long _sequenceNumber;
    46    protected long _millis;
    47    protected String _category;
    48    protected String _thread;
    49    protected String _thrownStackTrace;
    50    protected Throwable _thrown;
    51    protected String _ndc;
    52    protected String _location;
    53
    54    //--------------------------------------------------------------------------
    55    //   Private Variables:
    56    //--------------------------------------------------------------------------
    57
    58    //--------------------------------------------------------------------------
    59    //   Constructors:
    60    //--------------------------------------------------------------------------
    61
    62    public LogRecord() {
    63      super();
    64
    65      _millis = System.currentTimeMillis();
    66      _category = "Debug";
    67      _message = "";
    68      _level = LogLevel.INFO;
    69      _sequenceNumber = getNextId();
    70      _thread = Thread.currentThread().toString();
    71      _ndc = "";
    72      _location = "";
    73    }
    74
    75    //--------------------------------------------------------------------------
    76    //   Public Methods:
    77    //--------------------------------------------------------------------------
    78
    79    /**
    80     * Get the level of this LogRecord.
    81     *
    82     * @return The LogLevel of this record.
    83     * @see #setLevel(LogLevel)
    84     * @see LogLevel
    85     */
    86    public LogLevel getLevel() {
    87      return (_level);
    88    }
    89
    90    /**
    91     * Set the level of this LogRecord.
    92     *
    93     * @param level The LogLevel for this record.
    94     * @see #getLevel()
    95     * @see LogLevel
    96     */
    97    public void setLevel(LogLevel level) {
    98      _level = level;
    99    }
    100
    101   /**
    102    * Abstract method. Must be overridden to indicate what log level
    103    * to show in red.
    104    */
    105   public abstract boolean isSevereLevel();
    106
    107   /**
    108    * @return true if getThrown().toString() is a non-empty string.
    109    */
    110   public boolean hasThrown() {
    111     Throwable thrown = getThrown();
    112     if (thrown == null) {
    113       return false;
    114     }
    115     String thrownString = thrown.toString();
    116     return thrownString != null && thrownString.trim().length() != 0;
    117   }
    118
    119   /**
    120    * @return true if isSevereLevel() or hasThrown() returns true.
    121    */
    122   public boolean isFatal() {
    123     return isSevereLevel() || hasThrown();
    124   }
    125
    126   /**
    127    * Get the category asscociated with this LogRecord.  For a more detailed
    128    * description of what a category is see setCategory().
    129    *
    130    * @return The category of this record.
    131    * @see #setCategory(String)
    132    */
    133   public String getCategory() {
    134     return (_category);
    135   }
    136
    137   /**
    138    * Set the category associated with this LogRecord. A category represents
    139    * a hierarchical dot (".") separated namespace for messages.
    140    * The definition of a category is application specific, but a common convention
    141    * is as follows:
    142    *
    143    * <p>
    144    * When logging messages
    145    * for a particluar class you can use its class name:
    146    * com.thoughtworks.framework.servlet.ServletServiceBroker.<br><br>
    147    * Futhermore, to log a message for a particular method in a class
    148    * add the method name:
    149    * com.thoughtworks.framework.servlet.ServletServiceBroker.init().
    150    * </p>
    151    *
    152    * @param category The category for this record.
    153    * @see #getCategory()
    154    */
    155   public void setCategory(String category) {
    156     _category = category;
    157   }
    158
    159   /**
    160    * Get the message asscociated with this LogRecord.
    161    *
    162    * @return The message of this record.
    163    * @see #setMessage(String)
    164    */
    165   public String getMessage() {
    166     return (_message);
    167   }
    168
    169   /**
    170    * Set the message associated with this LogRecord.
    171    *
    172    * @param message The message for this record.
    173    * @see #getMessage()
    174    */
    175   public void setMessage(String message) {
    176     _message = message;
    177   }
    178
    179   /**
    180    * Get the sequence number associated with this LogRecord.  Sequence numbers
    181    * are generally assigned when a LogRecord is constructed.  Sequence numbers
    182    * start at 0 and increase with each newly constructed LogRocord.
    183    *
    184    * @return The sequence number of this record.
    185    * @see #setSequenceNumber(long)
    186    */
    187   public long getSequenceNumber() {
    188     return (_sequenceNumber);
    189   }
    190
    191   /**
    192    * Set the sequence number assocsiated with this LogRecord.  A sequence number
    193    * will automatically be assigned to evey newly constructed LogRecord, however,
    194    * this method can override the value.
    195    *
    196    * @param number The sequence number.
    197    * @see #getSequenceNumber()
    198    */
    199   public void setSequenceNumber(long number) {
    200     _sequenceNumber = number;
    201   }
    202
    203   /**
    204    * Get the event time of this record in milliseconds from 1970.
    205    * When a LogRecord is constructed the event time is set but may be
    206    * overridden by calling setMillis();
    207    *
    208    * @return The event time of this record in milliseconds from 1970.
    209    * @see #setMillis(long)
    210    */
    211   public long getMillis() {
    212     return _millis;
    213   }
    214
    215   /**
    216    * Set the event time of this record.  When a LogRecord is constructed
    217    * the event time is set but may be overridden by calling this method.
    218    *
    219    * @param millis The time in milliseconds from 1970.
    220    * @see #getMillis()
    221    */
    222   public void setMillis(long millis) {
    223     _millis = millis;
    224   }
    225
    226   /**
    227    * Get the thread description asscociated with this LogRecord.  When a
    228    * LogRecord is constructed, the thread description is set by calling:
    229    * Thread.currentThread().toString().  You may supply a thread description
    230    * of your own by calling the setThreadDescription(String) method.
    231    *
    232    * @return The thread description of this record.
    233    * @see #setThreadDescription(String)
    234    */
    235   public String getThreadDescription() {
    236     return (_thread);
    237   }
    238
    239   /**
    240    * Set the thread description associated with this LogRecord.  When a
    241    * LogRecord is constructed, the thread description is set by calling:
    242    * Thread.currentThread().toString().  You may supply a thread description
    243    * of your own by calling this method.
    244    *
    245    * @param threadDescription The description of the thread for this record.
    246    * @see #getThreadDescription()
    247    */
    248   public void setThreadDescription(String threadDescription) {
    249     _thread = threadDescription;
    250   }
    251
    252   /**
    253    * Get the stack trace in a String-based format for the associated Throwable
    254    * of this LogRecord.  The stack trace in a String-based format is set
    255    * when the setThrown(Throwable) method is called.
    256    *
    257    * <p>
    258    * Why do we need this method considering that we
    259    * have the getThrown() and setThrown() methods?
    260    * A Throwable object may not be serializable, however, a String representation
    261    * of it is.  Users of LogRecords should generally call this method over
    262    * getThrown() for the reasons of serialization.
    263    * </p>
    264    *
    265    * @return The Stack Trace for the asscoiated Throwable of this LogRecord.
    266    * @see #setThrown(Throwable)
    267    * @see #getThrown()
    268    */
    269   public String getThrownStackTrace() {
    270     return (_thrownStackTrace);
    271   }
    272
    273   /**
    274    * Set the ThrownStackTrace for the log record.
    275    *
    276    * @param trace A String to associate with this LogRecord
    277    * @see #getThrownStackTrace()
    278    */
    279   public void setThrownStackTrace(String trace) {
    280     _thrownStackTrace = trace;
    281   }
    282
    283   /**
    284    * Get the Throwable associated with this LogRecord.
    285    *
    286    * @return The LogLevel of this record.
    287    * @see #setThrown(Throwable)
    288    * @see #getThrownStackTrace()
    289    */
    290   public Throwable getThrown() {
    291     return (_thrown);
    292   }
    293
    294   /**
    295    * Set the Throwable associated with this LogRecord.  When this method
    296    * is called, the stack trace in a String-based format is made
    297    * available via the getThrownStackTrace() method.
    298    *
    299    * @param thrown A Throwable to associate with this LogRecord.
    300    * @see #getThrown()
    301    * @see #getThrownStackTrace()
    302    */
    303   public void setThrown(Throwable thrown) {
    304     if (thrown == null) {
    305       return;
    306     }
    307     _thrown = thrown;
    308     StringWriter sw = new StringWriter();
    309     PrintWriter out = new PrintWriter(sw);
    310     thrown.printStackTrace(out);
    311     out.flush();
    312     _thrownStackTrace = sw.toString();
    313     try {
    314       out.close();
    315       sw.close();
    316     } catch (IOException e) {
    317       // Do nothing, this should not happen as it is StringWriter.
    318     }
    319     out = null;
    320     sw = null;
    321   }
    322
    323   /**
    324    * Return a String representation of this LogRecord.
    325    */
    326   public String toString() {
    327     StringBuffer buf = new StringBuffer();
    328     buf.append("LogRecord: [" + _level + ", " + _message + "]");
    329     return (buf.toString());
    330   }
    331
    332   /**
    333    * Get the NDC (nested diagnostic context) for this record.
    334    *
    335    * @return The string representing the NDC.
    336    */
    337   public String getNDC() {
    338     return _ndc;
    339   }
    340
    341   /**
    342    * Set the NDC (nested diagnostic context) for this record.
    343    *
    344    * @param ndc A string representing the NDC.
    345    */
    346   public void setNDC(String ndc) {
    347     _ndc = ndc;
    348   }
    349
    350   /**
    351    * Get the location in code where this LogRecord originated.
    352    *
    353    * @return The string containing the location information.
    354    */
    355   public String getLocation() {
    356     return _location;
    357   }
    358
    359   /**
    360    * Set the location in code where this LogRecord originated.
    361    *
    362    * @param location A string containing location information.
    363    */
    364   public void setLocation(String location) {
    365     _location = location;
    366   }
    367
    368   /**
    369    * Resets that sequence number to 0.
    370    *
    371    */
    372   public static synchronized void resetSequenceNumber() {
    373     _seqCount = 0;
    374   }
    375
    376   //--------------------------------------------------------------------------
    377   //   Protected Methods:
    378   //--------------------------------------------------------------------------
    379
    380   protected static synchronized long getNextId() {
    381     _seqCount++;
    382     return _seqCount;
    383   }
    384   //--------------------------------------------------------------------------
    385   //   Private Methods:
    386   //--------------------------------------------------------------------------
    387
    388   //--------------------------------------------------------------------------
    389   //   Nested Top-Level Classes or Interfaces:
    390   //--------------------------------------------------------------------------
    391
    392 }
    393
    394
    395