src/jalview/util/Log4j.java

   1 package jalview.util;
   2
   3 import java.util.Map;
   4
   5 import org.apache.logging.log4j.Level;
   6 import org.apache.logging.log4j.LogManager;
   7 import org.apache.logging.log4j.Logger;
   8 import org.apache.logging.log4j.core.Appender;
   9 import org.apache.logging.log4j.core.Filter;
  10 import org.apache.logging.log4j.core.Layout;
  11 import org.apache.logging.log4j.core.LoggerContext;
  12 import org.apache.logging.log4j.core.appender.ConsoleAppender;
  13 import org.apache.logging.log4j.core.config.Configuration;
  14 import org.apache.logging.log4j.core.config.ConfigurationFactory;
  15 import org.apache.logging.log4j.core.config.Configurator;
  16 import org.apache.logging.log4j.core.config.LoggerConfig;
  17 import org.apache.logging.log4j.core.config.builder.api.AppenderComponentBuilder;
  18 import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilder;
  19 import org.apache.logging.log4j.core.config.builder.api.FilterComponentBuilder;
  20 import org.apache.logging.log4j.core.config.builder.api.LayoutComponentBuilder;
  21 import org.apache.logging.log4j.core.config.builder.impl.BuiltConfiguration;
  22 import org.apache.logging.log4j.core.filter.ThresholdFilter;
  23 import org.apache.logging.log4j.core.layout.PatternLayout;
  24
  25 import jalview.log.JLogger;
  26 import jalview.log.JalviewAppender;
  27
  28 public class Log4j
  29 {
  30
  31   public final static String SIMPLE_PATTERN = "%level - %m%n";
  32
  33   private static boolean init = false;
  34
  35   public static boolean isInit()
  36   {
  37     return init;
  38   }
  39
  40   public static Level log4jLevel(JLogger.LogLevel loglevel)
  41   {
  42     return Level.toLevel(loglevel.toString());
  43   }
  44
  45   public static void init(JLogger.LogLevel myLevel)
  46   {
  47     init(log4jLevel(myLevel));
  48   }
  49
  50   public static void init(Level myLevel)
  51   {
  52     if (init)
  53       return;
  54     try
  55     {
  56       // configure the root logger to stderr
  57       ConfigurationBuilder<BuiltConfiguration> configBuilder = Log4j
  58               .getConfigurationBuilder();
  59
  60       configBuilder.setStatusLevel(Level.WARN);
  61
  62       String consoleLoggerName = "STDERR";
  63       AppenderComponentBuilder appenderBuilder = configBuilder
  64               .newAppender(consoleLoggerName, "Console");
  65       appenderBuilder.addAttribute("target",
  66               ConsoleAppender.Target.SYSTEM_ERR);
  67       appenderBuilder.add(Log4j.getSimpleLayoutBuilder());
  68       appenderBuilder.add(Log4j.getThresholdFilterBuilder());
  69       configBuilder.add(appenderBuilder);
  70
  71       configBuilder.add(configBuilder.newRootLogger(myLevel)
  72               .add(configBuilder.newAppenderRef(consoleLoggerName)));
  73
  74       Configurator.initialize(configBuilder.build());
  75
  76       init = true;
  77     } catch (Exception e)
  78     {
  79       System.err.println("Problems initializing the log4j system\n");
  80       e.printStackTrace(System.err);
  81     }
  82   }
  83
  84   public static Logger getLogger(String name)
  85   {
  86     return getLogger(name, Level.INFO);
  87   }
  88
  89   public static Logger getLogger(String name, JLogger.LogLevel loglevel)
  90   {
  91     return getLogger(name, log4jLevel(loglevel));
  92   }
  93
  94   public static Logger getLogger(String name, Level level)
  95   {
  96     Logger logger = LogManager.getLogger(name);
  97     Log4j.setLevel(logger, level);
  98     return logger;
  99   }
 100
 101   public static ConfigurationBuilder<BuiltConfiguration> getConfigurationBuilder()
 102   {
 103     return ConfigurationFactory.newConfigurationBuilder();
 104   }
 105
 106   public static Layout getSimpleLayout()
 107   {
 108     return PatternLayout.newBuilder().withPattern(SIMPLE_PATTERN).build();
 109   }
 110
 111   public static LayoutComponentBuilder getSimpleLayoutBuilder()
 112   {
 113     return getConfigurationBuilder().newLayout("PatternLayout")
 114             .addAttribute("pattern", Log4j.SIMPLE_PATTERN);
 115   }
 116
 117   public static Filter getThresholdFilter(Level level)
 118   {
 119     return ThresholdFilter.createFilter(level, Filter.Result.ACCEPT,
 120             Filter.Result.NEUTRAL);
 121   }
 122
 123   public static FilterComponentBuilder getThresholdFilterBuilder()
 124   {
 125     return getConfigurationBuilder().newFilter("ThresholdFilter",
 126             Filter.Result.ACCEPT, Filter.Result.NEUTRAL);
 127   }
 128
 129   public static void setLevel(Logger logger, JLogger.LogLevel loglevel)
 130   {
 131     setLevel(logger, log4jLevel(loglevel));
 132   }
 133
 134   public static void setLevel(Logger logger, Level level)
 135   {
 136     if (!Platform.isJS())
 137     {
 138       LoggerContext context = (LoggerContext) LogManager.getContext(false);
 139       Configuration config = context.getConfiguration();
 140       LoggerConfig loggerConfig = config.getLoggerConfig(logger.getName());
 141       loggerConfig.setLevel(level);
 142
 143       Map<String, Appender> appenders = config.getAppenders();
 144
 145       Appender jappender = config.getAppender(JalviewAppender.NAME);
 146
 147       context.updateLoggers();
 148     }
 149   }
 150
 151   public static void setRootLevel(JLogger.LogLevel loglevel)
 152   {
 153     setRootLevel(log4jLevel(loglevel));
 154   }
 155
 156   public static void setRootLevel(Level level)
 157   {
 158     setLevel(LogManager.getRootLogger(), level);
 159   }
 160
 161   public static Appender getAppender(String name)
 162   {
 163     LoggerContext context = (LoggerContext) LogManager.getContext(false);
 164     Configuration config = context.getConfiguration();
 165     Map<String, Appender> appenders = config.getAppenders();
 166     return appenders.get(name);
 167   }
 168
 169   public static void addAppender(Logger logger, Logger logger2,
 170           String name2)
 171   {
 172     LoggerContext context = (LoggerContext) LogManager.getContext(false);
 173     Configuration config = context.getConfiguration();
 174     LoggerConfig logger2Config = config.getLoggerConfig(logger2.getName());
 175     Map<String, Appender> logger2AppendersMap = logger2Config
 176             .getAppenders();
 177     Appender appender = logger2AppendersMap.get(name2);
 178     addAppender(logger, appender);
 179     context.updateLoggers();
 180   }
 181
 182   public static void addAppender(Logger logger, Appender appender)
 183   {
 184     if (appender == null)
 185       return;
 186     LoggerContext context = (LoggerContext) LogManager.getContext(false);
 187     Configuration config = context.getConfiguration();
 188     LoggerConfig loggerConfig = config.getLoggerConfig(logger.getName());
 189     if (loggerConfig == null)
 190       return;
 191
 192     Level level = loggerConfig.getLevel();
 193
 194     config.addAppender(appender);
 195     loggerConfig.addAppender(appender, null, null);
 196
 197     context.updateLoggers();
 198   }
 199
 200   public static void addAppenderToRootLogger(Appender appender)
 201   {
 202     Log4j.addAppender(LogManager.getRootLogger(), appender);
 203   }
 204 }