Como inicializar o log4j corretamente?

Depois de adicionar o log4j ao meu aplicativo, recebo a seguinte saída toda vez que executo meu aplicativo:

log4j: WARN Não foram encontrados anexos para o criador de logs (slideselector.facedata.FaceDataParser).
log4j: WARN Inicialize o sistema log4j corretamente.

Parece que isso significa que um arquivo de configuração está ausente. Onde esse arquivo de configuração deve estar localizado e qual é um bom conteúdo inicial?

Estou usando java comum para desenvolver um aplicativo de desktop. Portanto, nenhum servidor web etc ...

Log4jpor padrão, procura um arquivo chamado log4j.propertiesou log4j.xmlno caminho de classe.

Você pode controlar qual arquivo ele usa para se inicializar, definindo as propriedades do sistema conforme descrito aqui (procure a seção "Procedimento de inicialização padrão").

Por exemplo:

java -Dlog4j.configuration=customName ....

Fará com log4jque procure um arquivo chamado customName no caminho de classe.

Se você estiver tendo problemas, acho útil ativar o log4j.debug:

-Dlog4j.debug

Ele imprimirá no System.out muitas informações úteis sobre qual arquivo ele se inicializou, quais registradores / anexos foram configurados e como etc.

O arquivo de configuração pode ser um arquivo de propriedades java ou um arquivo xml. Aqui está uma amostra do formato do arquivo de propriedades retirado da página de documentação de introdução do log4j :

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

Embora a configuração apropriada do log4j seja ótima para projetos "reais", você pode querer uma solução rápida e suja, por exemplo, se estiver apenas testando uma nova biblioteca.

Nesse caso, uma chamada para o método estático

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

configurará o log básico no console e as mensagens de erro desaparecerão.

Se você se livrar de tudo (por exemplo, se estiver em testes)

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

Conforme a página de perguntas frequentes do Apache Log4j :

Por que vejo um aviso sobre "Nenhum anexo encontrado para o logger" e "Por favor, configure o log4j corretamente"?

Isso ocorre quando os arquivos delog4j.propertieslog4j.xml configuração padrão e não podem ser encontrados e o aplicativo não executa nenhuma configuração explícita. log4jusa Thread.getContextClassLoader().getResource()para localizar os arquivos de configuração padrão e não verifica diretamente o sistema de arquivos. Conhecer o local apropriado para colocar o log4j.properties ou log4j.xmlrequer entender a estratégia de pesquisa do carregador de classes em uso. log4jnão fornece uma configuração padrão, pois a saída para o console ou para o sistema de arquivos pode ser proibida em alguns ambientes.

Basicamente, o aviso Nenhum anexo foi encontrado para o criador de logs significa que você está usando o log4jsistema de registro, mas não adicionou nenhum anexo (como FileAppender, ConsoleAppender, SocketAppender, SyslogAppender etc.) ao seu arquivo de configuração ou o arquivo de configuração é ausência de.

Existem três maneiras de configurar o log4j: com um arquivo de propriedades ( log4j.properties), com um arquivo XML e através do código Java ( rootLogger.addAppender(new NullAppender());).

log4j.properties

Se você possui um arquivo de propriedades presente (por exemplo, ao instalar o Solr), é necessário colocar esse arquivo no diretório do caminho de classe .

caminho de classe

Aqui estão algumas sugestões de comando no Linux como determinar seu valor do caminho de classe:

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

ou a partir de Java: System.getProperty("java.class.path").

XML do Log4j

Abaixo está um arquivo de configuração XML básico para log4j no 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>

Tomcat

Se você estiver usando o Tomcat, poderá colocar sua pasta log4j.propertiesem: /usr/share/tomcat?/lib/ou /var/lib/tomcat?/webapps/*/WEB-INF/lib/.

Solr

Para referência, o log4j.propertiesarquivo padrão do Solr se parece com:

#  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 que o log4j não pode encontrar meu arquivo de propriedades em um aplicativo J2EE ou WAR?

A resposta curta: as classes log4j e o arquivo de propriedades não estão no escopo do mesmo carregador de classe.

O Log4j usa apenas o Class.forName()mecanismo padrão para carregar classes. Os recursos são tratados da mesma forma. Consulte a documentação para java.lang.ClassLoaderobter mais detalhes.

Portanto, se você estiver tendo problemas, tente carregar a classe ou o recurso por conta própria. Se você não encontrar, nem o log4j. ;)

Veja também:

• Breve introdução ao log4j no site Apache
• Apache: Serviços de Log: Perguntas frequentes no site Apache

Você pode definir o local do seu log4j.properties de dentro do seu aplicativo java usando:

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

Mais informações estão disponíveis aqui: https://logging.apache.org/log4j/1.2/manual.html

Encontre um log4j.properties ou log4j.xml on-line que possua um aplicativo raiz e coloque-o no caminho de classe.

### 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

registrará no console. Prefiro fazer logon em um arquivo para que você possa investigar posteriormente.

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

embora para aplicativos de log detalhado, 100 KB geralmente precisem ser aumentados para 1 MB ou 10 MB, especialmente para depuração.

Pessoalmente, configurei vários registradores e configurei o registrador raiz para avisar ou nível de erro em vez de depurar.

Outra maneira de fazer isso sem colocar o arquivo de propriedades no caminho de classe é definir a propriedade diretamente do código java. Aqui está o código de exemplo.

public class Log4JSample {

public static void main(String[] args) {
    Properties properties=new Properties();
    properties.setProperty("log4j.rootLogger","TRACE,stdout,MyFile");
    properties.setProperty("log4j.rootCategory","TRACE");

    properties.setProperty("log4j.appender.stdout",     "org.apache.log4j.ConsoleAppender");
    properties.setProperty("log4j.appender.stdout.layout",  "org.apache.log4j.PatternLayout");
    properties.setProperty("log4j.appender.stdout.layout.ConversionPattern","%d{yyyy/MM/dd HH:mm:ss.SSS} [%5p] %t (%F) - %m%n");

    properties.setProperty("log4j.appender.MyFile", "org.apache.log4j.RollingFileAppender");
    properties.setProperty("log4j.appender.MyFile.File", "my_example.log");
    properties.setProperty("log4j.appender.MyFile.MaxFileSize", "100KB");
    properties.setProperty("log4j.appender.MyFile.MaxBackupIndex", "1");
    properties.setProperty("log4j.appender.MyFile.layout",  "org.apache.log4j.PatternLayout");
    properties.setProperty("log4j.appender.MyFile.layout.ConversionPattern","%d{yyyy/MM/dd HH:mm:ss.SSS} [%5p] %t (%F) - %m%n");

    PropertyConfigurator.configure(properties);

    Logger logger = Logger.getLogger("MyFile");

    logger.fatal("This is a FATAL message.");
    logger.error("This is an ERROR message.");
    logger.warn("This is a WARN message.");
    logger.info("This is an INFO message.");
    logger.debug("This is a DEBUG message.");
    logger.trace("This is a TRACE message.");
}

}

Você pode configurar o nível do log usando setLevel () .

Os níveis são úteis para definir facilmente o tipo de informação que você deseja que o programa exiba.

Por exemplo:

Logger.getRootLogger().setLevel(Level.WARN); //will not show debug messages

O conjunto de níveis possíveis é:

VESTÍGIO,

DEPURAR,

INFO,

ADVERTIR,

ERRO e

FATAL

De acordo com o manual Logging Services

import org.apache.log4j.BasicConfigurator;

Chame este método

BasicConfigurator.configure();

Para ativar -Dlog4j.debug, vou para Sistema, Configurações avançadas do sistema, Variáveis ​​de ambiente e defino a variável do sistema _JAVA_OPTIONScomo -Dlog4j.debug.

No que você está desenvolvendo? Você está usando o 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

Eu tenho propriedades como esta em um aplicativo Java meu.

Meu log4j foi corrigido pelo arquivo de propriedades abaixo:

## 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

Criei o arquivo log4j.properties na pasta resources ao lado do arquivo hibernate.cfg.xml e o preenchi com o texto abaixo:

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

agora eu me livrei de avisos e erros

Simplesmente, crie log4j.properties na pasta src / main / assembly. Dependendo se você deseja que as mensagens de log sejam mostradas no console ou no arquivo que você modificou. A seguir, mostramos suas mensagens no console.

# Root logger option
log4j.rootLogger=INFO, stdout

# 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.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

Como explicado anteriormente, existem 2 abordagens

O primeiro é apenas adicionar esta linha ao seu método principal:

BasicConfigurator.configure();

A segunda abordagem é incluir esse arquivo log4j.properties padrão em seu caminho de classe:

Ao adotar a segunda abordagem, você precisa inicializar o arquivo corretamente.

Por exemplo.

Properties props = new Properties();

props.load(new FileInputStream("log4j property file path"));

props.setProperty("log4j.appender.File.File", "Folder where you want to store log files/" + "File Name");

Certifique-se de criar a pasta necessária para armazenar arquivos de log.

Tente definir atributo de depuração no log4j: nó de configuração como true.

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/" debug="true">

Ele imprime as informações conforme o arquivo de configuração é lido e usado para configurar o ambiente log4j. Você pode obter mais detalhes para resolver seu problema.

API de registro em log - O Java Logging API facilita o serviço e manutenção de software nas instalações do cliente, produzindo relatórios de registro adequados para análise por usuários finais, administradores de sistema, engenheiros de serviço de campo e equipes de desenvolvimento de software. As APIs de log capturam informações como falhas de segurança, erros de configuração, gargalos de desempenho e / ou bugs no aplicativo ou plataforma. O pacote principal inclui suporte para o fornecimento de registros de log formatados em texto sem formatação ou XML na memória, fluxos de saída, consoles, arquivos e soquetes. Além disso, as APIs de log são capazes de interagir com os serviços de log que já existem no sistema operacional host.

Pacote ^{java.util.logging} «Fornece as classes e interfaces dos principais recursos de log da plataforma Java.

Log4j 1.x «log4j é um popular utilitário de registro baseado em Java. Log4j é um projeto de código aberto baseado no trabalho de muitos autores. Ele permite que o desenvolvedor controle quais instruções de log são enviadas para vários locais usando Appenders [console, arquivos, banco de dados e email]. É totalmente configurável em tempo de execução usando arquivos de configuração externos.

O Log4j possui três componentes principais:

• Loggers - [DESLIGADO, FATAL, ERRO, AVISO, INFO, DEBUG, TRACE]

• Apêndices

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

  • Log4J Appender para MongoDB: MongoDbAppender -Driver

• Layouts - [PatternLayout, EnhancedPatternLayout]

Os arquivos de configuração podem ser gravados em XML ou no formato de propriedades Java (chave = valor).

1. log4j_External.properties «Formato das propriedades Java (chave = valor)

A cadeia entre uma abertura " $ { " e o fechamento " } " é interpretada como uma chave. O valor da variável substituída pode ser definido como uma propriedade do sistema ou no próprio arquivo de configuração. Defina opções específicas do aplicativo. «Log4j.appender.appenderName.option = value, Para cada appender nomeado, você pode configurar seu Layout.

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
log.mongoDB.password=Yash@123
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

Estrutura de tabela MySQL para tabela 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;

2. log4j_External.xml «XML log4j: configuração com arquivo 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>

3. Configuração do Log4j a partir do URL no programa Java:

Para especificar uma configuração personalizada com um arquivo externo, a classe usada deve implementar o interface Configurator .

quando os arquivos de configuração padrão "log4j.properties", "log4j.xml" não estão disponíveis

• Para "log4j.properties", você pode alimentar o PropertyConfigurator método .configure (java.net.URL).
• Para "log4j.xml", o DOMConfigurator será usado.

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();
    }
}

A correção para mim foi colocar "log4j.properties" na pasta "src".

Se estivermos usando o wrapper de logon do apache commons sobre o log4j, precisamos ter os dois jars disponíveis no caminho de classe. Além disso, commons-logging.propertieselog4j.properties/xml deve estar disponível no caminho de classe.

Também podemos passar a classe de implementação e o log4j.propertiesnome como JAVA_OPTSusando -Dorg.apache.commons.logging.Log=<logging implementation class name> -Dlog4j.configuration=<file:location of log4j.properties/xml file>. O mesmo pode ser feito via configuração JAVA_OPTSno caso de aplicativo / servidor da web.

Isso ajudará a externalizar propriedades que podem ser alteradas na implantação.

Essa é uma maneira alternativa de usar .yaml

Estrutura lógica:

Configuration:
    Properties:
    Appenders:
    Loggers:

Amostra:

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 CONFIGURAÇÃO: USANDO YAML

Para testes, uma maneira rápida e suja, incluindo a configuração do nível do log:

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..

Solução Maven:

Me deparei com os mesmos problemas acima e, para uma solução inteligente, usei 2 dependências. Essa configuração é destinada apenas a testes rápidos se você quiser que um projeto simples esteja usando um criador de logs, com uma configuração padrão. Eu posso imaginar que você deseja criar um arquivo de configuração mais tarde, se precisar de mais informações e / ou ajustar seus próprios níveis de log.

    <properties>
        <slf4jVersion>1.7.28</slf4jVersion>
    </properties>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4jVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-jdk14</artifactId>
            <version>${slf4jVersion}</version>
        </dependency>

Acabei de fazer isso e o problema foi corrigido.

Seguiu o blog abaixo

https://intellij-support.jetbrains.com/hc/en-us/community/posts/206875685-How-to-fix-log4j-WARN-console-messages-when-running-an-Application-inside-IntelliJ- Idéia

Mas aqui ele diz como abaixo

Para corrigir isso, basta inserir o seguinte arquivo log4j.resources na pasta main / resources do seu projeto

em vez de criar log4j.resources, crie log4j.properties. Clique com o botão direito do mouse em Recurso em IntelliJ -> Novo -> Pacote de Recursos - Apenas nomeie-o como log4j

Se você está tendo esse erro no Intellij IDEA, mesmo após adicionar o log4j.propertiesoulog4j.xml arquivo na sua pasta de teste de recursos, talvez o Intellij IDEA ainda não esteja ciente da existência do arquivo.

Portanto, depois de adicionar o arquivo, clique com o botão direito do mouse no arquivo e escolha Recompilar log4j.xml .