java - configurar - log4j2 json configuration example

Configurando Log4j Loggers Programmatically

Question

Estoy intentando usar SLF4J (con el enlace log4j ) por primera vez.

Me gustaría configurar 3 registradores con nombres diferentes que LoggerFactory pueda devolver, que registrarán diferentes niveles y enviarán los mensajes a diferentes appenders:

• Logger 1 "FileLogger" registra DEBUG y lo agrega a DailyRollingFileAppender
• Logger 2 "TracingLogger" registra TRACE + y lo agrega a un JmsAppender
• Logger 3 "ErrorLogger" registra ERROR + y lo agrega a un JmsAppender diferente

Además, quiero que se configuren programáticamente (en Java, a diferencia de XML o un archivo log4j.properties ).

Me imagino que, normalmente, definiría estos Logger en algún lugar en algún código de arranque, como un método init() . Sin embargo, debido a que quiero usar slf4j-log4j , estoy confundido acerca de dónde podría definir los registradores y ponerlos a disposición de la ruta de clases.

No creo que esto sea una violación del propósito subyacente de SLF4J (como una fachada), porque mi código que usa la API SLF4J nunca sabrá que existen estos registradores. Mi código solo hace llamadas normales a la API SLF4J, que luego las reenvía a Log4j Loggers que encuentra en classpath.

Pero, ¿cómo configuro esos Log4j Loggers en el classpath ... en Java?

Answer 1

En el caso de que haya definido un appender en las propiedades de log4j y desee actualizarlo programáticamente, establezca el nombre en las propiedades de log4j y obténgalo por su nombre.

Aquí hay un ejemplo de entrada de log4j.properties:

log4j.appender.stdout.Name=console
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.Threshold=INFO

Para actualizarlo, haga lo siguiente:

((ConsoleAppender) Logger.getRootLogger().getAppender("console")).setThreshold(Level.DEBUG);

Answer 2

Parece que está intentando usar log4j desde "ambos extremos" (el extremo consumidor y el final de la configuración).

Si desea codificar en contra de slf4j api pero determinar de antemano (y programáticamente) la configuración de log4j Loggers que devolverá classpath, es absolutamente necesario tener algún tipo de adaptación de registro que haga uso de la construcción perezosa.

public class YourLoggingWrapper {
    private static boolean loggingIsInitialized = false;

    public YourLoggingWrapper() {
        // ...blah
    }

    public static void debug(String debugMsg) {
        log(LogLevel.Debug, debugMsg);
    }

    // Same for all other log levels your want to handle.
    // You mentioned TRACE and ERROR.

    private static void log(LogLevel level, String logMsg) {
        if(!loggingIsInitialized)
            initLogging();

        org.slf4j.Logger slf4jLogger = org.slf4j.LoggerFactory.getLogger("DebugLogger");

        switch(level) {
        case: Debug:
            logger.debug(logMsg);
            break;
        default:
            // whatever
        }
    }

    // log4j logging is lazily constructed; it gets initialized
    // the first time the invoking app calls a log method
    private static void initLogging() {
        loggingIsInitialized = true;

        org.apache.log4j.Logger debugLogger = org.apache.log4j.LoggerFactory.getLogger("DebugLogger");

        // Now all the same configuration code that @oers suggested applies...
        // configure the logger, configure and add its appenders, etc.
        debugLogger.addAppender(someConfiguredFileAppender);
    }

Con este enfoque, no necesita preocuparse acerca de dónde / cuándo se configuran los registradores log4j. La primera vez que el classpath los solicita, se construyen de forma perezosa, se devuelven y se ponen a disposición a través de slf4j. Espero que esto haya ayudado!

Answer 3

Puede agregar / eliminar Appender programáticamente a Log4j:

  ConsoleAppender console = new ConsoleAppender(); //create appender
  //configure the appender
  String PATTERN = "%d [%p|%c|%C{1}] %m%n";
  console.setLayout(new PatternLayout(PATTERN)); 
  console.setThreshold(Level.FATAL);
  console.activateOptions();
  //add appender to any Logger (here is root)
  Logger.getRootLogger().addAppender(console);

  FileAppender fa = new FileAppender();
  fa.setName("FileLogger");
  fa.setFile("mylog.log");
  fa.setLayout(new PatternLayout("%d %-5p [%c{1}] %m%n"));
  fa.setThreshold(Level.DEBUG);
  fa.setAppend(true);
  fa.activateOptions();

  //add appender to any Logger (here is root)
  Logger.getRootLogger().addAppender(fa);
  //repeat with all other desired appenders

Te sugiero que lo pongas en un init () en alguna parte, donde estés seguro, que esto se ejecutará antes que cualquier otra cosa. A continuación, puede eliminar todos los apéndices existentes en el registrador de raíz con

 Logger.getRootLogger().getLoggerRepository().resetConfiguration();

y comienza agregando el tuyo. Necesitas log4j en el classpath por supuesto para que esto funcione.

Observación:
Puede tomar cualquier Logger.getLogger(...) le gusta agregar appenders. Acabo de tomar el registrador de raíz porque está en la parte inferior de todas las cosas y maneja todo lo que se pasa a través de otros apéndices en otras categorías (a menos que se configure de otra manera configurando el indicador de adición).

Si necesita saber cómo funciona el registro y cómo se decide dónde se escriben los registros, lea este manual para obtener más información al respecto.
En breve:

  Logger fizz = LoggerFactory.getLogger("com.fizz")

le dará un registrador para la categoría "com.fizz".
Para el ejemplo anterior, esto significa que todo lo que se registra con él será referido a la consola y al apéndice del archivo en el registrador de raíz.
Si agrega un appender a Logger.getLogger ("com.fizz"). AddAppender (newAppender), entonces el inicio de sesión de fizz será manejado por todos los appenders del registrador de raíz y el newAppender .
No crea registradores con la configuración, solo proporciona manejadores para todas las categorías posibles en su sistema.