it-swarm.dev

Jak poprawnie zainicjować log4j?

Po dodaniu log4j do mojej aplikacji otrzymuję następujące wyniki za każdym razem, gdy wykonuję swoją aplikację:

 log4j: WARN Nie znaleziono aplikatorów dla programu rejestrującego (slideselector.facedata.FaceDataParser) .
 log4j: WARN Proszę zainicjować system log4j prawidłowo .

Wygląda na to, że brakuje pliku konfiguracyjnego ......... Gdzie powinien znajdować się ten plik konfiguracyjny i jaka jest dobra zawartość początkowa? 

Używam zwykłej Java do tworzenia aplikacji na komputery. Więc nie ma serwera sieciowego itp ...

255
Janusz

Log4j domyślnie szuka pliku o nazwie log4j.properties lub log4j.xml w ścieżce klas. Możesz kontrolować, który plik jest używany do zainicjowania się poprzez ustawienie właściwości systemu zgodnie z opisem tutaj (Poszukaj "Domyślnej procedury inicjowania"). 

Na przykład:

Java -Dlog4j.configuration=customName ....

Spowoduje, że log4j wyszuka plik o nazwie customName w ścieżce klas.

Jeśli masz problemy, włącza się log4j.debug:

-Dlog4j.debug

To wydrukuje do System.out wiele pomocnych informacji o tym, który plik był używany do zainicjowania, które rejestratory/aplikacje zostały skonfigurowane i jak itp. 

Plik konfiguracyjny może być plikiem właściwości Java lub plikiem xml. Oto przykład formatu pliku właściwości pobranego z strony dokumentacji intro 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
258
polarbear

Poprawne skonfigurowanie log4j doskonale sprawdza się w przypadku "prawdziwych" projektów, które mogą wymagać szybkiego i brudnego rozwiązania, np. jeśli właśnie 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ą.

223
Peter Lind

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

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

Zgodnie z Apache Log4j FAQ page :

Dlaczego widzę ostrzeżenie o "Nie znaleziono aplikacji dla rejestratora" i "Proszę poprawnie skonfigurować log4j"?

Dzieje się tak, gdy nie można znaleźć domyślnej konfiguracji files log4j.properties i log4j.xml, a 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. Znajomość odpowiedniej lokalizacji do umieszczenia log4j.properties lub log4j.xml wymaga zrozumienia strategii wyszukiwania używanego modułu ładującego klasy. log4j nie zapewnia domyślnej konfiguracji, ponieważ wyjście do konsoli lub do systemu plików może być zabronione w niektórych środowiskach.

Zasadniczo ostrzeżenie Nie można znaleźć dodatków do rejestratora oznacza, że ​​używasz log4j systemu logowania, ale nie dodałeś żadnych Appenderów (takich jak FileAppender, ConsoleAppender, SocketAppender, SyslogAppender, itp. .) do pliku konfiguracyjnego lub brakuje pliku konfiguracyjnego.

Istnieją trzy sposoby konfiguracji log4j: z plikiem właściwości (log4j.properties), z plikiem XML ​​ oraz kodem 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 propozycji poleceń w Linuksie, jak określić wartość ścieżki klasy:

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

lub z Java: 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>

Kocur

Jeśli korzystasz z Tomcat, możesz umieścić plik log4j.properties w folderze: /usr/share/tomcat?/lib/ lub /var/lib/tomcat?/webapps/*/WEB-INF/lib/.

Solr

Dla odniesienia, domyślny plik 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 należą do tego samego programu ładującego klasy.

Log4j używa tylko domyślnego mechanizmu Class.forName() do ładowania klas. Zasoby są obsługiwane w podobny sposób. Więcej informacji można znaleźć w dokumentacji Java.lang.ClassLoader.

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


Zobacz też:

19
kenorb

Możesz ustawić lokalizację swojego log4j.properties w 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

12
Arash

Znajdź plik log4j.properties lub log4j.xml online, który ma prokurenta i umieść go w ścieżce klas.

### 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ę logować się do pliku, aby móc później zbadać.

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

aczkolwiek w przypadku aplikacji do rejestrowania w pełnym zakresie 100 KB zwykle musi zostać zwiększone do 1 MB lub 10 MB, szczególnie w przypadku debugowania.

Osobiście skonfigurowałem wiele rejestratorów i ustawiłem program rejestrujący root na ostrzeżenie lub poziom błędu zamiast debugowania.

10
JeeBee

Innym sposobem, aby to zrobić bez umieszczania pliku właściwości w ścieżce klas, jest ustawienie właściwości bezpośrednio z kodu Java. 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.");
}

}

7
stones333

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

Poziomy są przydatne do łatwego ustawiania rodzaju informacji, które program ma wyświetlać.

Na przykład:

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

Zestaw możliwych poziomów to:

ŚLAD,

ODPLUSKWIĆ,

INFO,

OSTRZEC,

BŁĄD i

FATALNY

Zgodnie z Logging Services manual

5
Math
import org.Apache.log4j.BasicConfigurator;

Zadzwoń do tej metody

BasicConfigurator.configure();
5
Winson So

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

3
Feng Zhang

Po prostu stwórz log4j.properties w folderze src/main/Assembly. W zależności od tego, czy chcesz, aby komunikaty z logami były wyświetlane w konsoli, czy w pliku, możesz modyfikować swój plik. Następujące pokaże twoje wiadomości 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
1
NSonmez

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

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

1
Aybek Kokanbekov

Dla mnie rozwiązaniem było umieszczenie pliku „log4j.properties” w folderze „src”.

1
Silver

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

Pierwszym jest dodanie tej linii do głównej metody:

BasicConfigurator.configure();

Drugie podejście polega na dodaniu tego standardowego pliku log4j.properties do swojej klasy classpath:

Podejmując drugie podejście, musisz upewnić się, że plik został zainicjowany poprawnie.

Na przykład.

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ś wymagany folder do przechowywania plików dziennika.

1
AkashK

Spróbuj ustawić atrybut debugowania w log4j: node konfiguracji na true.

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

Drukuje informacje, gdy plik konfiguracyjny jest odczytywany i używany do konfigurowania środowiska log4j. Możesz uzyskać więcej informacji, aby rozwiązać swój problem.

1
atom88

Interfejs API rejestrowania - Interfejs API rejestrowania Java ułatwia serwisowanie i konserwację oprogramowania u klientów poprzez tworzenie raportów dziennika odpowiednich do analizy przez użytkowników końcowych, administratorów systemu, inżynierów serwisowych i zespoły programistów. Interfejsy API rejestrowania przechwytują informacje, takie jak awarie bezpieczeństwa, błędy konfiguracji, wąskie gardła wydajności i/lub błędy w aplikacji lub platformie. Pakiet podstawowy obejmuje obsługę dostarczania do pamięci rekordów dziennika w formacie zwykłego tekstu lub XML, strumieni wyjściowych, konsol, plików i gniazd. Ponadto interfejsy API rejestrowania mogą wchodzić w interakcje z usługami rejestrowania, które już istnieją w systemie operacyjnym Host.

Pakiet Java.util.logging "Zapewnia klasy i interfejsy podstawowych funkcji rejestrowania platformy Java.


Log4j 1.x "log4j jest popularnym logowaniem opartym na Javie użyteczność. Log4j to projekt typu open source oparty na pracy wielu autorów. Pozwala deweloperowi kontrolować, które wyciągi dziennika są wyprowadzane do różnych lokalizacji za pomocą programów dołączających [konsola, pliki, baza danych i poczta e-mail]. Jest w pełni konfigurowalny w czasie wykonywania przy użyciu zewnętrznych plików konfiguracyjnych.

Log4j ma trzy główne elementy:

  • rejestratory - [OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE]
  • Osoby dołączające

  • Układy - [PatternLayout, EnhancedPatternLayout]

Pliki konfiguracyjne można zapisać w formacie XML lub w formacie Java właściwości (klucz = wartość).

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

Ciąg między otwierającym „ $ {” a zamykającym „} ”jest interpretowany jako klucz. Wartość podstawionej zmiennej można zdefiniować jako właściwość systemową lub w samym pliku konfiguracyjnym. Ustaw opcje specyficzne dla programu dołączającego. "Log4j.appender.appenderName.option = wartość, Dla każdego nazwanego appendera możesz 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
[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

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 plikiem zewnętrznym, używana klasa musi implementować interfejs konfiguratora .

gdy domyślne pliki konfiguracyjne „log4j.properties”, „log4j.xml” są niedostępne

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

W czym się rozwijasz? Czy 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 takie właściwości w mojej aplikacji Java.

1
Steven

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
1
Kanishk

Jest to alternatywny sposób użycia .yaml

Struktura logiczna:

Configuration:
    Properties:
    Appenders:
    Loggers:

Próba:

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: KORZYSTANIE Z YAML

0
emecas

Jeśli używamy pakowania zbiorczego logującego Apache na log4j, to musimy mieć oba słoiki dostępne w ścieżce klas. Również commons-logging.properties i log4j.properties/xml powinny być dostępne w ścieżce klas. 

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ć, ustawiając Java_OPTS w przypadku aplikacji/serwera WWW.

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

0
Shiv

Do testowania, szybka i brudna metoda, w tym ustawianie poziomu rejestrowania:

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..
0
Baked Inhalf