org.openmdx.kernel.log
Class PluggableLoggingMechanism

java.lang.Object
  org.openmdx.kernel.log.PluggableLoggingMechanism

public abstract class PluggableLoggingMechanism
extends Object

This PluggableLoggingMechanism mechanism implements a base class for pluggable mechanisms.

Pluggable mechanism implementations:

• are completely decoupled from the logging framework.
• are dynamically plugged into the logging framework.
• are instantiated and controlled by application itself.

  The logging framework is designed not to rely on dynamic classloading to prevent any problems with the wide range of application architecture frameworks (Corba, J2EE, ...). Therefore the applications must itself instantiate their pluggable mechanisms and attach / detach them with the log framework.

  A sample Pluggable Logging Mechanism

  
                  public class ObserverMechanism extends PluggableLoggingMechanism
                  {
                          public ObserverMechanism() {}
  
                          public String getMechanismName() { return "ObserverMechanism"; }
  
                          public void log(LogEvent  event)
                          {
                                  if (event.getLoggingLevel() == LogLevel.LOG_LEVEL_CRITICAL_ERROR) {
                                          System.out.println("*************************************");
                                          System.out.println("* OBSERVER: CRITICAL ERROR");
                                          System.out.println("* Class   : " + event.getClassName());
                                          System.out.println("* Method  : " + event.getMethodName());
                                          System.out.println("* Summary : " + event.getLogStringSummary());
                                          System.out.println("* Detail  : " + event.getLogStringDetail());
                                          System.out.println("*************************************");
                                  } //if
                          }
                  };
  
                  public class Sample
                  {
                          public static void main (String[] args)
                          {
                                  // initialize the logging subsystem
                                  AppLog.setConfigName("Sample");
                                  AppLog.setLogSource("MySample");
  
                // Read the observer's log property
                String observerMyProperty = SysLog.getLogConfig().getLogProperty(
                                             "ObserverMechanism.myProperty", "")
    
                                  // instantiate your pluggable logging mechanism
                                  ObserverMechanism observer = new ObserverMechanism();
  
                                  // Make it available to the log subsystem
                                  observer.attach(AppLog.getLogConfig());
                                  observer.activate();
  
                                  ...  YOUR IMPLEMENTATION ...
  
                                  // Release it from the log subsystem (optional)
                                  observer.deactivate();
                                  observer.detach();
                          }
                  }
   

  The log property file Sample.log.properties could look as follows:

                  LogFileExtension        = log
                  LogFilePath             =
                  LogLevel                = 3
                  java.LoggingMechanism   = StandardErrorLoggingMechanism
                  java.LoggingMechanism2  = ObserverMechanism
                  LogPerformance          = true
                  LogNotification         = false
        SysLog.ObserverMechanism.myProperty = demo
   

  Constructor Summary

  protected

  PluggableLoggingMechanism()

  Method Summary

  boolean	acceptsPerformance() Checks if the mechanisms accepts performance logs.
  boolean	acceptsStandard() Checks if the mechanisms accepts standard logs.
  boolean	acceptsStatistics() Checks if the mechanisms accepts statistics logs.
  boolean	activate() Activates the logging mechanism.
  boolean	attach(Config loggerConfig) Attach the logging mechanism to the logging framework.
  boolean	attach(Config[] loggerConfigs) Attach the logging mechanism to the logging framework.
  boolean	deactivate() Deactivates the logging mechanism.
  boolean	detach() Detach the logging mechanism from the logging framework
  String	getMechanismName() Return the name of the mechanism.
  boolean	isActive() Checks if the mechanism is open
  boolean	isAttached() Checks if the mechanism is attached to the logging framework
  void	log(LogEvent event) Logs an event.
  void	notifyLoggingLevelChange(int newLoggingLevel) This method is called, to inform the pluggable logging mechanism that the log level has changed.
  void	notifyLoggingPerformanceChange(boolean newState) This method is called, to inform the pluggable logging mechanism that the log performance has changed.
  void	notifyLoggingStatisticsChange(boolean newState) This method is called, to inform the pluggable logging mechanism that the log statistics has changed.

  Methods inherited from class java.lang.Object

  clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  Constructor Detail

  PluggableLoggingMechanism

  protected PluggableLoggingMechanism()

  Method Detail

  log

  public void log(LogEvent event)

  Logs an event.

  IMPORTANT: The pluggable logging mechanism only gets log events that conform the actual logging level.

  Parameters:

  event - A log event

  getMechanismName

  public String getMechanismName()

  Return the name of the mechanism.

  Returns:

  a string

  notifyLoggingLevelChange

  public void notifyLoggingLevelChange(int newLoggingLevel)

  This method is called, to inform the pluggable logging mechanism that the log level has changed. IMPORTANT: Actually the pluggable logging mechanism only gets log events that conform the actual logging level.

  Parameters:

  loggingLevel - A logging level

  notifyLoggingPerformanceChange

  public void notifyLoggingPerformanceChange(boolean newState)

  This method is called, to inform the pluggable logging mechanism that the log performance has changed.

  Parameters:

  newState - A new performance state

  notifyLoggingStatisticsChange

  public void notifyLoggingStatisticsChange(boolean newState)

  This method is called, to inform the pluggable logging mechanism that the log statistics has changed.

  Parameters:

  newState - A new performance state

  acceptsStandard

  public boolean acceptsStandard()

  Checks if the mechanisms accepts standard logs. CRITICAL_ERROR ... TRACE level The default is to accept standard logs (true).

  Returns:

  true if log accepts standard logs

  acceptsStatistics

  public boolean acceptsStatistics()

  Checks if the mechanisms accepts statistics logs. The default is to reject statistics (false).

  Returns:

  true if log accepts statistic logs

  acceptsPerformance

  public boolean acceptsPerformance()

  Checks if the mechanisms accepts performance logs. The default is to accept perfromance logs (true).

  Returns:

  true if log accepts performance logs

  attach

  public final boolean attach(Config[] loggerConfigs)

  Attach the logging mechanism to the logging framework. This method can be called multiple times to attach the mechanism to multiple loggers. Do not forget to call activate() to activate the mechanism.

  Parameters:

  loggerConfigs - An array of loggers (AppLog, SysLog, ...) to attach the mechanism to.

  Returns:

  true if successful

  attach

  public final boolean attach(Config loggerConfig)

  Attach the logging mechanism to the logging framework. This method can be called multiple times to attach the mechanism to multiple loggers. Do not forget to call activate() to activate the mechanism.

  Parameters:

  loggerConfig - A logger (AppLog, SysLog, ...) to attach the mechanism to.

  Returns:

  true if successful

  detach

  public final boolean detach()

  Detach the logging mechanism from the logging framework

  Returns:

  true if successfull

  activate

  public final boolean activate()

  Activates the logging mechanism. The framework can now send log messages to the mechanism. The mechanism must have been attached to the logging framework prior to activate it.

  Returns:

  true if successfull

  deactivate

  public final boolean deactivate()

  Deactivates the logging mechanism. The framework can't now send anymore log messages to the mechanism.

  Returns:

  true if successfull

  isAttached

  public final boolean isAttached()

  Checks if the mechanism is attached to the logging framework

  Returns:

  true if attached

  isActive

  public final boolean isActive()

  Checks if the mechanism is open

  Returns:

  true if attached