Source code: konspire/common/log/Log.java

   package konspire.common.log;
   
   import java.util.*;
   import java.text.*;
   
   
   /**
    * <code>Log</code> is the base class which defines 
    * all of the logging constants and implements any 
   * general logging responsibilities.  It dispatches the actual
   * logging information over to a concrete subclass of 
   * <code>AbstractLoggingMechanism</code> to do the work of writing
   * out the log information. <p>
   *
   * This class could be extended to do application-specific behavior,
   * or better yet you could create a class "wrapper" like <code>AppLog</code>
   * to make instances well-known Singletons with handy static/class methods.
   *
   * @author Todd Lauinger
   * @version $Revision: 1.3 $
   *
   * @see AbstractLoggingMechanism
   * @see AppLog
   */
  public class Log {
  
      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      // Constants section
      
    // The following constants are levels for logging an error,
    // with the lowest number the most detailed
    // (and least critical) and the highest number the least detailed
    // (and most critical).
  
    /**
     * Turns the log off, no messages are logged
     */
    public static final int DEACTIVATE_LEVEL = 0;
  
    /**
     * The system encountered a critical error at this logging level, 
     * which affects the accuracy, integrity, reliability, or 
     * capability of the system.  Someone should be paged to address
     * the error as soon as possible.
     */
    public static final int CRITICAL_ERROR_LEVEL = 1;
  
    /**
     * The system encountered an unexpected error at this logging level, 
     * which probably means the code intercepted an error it cannot handle.
     * This error is not of a critical nature and can be recovered from
     * automatically.
     * Someone should probably be emailed to resolve the error in the near
     * future to increase the reliability of the product.
     */
    public static final int ERROR_LEVEL = 2;
  
    /**
     * The system encountered an expected error situation.  The system
     * recovered from it but the fact that it happened should be recorded
     * to see how frequent it happens.
     */
    public static final int WARNING_LEVEL = 3;
  
    /**
     * Normal logging level.  All interesting periodic events should 
     * be logged at this level so someone looking through the log can
     * see the amount and kind of processing happening in the system.
     */
    public static final int INFO_LEVEL = 4;
  
    /**
     * Moderately detailed logging level to be used to help debug
     * typical problems in the system.  Not so detailed that the
     * big picture gets lost.
     */
    public static final int DETAIL_LEVEL = 5;
  
    /**
     * Most detailed logging level. Everything
     * sent to the log will be logged.  Use this level to 
     * trace system execution for really nasty problems.
     */
    public static final int TRACE_LEVEL = 6;
  
  
    // The following constants define different output log mechanisms a log
    // can accommodate.
    
    /**
     * Logging mechanism to log all messages to System.err
     */
    public static final String STANDARD_ERR_MECHANISM = StandardErrLoggingMechanism.class.getName();
  
    /**
     * Logging mechanism to log all messages to a unique file 
     * specific to that <code>Log</code> instance.  Reuse the same
     * log file name (append to it) if it already exists.
     */
   public static final String UNIQUE_FILE_MECHANISM = UniqueFileLoggingMechanism.class.getName();
 
   /**
    * Logging mechanism to log all messages to a unique 
    * file specific to that <code>Log</code> instance. Don't append
    * to an existing log, instead create a new one with a date stamp.
    */
   public static final String UNIQUE_DATED_FILE_MECHANISM = UniqueDatedFileLoggingMechanism.class.getName();
 
   /**
    * Logging mechanism to log all messages to a shared 
    * file for any <code>Log</code> instances using this mechanism.
    * Append to an existing log, if it already exists.
    */
   public static final String SHARED_FILE_MECHANISM = SharedFileLoggingMechanism.class.getName();
 
   /**
    * Logging mechanism to log all messages to a shared file 
    * for any <code>Log</code> instances using this mechanism.
    * Don't append to an existing log, instead create a new one with a
    * date stamp.
    */
   public static final String SHARED_DATED_FILE_MECHANISM = SharedDatedFileLoggingMechanism.class.getName();
 
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // Constructor section
 
   /**
    * Class constructor to properly create and register a new log.  All other
    * constructors and subclasses should eventually call this method!
    */
   protected Log() {
 
     // Add the new Log instance to LogManager
     LogManager.getInstance().addElement(this);
   }
   
   /**
    * Public constructor to register a new log with a particular name.
    * The name of the log is very important.  It is used as a key into
    * the log properties file to find settings for how the log is to
    * be opened.
    */
   public Log(String name) {
       this();
       this.name = name;
       
       // Get logging level and field separator from properties file
       currentLoggingLevel = 
           LogProperties.getInstance().getLoggingLevel(this);
       logFieldSeparator = 
           LogProperties.getInstance().getLogFieldSeparator(this);
 
         System.out.println("Initializing log named " + name + 
             " at logging level " + currentLoggingLevel + 
             " with separator " + logFieldSeparator);
 
       // Get a list of all of the mechanism names and open them
       String mechanismName = null;
       Enumeration e = LogProperties.getInstance().
       getLoggingMechanismNames(this).elements();
       while (e.hasMoreElements()) {
           mechanismName = (String) e.nextElement();
           addLoggingMechanism(mechanismName);
       }
           
   }
 
 
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // Instance Variable section
   
   /**
    * Keeps the name of the Log instance.
    */
   protected String name = "Log";
   
   /**
    * Keep the logging level the log is currently operating at.
    */
   protected int currentLoggingLevel;
 
   /**
    * Keeps a collection of logging mechanisms to use when 
    * writing out the log.
    */
   protected Vector loggingMechanisms = new Vector(10);
 
   /**
    * Keeps the date the log opened
    */
   protected Date dateOpened = new Date();
 
 
     /**
      * Keeps a string demarking fields within the log file.
      */
     protected String logFieldSeparator = 
         LogProperties.DEFAULT_LOG_FIELD_SEPARATOR;
 
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // Instance method section
   
   /**
    * Gets the logging level of the current log.
    */
   public int getLoggingLevel() {
 
     return currentLoggingLevel;
   }
 
   /**
    * Changes the logging level of the current log.
    *
    * Use this method to activate, deactivate, or change the logging
    * detail level of an active log.
    */
   synchronized public void setLoggingLevel(int newLoggingLevel) {
 
         AbstractLoggingMechanism currentLoggingMechanism = null;
         
     // See if we have to open or close the log
     if (newLoggingLevel == Log.DEACTIVATE_LEVEL) {
 
       if (currentLoggingLevel != Log.DEACTIVATE_LEVEL) {
 
         // Must close the log.  
         // Close/deregister with all logging mechanisms
         for (Enumeration e = loggingMechanisms.elements();
                 e.hasMoreElements(); ) {
         
             currentLoggingMechanism = (AbstractLoggingMechanism) 
                                         e.nextElement();
             currentLoggingMechanism.closeForLog(this);
             }
       }
 
     }  // Activating the log, see if we need to open it first
     else if (currentLoggingLevel == Log.DEACTIVATE_LEVEL) {
 
       // Open/register with each logging mechanism
       for (Enumeration e = loggingMechanisms.elements();
               e.hasMoreElements(); ) {
         
           currentLoggingMechanism = (AbstractLoggingMechanism) 
                                         e.nextElement();
           currentLoggingMechanism.openForLog(this, newLoggingLevel);
       }
 
       // Update dateOpened
       dateOpened = new Date();
         
     }
 
     // Notify the log of the change if not deactivated
     if ( (newLoggingLevel != Log.DEACTIVATE_LEVEL) &&
             (currentLoggingLevel != Log.DEACTIVATE_LEVEL) )
 
       for (Enumeration e = loggingMechanisms.elements();
               e.hasMoreElements(); ) {
           currentLoggingMechanism = (AbstractLoggingMechanism) 
                                         e.nextElement();
           currentLoggingMechanism.notifyLoggingLevelChange(this, newLoggingLevel);
           }
 
     // Set the new logging level
     currentLoggingLevel = newLoggingLevel;
     
   }
 
   /**
    * Returns a <code>Vector</code> of logging mechanisms 
    * currently active for the log.
    *
    * @return a <code>Vector</code> of logging mechanisms 
    *    currently active for the log.
    */
   public synchronized Vector getLoggingMechanisms() {
       return this.loggingMechanisms;
   }
 
   /**
    * If a logging mechanism of the type input is in effect for this log, 
    * return the logging mechanism instance matching the name given as
    * input.
    *
    * @param loggingMechanismName  Name of the logging mechanism to search for,
    *         one of the constants in the <code>Log</code> class.
    *
    * @return The concrete instance of an <code>AbstractLoggingMechanism</code>
    *         that is currently in effect for the Log if one found, null if not.
    */
   public synchronized AbstractLoggingMechanism getLoggingMechanism(String loggingMechanismName) {
 
         AbstractLoggingMechanism currentLoggingMechanism = null;
         
     // Run through the loggingMechanisms vector to try and find
     // the mechanism for the name provided.
     for (Enumeration e = loggingMechanisms.elements();
                 e.hasMoreElements(); ) {
         
         currentLoggingMechanism = (AbstractLoggingMechanism) 
                                       e.nextElement();
       if (currentLoggingMechanism.getName().equals(loggingMechanismName)) {
           return currentLoggingMechanism;
       }
         }
         
         // Not found in the enumeration, return null
         return null;
   }
 
   /**
    * Adds a Logging Mechanism to the list of mechanisms that this
    * log writes to.  Opens the mechanism and registers it also.
    *
    * @param loggingMechanismName The name of the Logging Mechanism.
    *
    * @return The concrete instance of <code>AbstractLoggingMechanism</code>
    *         that implements the mechanism just added, null if an error
    *         occurred like the log could not be opened or that log was
    *         previously opened!
    */
   public synchronized AbstractLoggingMechanism addLoggingMechanism(String loggingMechanismName) {
 
     AbstractLoggingMechanism newLoggingMechanism = null;
 
         System.out.println("  Adding log mechanism " + loggingMechanismName +
             " to log " + this.getName());
 
 
         // Try to find a duplicate.  If found, log an error.
         if (getLoggingMechanism(loggingMechanismName) != null) {
             System.err.println("Error: Tried to open an already open logging mechanism: " +
                 loggingMechanismName);
             System.err.println("Ignoring the call to re-open the logging mechanism");
             return null;
         }
 
     try {
       newLoggingMechanism =
         AbstractLoggingMechanism.getLoggingMechanismForString(loggingMechanismName);
     } catch (Throwable e) {
       System.err.println("Exception caught: " + e.getMessage());
       System.err.println("Unable to open logging mechanism " +
         loggingMechanismName + " for log " + this.getName());
       return null;
     }
 
         // Open the new mechanism and add it to the list of mechanisms currently logging to
     newLoggingMechanism.openForLog(this, currentLoggingLevel);
     loggingMechanisms.addElement(newLoggingMechanism);
     return newLoggingMechanism;
 
   }
 
   /**
    * Removes an active Logging Mechanism from the list of mechanisms that this
    * log writes to.  Closes the mechanism and deregisters it also.
    *
    * @param loggingMechanismName The name of the Logging Mechanism to remove.
    *
    */
   public synchronized void removeLoggingMechanism(String loggingMechanismName) {
 
     AbstractLoggingMechanism loggingMechanismToRemove = null;
 
         // Try to find the open mechanism.  If not found, log an error.
         loggingMechanismToRemove = getLoggingMechanism(loggingMechanismName);
         if (loggingMechanismToRemove == null) {
             System.err.println("Error: Tried to close logging mechanism: " +
                 loggingMechanismName + " which is not open");
             System.err.println("Ignoring the call to close the logging mechanism");
             return;
         }
 
     loggingMechanismToRemove.closeForLog(this);
     loggingMechanisms.removeElement(loggingMechanismToRemove);
 
   }
 
   /**
    * Removes all Logging Mechanisms from the list of mechanisms that this
    * log writes to.  Closes the mechanisms and deregisters them also.
    *
    */
   public synchronized void removeAllLoggingMechanisms() {
       
         AbstractLoggingMechanism currentLoggingMechanism = null;
         
     // Run through the loggingMechanisms vector and close the mechanisms
       for (Enumeration e = loggingMechanisms.elements();
               e.hasMoreElements(); ) {
           currentLoggingMechanism = (AbstractLoggingMechanism) 
                                     e.nextElement();
          currentLoggingMechanism.closeForLog(this);
       }
           
       loggingMechanisms.removeAllElements();
   }
 
   
   /**
    * Adds a message string to the log if the log's level is
    * currently set at or above the loggingLevel passed in.
    *
    * @param logString The string to write to all logging mechanisms
    *
    * @param loggingLevel The level at which to log the string.
    */
   synchronized public void logString(String logString, int loggingLevel) {
 
     // Log the message if higher or equal to current logging level,
     if (loggingLevel <= currentLoggingLevel) {
         
             AbstractLoggingMechanism currentLoggingMechanism = null;
         
         // Run through the loggingMechanisms vector and close the mechanisms
           for (Enumeration e = loggingMechanisms.elements();
               e.hasMoreElements(); ) {
               currentLoggingMechanism = (AbstractLoggingMechanism) 
                                         e.nextElement();
           currentLoggingMechanism.logString(this, loggingLevel, logString);
       }
     }
   }
 
   /**
    * Must close the log for the application if the application did not or
    * could not.
    *
    * @exception Throwable Default finalizer exception
    */
   protected void finalize() throws Throwable {
 
         // If the log file is open must address open mechanisms
     if (isOpen()) {
             removeAllLoggingMechanisms();
       }
       
     super.finalize();
   }
   
 
   /**
    * Gets the string that delimits the various fields of a log entry
    */
   public String getLogFieldSeparator() {
 
     return logFieldSeparator;
   }
 
   /**
    * Sets the string that delimits the various fields of a log entry
    */
   public void setLogFieldSeparator(String logFieldSeparator) {
 
     this.logFieldSeparator = logFieldSeparator;
   }
 
   /**
    * Return the name of the log, usually passed in by the constructor.
    */
   public String getName() {
       return name;
   }
 
   /**
    * Return whether the log is open (is not deactivated).
    */
   public boolean isOpen() {
 
     return (currentLoggingLevel != Log.DEACTIVATE_LEVEL);
   }
 
   /**
    * Return the date the log was opened, only valid if the log is
    * currently open.
    */
   public Date getDateOpened() {
 
     return dateOpened;
   }
   
 }