configuration - example - log4j2 maven




¿Cómo inicializar log4j correctamente? (14)

Después de agregar log4j a mi aplicación, obtengo el siguiente resultado cada vez que ejecuto mi aplicación:

log4j:WARN No appenders could be found for logger (slideselector.facedata.FaceDataParser).
log4j:WARN Please initialize the log4j system properly.

Parece que esto significa que falta un archivo de configuración. ¿Dónde debería ubicarse este archivo de configuración y qué es un buen contenido para comenzar?

Estoy usando plain java para desarrollar una aplicación de escritorio. Así que no hay servidor web, etc ...


¿Qué estás desarrollando en? ¿Estás utilizando Apache Tomcat?

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyyMMdd HH:mm:ss.SSS} [[%5p] %c{1} [%t]] %m%n

Tengo propiedades como esta en una de mis aplicaciones Java.


Busque un log4j.properties o log4j.xml en línea que tenga un agregador de raíz y colóquelo en su classpath.

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout
log4j.rootLogger=debug, stdout

se registrará en la consola. Prefiero iniciar sesión en un archivo para que pueda investigar después.

log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.maxFileSize=100KB
log4j.appender.file.maxBackupIndex=5
log4j.appender.file.File=test.log
log4j.appender.file.threshold=debug
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=debug,file

aunque para aplicaciones de registro detallado, 100KB generalmente se debe aumentar a 1MB o 10MB, especialmente para la depuración.

Personalmente, configuro varios registradores y configuro el registrador raíz para advertir o nivel de error en lugar de depurar.


Esta es una forma alternativa usando .yaml

Estructura lógica:

Configuration:
    Properties:
    Appenders:
    Loggers:

Muestra:

Configutation:
    name: Default

    Properties:
        Property:
            name: log-path
            value: "logs"

    Appenders:

        Console:
        name: Console_Appender
        target: SYSTEM_OUT
        PatternLayout:
            pattern: "[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n"

       File:
          name: File_Appender
          fileName: ${log-path}/logfile.log
          PatternLayout:
            pattern: "[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n"

    Loggers:

        Root:
            level: debug
            AppenderRef:
              - ref: Console_Appender

        Logger:
            - name: <package>.<subpackage>.<subsubpackage>.<...>
              level: debug
              AppenderRef:
                 - ref: File_Appender
                 level: error             

Ref: LOG4J 2 CONFIGURACIÓN: USANDO YAML


He creado el archivo log4j.properties en la carpeta de recursos junto al archivo hibernate.cfg.xml y lo he llenado con el texto a continuación:

log4j.rootLogger=INFO, CONSOLE

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ABSOLUTE} %-5p [%c{1}:%L] %m%n

Ahora me deshice de advertencias y errores.


Log4j busca de forma predeterminada un archivo llamado log4j.properties o log4j.xml en la ruta de clase. Puede controlar qué archivo utiliza para inicializarse configurando las propiedades del sistema como se describe logging.apache.org/log4j/1.2/manual.html (busque la sección "Procedimiento de inicialización predeterminado").

Por ejemplo:

java -Dlog4j.configuration=customName ....

Hará que log4j busque un archivo llamado customName en el classpath.

Si tiene problemas, me resulta útil activar log4j.debug:

-Dlog4j.debug

Se imprimirá en el sistema toda la información útil sobre qué archivo se utilizó para inicializarse, qué registradores / agregadores se configuraron y cómo, etc.

El archivo de configuración puede ser un archivo de propiedades java o un archivo xml. Aquí hay una muestra del formato del archivo de propiedades tomado de logging.apache.org/log4j/1.2/manual.html :

log4j.rootLogger=debug, stdout, R

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log

log4j.appender.R.MaxFileSize=100KB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

Mi log4j se corrigió por debajo del archivo de propiedades:

## direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout
log4j.rootLogger=debug, stdout
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.maxFileSize=100KB
log4j.appender.file.maxBackupIndex=5
log4j.appender.file.File=./logs/test.log
log4j.appender.file.threshold=debug
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=debug,file

Para habilitar -Dlog4j.debug , voy a Sistema, Configuración avanzada del sistema, Variables de entorno y Establecer la variable del sistema _JAVA_OPTIONS en -Dlog4j.debug .


Para las pruebas, una forma rápida y sucia que incluye la configuración del nivel de registro:

org.apache.log4j.BasicConfigurator.configure();
org.apache.log4j.Logger.getRootLogger().setLevel(org.apache.log4j.Level.WARN);

// set to Level.DEBUG for full, or Level.OFF..

Puede establecer la ubicación de su log4j.properties dentro de su aplicación java usando:

org.apache.log4j.PropertyConfigurator.configure(file/location/log4j.properties)

Más información está disponible aquí: https://logging.apache.org/log4j/1.2/manual.html


Según la página de preguntas frecuentes de Apache Log4j :

¿Por qué veo una advertencia sobre "No se encontraron agregadores para el registrador" y "Configure log4j correctamente"?

Esto ocurre cuando los archivos de configuración predeterminados log4j.properties y log4j.xml no se pueden encontrar y la aplicación no realiza una configuración explícita. log4j utiliza Thread.getContextClassLoader().getResource() para localizar los archivos de configuración predeterminados y no comprueba directamente el sistema de archivos. Conocer la ubicación adecuada para colocar log4j.properties o log4j.xml requiere comprender la estrategia de búsqueda del cargador de clases en uso. log4j no proporciona una configuración predeterminada ya que la salida a la consola o al sistema de archivos puede estar prohibida en algunos entornos.

Básicamente, la advertencia No se encontraron agregadores para el registrador significa que está usando el sistema de registro log4j , pero no ha agregado ningún Anexador (como FileAppender, ConsoleAppender, SocketAppender, SyslogAppender, etc.) en su archivo de configuración o el archivo de configuración Está perdido.

Hay tres formas de configurar log4j: con un archivo de propiedades ( log4j.properties ), con un archivo XML y mediante código Java ( rootLogger.addAppender(new NullAppender()); ).

log4j.properties

Si tiene un archivo de propiedades presente (por ejemplo, al instalar Solr), debe colocar este archivo en su directorio classpath .

ruta de clase

Aquí hay algunas sugerencias de comandos en Linux para determinar su valor de classpath:

$ echo $CLASSPATH
$ ps wuax | grep -i classpath
$ grep -Ri classpath /etc/tomcat? /var/lib/tomcat?/conf /usr/share/tomcat?

o desde Java: System.getProperty("java.class.path") .

Log4j XML

A continuación se muestra un archivo de configuración XML básico para log4j en formato XML:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
  <appender name="console" class="org.apache.log4j.ConsoleAppender"> 
    <param name="Target" value="System.out"/> 
    <layout class="org.apache.log4j.PatternLayout"> 
      <param name="ConversionPattern" value="%-5p %c{1} - %m%n"/> 
    </layout> 
  </appender> 

  <root> 
    <priority value ="debug" /> 
    <appender-ref ref="console" /> 
  </root>

</log4j:configuration>

Gato

Si está utilizando Tomcat, puede colocar su log4j.properties en: /usr/share/tomcat?/lib/ or /var/lib/tomcat?/webapps/*/WEB-INF/lib/ .

Solr

Para la referencia, el archivo log4j.properties predeterminado de Solr se ve así:

#  Logging level
solr.log=logs/
log4j.rootLogger=INFO, file, CONSOLE

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender

log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%-4r [%t] %-5p %c %x \u2013 %m%n

#- size rotation with log cleanup.
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.MaxFileSize=4MB
log4j.appender.file.MaxBackupIndex=9

#- File to log to and log format
log4j.appender.file.File=${solr.log}/solr.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS}; %C; %m\n

log4j.logger.org.apache.zookeeper=WARN
log4j.logger.org.apache.hadoop=WARN

# set to INFO to enable infostream log messages
log4j.logger.org.apache.solr.update.LoggingInfoStream=OFF

¿Por qué log4j no puede encontrar mi archivo de propiedades en una aplicación J2EE o WAR?

La respuesta corta: las clases log4j y el archivo de propiedades no están dentro del alcance del mismo cargador de clases.

Log4j solo usa el mecanismo predeterminado Class.forName() para cargar clases. Los recursos se manejan de manera similar. Consulte la documentación de java.lang.ClassLoader para obtener más detalles.

Por lo tanto, si tiene problemas, intente cargar la clase o el recurso usted mismo. Si no lo encuentras, tampoco lo hará log4j. ;)

Ver también:


Si bien configurar log4j correctamente es ideal para proyectos "reales", es posible que desee una solución rápida y sucia, por ejemplo, si solo está probando una nueva biblioteca.

Si es así una llamada al método estático.

org.apache.log4j.BasicConfigurator.configure();

configurará el registro básico en la consola, y los mensajes de error desaparecerán.


Si estamos usando el contenedor de registro de apache commons encima de log4j, entonces debemos tener los dos archivos jar disponibles en classpath. Además, commons-logging.properties y log4j.properties/xml deberían estar disponibles en classpath.

También podemos pasar la clase de implementación y el nombre log4j.properties como JAVA_OPTS usando -Dorg.apache.commons.logging.Log=<logging implementation class name> -Dlog4j.configuration=<file:location of log4j.properties/xml file> . Lo mismo se puede hacer configurando JAVA_OPTS en el caso de la aplicación / servidor web.

Ayudará a externalizar las propiedades que se pueden cambiar en la implementación.


API de registro: la API de registro de Java facilita el servicio y el mantenimiento del software en los sitios de los clientes al producir informes de registro adecuados para el análisis de los usuarios finales, administradores de sistemas, ingenieros de servicio de campo y equipos de desarrollo de software. Las API de registro capturan información como fallas de seguridad, errores de configuración, cuellos de botella de rendimiento y / o errores en la aplicación o plataforma. El paquete principal incluye soporte para entregar registros de texto sin formato o registros de formato XML a la memoria, flujos de salida, consolas, archivos y sockets. Además, las API de registro pueden interactuar con los servicios de registro que ya existen en el sistema operativo host.

Package java.util.logging «Proporciona las clases e interfaces de las instalaciones de registro de la plataforma Java.

Log4j 1.x «log4j es una popular utilidad de registro basada en Java. Log4j es un proyecto de código abierto basado en el trabajo de muchos autores. Permite al desarrollador controlar qué instrucciones de registro se envían a una variedad de ubicaciones mediante el uso de Anexos [consola, archivos, DB y correo electrónico]. Es totalmente configurable en tiempo de ejecución utilizando archivos de configuración externos.

Log4j tiene tres componentes principales:

  • Loggers - [OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE]
  • Anexos

    • Apache Commons Logging: ConsoleAppender, FileAppender, RollingFileAppender, DailyRollingFileAppender, JDBCAppender- Driver , SocketAppender

    • Log4J Appender para MongoDB: MongoDbAppender - Driver

  • Diseños - [PatternLayout, EnhancedPatternLayout]

Los archivos de configuración se pueden escribir en XML o en el formato de propiedades de Java (clave = valor).

  1. log4j_External.properties «Formato de propiedades de Java (clave = valor)

La cadena entre una apertura " $ { " y el cierre " } " se interpreta como una clave. El valor de la variable sustituida se puede definir como una propiedad del sistema o en el propio archivo de configuración. Establecer opciones específicas de appender. «Log4j.appender.appenderName.option = value, para cada appender nombrado puede configurar su diseño.

log4j.rootLogger=INFO, FILE, FILE_PER_SIZE, FILE_PER_DAY, CONSOLE, MySql

#log.path=./
log.path=E:/Logs

# https://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html
# {%-5p - [WARN ,INFO ,ERROR], %5p 0- [ WARN, INFO,ERROR]}
log.patternLayout=org.apache.log4j.PatternLayout
log.pattern=%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n

# System.out | System.err
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Target=System.err
log4j.appender.CONSOLE.layout=${log.patternLayout}
log4j.appender.CONSOLE.layout.ConversionPattern=${log.pattern}

# File Appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log.path}/logFile.log
#log4j:ERROR setFile(null,false) call failed. - Defaults setFile(null,true)
#log4j.appender.FILE.Append = false
log4j.appender.FILE.layout=${log.patternLayout}
log4j.appender.FILE.layout.ConversionPattern=${log.pattern}

# BackUP files for every Day.
log4j.appender.FILE_PER_DAY=org.apache.log4j.DailyRollingFileAppender
# [[ Current File ] - logRollingDayFile.log ], { [BackUPs] logRollingDayFile.log_2017-12-10, ... }
log4j.appender.FILE_PER_DAY.File=${log.path}/logRollingDayFile.log
log4j.appender.FILE_PER_DAY.DatePattern='_'yyyy-MM-dd
log4j.appender.FILE_PER_DAY.layout=${log.patternLayout}
log4j.appender.FILE_PER_DAY.layout.ConversionPattern=${log.pattern}

# BackUP files for size rotation with log cleanup.
log4j.appender.FILE_PER_SIZE=org.apache.log4j.RollingFileAppender
# [[ Current File ] - logRollingFile.log ], { [BackUPs] logRollingFile.log.1, logRollingFile.log.2}
log4j.appender.FILE_PER_SIZE.File=${log.path}/logRollingFile.log
log4j.appender.FILE_PER_SIZE.MaxFileSize=100KB
log4j.appender.FILE_PER_SIZE.MaxBackupIndex=2
log4j.appender.FILE_PER_SIZE.layout=${log.patternLayout}
log4j.appender.FILE_PER_SIZE.layout.ConversionPattern=${log.pattern}

# MySql Database - JDBCAppender
log4j.appender.MySql=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.MySql.driver=com.mysql.jdbc.Driver
log4j.appender.MySql.URL=jdbc:mysql://localhost:3306/automationlab
log4j.appender.MySql.user=root
log4j.appender.MySql.password=
log4j.appender.MySql.layout=org.apache.log4j.EnhancedPatternLayout
log4j.appender.MySql.layout.ConversionPattern=INSERT INTO `logdata` VALUES ('%p', '%d{yyyy-MM-dd HH:mm:ss}', '%C', '%M', '%L', '%m');
#log4j.appender.MySql.sql=INSERT INTO `logdata` VALUES ('%p', '%d{yyyy-MM-dd HH:mm:ss}', '%C', '%M', '%L', '%m');

# Direct log events[Messages] to MongoDB Collection - MongoDbAppender
log.mongoDB.hostname=loalhost
log.mongoDB.userName=Yash777
[email protected]
log.mongoDB.DB=MyLogDB
log.mongoDB.Collection=Logs

log4j.appender.MongoDB=org.log4mongo.MongoDbAppender
log4j.appender.MongoDB.hostname=${log.mongoDB.hostname}
log4j.appender.MongoDB.userName=${log.mongoDB.userName}
log4j.appender.MongoDB.password=${log.mongoDB.password}
log4j.appender.MongoDB.port=27017
log4j.appender.MongoDB.databaseName=${log.mongoDB.DB}
log4j.appender.MongoDB.collectionName=${log.mongoDB.Collection}
log4j.appender.MongoDB.writeConcern=FSYNCED

MySQL estructura de tabla para tabla logdata

CREATE TABLE IF NOT EXISTS `logdata` (
  `Logger_Level` varchar(5) COLLATE utf8_unicode_ci NOT NULL,
  `DataTime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `ClassName` varchar(30) COLLATE utf8_unicode_ci NOT NULL,
  `MethodName` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `LineNumber` int(10) NOT NULL,
  `Message` text COLLATE utf8_unicode_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
  1. log4j_External.xml «XML log4j: configuración con archivo DTD público
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE log4j:configuration PUBLIC
  "-//APACHE//DTD LOG4J 1.2//EN" "http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/xml/doc-files/log4j.dtd">
<log4j:configuration debug="false">

    <appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">
        <param name="target" value="System.out" />
        <param name="threshold" value="debug" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" />
        </layout>
    </appender>

    <appender name="FILE" class="org.apache.log4j.FileAppender">
        <param name="file" value="E:/Logs/logFile.log" />
        <param name="append" value="false" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" />
        </layout>
    </appender>

    <appender name="FILE_PER_SIZE" class="org.apache.log4j.RollingFileAppender">
        <param name="file" value="E:/Logs/logRollingFile.log" />
        <param name="immediateFlush" value="true"/>
        <param name="maxFileSize" value="100KB" />
        <param name="maxBackupIndex" value="2"/>
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" />
        </layout>
    </appender>

    <appender name="FILE_PER_DAY" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="file" value="E:/Logs/logRollingDayFile.log" />
        <param name="datePattern" value="'_'yyyy-MM-dd" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n"/>
        </layout>
    </appender>

    <root>
        <priority value="info" />
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="FILE" />
        <appender-ref ref="FILE_PER_SIZE" />
        <appender-ref ref="FILE_PER_DAY" />
    </root>
</log4j:configuration>
  1. Configuración de Log4j desde la URL en el programa Java:

Para especificar una configuración personalizada con un archivo externo, la clase utilizada debe implementar la interfaz del Configurador .

cuando los archivos de configuración predeterminados "log4j.properties", "log4j.xml" no están disponibles

public class LogFiles {
    // Define a static logger variable so that it references the Logger instance named "LogFiles".
    static final Logger log = Logger.getLogger( LogFiles.class );

    @SuppressWarnings("deprecation")
    public static void main(String[] args) {
        System.out.println("CONFIGURATION_FILE « "+LogManager.DEFAULT_CONFIGURATION_FILE);
        System.out.println("DEFAULT_XML_CONFIGURATION_FILE = 'log4j.xml' « Default access modifier");

        String fileName = //"";
                //"log4j_External.xml";
                "log4j_External.properties";
        String configurationFile = System.getProperty("user.dir")+"/src/" + fileName;

        if( fileName.contains(".xml") ) {
            DOMConfigurator.configure( configurationFile );
            log.info("Extension *.xml");
        } else if ( fileName.contains(".properties") ) {
            PropertyConfigurator.configure( configurationFile );
            log.info("Extension *.properties");
        } else {
            DailyRollingFileAppender dailyRollingAppender = new DailyRollingFileAppender();
            dailyRollingAppender.setFile("E:/Logs/logRollingDayFile.log");
            dailyRollingAppender.setDatePattern("'_'yyyy-MM-dd");

            PatternLayout layout = new PatternLayout();
            layout.setConversionPattern( "%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" );
            dailyRollingAppender.setLayout(layout);

            dailyRollingAppender.activateOptions();

            Logger rootLogger = Logger.getRootLogger();
            rootLogger.setLevel(Level.DEBUG);
            rootLogger.addAppender(dailyRollingAppender);

            log.info("Configuring from Java Class.");
        }

        log.info("Console.Message.");
        method2();
        methodException(0);
    }

    static void method2() {
        log.info("method2 - Console.Message.");
    }
    static void methodException(int b) {
        try {
            int a = 10/b;
            System.out.println("Result : "+ a);
            log.info("Result : "+ a);
        } catch (Exception ex) { // ArithmeticException: / by zero
            log.error(String.format("\n\tException occurred: %s", stackTraceToString(ex)));
        }
    }
    public static String stackTraceToString(Exception ex) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        ex.printStackTrace(pw);
        return sw.toString();
    }
}

import org.apache.log4j.BasicConfigurator;

Llama a este método

BasicConfigurator.configure();




log4j