Wie log4j richtig initialisieren?

Das richtige Einrichten von log4j eignet sich hervorragend für "echte" Projekte. Möglicherweise möchten Sie jedoch eine schnelle Lösung, z. wenn Sie gerade eine neue Bibliothek testen.

Wenn ja, rufen Sie die statische Methode auf

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

wird die grundlegende Protokollierung an der Konsole eingerichtet, und die Fehlermeldungen werden weg sein.

Wenn Sie einfach alles loswerden (z. B. wenn Sie sich in Tests befinden)

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

Wie auf Apache Log4j FAQ Seite :

Warum wird eine Warnung zu "Keine Appenders für Logger gefunden" und "Bitte log4j richtig konfigurieren" angezeigt?

Dies geschieht, wenn die Standardkonfiguration files log4j.properties und log4j.xml nicht gefunden werden kann und die Anwendung keine explizite Konfiguration durchführt. log4j verwendet Thread.getContextClassLoader().getResource() zum Auffinden der Standardkonfigurationsdateien und prüft das Dateisystem nicht direkt. Um den richtigen Speicherort für log4j.properties oder log4j.xml zu kennen, müssen Sie die Suchstrategie des verwendeten Klassenladeprogramms kennen. log4j bietet keine Standardkonfiguration, da die Ausgabe an die Konsole oder das Dateisystem in einigen Umgebungen möglicherweise verboten ist.

Grundsätzlich bedeutet die Warnung Es wurden keine Appenders für den Logger gefunden. Sie verwenden das Protokollsystem log4j . Sie haben jedoch keine Appender hinzugefügt (wie FileAppender, ConsoleAppender, SocketAppender, SyslogAppender usw.). in Ihre Konfigurationsdatei oder die Konfigurationsdatei fehlt.

Es gibt drei Möglichkeiten, log4j zu konfigurieren: mit einer Eigenschaftsdatei (log4j.properties), mit einer XML-Datei und durch Java-Code (rootLogger.addAppender(new NullAppender());).

log4j.properties

Wenn Ihre Eigenschaftendatei vorhanden ist (z. B. bei der Installation von Solr), müssen Sie diese Datei in Ihrem Verzeichnis classpath ablegen.

klassenpfad

In Linux finden Sie einige Befehlsvorschläge, wie Sie Ihren Klassenpfadwert ermitteln können:

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

oder von Java aus: System.getProperty("Java.class.path").

Log4j XML

Nachfolgend finden Sie eine grundlegende XML-Konfigurationsdatei für log4j im XML-Format:

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

Kater

Wenn Sie Tomcat verwenden, können Sie Ihren log4j.properties in: /usr/share/tomcat?/lib/ oder /var/lib/tomcat?/webapps/*/WEB-INF/lib/ ablegen.

Solr

Für die Referenz sieht die Solr-Standarddatei log4j.properties folgendermaßen aus:

#  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

Warum kann log4j meine Eigenschaftendatei nicht in einer J2EE- oder WAR-Anwendung finden?

Die kurze Antwort: Die log4j-Klassen und die Eigenschaftendatei befinden sich nicht im selben Klassenlader.

Log4j verwendet zum Laden von Klassen nur den Standardmechanismus Class.forName(). Ressourcen werden ähnlich behandelt. Weitere Informationen finden Sie in der Dokumentation zu Java.lang.ClassLoader.

Wenn Sie also Probleme haben, laden Sie die Klasse oder die Ressource selbst. Wenn Sie es nicht finden, log4j auch nicht. ;)

Siehe auch:

• Kurze Einführung in log4j auf der Apache-Site
• Apache: Protokollierungsdienste: FAQ auf der Apache-Site

Sie können den Speicherort Ihrer log4j.properties in Ihrer Java-App festlegen, indem Sie Folgendes verwenden:

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

Weitere Informationen finden Sie hier: https://logging.Apache.org/log4j/1.2/manual.html

Suchen Sie online nach "log4j.properties" oder "log4j.xml", die über einen Root-Appender verfügt, und legen Sie ihn in Ihrem Klassenpfad ab.

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

wird sich an der Konsole anmelden. Ich ziehe es vor, sich in eine Datei einzuloggen, damit Sie danach nachforschen können.

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

für ausführliche Protokollierungsanwendungen müssen jedoch normalerweise 100 KB auf 1 MB oder 10 MB erhöht werden, insbesondere für das Debuggen.

Persönlich habe ich mehrere Logger eingerichtet und den Root-Logger auf Warnungs- oder Fehlerstufe anstatt auf Debug gesetzt.

Eine andere Möglichkeit, dies zu tun, ohne die Eigenschaftendatei in den Klassenpfad zu setzen, besteht darin, die Eigenschaft direkt aus dem Java-Code festzulegen. Hier ist der Beispielcode.

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

}

Sie können die Protokollebene mit setLevel () einrichten.

Die Ebenen sind nützlich, um die Art der Informationen, die das Programm anzeigen soll, einfach einzustellen.

Zum Beispiel:

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

Die möglichen Ebenen sind:

SPUR,

DEBUGGEN,

INFO,

WARNEN,

FEHLER und

TÖDLICH

Laut Logging Services Handbuch

import org.Apache.log4j.BasicConfigurator;

Rufen Sie diese Methode auf

BasicConfigurator.configure();

Um -Dlog4j.debug zu aktivieren, gehe ich zu System, Erweiterte Systemeinstellungen, Umgebungsvariablen und setze die Systemvariable _Java_OPTIONS auf -Dlog4j.debug.

Erstellen Sie einfach log4j.properties im Ordner src/main/Assembly. Je nachdem, ob Protokollnachrichten in der Konsole oder in der Datei angezeigt werden sollen, ändern Sie Ihre Datei. Im Folgenden werden Ihre Nachrichten in der Konsole angezeigt. 

# 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

Ich habe die Datei log4j.properties im Ordner resources neben der Datei hibernate.cfg.xml erstellt und mit folgendem Text gefüllt:

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

jetzt habe ich Warnungen und Fehler beseitigt

Das Update für mich war, "log4j.properties" in den "src" -Ordner zu legen.

Wie zuvor erklärt, gibt es zwei Ansätze 

Zuerst fügen Sie einfach diese Zeile zu Ihrer Hauptmethode hinzu:

BasicConfigurator.configure();

Der zweite Ansatz besteht darin, diese Standarddatei log4j.properties zu Ihrem Klassenpfad hinzuzufügen:

Bei der zweiten Vorgehensweise müssen Sie sicherstellen, dass Sie die Datei ordnungsgemäß initialisieren.

Z.B.

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

Stellen Sie sicher, dass Sie den erforderlichen Ordner zum Speichern der Protokolldateien erstellen.

Versuchen Sie, das Debug-Attribut in log4j: Configuration Node auf true zu setzen.

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

Er druckt Informationen aus, während die Konfigurationsdatei gelesen und zur Konfiguration der log4j-Umgebung verwendet wird. Möglicherweise erhalten Sie weitere Details, um Ihr Problem zu lösen.

Logging API - Die Java Logging API vereinfacht die Software-Wartung und -wartung vor Ort beim Kunden, indem Protokollberichte erstellt werden, die für Endanwender, Systemadministratoren, Außendiensttechniker und Software-Entwicklungsteams geeignet sind Protokollierungs-APIs erfassen Informationen wie Sicherheitsfehler, Konfigurationsfehler, Leistungsengpässe und/oder Fehler in der Anwendung oder Plattform Das Kernpaket umfasst Unterstützung für die Übermittlung von Klartext- oder XML-formatierten Protokollsätzen an Arbeitsspeicher, Ausgabeströme, Konsolen, Dateien und Sockets. Darüber hinaus können die Protokollierungs-APIs mit Protokollierungsdiensten interagieren, die bereits auf dem Host-Betriebssystem vorhanden sind.

Paket ^{Java.util.logging} «Stellt die Klassen und Schnittstellen der zentralen Protokollierungsfunktionen der Java-Plattform bereit.

Log4j 1.x «log4j ist ein beliebtes Java-basiertes Protokollierungsprogramm. Log4j ist ein Open Source-Projekt, das auf der Arbeit vieler Autoren basiert. Der Entwickler kann mit Appenders [Konsole, Dateien, Datenbank und E-Mail] steuern, welche Protokollanweisungen an verschiedene Speicherorte ausgegeben werden. Es ist zur Laufzeit vollständig über externe Konfigurationsdateien konfigurierbar.

Log4j besteht aus drei Hauptkomponenten:

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

• Appenders

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

  • Log4J Appender für MongoDB:MongoDbAppender - Driver

• Layouts - [PatternLayout, EnhancedPatternLayout]

Konfigurationsdateien können in XML oder in Java-Eigenschaften (Schlüssel = Wert) geschrieben werden.

1. log4j_External.properties «Java-Eigenschaften (Schlüssel = Wert)

Die Zeichenfolge zwischen einem öffnenden "$ {" und einem schließenden "}" wird als Schlüssel interpretiert. Der Wert der ersetzten Variablen kann als Systemeigenschaft oder in der Konfigurationsdatei selbst definiert werden . Appender-spezifische Optionen festlegen. «Log4j.appender.appenderName.option = Wert. Für jeden benannten Appender können Sie sein Layout konfigurieren.

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-Tabellenstruktur für die Tabelle 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: Konfiguration mit öffentlicher DTD-Datei

<?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. Log4j-Konfiguration von der URL in Java-Programm:

Um eine benutzerdefinierte Konfiguration mit einer externen Datei anzugeben, muss die verwendete Klasse das Configurator-Interface implementieren.

wenn die Standardkonfigurationsdateien "log4j.properties" und "log4j.xml" nicht verfügbar sind

• Für "log4j.properties" können Sie die Methode PropertyConfigurator . Configure (Java.net.URL) verwenden.
• Für "log4j.xml" wird DOMConfigurator verwendet.

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

Was entwickelst du? Verwenden Sie 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

Ich habe eine Eigenschaft wie diese in einer Java-App von mir.

Mein log4j wurde durch die folgende Eigenschaftsdatei behoben:

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

Dies ist eine alternative Möglichkeit, .yaml zu verwenden

Logikstruktur:

Configuration:
    Properties:
    Appenders:
    Loggers:

Probe:

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 KONFIGURATION: VERWENDUNG VON YAML

Wenn wir Apache Commons Logging-Wrapper über log4j verwenden, müssen beide Klassen in classpath verfügbar sein. Außerdem sollten commons-logging.properties und log4j.properties/xml im Klassenpfad verfügbar sein. 

Wir können die Implementierungsklasse und log4j.properties name auch als Java_OPTS übergeben, entweder mit -Dorg.Apache.commons.logging.Log=<logging implementation class name> -Dlog4j.configuration=<file:location of log4j.properties/xml file>. Dasselbe kann bei App/Webserver über die Einstellung Java_OPTS erfolgen.

Es hilft, Eigenschaften zu externalisieren, die in der Bereitstellung geändert werden können.

Zum Testen eine schnelle Methode, einschließlich der Einstellung der Protokollebene:

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