Jak poprawnie zainicjować log4j?

Podczas prawidłowego konfigurowania log4j jest Świetne dla "prawdziwych" projektów, możesz potrzebować szybkiego i brudnego rozwiązania, np. jeśli dopiero testujesz nową bibliotekę.

Jeśli tak to wywołanie metody statycznej

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

Skonfiguruje podstawowe logowanie do konsoli, a komunikaty o błędach znikną.

Jeśli po prostu pozbędziesz się wszystkiego (np. jeśli jesteś w testach)

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

Zgodnie z strona FAQ Apache Log4j :

Dlaczego wyświetla się ostrzeżenie o "nie znaleziono żadnych aplikacji dla loggera" i "proszę poprawnie skonfigurować log4j"?

Występuje, gdy domyślna konfiguracja plików log4j.properties i log4j.xml nie może zostać znaleziona i aplikacja nie wykonuje jawnej konfiguracji. log4j używa Thread.getContextClassLoader().getResource() do zlokalizowania domyślnych plików konfiguracyjnych i nie sprawdza bezpośrednio systemu plików. Znając odpowiednie miejsce do umieszczenia log4j. properties lub log4j.xml wymaga zrozumienia strategii wyszukiwania używanej klasy loader. log4j nie zapewnia domyślnej konfiguracji, ponieważ wyjście do konsoli lub systemu plików może być zabronione w niektórych środowiskach.

Zasadniczo Ostrzeżenie brak appenderów dla loggera oznacza, że używasz log4j system logowania, ale nie dodałeś żadnych aplikacji (takich jak FileAppender, ConsoleAppender, SocketAppender, SyslogAppender, itp.) do pliku konfiguracyjnego lub brakuje pliku konfiguracyjnego.

Istnieją trzy sposoby konfiguracji log4j: za pomocą pliku właściwości (log4j.properties), za pomocą pliku XML i za pomocą kodu Java (rootLogger.addAppender(new NullAppender());).

log4j.properties

Jeśli Masz plik właściwości (np. podczas instalacji Solr), musisz umieścić ten plik w katalogu classpath .

Classpath

Oto kilka sugestii poleceń w Linuksie jak określić swoją classpath wartość:

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

Lub z Javy: System.getProperty("java.class.path").

Log4j XML

Poniżej znajduje się podstawowy plik konfiguracyjny XML dla log4j w formacie 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

Jeśli używasz Tomcat, możesz umieścić swój log4j.properties w folderze: /usr/share/tomcat?/lib/ lub /var/lib/tomcat?/webapps/*/WEB-INF/lib/.

Solr

Dla odniesienia, domyślny plik Solr log4j.properties wygląda następująco:

#  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

Dlaczego log4j nie może znaleźć mojego pliku właściwości w aplikacji J2EE lub WAR?

Krótka odpowiedź: klasy log4j i plik właściwości nie mieszczą się w zakresie tego samego classloadera.

Log4j używa tylko domyślnego mechanizmu Class.forName() do ładowania klas. Zasoby są traktowane podobnie. Więcej informacji można znaleźć w dokumentacji java.lang.ClassLoader.

Więc, jeśli masz problemy, spróbuj załadować klasę lub zasób samodzielnie. Jeśli nie możesz go znaleźć, log4j też nie.;)

Zobacz też:

• Krótkie wprowadzenie do log4j w Strona Apache
• [[86]} Apache: Logging Services: FAQ at Apache site

Znajdź log4j. properties lub log4j.xml online, który ma root appender, i umieścić go na swojej 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

Zaloguje się do konsoli. Wolę logowanie niż plik, abyś mógł później zbadać sprawę.

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

Chociaż dla aplikacji rejestrujących 100KB zwykle trzeba zwiększyć do 1MB lub 10MB, szczególnie dla debugowania.

Osobiście skonfigurowałem wiele loggerów i ustawiłem główny logger na ostrzeganie lub poziom błędu zamiast debugowania.

Możesz ustawić lokalizację log4j. properties z poziomu aplikacji java, używając:

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

Więcej informacji można znaleźć tutaj: https://logging.apache.org/log4j/1.2/manual.html

Innym sposobem, aby to zrobić bez umieszczania pliku właściwości na classpath, jest ustawienie właściwości bezpośrednio z kodu Javy. Oto przykładowy kod.

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.");
}

}

Możesz ustawić poziom dziennika za pomocą setLevel () .

Poziomy są przydatne, aby łatwo ustawić rodzaj informacji, które program ma wyświetlać.

Na przykład:

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

Zbiór możliwych poziomów to:

TRACE,

DEBUG,

INFO,

WARN,

Błąd i

FATAL

Zgodnie z Instrukcja obsługi logowania

import org.apache.log4j.BasicConfigurator;

Wywołanie tej metody

BasicConfigurator.configure();

Aby włączyć -Dlog4j.debug, przechodzę do System, Zaawansowane ustawienia systemowe, zmienne środowiskowe i ustawiam zmienną systemową _JAVA_OPTIONS na -Dlog4j.debug.

W czym się rozwijasz? Używasz 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

Mam taką właściwość w mojej aplikacji Java.

Mój log4j został naprawiony przez poniższy plik właściwości:

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

Utworzyłem plik log4j. properties w folderze resources obok hibernate.cfg.plik xml i wypełnił go tekstem poniżej:

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

Teraz pozbyłem się ostrzeżeń i błędów

Po prostu utwórz log4j. properties w folderze src/main / assembly. W zależności od tego, czy chcesz, aby wiadomości dziennika były wyświetlane w konsoli, czy w pliku, który modyfikujesz. Poniższe wiadomości zostaną wyświetlone w konsoli.

# 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

Jak wyjaśniono wcześniej istnieją 2 podejścia

Pierwszy to dodanie tej linii do głównej metody:

BasicConfigurator.configure();

Drugie podejście polega na dodaniu standardowego pliku log4j. properties do swojej ścieżki klasowej:

Podczas drugiego podejścia musisz upewnić się, że poprawnie zainicjowałeś plik.

Np.

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");

Upewnij się, że utworzyłeś folder wymagany do przechowywania plików dziennika.

Spróbuj ustawić atrybut debugowania w węźle log4j: configuration na true.

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

Wyświetla informacje podczas odczytu pliku konfiguracyjnego i służy do konfiguracji środowiska log4j. Możesz uzyskać więcej informacji, aby rozwiązać swój problem.

Logowanie API - interfejs Java Logging API ułatwia serwisowanie i konserwację oprogramowania u klientów poprzez tworzenie raportów dzienników odpowiednich do analizy przez użytkowników końcowych, administratorów systemów, inżynierów serwisu w terenie i zespoły programistyczne. Interfejsy API rejestrowania przechwytują informacje, takie jak awarie zabezpieczeń, błędy konfiguracji, wąskie gardła wydajności i/lub błędy w aplikacji lub platformie. Pakiet core zawiera wsparcie dla dostarczania zwykłego tekstu lub XML sformatowane rekordy dziennika do pamięci, strumieni wyjściowych, konsol, plików i gniazd. Ponadto interfejsy API rejestrowania umożliwiają interakcję z usługami rejestrowania, które już istnieją w systemie operacyjnym hosta.

Pakiet ^{java.util.logowanie} " dostarcza klasy i interfejsy podstawowych urządzeń rejestrujących platformy Java.

Log4j 1x " log4j to popularne narzędzie do logowania oparte na Javie. Log4j jest open source projekt oparty na pracy wielu autorów. Pozwala programistom kontrolować, które instrukcje dziennika są wysyłane do różnych lokalizacji za pomocą aplikacji [konsola, pliki, DB i e-mail]. Jest w pełni konfigurowalny w czasie wykonywania za pomocą zewnętrznych plików konfiguracyjnych.

Log4j ma trzy główne składniki:

• [[34]}loggery - [OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE]

• Appenders

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

  • Log4J Appender dla MongoDB: MongoDbAppender - Driver

• Layouts - [PatternLayout, EnhancedPatternLayout]

Pliki konfiguracyjne mogą być zapisywane w formacie XML lub we właściwościach Javy (klucz=wartość).

1. log4j_External.właściwości " Java properties (klucz=wartość) format

ciąg między otworem "${" i zamknięcie "}" jest interpretowany jako klucz. Wartość podstawionej zmiennej może być zdefiniowana jako właściwość systemowa lub w samym pliku konfiguracyjnym. Ustaw opcje specyficzne dla aplikacji. "log4j. appender./ align = "left" / option = value, dla każdego nazwanego appendera można skonfigurować jego układ.

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

Struktura tabeli MySQL dla tabeli 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: konfiguracja z publicznym plikiem DTD

<?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. Konfiguracja Log4j z adresu URL w programie Java:

Aby określić niestandardową konfigurację z zewnętrznym plikiem, używana klasa musi zaimplementować Konfigurator interface.

Gdy domyślne pliki konfiguracyjne "log4j. properties", " log4j.xml" nie są dostępne

• dla "log4j. properties" możesz podać PropertyConfigurator.metoda configure (java.net. URL).
• dla "log4j.xml" DOMConfigurator zostaną wykorzystane.

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

Jeśli używamy Apache commons logging wrapper na log4j, to musimy mieć oba Jary dostępne w classpath. Również commons-logging.properties i log4j.properties/xml powinny być dostępne w classpath.

Możemy również przekazać klasę implementacji i log4j.properties nazwę jako JAVA_OPTS używając -Dorg.apache.commons.logging.Log=<logging implementation class name> -Dlog4j.configuration=<file:location of log4j.properties/xml file>. To samo można zrobić poprzez ustawienie JAVA_OPTS w przypadku app/web server.

Pomoże to uzewnętrznić właściwości, które można zmienić podczas wdrażania.

Jest to alternatywny sposób użycia .yaml

Struktura Logiczna:

Configuration:
    Properties:
    Appenders:
    Loggers:

Próbka:

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 Konfiguracja: USING YAML

Do testowania, szybki sposób, w tym ustawienie poziomu dziennika:

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