How to use

LogFactory

in

org.apache.commons.logging

/**
 * Set the log category for warn logging.
 * <p>Default is no warn logging. Specify this setting to activate warn
 * logging into a specific category.
 * @since 5.1
 * @see org.apache.commons.logging.LogFactory#getLog(String)
 * @see java.util.logging.Logger#getLogger(String)
 */
public void setWarnLogCategory(String loggerName) {
  this.warnLogger = LogFactory.getLog(loggerName);
}

/**
 * Convenience method to return a named logger, without the application
 * having to care about factories.
 *
 * @param clazz Class from which a log name will be derived
 * @throws LogConfigurationException if a suitable <code>Log</code>
 *  instance cannot be returned
 */
public static Log getLog(Class clazz) throws LogConfigurationException {
  return getFactory().getInstance(clazz);
}

/**
 * Orderly terminates all the plugins.
 */
public void stop() {
  for (PluginWrapper p : activePlugins) {
    p.stop();
    p.releaseClassLoader();
  }
  activePlugins.clear();
  // Work around a bug in commons-logging.
  // See http://www.szegedi.org/articles/memleak.html
  LogFactory.release(uberClassLoader);
}

/**
 * Release any internal references to previously created {@link LogFactory}
 * instances that have been associated with the specified class loader
 * (if any), after calling the instance method <code>release()</code> on
 * each of them.
 *
 * @param classLoader ClassLoader for which to release the LogFactory
 */
public static void release(ClassLoader classLoader) {
  if (isDiagnosticsEnabled()) {
    logDiagnostic("Releasing factory for classloader " + objectId(classLoader));
  }
  // factories is not final and could be replaced in this block.
  final Hashtable factories = LogFactory.factories;
  synchronized (factories) {
    if (classLoader == null) {
      if (nullClassLoaderFactory != null) {
        nullClassLoaderFactory.release();
        nullClassLoaderFactory = null;
      }
    } else {
      final LogFactory factory = (LogFactory) factories.get(classLoader);
      if (factory != null) {
        factory.release();
        factories.remove(classLoader);
      }
    }
  }
}

/**
 * Release any internal references to previously created {@link LogFactory}
 * instances, after calling the instance method <code>release()</code> on
 * each of them.  This is useful in environments like servlet containers,
 * which implement application reloading by throwing away a ClassLoader.
 * Dangling references to objects in that class loader would prevent
 * garbage collection.
 */
public static void releaseAll() {
  if (isDiagnosticsEnabled()) {
    logDiagnostic("Releasing factory for all classloaders.");
  }
  // factories is not final and could be replaced in this block.
  final Hashtable factories = LogFactory.factories;
  synchronized (factories) {
    final Enumeration elements = factories.elements();
    while (elements.hasMoreElements()) {
      LogFactory element = (LogFactory) elements.nextElement();
      element.release();
    }
    factories.clear();
    if (nullClassLoaderFactory != null) {
      nullClassLoaderFactory.release();
      nullClassLoaderFactory = null;
    }
  }
}

/**
 * Release any internal references to previously created {@link org.apache.commons.logging.LogFactory}
 * instances, after calling the instance method <code>release()</code> on
 * each of them.  This is useful in environments like servlet containers,
 * which implement application reloading by throwing away a ClassLoader.
 * Dangling references to objects in that class loader would prevent
 * garbage collection.
 */
public static void releaseAll() {
  getFactory().release();
}

  /**
   * Restore the factory configuration to the provided value.
   */
  private void resetFactory(Object value)
  {
      org.apache.commons.logging.LogFactory.getFactory().setAttribute("org.apache.commons.logging.Log", value);
  }
}

@Override
public void initialize(final String cat)
{
  this.log = _creator.getInstance(cat);
}   
 

/**
* Install our custom logger by setting the factory attribute
*/
private Object configureFactory()
{
  Object oldValue = org.apache.commons.logging.LogFactory.getFactory().getAttribute("org.apache.commons.logging.Log");
  org.apache.commons.logging.LogFactory.getFactory().setAttribute("org.apache.commons.logging.Log", logImpl);
  return oldValue;
}

/**
 * Creates an instance of the LogFactoryMock and sets the system property LogFactory looks at to find the correct LogFactory to return when a factory is requested and releases all instances to make
 * sure that a LogFactoryMock is returned.
 * 
 * @return An instance of LogFactoryMock.
 */
public static LogFactoryMock createInstance() {
 LogFactoryMock.resetInstance();
 System.setProperty("org.apache.commons.logging.LogFactory", "se.vgregion.kivtools.mocks.LogFactoryMock");
 LogFactory.releaseAll();
 return (LogFactoryMock) LogFactory.getFactory();
}

/**
 * Release any internal references to previously created {@link LogFactory}
 * instances that have been associated with the specified class loader
 * (if any), after calling the instance method <code>release()</code> on
 * each of them.
 *
 * @param classLoader ClassLoader for which to release the LogFactory
 */
public static void release(ClassLoader classLoader) {
  getFactory().release();
}

/**
 * Release any internal references to previously created {@link LogFactory}
 * instances that have been associated with the specified class loader
 * (if any), after calling the instance method <code>release()</code> on
 * each of them.
 *
 * @param classLoader ClassLoader for which to release the LogFactory
 */
public static void release(ClassLoader classLoader) {
  if (isDiagnosticsEnabled()) {
    logDiagnostic("Releasing factory for classloader " + objectId(classLoader));
  }
  synchronized (factories) {
    if (classLoader == null) {
      if (nullClassLoaderFactory != null) {
        nullClassLoaderFactory.release();
        nullClassLoaderFactory = null;
      }
    } else {
      LogFactory factory = (LogFactory) factories.get(classLoader);
      if (factory != null) {
        factory.release();
        factories.remove(classLoader);
      }
    }
  }
}

/**
 * Sets the logging level.
 * @param level the logging level ("debug", "info", "error" etc., see Jakarta Commons Logging)
 */
protected static void setLogLevel(String level) {
  // Set the evel for future loggers.
  LogFactory.getFactory().setAttribute("level", level);
}

@Override
public void initialize(final String cat)
{
  this.log = _creator.getInstance(cat);
}   
 

/**
 * Release any internal references to previously created {@link LogFactory}
 * instances, after calling the instance method <code>release()</code> on
 * each of them.  This is useful in environments like servlet containers,
 * which implement application reloading by throwing away a ClassLoader.
 * Dangling references to objects in that class loader would prevent
 * garbage collection.
 */
public static void releaseAll() {
  if (isDiagnosticsEnabled()) {
    logDiagnostic("Releasing factory for all classloaders.");
  }
  synchronized (factories) {
    Enumeration elements = factories.elements();
    while (elements.hasMoreElements()) {
      LogFactory element = (LogFactory) elements.nextElement();
      element.release();
    }
    factories.clear();
    if (nullClassLoaderFactory != null) {
      nullClassLoaderFactory.release();
      nullClassLoaderFactory = null;
    }
  }
}

/**
 * Set the name of the logger to use.
 * The name will be passed to the underlying logger implementation through Commons Logging,
 * getting interpreted as log category according to the logger's configuration.
 * <p>This can be specified to not log into the category of this warner class but rather
 * into a specific named category.
 * @see org.apache.commons.logging.LogFactory#getLog(String)
 * @see java.util.logging.Logger#getLogger(String)
 */
public void setLoggerName(String loggerName) {
  this.logger = LogFactory.getLog(loggerName);
}

/**
 * Convenience method to return a named logger, without the application
 * having to care about factories.
 *
 * @param name Logical name of the <code>Log</code> instance to be
 *  returned (the meaning of this name is only known to the underlying
 *  logging implementation that is being wrapped)
 * @throws LogConfigurationException if a suitable <code>Log</code>
 *  instance cannot be returned
 */
public static Log getLog(String name) throws LogConfigurationException {
  return getFactory().getInstance(name);
}

/**
 * Release any internal references to previously created {@link LogFactory}
 * instances, after calling the instance method <code>release()</code> on
 * each of them.  This is useful in environments like servlet containers,
 * which implement application reloading by throwing away a ClassLoader.
 * Dangling references to objects in that class loader would prevent
 * garbage collection.
 */
public static void releaseAll() {
  getFactory().release();
}

/**
 * Terminates the plugin.
 */
public void stop() {
  Plugin plugin = getPlugin();
  if (plugin != null) {
    try {
      LOGGER.log(Level.FINE, "Stopping {0}", shortName);
      plugin.stop();
    } catch (Throwable t) {
      LOGGER.log(WARNING, "Failed to shut down " + shortName, t);
    }
  } else {
    LOGGER.log(Level.FINE, "Could not find Plugin instance to stop for {0}", shortName);
  }
  // Work around a bug in commons-logging.
  // See http://www.szegedi.org/articles/memleak.html
  LogFactory.release(classLoader);
}

/**
 * Release any internal references to previously created {@link LogFactory}
 * instances that have been associated with the specified class loader
 * (if any), after calling the instance method <code>release()</code> on
 * each of them.
 *
 * @param classLoader ClassLoader for which to release the LogFactory
 */
public static void release(ClassLoader classLoader) {
  if (isDiagnosticsEnabled()) {
    logDiagnostic("Releasing factory for classloader " + objectId(classLoader));
  }
  synchronized (factories) {
    if (classLoader == null) {
      if (nullClassLoaderFactory != null) {
        nullClassLoaderFactory.release();
        nullClassLoaderFactory = null;
      }
    } else {
      LogFactory factory = (LogFactory) factories.get(classLoader);
      if (factory != null) {
        factory.release();
        factories.remove(classLoader);
      }
    }
  }
}