Cominciamo con l’analizzare i passi da compiere per poter configurare LOG4J nella nostra web application. Vorrei premettere, comunque, che esistono diversi modi per configurare LOG4J ma, per la mia esperienza quello chesto per indicarvi è il modello più diffuso. In alternativa è possibile configurarle LOG4J anche attraverso un file XML oppure attraverso una servlet di inizializzazione della nostra WEB APPLICATION.

Ecco l’elenco degli step da seguire:

Scaricare dal sito ufficiale la distribuzione in formato binario cliccando qui;

Una volta scaricato estraete dal file zippato il file log4j.jar (alcune volte il nome riporta anche la versione per es. log4j_1_2.jar).;

se volete che venga utilizzato per qualsiasi applicazione voi vogliate sviluppare copiate il file precedentemente estratto nella cartella in cui è installato Tomcatnella posizione <CATALINA_HOME>\common\lib oppure nella cartella WEB_INF/lib se volete utilizzarla solo nella vostra web application.

A questo punto entriamo nel vivo della configurazione andando a costruire un file di configurazione per LOG4J che chiameremo log4j.properties (vedi sezione successiva per i contenuti di questo file);

Copiamo il file log4j.properties nella cartella della nostra web application WEB-INF/classes se siamo intenzionati ad utilizzare LOG4J solo nella nostra WEB APPLICATION oppure nella cartella <CATALINA_HOME>\common\classes se volete adottarlo per tutte le web applications che svilupperete anche in futuro.

 
A questo punto Tomcatriconoscerà al suo Startup LOG4J e applicherà durante la sue elaborazioni una sorta di reindirizzamento dell’output di Tomcat in LOG4J ogni volta che questo sarà chiamato in causa. E’ importante osservare che siamo noi da codice a definire cosa dovrà essere scritto mediante LOG4J e non Tomcat, quindi se usiamo un System.out.print piuttosto che una istruzione di LOG4J questa continuerà ad essere scritta nel monitor di Tomcat anziché nell’output impostato per LOG4J. Esiste la possibilità anche di configurareLOG4Jper Tomcat versione 3 ma in questo caso l’identificazione da parte di Tomcat non è automatica. Demando, ad un articolo in inglese trovato su internet!

In questo file configureremo le funzionalità che dovrà avere LOG4J. LOG4J infatti consente allo sviluppatore di poter definire una serie di settaggi più o meno complessi. Noi in questa sezione andremo ad analizzare i settagli più importanti, attraverso il seguente esempio:

1
#### Utilizza due differenti flussi per il Log
log4j.rootCategory=debug, stdout, R 

2
# Stampo solo i messaggi con priorità WARN o più alto per categoria
log4j.category.your.category.name=WARN
# Specifico inherit per il livello di priorità
#log4j.category.your.category.name=INHERITED 

3
#### Prima scrittura sulla console di Tomcat
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 

4
# Pattern che deve avere l’output
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n 

5
#### Secondo append sul file in cui vado a scrivere
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log 

6
# Controlli sulla grandezza del file
log4j.appender.R.MaxFileSize=100KB
# Numero di Backup dei fileslog4j.appender.R.MaxBackupIndex=1 

7
# Pattern che deve avere l’output sul file
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

 
Ho numerato i vari pezzi di codice per comodità di lettura e descrizione. Cominciamo quindi con la loro descrizione:

E’ praticamente l’elemento di partenza di Log4j. Vado a impostare innanzitutto il livello di errore che voglio gestire:

Debug per i messaggi di debugging

Info per i messaggi di tipo “verbose”

Warn per i messaggi di warning

Error per i messaggi di errore che si verificano in esecuzione

Fatal per gli errori gravi che determinano la caduta del sistema

Log per i messaggi di log

All invece per gestire tutti i messaggi.

Con gli elementi dopo la virgola (rispettivamente stdout ed R vado a indicare invece i due output in cui andrà a scrivere i messaggi log4j. STDOUT sta per Standard Output ed indirizzeremo il flusso a monitor (standard) mentre con R vado a definire l’output su file.

Configuro la categoria dei messaggi che voglio visualizzare ed il livello di priorità;

Vado a indicare il tipo di output ed il tipo di pattern. In questo caso come tipo di output abbiamo scelto il ConsoleApplender che individua come flusso quello di default (a monitor). Ne possiamo però utilizzare anche altri:

FileAppender per scrivere in append su di un file;

RollingFileAppender che mi permette di definire invece un file di default con una sua grandezza massima (100 Kb nel punto 6) e una volta raggiunta tale dimensione ne crea un secondo e così via cancellando quelli più vecchi. Indichiamo anche infatti il numero massimo di files di backup (vedi MaxBackupIndexnel punto 6);

DailyRollingFileAppender è come il precedentesolo che fa un discorso di tipo giornaliero (per esempio 2 files al giorno) salvando i files di log anche con la data del salvataggio.

Con la seconda riga invece si stabilisce il tipo di Layout che desidero impostare per il log. Anche in questo caso abbiamo una vasta scelta:

PatternLayout in cui bisogna indicare successivamente uno schema di visualizzazione (punto 4) con cui voglio le informazioni;

HTMLLayout che produce un layout in pagina HTML;

XMLLayout produce invece un layout di tipo XML;

TTCCLayout altro tipo ancora di layout.

Vado a configurare con conversionPattern lo schema con cui settare il pattern per visualizzare i messaggi. In particolare:

%5p indica il tpo di priorità del messaggio (WARN, DEBUG, ecc.);

[%t] indica il nome del thread che ha generato il messaggio;

%F nome del file da cui è partita la chiamata;

%L numero di linea che ha prodotto l’output;

%m Mio eventuale messaggio;

%n new line (a capo);

%c Categoria che ha scatenato il log.

Procedo come nel punto 3, solo che questa volta l’output viene indirizzato su di un file come specificato nella seconda riga;

Definisco gli attributi del RollingFileAppender ovvero le dimensioni del file, ed il numero dei files di backup di cui deve tener traccia;

Stabilisco anche per il file, il tipo di pattern e successivamente il formato che dovrà avere così come indicato nel punto 4.

Osservazione: come ho spiegato precedentemente sono innumerevoli gli elementi che possono essere configurati nel file di properties , ma quelli da me utilizzati e descritti nel file di esempio sono sicuramente i più utili e ci permetteranno di lavorare al meglio.

Bene!!! Dopo la fase di configurazione, finalmente analizziamo come applicare il logging di LOG4J nel codice Java.

Cominciamo subito affermando che possiamo applicare LOG4J sia alle servlet che alle JSP. In questo ultimo caso, sempre Jackarta, ha sviluppato delle taglib apposite che ci permettono di fare un debug di una pagina JSP. Rimando al prossimo paragrafo per questo ultimo aspetto.

Come prima operazione nella classe Java occorre importare l’apposito package log4j:

import org.apache.log4j.*;

Quindi si va a definire un oggetto statico che utilizzeremo per i messaggi. Possiamo sfruttare sia la Root che la categoriaall’interno della classe in cui ci troviamo:

static Category cat = Category.getRoot();

oppure

static Category cat = Category.getInstance(TestLogging.class.getName());

Per visualizzare i messaggi infine:

cat.<tipo_messaggio>(“messaggio”);

Per tipo messaggio si intendono i livelli di errore (warn, error ecc.)

per esempio:

cat.error(“Sono qui”);

A questo punto la gestione diviene esattamente come i famosi System.out.print che siamo abituati ad utilizzare in fase di test.

Per poter utilizzare LOG4J in una pagina JSP invece, occorre utilizzare un ulteriore pacchetto prodotto sempre dalla Apache Foundation. Questo pacchetto riguarda una taglib da loro sviluppata (giunta ormai alla versione 1.1) che ci permetterà di utilizzare anche in una pagina JSP la gestione del debug con LOG4J. Per fare ciò occorre:

Scaricare dal sito http://jakarta.apache.org/taglibs/doc/log-doc/intro.html la taglib LOG1.1;

Estrarre nella propria macchina in locale il file taglibs-log.jar e copiarlo nella cartella WEB-INF/lib della nostra applicazione;

Copiare dal file estratto anche il file taglibs-log.tld nella cartella /WEB-INF della nostra applicazione;

Modificare il file WEB.XML della nostra applicazione aggiungendo il seguente codice:

<taglib>

<taglib-uri>http://jakarta.apache.org/taglibs/log-1.0</taglib-uri> 

<taglib-location>/WEB-INF/log.tld</taglib-location> 

</taglib>

A questo punto inserire agli inizi della pagina JSP il seguente codice:

<%@ taglib uri=http://jakarta.apache.org/taglibs/log-1.0 prefix=”log” %>

E quindi nella pagina JSP andremo ad utilizzare i seguenti tag per scrivere nel file log:

<log:debug>Message embedded within open and close tags.</log:debug>

<log:debug message="Message passed as an attribute to the tag" /> 

<log:info category="test">Using category attribute.</log:info>

E’ chiaro che automaticamente la nostra web application riconoscerà i tag ed andrà a scrivere i vari messaggi di logging nelle fonti che sono state configurate nel file log4j.properties

Fig. 1  LOG4J NELLA JSP

Spero di essere stato nel complesso esaustivo. La pretesa di questo articolo è quella di fornire delle consigli e un po’ di documentazione, soprattutto in italiano, su un argomento poco presente (o quasi nullo) nella nostra lingua ma che è di fondamentale importanza per chi gestisce siti web con servlet e pagine JSP ed alle volte requisito fondamentale per avere una idea di quello che accade sul server remoto in cui la nostra applicazione gira.