Log4j2MLog.java

/*
 * Copyright (C) 2015 Machinery For Change, Inc.
 */
 package com.github.x3333.logging;

import java.text.MessageFormat;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.ResourceBundle;

import com.mchange.v2.log.FallbackMLog;
import com.mchange.v2.log.LogUtils;
import com.mchange.v2.log.MLevel;
import com.mchange.v2.log.MLog;
import com.mchange.v2.log.MLogger;
import com.mchange.v2.log.NullMLogger;

import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.Appender;

/**
 * @author Tercio Gaudencio Filho (terciofilho [at] gmail.com)
 */
public final class Log4j2MLog extends MLog {
  static final String CHECK_CLASS = "org.apache.logging.log4j.Logger";

  MLogger global = null;

  public Log4j2MLog() throws ClassNotFoundException {
    Class.forName(CHECK_CLASS);
  }

  @Override
  public MLogger getMLogger(final String name) {
    final Logger lg = LogManager.getLogger(name);
    if (lg == null) {
      this.fallbackWarn(" with name '" + name + "'");
      return NullMLogger.instance();
    }
    return new Log4jMLogger(lg);
  }

  @Override
  public MLogger getMLogger(@SuppressWarnings("rawtypes") final Class cl) {
    final Logger lg = LogManager.getLogger(cl);
    if (lg == null) {
      this.fallbackWarn(" for class '" + cl.getName() + "'");
      return NullMLogger.instance();
    }
    return new Log4jMLogger(lg);
  }

  @Override
  public MLogger getMLogger() {
    final Logger lg = LogManager.getRootLogger();
    if (lg == null) {
      this.fallbackWarn(" (root logger)");
      return NullMLogger.instance();
    }
    return new Log4jMLogger(lg);
  }

  private void fallbackWarn(final String subst) {
    FallbackMLog.getLogger()
        .warning("Could not create or find log4j Logger" + subst + ". " + "Using NullMLogger. All messages sent to this"
            + "logger will be silently ignored. You might want to fix this.");
  }

  private static final class Log4jMLogger implements MLogger {
    // protected by this' lock
    MLevel myLevel = null;

    final Logger logger;

    Log4jMLogger(final Logger logger) {
      this.logger = logger;
    }

    private static MLevel guessMLevel(final Level lvl) {
      if (lvl == null) {
        return null;
      } else if (lvl == Level.ALL) {
        return MLevel.ALL;
      } else if (lvl == Level.DEBUG) {
        return MLevel.FINEST;
      } else if (lvl == Level.ERROR) {
        return MLevel.SEVERE;
      } else if (lvl == Level.FATAL) {
        return MLevel.SEVERE;
      } else if (lvl == Level.INFO) {
        return MLevel.INFO;
      } else if (lvl == Level.OFF) {
        return MLevel.OFF;
      } else if (lvl == Level.WARN) {
        return MLevel.WARNING;
      } else {
        throw new IllegalArgumentException("Unknown level: " + lvl);
      }
    }

    private static Level level(final MLevel lvl) {
      if (lvl == null) {
        return null;
      } else if (lvl == MLevel.ALL) {
        return Level.ALL;
      } else if (lvl == MLevel.CONFIG) {
        return Level.DEBUG;
      } else if (lvl == MLevel.FINE) {
        return Level.DEBUG;
      } else if (lvl == MLevel.FINER) {
        return Level.DEBUG;
      } else if (lvl == MLevel.FINEST) {
        return Level.DEBUG;
      } else if (lvl == MLevel.INFO) {
        return Level.INFO;
      } else if (lvl == MLevel.INFO) {
        return Level.OFF;
      } else if (lvl == MLevel.SEVERE) {
        return Level.ERROR;
      } else if (lvl == MLevel.WARNING) {
        return Level.WARN;
      } else {
        throw new IllegalArgumentException("Unknown MLevel: " + lvl);
      }
    }

    private static String createMessage(final String srcClass, final String srcMeth, final String msg) {
      final StringBuffer sb = new StringBuffer(511);
      sb.append("[class: ");
      sb.append(srcClass);
      sb.append("; method: ");
      sb.append(srcMeth);
      if (!srcMeth.endsWith(")")) {
        sb.append("()");
      }
      sb.append("] ");
      sb.append(msg);
      return sb.toString();
    }

    @SuppressWarnings("unused")
    private static String createMessage(final String srcMeth, final String msg) {
      final StringBuffer sb = new StringBuffer(511);
      sb.append("[method: ");
      sb.append(srcMeth);
      if (!srcMeth.endsWith(")")) {
        sb.append("()");
      }
      sb.append("] ");
      sb.append(msg);
      return sb.toString();
    }

    @Override
    public ResourceBundle getResourceBundle() {
      return null;
    }

    @Override
    public String getResourceBundleName() {
      return null;
    }

    @Override
    public void setFilter(final Object java14Filter) throws SecurityException {
      this.warning("setFilter() not supported by MLogger " + this.getClass().getName());
    }

    @Override
    public Object getFilter() {
      return null;
    }

    private void log(final Level lvl, final Object msg, final Throwable throwable) {
      this.logger.log(lvl, msg, throwable);
    }

    @Override
    public void log(final MLevel lvl, final String msg) {
      this.log(level(lvl), msg, null);
    }

    @Override
    public void log(final MLevel lvl, final String msg, final Object param) {
      this.log(level(lvl), (msg != null ? MessageFormat.format(msg, new Object[] {param}) : null), null);
    }

    @Override
    public void log(final MLevel lvl, final String msg, final Object[] params) {
      this.log(level(lvl), (msg != null ? MessageFormat.format(msg, params) : null), null);
    }

    @Override
    public void log(final MLevel lvl, final String msg, final Throwable throwable) {
      this.log(level(lvl), msg, throwable);
    }

    @Override
    public void logp(final MLevel lvl, final String srcClass, final String srcMeth, final String msg) {
      this.log(level(lvl), createMessage(srcClass, srcMeth, msg), null);
    }

    @Override
    public void logp(final MLevel lvl, final String srcClass, final String srcMeth, final String msg,
        final Object param) {
      this.log(level(lvl),
          createMessage(srcClass, srcMeth, (msg != null ? MessageFormat.format(msg, new Object[] {param}) : null)),
          null);
    }

    @Override
    public void logp(final MLevel lvl, final String srcClass, final String srcMeth, final String msg,
        final Object[] params) {
      this.log(level(lvl), createMessage(srcClass, srcMeth, (msg != null ? MessageFormat.format(msg, params) : null)),
          null);
    }

    @Override
    public void logp(final MLevel lvl, final String srcClass, final String srcMeth, final String msg,
        final Throwable throwable) {
      this.log(level(lvl), createMessage(srcClass, srcMeth, msg), throwable);
    }

    @Override
    public void logrb(final MLevel lvl, final String srcClass, final String srcMeth, final String rb,
        final String msg) {
      this.log(level(lvl), createMessage(srcClass, srcMeth, formatMessage(rb, msg, null)), null);
    }

    @Override
    public void logrb(final MLevel lvl, final String srcClass, final String srcMeth, final String rb, final String msg,
        final Object param) {
      this.log(level(lvl), createMessage(srcClass, srcMeth, formatMessage(rb, msg, new Object[] {param})), null);
    }

    @Override
    public void logrb(final MLevel lvl, final String srcClass, final String srcMeth, final String rb, final String msg,
        final Object[] params) {
      this.log(level(lvl), createMessage(srcClass, srcMeth, formatMessage(rb, msg, params)), null);
    }

    @Override
    public void logrb(final MLevel lvl, final String srcClass, final String srcMeth, final String rb, final String msg,
        final Throwable throwable) {
      this.log(level(lvl), createMessage(srcClass, srcMeth, formatMessage(rb, msg, null)), throwable);
    }

    @Override
    public void entering(final String srcClass, final String srcMeth) {
      this.log(Level.DEBUG, createMessage(srcClass, srcMeth, "entering method."), null);
    }

    @Override
    public void entering(final String srcClass, final String srcMeth, final Object param) {
      this.log(Level.DEBUG, createMessage(srcClass, srcMeth, "entering method... param: " + param.toString()), null);
    }

    @Override
    public void entering(final String srcClass, final String srcMeth, final Object[] params) {
      this.log(Level.DEBUG, createMessage(srcClass, srcMeth, "entering method... " + LogUtils.createParamsList(params)),
          null);
    }

    @Override
    public void exiting(final String srcClass, final String srcMeth) {
      this.log(Level.DEBUG, createMessage(srcClass, srcMeth, "exiting method."), null);
    }

    @Override
    public void exiting(final String srcClass, final String srcMeth, final Object result) {
      this.log(Level.DEBUG, createMessage(srcClass, srcMeth, "exiting method... result: " + result.toString()), null);
    }

    @Override
    public void throwing(final String srcClass, final String srcMeth, final Throwable throwable) {
      this.log(Level.DEBUG, createMessage(srcClass, srcMeth, "throwing exception... "), throwable);
    }

    @Override
    public void severe(final String msg) {
      this.log(Level.ERROR, msg, null);
    }

    @Override
    public void warning(final String msg) {
      this.log(Level.WARN, msg, null);
    }

    @Override
    public void info(final String msg) {
      this.log(Level.INFO, msg, null);
    }

    @Override
    public void config(final String msg) {
      this.log(Level.DEBUG, msg, null);
    }

    @Override
    public void fine(final String msg) {
      this.log(Level.DEBUG, msg, null);
    }

    @Override
    public void finer(final String msg) {
      this.log(Level.DEBUG, msg, null);
    }

    @Override
    public void finest(final String msg) {
      this.log(Level.DEBUG, msg, null);
    }

    @Override
    public synchronized void setLevel(final MLevel lvl) throws SecurityException {
      ((org.apache.logging.log4j.core.Logger) this.logger).setLevel(level(lvl));
      this.myLevel = lvl;
    }

    @Override
    public synchronized MLevel getLevel() {
      // System.err.println( logger.getLevel() );
      if (this.myLevel == null) {
        this.myLevel = guessMLevel(this.logger.getLevel());
      }
      return this.myLevel;
    }

    @Override
    public boolean isLoggable(final MLevel lvl) {
      return this.logger.isEnabled(level(lvl));
    }

    @Override
    public String getName() {
      return this.logger.getName();
    }

    @Override
    public void addHandler(final Object handler) throws SecurityException {
      if (!(handler instanceof Appender)) {
        throw new IllegalArgumentException("The 'handler' " + handler + " is not compatible with MLogger " + this);
      }
      ((org.apache.logging.log4j.core.Logger) this.logger).addAppender((Appender) handler);
    }

    @Override
    public void removeHandler(final Object handler) throws SecurityException {
      if (!(handler instanceof Appender)) {
        throw new IllegalArgumentException("The 'handler' " + handler + " is not compatible with MLogger " + this);
      }
      ((org.apache.logging.log4j.core.Logger) this.logger).removeAppender((Appender) handler);
    }

    @Override
    public Object[] getHandlers() {
      final List<Appender> tmp = new LinkedList<>();
      final Map<String, Appender> appenders = ((org.apache.logging.log4j.core.Logger) this.logger).getAppenders();
      for (final Entry<String, Appender> appender : appenders.entrySet()) {
        tmp.add(appender.getValue());
      }
      return tmp.toArray();
    }

    @Override
    public void setUseParentHandlers(final boolean uph) {
      ((org.apache.logging.log4j.core.Logger) this.logger).setAdditive(uph);
    }

    @Override
    public boolean getUseParentHandlers() {
      return ((org.apache.logging.log4j.core.Logger) this.logger).isAdditive();
    }
  }

  private static String formatMessage(final String rbname, String msg, final Object[] params) {
    if (msg == null) {
      if (params == null) {
        return "";
      } else {
        return LogUtils.createParamsList(params);
      }
    } else {
      final ResourceBundle rb = ResourceBundle.getBundle(rbname);
      if (rb != null) {
        final String check = rb.getString(msg);
        if (check != null) {
          msg = check;
        }
      }
      return (params == null ? msg : MessageFormat.format(msg, params));
    }
  }
}