HandlerUtils.java

package org.springframework.roo.support.logging;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.ConsoleHandler;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.Validate;

/**
 * Utility methods for dealing with {@link Handler} objects.
 * 
 * @author Ben Alex
 * @since 1.0
 */
public final class HandlerUtils {

  /**
   * Forces all {@link Handler} instances registered in the presented
   * {@link Logger} to be flushed.
   * 
   * @param logger to flush (required)
   * @return the number of {@link Handler}s flushed (may be 0 or above)
   */
  public static int flushAllHandlers(final Logger logger) {
    Validate.notNull(logger, "Logger is required");

    int flushed = 0;
    final Handler[] handlers = logger.getHandlers();
    if (handlers != null && handlers.length > 0) {
      for (final Handler h : handlers) {
        flushed++;
        h.flush();
      }
    }

    return flushed;
  }

  /**
   * Obtains a {@link Logger} that guarantees to set the {@link Level} to
   * {@link Level#FINE} if it is part of org.springframework.roo.
   * Unfortunately this is needed due to a regression in JDK 1.6.0_18 as per
   * issue ROO-539.
   * 
   * @param clazz to retrieve the logger for (required)
   * @return the logger, which will at least of {@link Level#FINE} if no level
   *         was specified
   */
  public static Logger getLogger(final Class<?> clazz) {
    Validate.notNull(clazz, "Class required");
    final Logger logger = Logger.getLogger(clazz.getName());
    if (logger.getLevel() == null && clazz.getName().startsWith("org.springframework.roo")) {
      logger.setLevel(Level.FINE);
    }
    return logger;
  }

  /**
   * Registers the presented target {@link Handler} against any
   * {@link DeferredLogHandler} encountered in the presented {@link Logger}.
   * <p>
   * Generally this method is used on {@link Logger} instances that have
   * previously been presented to the
   * {@link #wrapWithDeferredLogHandler(Logger, Level)} method.
   * <p>
   * The method will return a count of how many {@link DeferredLogHandler}
   * instances it detected. Note that no attempt is made to distinguish
   * between instances already possessing the intended target {@link Handler}
   * or those already possessing any target {@link Handler} at all. This
   * method always overwrites the target {@link Handler} and the returned
   * count represents how many overwrites took place.
   * 
   * @param logger to introspect for {@link DeferredLogHandler} instances
   *            (required)
   * @param target to set as the target {@link Handler}
   * @return number of {@link DeferredLogHandler} instances detected and
   *         updated (may be 0 if none found)
   */
  public static int registerTargetHandler(final Logger logger, final Handler target) {
    Validate.notNull(logger, "Logger is required");
    Validate.notNull(target, "Target handler is required");

    int replaced = 0;
    final Handler[] handlers = logger.getHandlers();
    if (handlers != null && handlers.length > 0) {
      for (final Handler h : handlers) {
        if (h instanceof DeferredLogHandler) {
          replaced++;
          final DeferredLogHandler defLogger = (DeferredLogHandler) h;
          defLogger.setTargetHandler(target);
        }
      }
    }

    return replaced;
  }

  /**
   * Replaces each {@link Handler} defined against the presented
   * {@link Logger} with {@link DeferredLogHandler}.
   * <p>
   * This is useful for ensuring any {@link Handler} defaults defined by the
   * user are preserved and treated as the {@link DeferredLogHandler}
   * "fallback" {@link Handler} if the indicated severity {@link Level} is
   * encountered.
   * <p>
   * This method will create a {@link ConsoleHandler} if the presented
   * {@link Logger} has no current {@link Handler}.
   * 
   * @param logger to introspect and replace the {@link Handler}s for
   *            (required)
   * @param fallbackSeverity to trigger fallback mode (required)
   * @return the number of {@link DeferredLogHandler}s now registered against
   *         the {@link Logger} (guaranteed to be 1 or above)
   */
  public static int wrapWithDeferredLogHandler(final Logger logger, final Level fallbackSeverity) {
    Validate.notNull(logger, "Logger is required");
    Validate.notNull(fallbackSeverity, "Fallback severity is required");

    final List<DeferredLogHandler> newHandlers = new ArrayList<DeferredLogHandler>();

    // Create DeferredLogHandlers for each Handler in presented Logger
    final Handler[] handlers = logger.getHandlers();
    if (handlers != null && handlers.length > 0) {
      for (final Handler h : handlers) {
        logger.removeHandler(h);
        newHandlers.add(new DeferredLogHandler(h, fallbackSeverity));
      }
    }

    // Create a default DeferredLogHandler if no Handler was defined in the
    // presented Logger
    if (newHandlers.isEmpty()) {
      final ConsoleHandler consoleHandler = new ConsoleHandler();
      consoleHandler.setFormatter(new Formatter() {
        @Override
        public String format(final LogRecord record) {
          return record.getMessage() + IOUtils.LINE_SEPARATOR;
        }
      });
      newHandlers.add(new DeferredLogHandler(consoleHandler, fallbackSeverity));
    }

    // Add the new DeferredLogHandlers to the presented Logger
    for (final DeferredLogHandler h : newHandlers) {
      logger.addHandler(h);
    }

    return newHandlers.size();
  }

  /**
   * Constructor is private to prevent instantiation
   * 
   * @since 1.2.0
   */
  private HandlerUtils() {}
}