Hi,
I have worked with this class for logging. On a client-server
environment, creates 1 log per client. I don't remember internally how
it works, but you can check it out, if it helps.
Root logger configuration is based on "log4j-conf.xml", the rest are
based on root config, but some properties can be changed dynamically,
such as layout (XML, HTML, plain text, ...).
With javadoc you can generate the documentation of it.
César
===================
Paolo Bacci escribió:
Hi all,
I'm having problems writing to multiple appenders.
I made a log4j.properties and I'd like it to write to 2 different log
files,
but it seems like nothing works....
I'm doing this on my .properties:
log4j.rootLogger=all, stdout, R, html
log4j.secondAppender=INHERITED, app
#### App appender properties
log4j.appender.app=org.apache.log4j.RollingFileAppender
log4j.appender.app.File=/tmp/log.log
# Control the maximum log file size
log4j.appender.app.MaxFileSize=100KB
# Archive log files (one backup file here)
log4j.appender.app.MaxBackupIndex=1
log4j.appender.app.layout=org.apache.log4j.PatternLayout
log4j.appender.app.layout.ConversionPattern=%d:%-5r %-5p[%t | %c{1}:%L |
%M] %m%n
Rootlogger is doing great, but the second one is just not doing
anything at
all.
Does anybody has any clue about why is it happening?
thanks in advance
Paolo
package lprs.examen;
//**********************************************************
//LIBRERIAS
//**********************************************************
import java.io.File;
import java.util.Enumeration;
import org.apache.log4j.Appender;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.FileAppender;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggerRepository;
import org.apache.log4j.xml.DOMConfigurator;
import org.apache.log4j.Layout;
import org.apache.log4j.PatternLayout;
import org.apache.log4j.SimpleLayout;
import org.apache.log4j.xml.XMLLayout;
import org.apache.log4j.HTMLLayout;
/************************************************************
*<!-- CLASE TRAZADOR
*========================================================-->
* Clase que crea y configura un trazador, ofreciendo
* un sistema de trazado estandar.
* <p>
* La idea es crear un sistema de trazado comun para
* todas las practicas, de sencilla configuracion, con
* perspectivas de ampliacion y reutilizacion.
*
* <p><b><u> ESTRUCTURA LOG4J </u></b>
* <table border="1">
* <tr><td><b>ENTIDAD</b></td><td><b> OBJETIVO </b></td> <td><b>
TIPOS </b></td></b></tr>
* <tr><td> Logger:</td> <td>Grupo de destinos de trazado </td> <td>
Root, L1, L2 ...Ln </td> </tr>
* <tr><td>Appender: </td> <td>Definicion del destino de trazado</td> <td>
LOG, CONSOLA, ... </td> </tr>
* </table>
* <p>
* El Logger Root es el principal y esta compartido por todos los trazadores
* de un programacion
*
* <p><b><u>MANEJO</u></b>
* <table>
* <tr>
* <td> 1.- <b> Definicion de Appenders en fichero XML: </b>
* <ul>
* <li>1.1.- Destinos posibles del trazado: consola, log ...
* <li>1.2.- Lista de propiedades de cada destino
* <li>1.3.- Filtrado por niveles log4j para cada destino.--
* Niveles log4j: debug, info, warn, error, fatal
* </ul>
* </td> </tr>
* <tr>
* <td> 2.- <b> Creando y Configurando Trazador </b>:
* <ul>
* <li> t=new Trazador();
* <li> t.setRutaConfifXML("conf/log4j-conf.xml")
* <li> t.configuraTrazador(); // Carga XML o config basica
* </ul>
* </td> </tr>
* <tr>
* <td> 3.-<b> Conmutacion del trazado principal </b> (logger root):
* <ul>
* <li> t.setRutaNuevoLog("logs/cliente1.txt");
* <li> t.conmutaTrazado();
* </ul>
* <p>
* Ejm.: logs/cliente1.txt --
* logs/cliente2.txt --
* </td> </tr>
* <tr>
* <td> 4.- <b> Creacion de nuevo destino de trazado </b>
* (Nuevo {logger "sesion1" + FileAppender "sesion1"}):
* <ul>
* <li> t.rutaNuevoLog("logs/servidor/sesion1.txt"); // Destino del
nuevo FileAppender
* <li> t.nuevoLog("sesion1"); // Nuevo {Logger +
FileAppender}
* </ul>
* <p>
* Ejm.: logs/servidor/sesion1.txt --
* logs/servidor/sesion2.txt --
* </td> </tr>
* <td> 5.- El Appender "LOG" del fichero XML es la referencia para
* la configuracion de todos los nuevos logs.
* </td> </tr>
* <td> 6.- Si no existe Appender "LOG" se deshabilita la creacion de
* nuevos logs y la conmutacion del log principal hacia otro
* fichero.
* </td> </tr>
* <td> 7.- Si no existe fichero XML se volcaran los errores por consola.
*
* </td> </tr>
* </table>
*
* <p><b><u>FICHERO CONFIGURACION</u></b>
*
* <p> Define:
* <ul>
* <li> <u>Destinos (Appenders)</u>: mail, red, log, consola
* <li> <u>Logger: </u> si existe appender LOG, no se deben
* definir loggers, aparte del root.
* <li> <u>Filtrado: </u> habilita/deshabilita un grupo de
* mensajes para cada destino. Por ejm.: DEBUG.
* <li> <u>LayOut del Log: </u> TXT, HTML, XML ...
* </ul>
*
* <p><b><u>MODOS DE TRAZADO / TRAZADOR (aun no operativo)</u></b>
* <table>
* <tr> <td>
* 1.- <b>Errores por pantalla</b>: si no existe appender LOG en el
* fichero de configuracion, volcado
* de warnings y errores por consola.
* <ul>
* <li> <u> Depuracion ON </u>: activa globalmente (todos los loggers)
el
* trazado detallado + Pila de errores.
* <li> <u> Depuracion OFF</u>: activa globalmente (todos los loggers)
* el traza simple de errores (1 linea).
*
* <li> <u> Exhaustiva ON:</u>: activa localmente (cliente actual) el
* volcado de contenido de variables
* (trazas cansinas).
* <li> <u> Exhaustiva OFF:</u>: desactiva las trazas cansinas
* para el cliente actual.
* </ul>
* </td> </tr>
* <tr> <td>
* 2.- <b> Errores a log</b>: si existe appender LOG en el fichero
* de configuracion, volcado en logs segun
* especifique el appender LOG del fichero XML.
*
* <ul>
* <li> <u> Depuracion ON </u>: activa globalmente (todos los loggers)
el
* trazado detallado + Pila de errores.
* <li> <u> Depuracion OFF</u>: activa globalmente (todos los loggers)
* el traza simple de errores (1 linea).
*
* <li> <u> Exhaustiva ON:</u>: activa localmente (cliente actual) el
* volcado de contenido de variables
* (trazas cansinas).
* <li> <u> Exhaustiva OFF:</u>: desactiva las trazas cansinas
* para el cliente actual.
* </ul> * </table>
*
* <p><b><u>NOTA SOBRE LAS CATEGORIAS:</u></b>
* <ul>
* <li> Antiguamente los loggers recibian el nombre de
* categorias.
*
* <li> Este concepto lia bastante las cosas, queriendo
* expresar loggers nuevos, asi que ya no se usa y
* todos los metodos que manejan este concepto estan
* deprecados.
* </ul>
*<!--====================================================-->
* <p>Login: <b> lswc5091 </b>
* -- Fecha: <b> 23 - Nov - 2005 </b>
* @author Cesar Delgado Gonzalez
************************************************************/
public class Trazador {
//**********************************************************
// PROPIEDADES
//**********************************************************
//-------------------------------------------------
// PUBLICAS
//-------------------------------------------------
// 1.- Tipos de mensajes de log4j
public static final int DEBUG = 0;
public static final int INFO = 1;
public static final int WARN = 2;
public static final int ERROR = 3;
public static final int FATAL = 4;
//-------------------------------------------------
// PRIVADAS
//-------------------------------------------------
// 0.- Tipos layouts para fichero de log
private static final int NONE = 0; // Utiliza layout de fichero
config
private static final int SIMPLE = 1;
private static final int PATTERN = 2;
private static final int XML = 3;
private static final int HTML = 4;
// 1.- Tipos de trazado
private static boolean detalles = true;
private static boolean exhaustiva = false;
// 2.- Propiedades del Trazador
private static String nombreAplicacion = new String("Log4J Log
Messages");
private String confXML = new String("conf/log4j-conf.xml");
private String nombreLog = null;
private String extensionLog= new String(".log");
private String conversion = new String("%d{dd MMM yyyy
HH:mm:ss.SSS} [%p] [%t] [%c] - %m%n");
private int layout = NONE;
// 3.- Trazador
private Logger traza = null;
// 4.- Existencia del Appender LOG
private static boolean[] existeLog = null;
// NULL ==> No se ha cargado fichero de config
// existeLog[0] => Existe Appender LOG?
// existeLog[1] => Existe Fichero XML de configuracion?
//**********************************************************
// MANEJO DE PROPIEDADES DEL TRAZADOR
//**********************************************************
/**************************************************
*<!-- IS DETALLADO ON
*===============================================-->
* Detallado ON => Trazas detalladas para
* este trazador.
* <br>
*
* Activada por defecto
*
* @return Activada la depuracion?
**************************************************/
public synchronized static boolean isDetalladoOn() {
return detalles;
}
/**************************************************
*<!-- SET DETALLADO
*===============================================-->
* Detallado ON/OFF => Habilita trazas detalladas.
* <br>
* Activada por defecto
**************************************************/
public synchronized static void
setDetallado(boolean on) {
detalles = on;
}
/**************************************************
*<!-- SET DETALLADO ON
*===============================================-->
* Detallado ON => Habilita trazas detalladas.
* <br>
* Activada por defecto
**************************************************/
public synchronized static void setDetalladoOn() {
detalles = true;
}
/**************************************************
*<!-- SET DETALLADO OFF
*===============================================-->
* Detallado ON => Deshabilita trazas detalladas.
* <br>
* Activada por defecto
**************************************************/
public synchronized static void setDetalladoOff() {
detalles = false;
}
/**************************************************
*<!-- IS EXHAUSTIVO ON
*===============================================-->
* Exhaustivo ON => Trazas detalladas para
* este trazador.
* <br>
* Desactivada por defecto
*
* @return [aAeEiIoOuU!?]Activada la depuracion?
**************************************************/
public synchronized static boolean isExhaustivoOn() {
return exhaustiva;
}
/**************************************************
*<!-- SET EXHAUSTIVO
*===============================================-->
* Exhaustivo ON/OFF => Depuracion exhaustiva
* <br>
* Desactivada por defecto
**************************************************/
public synchronized static void setExhaustivo(boolean on) {
exhaustiva = on;
}
/**************************************************
*<!-- SET EXHAUSTIVO ON
*===============================================-->
* Exhaustivo ON => Habilita la depuracion
* exhaustiva.
* <br>
* Desactivada por defecto
**************************************************/
public synchronized static void setExhaustivoOn() {
exhaustiva = true;
}
/**************************************************
*<!-- SET EXHAUSTIVO OFF
*===============================================-->
* Exhaustivo OFF => Habilita la depuracion
* exhaustiva.
* <br>
* Desactivada por defecto
**************************************************/
public synchronized static void setExhaustivoOff() {
exhaustiva = false;
}
/**************************************************
*<!-- SET NOMBRE APLICACION
*===============================================-->
* Se da valor al nombre de la aplicacion,
* util para logs HTML o XML
* <br>
* Valor por defecto "Log4J Log Messages"
**************************************************/
public synchronized static void setNombreAplicacion(String nombre) {
nombreAplicacion = nombre;
}
/**************************************************
*<!-- GET RUTA_CONFIG_XML
*===============================================-->
* @return Ruta+Nombre del fichero XML.
* @see #configuraTrazador()
**************************************************/
public synchronized String getRutaConfigXML() {
return confXML;
}
/**************************************************
*<!-- SET RUTA_CONFIG_XML
*===============================================-->
* Setea la Ruta+Nombre del fichero de XML de
* configuracion LOG4J.
* Por defecto:<i>"conf/log4j-conf.xml"</i>
* @see #configuraTrazador()
**************************************************/
public synchronized void setRutaConfigXML(String ruta) {
confXML = ruta;
}
/**************************************************
*<!-- SET RUTA_RUTA_NUEVO_LOG
*===============================================-->
* Setea Ruta+Nombre del fichero de log a crear.
* Por defecto:
* <i>el indicado en el fichero de configuracion</i>
*
* @see #conmutaTrazado()
* @see #nuevoLog(String)
**************************************************/
public synchronized void setRutaNuevoLog(String ruta) {
nombreLog = ruta;
}
/**************************************************
*<!-- SET LAYOUT SIMPLE
*===============================================-->
* Activando trazado simple en log
**************************************************/
public synchronized void setLayoutSimple() {
layout=SIMPLE;
extensionLog = new String(".txt");
}
/**************************************************
*<!-- SET LAYOUT PATTERN
*===============================================-->
* Activando trazado mediante patrones de conversion
**************************************************/
public synchronized void setLayoutPattern() {
layout=PATTERN;
extensionLog = new String(".log");
}
/**************************************************
*<!-- SET LAYOUT XML
*===============================================-->
* Activando trazado XML
**************************************************/
public synchronized void setLayoutXML() {
layout=XML;
extensionLog = new String(".xml");
}
/**************************************************
*<!-- SET LAYOUT HTML
*===============================================-->
* Activando trazado HTML
**************************************************/
public synchronized void setLayoutHTML() {
layout=HTML;
extensionLog = new String(".html");
}
/**************************************************
*<!-- SET CONVERSION PATTERN
*===============================================-->
* Formato de la traza a emplear
* <br>
* Ver:
**************************************************/
public synchronized void setConversionPattern(String patron) {
conversion=new String(patron);
}
/**************************************************
*<!-- GET RUTA_NUEVO_LOG
*===============================================-->
* @return Ruta+Nombre del fichero asociado
* al trazador.
* @see #conmutaTrazado()
* @see #nuevoLog(String)
**************************************************/
public synchronized String getRutaNuevoLog() {
return nombreLog;
}
/**************************************************
*<!-- GET LOGGER
*===============================================-->
* @return Logger del Trazador
**************************************************/
public synchronized Logger getLogger() {
return traza;
}
/**************************************************
*<!-- GET LAYOUT
*===============================================-->
* @return Layout del fichero del log del trazador
**************************************************/
public synchronized String getLayout() {
//------------ DECLARACIONES LOCALES ------------
String salida = null;
//------------------ ACCIONES -------------------
// 1.- Seleccionando tipo Layout del fichero
//------------------------------------------
switch (layout) {
case SIMPLE:
salida = new String("org.apache.log4j.SimpleLayout");
break;
case PATTERN:
salida = new String("org.apache.log4j.PatternLayout");
break;
case XML:
salida = new String("org.apache.log4j.XMLLayout");
break;
case HTML:
salida = new String("org.apache.log4j.HTMLLayout");
break;
default:
salida = new String("Especificado en fichero
configuracion");
break;
}
// 2.- Retornando Layout
//------------------------------------------
return salida;
}
/**************************************************
*<!-- GET CONVERSION PATTERN
*===============================================-->
* @return Formato del encabezado de la traza
**************************************************/
public synchronized String getConversionPattern() {
return conversion;
}
//**********************************************************
// CONFIGURACION AVANZADA: NUEVOS LOGGERS
//**********************************************************
//-------------------------------------------------
// CONFIG_LAYOUT
//-------------------------------------------------
// Crea y configura el formato del fichero de
// log
//-------------------------------------------------
private Layout configLayout(Layout inicial) {
//------------ DECLARACIONES LOCALES ------------
Layout esquema = inicial;
//------------------ ACCIONES -------------------
// 1.- Seleccionando tipo Layout del fichero
//------------------------------------------
switch (layout) {
case SIMPLE:
SimpleLayout salida_1 = new SimpleLayout();
esquema = (Layout) salida_1;
break;
case PATTERN:
PatternLayout salida_2 = new PatternLayout(conversion);
esquema = (Layout) salida_2;
break;
case XML:
XMLLayout salida_3 = new XMLLayout();
esquema = (Layout) salida_3;
break;
case HTML:
HTMLLayout salida_4 = new HTMLLayout();
salida_4.setTitle(nombreAplicacion);
esquema = (Layout) salida_4;
break;
default:
Layout salida_5 = inicial;
esquema = (Layout) salida_5;
break;
}
return esquema;
}
//-------------------------------------------------
// CONFIG_APPENDER
//-------------------------------------------------
// Configura el FileAppender DESTINO igual que
// el FileAppender Origen
//-------------------------------------------------
private void configAppender(FileAppender origen,
FileAppender
destino) {
//------------------ ACCIONES -------------------
try {
destino.setLayout(configLayout(origen.getLayout()));
destino.addFilter(origen.getFilter());
destino.setThreshold(origen.getThreshold());
destino.activateOptions();
imprimeTraza (DEBUG,
"Trazador.configAppender()",
"TRAZADOR - CONFIGURANDO APPENDER => Nuevo fichero
de log",
"-> Nombre del Appender: " + destino.getName() +
"\n -> Fichero de Log: " +
destino.getFile().toString());
} catch (Exception e) {
imprimeTraza (DEBUG,
"Trazador.configAppender()",
"TRAZADOR - CONFIGURANDO APPENDER => Nuevo fichero
de log",
e.toString());
e.printStackTrace();
}}
//-------------------------------------------------
// BUSCA_APPENDER_LOG
//-------------------------------------------------
// Localiza y devuelve el appender LOG. Caso
// de no existir, devuelve NULL.
//
// Utilidades:
// 1.- Configuracion del nuevo appender de una
// nueva categoria con las propiedades
// definidas para el appender LOG en el
// fichero XML
//
// 2.- Deshabilitar los logs, caso de no existir
// appender LOG
//-------------------------------------------------
private FileAppender buscaAppenderLog() {
//------------ DECLARACIONES LOCALES ------------
Enumeration salidas = null;
Appender actual = null;
FileAppender log = null;
//------------------ ACCIONES -------------------
try {
// 1.- Capturando Appenders de Categoria Root
//-------------------------------------------
salidas = Logger.getRootLogger().getAllAppenders();
// 2.- Buscando Appender LOG de tipo FileAppender
//-----------------------------------------------
while (salidas.hasMoreElements()) {
// 2.1.- Captura del siguiente Appender de la
lista
actual = (Appender) salidas.nextElement();
// 2.2.- Comprobando que sea Appender LOG
if (actual.getName().contains("LOG")) {
log = (FileAppender) actual;
break;
}
}
return log;
} catch (Exception e) {
imprimeTraza (ERROR,
"Trazador.buscaAppenderLOG()",
"TRAZADOR - LOCALIZANDO APPENDER LOG." +
"\n Lo mas probable es que LOG no sea del tipo
FileAppender",
e.toString());
e.printStackTrace();
return log;
}}
//-------------------------------------------------
// BUSCA_CATEGORIA
//-------------------------------------------------
// Busca una categoria no Root. En su
// defecto devuelve la categoria root.
//-------------------------------------------------
private Logger buscaCategoria() {
//------------ DECLARACIONES LOCALES ------------
Enumeration categorias = null;
Logger categoria = null;
Logger salida = null;
LoggerRepository repositorio = null;
//------------------ ACCIONES -------------------
try {
// 1.- Por Defecto => Categoria Root
//------------------------------------------
salida = Logger.getRootLogger();
// 2.- Capturando Repositorio de Categorias
//------------------------------------------
repositorio = salida.getLoggerRepository();
categorias = repositorio.getCurrentLoggers();
// 3.- Buscando Categoria No root
//-------------------------------
while (categorias.hasMoreElements()) {
categoria = (Logger) categorias.nextElement();
if (!categoria.equals(Logger.getRootLogger())) {
salida = categoria;
break;
}
}
return salida;
} catch (Exception e) {
imprimeTraza (ERROR,
"Trazador.buscaCategoria()",
"TRAZADOR - BUSCANDO CATEGORIA NO ROOT",
e.toString());
e.printStackTrace();
return salida;
}}
//-------------------------------------------------
// CONFIG_CATEGORIA
//-------------------------------------------------
// Configura el appender de un nueva categoria,
// tomando como base el appender de otra que no
// sea la principal. En su defecto, copiara la
// configuracion del appender LOG
//
//-------------------------------------------------
private boolean configCategoria(FileAppender ficheroNuevo){
//------------ DECLARACIONES LOCALES ------------
boolean root = true;
Logger categoria = null;
FileAppender fichero = null;
//------------------ ACCIONES -------------------
try {
// 1.- Buscando Categoria No Root
//-------------------------------
categoria = buscaCategoria();
root = categoria.equals(Logger.getRootLogger());
// 2.- Configurando Nuevo Appender
//--------------------------------
if (!root) {
// Asumimos que solo hay 1 appender en categorias No Root
// (No definir categorias en el fichero XML !!!!!)
fichero = (FileAppender)
categoria.getAllAppenders().nextElement();
configAppender(fichero, ficheroNuevo);
// 3.- Configuracion Nuevo Appender = Appender LOG
//-------------------------------------------------
} else {
fichero = buscaAppenderLog();
configAppender(fichero, ficheroNuevo);
}
return root;
} catch (Exception e) {
imprimeTraza (ERROR,
"Trazador.configCategoria()",
"TRAZADOR - CONFIGURANDO EL APPENDER DE LA CATEGORIA",
e.toString());
e.printStackTrace();
return root;
}}
//-------------------------------------------------
// CREA_APPENDER
//-------------------------------------------------
// Crea un nuevo appender para un nuevo logger,
// y lo configura tal y como esta configurado
// el appender LOG del fichero XML.
//
// Si no hay appender LOG, se ignora la creacion
// de la categoria.
//
// La idea es:
//
// 1.- Capturar configuracion del appender de
// una categoria que no sea la root.
//
// Por definicion, debe ser identica a la
// a la configuracion del appender LOG
// que aparece en el fichero XML.
//
// 2.- Caso de solo existir la principal:
// 2.1.- Se configura el nuevo appender
// con las propiedades del
// appender LOG
//
// 2.2.- El appender LOG se filtra para
// no desbordar el log asociado a la
// categoria root
//
// 2.- Si no existe Appender LOG en el fichero XML =>
// se ignora la creacion del logger.
//
//-------------------------------------------------
private FileAppender creaAppender(String nombre) {
//------------ DECLARACIONES LOCALES ------------
FileAppender fichero = null;
FileAppender ficheroNuevo = null;
boolean root = false;
//------------------ ACCIONES -------------------
try {
// 1.- Creando Appender
//---------------------
ficheroNuevo = new FileAppender();
// 2.- Configurando Nuevo Appender
//--------------------------------
// 2.1.- Nombre y Fichero Salida
ficheroNuevo.setFile(nombreLog+extensionLog);
ficheroNuevo.setName(nombre);
// 2.2.- Resto de Configuracion
root = configCategoria(ficheroNuevo);
// 3.- Filtrando Categoria Root
//-----------------------------
if (root) {
fichero = buscaAppenderLog();
fichero.setThreshold(Level.ERROR);
}
return ficheroNuevo;
} catch (Exception e) {
imprimeTraza (ERROR,
"Trazador.creaAppender()",
"TRAZADOR - CREANDO APPENDER PARA NUEVA
CATEGORIA",
e.toString());
e.printStackTrace();
return ficheroNuevo;
}}
/************************************************************
*<!-- NUEVO_LOG
*========================================================-->
* Habilita el volcado sobre un nuevo fichero de log
* para este objeto trazador (si se le especifica
* un nombre de log en "this.nombreLog").
*
* <p><b>USO:</b>
* <ul>
* <li> 1.- Creacion de Nuevo Trazador:
* <b><i> t = new Trazador(); </i></b>
* <li> 2.- Especificacion de Fichero de log:
* <b><i> t.setRutaNuevoLog("/logs/salida"); </i></b>
* <li> 3.- Especificacion de Layout del log:
* <b><i> t.setLayoutHTML(); </i></b>
* <li> 4.- Creando nuevo logger de trazado:
* <b><i> t.nuevoLog("depuracion"); </i></b>
* </ul>
*
* @param nombre Nombre del nuevo logger y nuevo appender.
* @see #confXML
* @see #nombreLog
* @see #imprimeTraza(int, String, String, String)
************************************************************/
public synchronized void nuevoLog(String nombre) {
try {
if (existeLog[0]) {
if (nombreLog!=null) {
// 1.- Creando y Configurando Nuevo Appender
//------------------------------------------
FileAppender fichero = creaAppender(nombre);
// 2.- Nuevo Appender => Nueva Categoria
//---------------------------------------
traza = Logger.getLogger(nombre);
traza.addAppender(fichero);
} else {
imprimeTraza (INFO,
"Trazador.nuevoLog()",
"TRAZADOR - CREANDO NUEVO LOG: posibles
situaciones",
" a) Deshabilitados Logs de Depuracion:
No existe Appender LOG" +
" en el fichero de configuracion
XML" +
"\n b) No se ha seteado el nombre del log
adecuadamente");
}
}
} catch (Exception e) {
imprimeTraza (ERROR,
"Trazador.nuevoLog()",
"TRAZADOR - CREANDO NUEVO LOG:",
e.toString());
e.printStackTrace();
}}
//************************************************************
//* CONFIGURACION BASICA: XML + LOGGER ROOT
//************************************************************
/************************************************************
*<!-- CONMUTA_TRAZADO
*========================================================-->
* Conmuta la salida del trazado principal, modificando
* el appender LOG.
*
* <p><b> RESTRICCIONES </b>
* <ul>
* <li> 1.- Debe Existir appender LOG en fichero XML.
* <li> 2.- Appender LOG debe estar asociado a logger
* ROOT.
* </ul>
***********************************************************/
public void conmutaTrazado() {
//------------ DECLARACIONES LOCALES ------------
FileAppender fichero = null;
//------------------ ACCIONES -------------------
try {
if (nombreLog != null) {
// 1.- Localizando Appender LOG
//------------------------------
fichero = buscaAppenderLog();
// 2.- Desviando Salida del Appender LOG
//--------------------------------------
if (fichero != null) {
imprimeTraza (DEBUG,
"Trazador.actualizaConfig()",
"TRAZADOR - SE HA ACTIVADO
UN NUEVO FICHERO DE LOG PARA TRAZADO PRINCIPAL",
"-> Nombre del Appender: "
+ fichero.getName() + "\n" +
"-> Fichero de Log: " +
nombreLog+extensionLog + "\n" +
"-> Layout del log: " +
getLayout());
fichero.setFile(nombreLog+extensionLog);
fichero.setLayout(configLayout(fichero.getLayout()));
fichero.activateOptions();
}}
} catch (Exception e) {
imprimeTraza (ERROR,
"Trazador.actualizaConfig()",
"TRAZADOR - MODIFICANDO LA CONFIGURACION
BASICA",
e.toString());
e.printStackTrace();
}}
//-------------------------------------------------
// CARGA_CONFIG_BASICA
//-------------------------------------------------
// Configura el trazador segun los parametros
// del fichero de configuracion
//-------------------------------------------------
private void cargaConfigBasica() {
//------------ DECLARACIONES LOCALES ------------
String salida = null;
boolean existe = false;
//------------------ ACCIONES -------------------
try {
existe = (new File(confXML).exists());
// 1.- Existe Fichero de Config ---> Se carga
//-------------------------------------------
if (existe) {
// 1.1.- Carga la configuracion Log4j
salida = new String (confXML);
DOMConfigurator.configure(confXML);
// 1.2.- Detecta la existencia de Logger LOG
if (existeLog==null) {
existeLog=new boolean[2];
existeLog[0] = (buscaAppenderLog()!=null);
existeLog[1] = true; // Hay XML de config
}
// 1.3.- Trazado de Depuracion
imprimeTraza (DEBUG,
"Trazador.cargaConfigBasica()",
"TRAZADOR - EXISTE FICHERO DE CONFIGURACION
",
"Cargado OK el fichero de configuracion: "
+ confXML);
// 2.- No Existe Fichero de Config ---> Config Basica
//-----------------------------------------------------
} else {
salida = new String ("Configuracion Basica");
BasicConfigurator.configure();
traza.setLevel((Level) Level.WARN);
existeLog = new boolean[1];
existeLog[0] = false; // No hay appender LOG
existeLog[1] = false; // No hay XML de config
imprimeTraza (DEBUG,
"Trazador.cargaConfigBasica()",
"TRAZADOR - NO EXISTE FICHERO DE
CONFIGURACION ",
"Se utilizara la basica: " +
" 1.- Avisos y Errores por Consola " +
" 2.- Filtrado => Debug, Info");
}
} catch (Exception e) {
imprimeTraza (ERROR,
"Trazador.cargaConfigBasica()",
"TRAZADOR - CARGANDO CONFIGURACION BASICA
DE: " + salida,
e.toString());
e.printStackTrace();
}}
/************************************************************
*<!-- CONFIGURA_TRAZADOR
*========================================================-->
* Configura el trazador segun los parametros del
* fichero de configuracion. En su defecto, adoptara
* una configuracion basica (errores por consola).
*
* @see #confXML
* @see #nombreLog
************************************************************/
public void configuraTrazador() {
// 1.- Por Defecto => Volcado sobre Root
//-------------------------------------
traza = Logger.getRootLogger();
// 2.- Configurando Trazador
//---------------------------
cargaConfigBasica();
}
//************************************************************
//* TRAZADO
//************************************************************
//-------------------------------------------------
// IMPRIME SIMPLE
//-------------------------------------------------
// Depuracion OFF ===> Formato de traza simple
//-------------------------------------------------
private void imprimeSimple(int tipo, String mensaje) {
//--------------------- ACCIONES -----------------------
try {
switch (tipo) {
case DEBUG:
traza.debug (mensaje.toLowerCase());
break;
case INFO:
traza.info (mensaje.toLowerCase());
break;
case WARN:
traza.warn (mensaje.toLowerCase());
break;
case ERROR:
traza.error (mensaje.toLowerCase());
break;
case FATAL:
traza.fatal (mensaje.toLowerCase());
break;
default:
traza.error (mensaje.toLowerCase());
}
} catch (Exception e) {
// System.out.println ==> Si se intenta imprimir y salta
excepcion
// se emplea traza normal para evitar
bucle
// de errores:
// traza.debug -> Excepcion
// traza.error -> Exception
// ...
// Toda la vida
System.out.println("\n TRAZADOR - ERROR: al imprimir traza
\n " +
"Metodo:
Trazador.imprimeDetallado() \n" +
"Descripcion:
posible error al acceder al trazador \n" +
"Volcado:" +
e.toString());
e.printStackTrace();
} catch (Error e) {
System.out.println("\n TRAZADOR - ERROR: al imprimir traza
\n " +
"Metodo: Trazador.imprimeDetallado() \n" +
"Descripcion: posible error al acceder al trazador
\n" +
"Volcado:" + e.toString());
e.printStackTrace();
}}
//-------------------------------------------------
// IMPRIME DETALLADO
//-------------------------------------------------
// Depuracion ON ===> Formato de traza detallado
//-------------------------------------------------
private void imprimeDetallado( int tipo,
String metodo,
String titulo,
String descripcion) {
//------------ DECLARACIONES LOCALES ------------
String[] mensaje = null;
try {
//--------------- INICIALIZACIONES --------------
mensaje = new String[5];
mensaje[DEBUG] = "Depurado";
mensaje[INFO] = "Informacion";
mensaje[WARN] = "Alerta";
mensaje[ERROR] = "!!! ERROR !!!";
mensaje[FATAL] = "!!! ERROR FATAL !!! => Interrumpiendo
Ejecucion";
//------------------ ACCIONES -------------------
switch (tipo) {
case DEBUG:
traza.debug ("\n----- > " + titulo + ": \n" +
metodo + ": " + mensaje[tipo] +
"\n" +
descripcion + "\n" +
"\n-------------------------------------------");
break;
case INFO:
traza.info ("\n----- > " + titulo + ": \n" +
metodo + ": " + mensaje[tipo] + "\n" +
descripcion + "\n" +
"\n-------------------------------------------");
break;
case WARN:
traza.warn ("\n----- > " + titulo + ": \n" +
metodo + ": " + mensaje[tipo] + "\n" +
descripcion + "\n" +
"\n-------------------------------------------");
break;
case ERROR:
traza.error ("\n----- > " + titulo + ": \n" +
metodo + ": " + mensaje[tipo] + "\n" +
descripcion + "\n" +
"\n-------------------------------------------");
break;
case FATAL:
traza.fatal ("\n----- > " + titulo + ": \n" +
metodo + ": " + mensaje[tipo] + "\n" +
descripcion + "\n" +
"\n-------------------------------------------");
break;
default:
traza.error ("\n----- > " + titulo + ": \n" +
metodo + ": " + mensaje[tipo] + "\n" +
descripcion + "\n" +
" ERROR EN TRAZADOR: nivel de traza
inadecuado " +
"\n-------------------------------------------");
}
} catch (Exception e) {
// System.out.println ==> Si se intenta imprimir y salta
excepcion
// se emplea traza normal para evitar
bucle
// de errores:
// traza.debug -> Excepcion
// traza.error -> Exception
// ...
// Toda la vida
System.out.println("\n TRAZADOR - ERROR: al imprimir traza
\n " +
"Metodo:
Trazador.imprimeDetallado() \n" +
"Descripcion:
posible error al acceder al trazador \n" +
"Volcado:" +
e.toString());
e.printStackTrace();
} catch (Error e) {
System.out.println("\n TRAZADOR - ERROR: al imprimir traza
\n " +
"Metodo: Trazador.imprimeDetallado() \n" +
"Descripcion: posible error al acceder al trazador
\n" +
"Volcado:" + e.toString());
e.printStackTrace();
}}
//-------------------------------------------------
// IMPRIME DETALLADO HTML
//-------------------------------------------------
// Depuracion ON ===> Formato de traza detallado
//
// Trazas adecuadas para un log HTML
//-------------------------------------------------
private void imprimeDetalladoHTML( int tipo,
String metodo,
String titulo,
String descripcion) {
try {
//------------------ ACCIONES -------------------
// 1.- Imprimiendo traza
switch (tipo) {
case DEBUG:
traza.debug (titulo + " - " + metodo +
" - DESCRIPCION:" +
descripcion );
break;
case INFO:
traza.info (titulo + " - " + metodo +
" - DESCRIPCION:" +
descripcion );
break;
case WARN:
traza.warn (titulo + " - " + metodo +
" - DESCRIPCION:" +
descripcion );
break;
case ERROR:
traza.error (titulo + " - " + metodo +
" - DESCRIPCION:" +
descripcion );
break;
case FATAL:
traza.fatal (titulo + " - " + metodo +
" - DESCRIPCION:" +
descripcion );
break;
default:
traza.error (titulo + " - " + metodo +
" - DESCRIPCION:" +
descripcion );
}
} catch (Exception e) {
// System.out.println ==> Si se intenta imprimir y salta
excepcion
// se emplea traza normal para evitar
bucle
// de errores:
// traza.debug -> Excepcion
// traza.error -> Exception
// ...
// Toda la vida
System.out.println("\n TRAZADOR - ERROR: al imprimir traza
\n " +
"Metodo:
Trazador.imprimeDetallado() \n" +
"Descripcion:
posible error al acceder al trazador \n" +
"Volcado:" +
e.toString());
e.printStackTrace();
} catch (Error e) {
System.out.println("\n TRAZADOR - ERROR: al imprimir traza
\n " +
"Metodo: Trazador.imprimeDetallado() \n" +
"Descripcion: posible error al acceder al trazador
\n" +
"Volcado:" + e.toString());
e.printStackTrace();
}}
//-------------------------------------------------
// IMPRIME DETALLADO XML
//-------------------------------------------------
// Depuracion ON ===> Formato de traza detallado
//
// Trazas adecuadas para un log XML
//-------------------------------------------------
private void imprimeDetalladoXML( int tipo,
String metodo,
String titulo,
String descripcion) {
//------------ DECLARACIONES LOCALES ------------
String[] mensaje = null;
try {
//--------------- INICIALIZACIONES --------------
mensaje = new String[5];
mensaje[DEBUG] = "Depurado";
mensaje[INFO] = "Informacion";
mensaje[WARN] = "Alerta";
mensaje[ERROR] = "!!! ERROR !!!";
mensaje[FATAL] = "!!! ERROR FATAL !!! => Interrumpiendo
Ejecucion";
//------------------ ACCIONES -------------------
switch (tipo) {
case DEBUG:
traza.debug ("\n <titulo> " + titulo +
"</titulo> \n" +
"<metodo> " + metodo +
"</metodo> \n" +
"<mensaje> " +
mensaje[tipo] + "</mensaje> \n" +
"<descripcion> " +
descripcion + "</descripcion> \n"
);
break;
case INFO:
traza.info ("\n <titulo> " + titulo +
"</titulo> \n" +
"<metodo> " + metodo +
"</metodo> \n" +
"<mensaje> " +
mensaje[tipo] + "</mensaje> \n" +
"<descripcion> " +
descripcion + "</descripcion> \n"
);
break;
case WARN:
traza.warn ("\n <titulo> " + titulo +
"</titulo> \n" +
"<metodo> " + metodo +
"</metodo> \n" +
"<mensaje> " +
mensaje[tipo] + "</mensaje> \n" +
"<descripcion> " +
descripcion + "</descripcion> \n"
);
break;
case ERROR:
traza.error ("\n <titulo> " + titulo +
"</titulo> \n" +
"<metodo> " + metodo +
"</metodo> \n" +
"<mensaje> " +
mensaje[tipo] + "</mensaje> \n" +
"<descripcion> " +
descripcion + "</descripcion> \n"
);
break;
case FATAL:
traza.fatal ("\n <titulo> " + titulo +
"</titulo> \n" +
"<metodo> " + metodo +
"</metodo> \n" +
"<mensaje> " +
mensaje[tipo] + "</mensaje> \n" +
"<descripcion> " +
descripcion + "</descripcion> \n"
);
break;
default:
traza.error ("\n <titulo> " + titulo +
"</titulo> \n" +
"<metodo> " + metodo
+ "</metodo> \n" +
"<mensaje> " +
mensaje[ERROR] + "</mensaje> \n" +
"<descripcion> ERROR
EN TRAZADOR: " +
"nivel de
traza inadecuado " +
descripcion
+ "</descripcion> \n"
);
}
} catch (Exception e) {
// System.out.println ==> Si se intenta imprimir y salta
excepcion
// se emplea traza normal para evitar
bucle
// de errores:
// traza.debug -> Excepcion
// traza.error -> Exception
// ...
// Toda la vida
System.out.println("\n TRAZADOR - ERROR: al imprimir traza
\n " +
"Metodo:
Trazador.imprimeDetallado() \n" +
"Descripcion:
posible error al acceder al trazador \n" +
"Volcado:" +
e.toString());
e.printStackTrace();
} catch (Error e) {
System.out.println("\n TRAZADOR - ERROR: al imprimir traza
\n " +
"Metodo: Trazador.imprimeDetallado() \n" +
"Descripcion: posible error al acceder al trazador
\n" +
"Volcado:" + e.toString());
e.printStackTrace();
}}
/************************************************************
*<!-- IMPRIME TRAZA
*========================================================-->
* Establece un formato unico para el trazado.
*
* <p><b> OBJETIVOS </b>
* <ul>
* <li> Copy/Paste para cada traza
* <li> Cada tipo de traza (warn, error, etc.) puede
* tener un formato distinto, mas o menos
* sofisticado, segun la necesidad.
* </ul>
*<!--=====================================================-->
* @param tipo Constante indicando el tipo de mensaje.
* Ejms.: Trazador.DEBUG, Trazador.WARN ...
* @param metodo paquete.Clase.metodo() desde donde se ha
* lanzado la traza.
* Ejm.: cliente.ClienteDatagrama.lanzar()
* @param titulo Resumen del evento.
* @param descripcion Descripcion del evento.
* Ejm.: error.toString()
*
************************************************************/
public void imprimeTraza(int tipo,
String metodo,String titulo,
String descripcion) {
//--------------------- ACCIONES -----------------------
try {
if (detalles) {
switch (layout) {
case XML:
imprimeDetalladoXML(tipo,
metodo,
titulo,
descripcion);
break;
case HTML:
imprimeDetalladoHTML(tipo,
metodo,
titulo,
descripcion);
break;
default:
imprimeDetallado(tipo,
metodo,
titulo,
descripcion);
break;
}
} else {
imprimeSimple(tipo,
titulo);
}
} catch (Exception e) {
// System.out.println ==> Si se intenta imprimir y salta
excepcion
// se emplea traza normal para evitar
bucle
// de errores:
// traza.debug -> Excepcion
// traza.error -> Exception
// ...
// Toda la vida
System.out.println("\n TRAZADOR - ERROR: al imprimir traza
\n " +
"Metodo:
Trazador.imprimeDetallado() \n" +
"Descripcion: posible error
al acceder al trazador \n" +
"Volcado:" + e.toString());
e.printStackTrace();
} catch (Error e) {
System.out.println("\n TRAZADOR - ERROR: al imprimir traza
\n " +
"Metodo: Trazador.imprimeDetallado() \n" +
"Descripcion: posible error al acceder al trazador
\n" +
"Volcado:" + e.toString());
e.printStackTrace();
}}
/************************************************************
*<!-- TRATA EXCEPCION
*========================================================-->
* Esta funcion permite manejar las excepciones, para
* hacer lo que se considere pertinente en cada caso.
* Ejm.: imprimir la pila de errores en el fichero de log
* con el formato que sea oportuno.
*<!--=====================================================-->
* @param excepcion Excepcion lanzada por la aplicacion
************************************************************/
public void trataExcepcion (Exception excepcion) {
//------------------ ACCIONES -------------------
try {
if (detalles) {excepcion.printStackTrace();}
} catch (Exception e) {
Logger.getRootLogger().error("TRAZADOR - TRATANDO EXCEPCION --
" +
"Trazador.trataExcepcion(e)" +
"\n
DESCRIPCION: " + e.toString());
trataExcepcion(e);
}}
/************************************************************
*<!-- TRATA ERROR
*========================================================-->
* Esta funcion permite manejar los errores, para
* hacer lo que se considere pertinente en cada caso.
*
* Ejm.: imprimir la pila de errores en el fichero de log
* con el formato que sea oportuno (hipervinculos
* habilitados, etc.)
*<!--=====================================================-->
* @param error Error ocasionado por la aplicacion
************************************************************/
public void trataError (Error error) {
//------------------ ACCIONES -------------------
try {
if (detalles){error.printStackTrace();}
} catch (Exception e) {
Logger.getRootLogger().error("TRAZADOR - TRATANDO ERROR -- " +
"Trazador.trataError(e)" +
"\n DESCRIPCION: " + e.toString());
trataExcepcion(e);
}}
/************************************************************
*<!-- DEBUG
*========================================================-->
* Imprime traza simple de depuracion
*<!--=====================================================-->
* @param mensaje Mensaje a imprimir
************************************************************/
public void debug (String mensaje) {
if (exhaustiva) {
traza.debug(mensaje);
}
}
/************************************************************
*<!-- INFO
*========================================================-->
* Imprime traza simple de informacion
*<!--=====================================================-->
* @param mensaje Mensaje a imprimir
************************************************************/
public void info (String mensaje) {
if (exhaustiva) {
traza.info(mensaje);
}
}
/************************************************************
*<!-- WARN
*========================================================-->
* Imprime traza simple de aviso
*<!--=====================================================-->
* @param mensaje Mensaje a imprimir
************************************************************/
public void warn (String mensaje) {
if (exhaustiva) {
traza.warn(mensaje);
}
}
/************************************************************
*<!-- ERROR
*========================================================-->
* Imprime traza simple de error
*<!--=====================================================-->
* @param mensaje Mensaje a imprimir
************************************************************/
public void error (String mensaje) {
if (exhaustiva) {
traza.error(mensaje);
}
}
/************************************************************
*<!-- FATAL
*========================================================-->
* Imprime traza simple de error fatal
*<!--=====================================================-->
* @param mensaje Mensaje a imprimir
************************************************************/
public void fatal (String mensaje) {
if (exhaustiva) {
traza.fatal(mensaje);
}
}
//***********************************************************
//* CONSTRUCTOR
//**********************************************************/
public Trazador() {
traza = Logger.getRootLogger();}
public Trazador(boolean exhaustive) {
traza = Logger.getRootLogger();
exhaustiva = exhaustive;
}
public Trazador(boolean depuraOn, boolean exhaustive) {
traza = Logger.getRootLogger();
detalles = depuraOn;
exhaustiva = exhaustive;
}
public Trazador(Trazador trazado) {
traza=trazado.getLogger();
}
public Trazador(Trazador trazado, boolean exhaustive) {
traza = trazado.getLogger();
exhaustiva = exhaustive;
}
public Trazador(Trazador trazado, boolean depuraOn, boolean exhaustive) {
traza = trazado.getLogger();
detalles = depuraOn;
exhaustiva = exhaustive;
}
}<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/";>
<!-- ========================================================= -->
<!-- SALIDAS DEL TRAZADOR -->
<!-- -->
<!-- Ojo: las referencias son usadas por la clase Trazador -->
<!-- ========================================================= -->
<!-- =================== Salida por Defecto ================== -->
<appender name="CONSOLA" class="org.apache.log4j.ConsoleAppender">
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern"
value="%d{dd MMM yyyy HH:mm:ss.SSS} [%p] [%t] [%c] - %m%n"/>
</layout>
<filter class="org.apache.log4j.varia.LevelRangeFilter">
<param name="LevelMin" value="WARN" />
<param name="LevelMax" value="FATAL" />
</filter>
</appender>
<!-- =============== Fichero de log de depuración ============= -->
<appender name="LOG" class="org.apache.log4j.FileAppender">
<param name="File" value="logs/log.txt" />
<param name="Append" value="false" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern"
value="%d{dd MMM yyyy HH:mm:ss.SSS} [%p] [%t] [%c] - %m%n"/>
</layout>
<filter class="org.apache.log4j.varia.LevelRangeFilter">
<param name="LevelMin" value="DEBUG" />
<param name="LevelMax" value="FATAL" />
</filter>
</appender>
<!-- ======================== E-MAIL ======================== -->
<!-- Para cuando haga falta (está sin probar)
<appender name="ASYNC" class="org.apache.log4j.AsyncAppender">
<appender-ref ref="MAIL"/>
</appender>
<appender name="MAIL" class="com.frontiers.server.mail.MailAppender">
<param name="Threshold" value="ERROR" />
<param name="To"
value="[EMAIL PROTECTED] ,
[EMAIL PROTECTED], [EMAIL PROTECTED]" />
<param name="Subject" value="Error from CaseServer!!" />
<param name="From" value="[EMAIL PROTECTED]" />
<param name="Location"
value="CaseServer at X company.
I.P. address: 10.1.1.44" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern"
value="%d{ISO8601} %-5p %c{1} - %m%n"/>
</layout>
</appender>
-->
<!-- ======================== RED ======================== -->
<!-- Para cuando haga falta
-->
<!-- ========================================================= -->
<!-- CONFIGURACION DEL TRAZADOR -->
<!-- ========================================================= -->
<!-- ===================== Salidas Trazado =================== -->
<root>
<priority value ="debug"/>
<appender-ref ref="CONSOLA"/>
<appender-ref ref="LOG"/>
<!-- Mail: <appender-ref ref="ASYNC"/> -->
<!-- Red: <appender-ref ref="RED"/> -->
</root>
</log4j:configuration>
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
