/*************************************************************
Copyright(c) 2008 Kaesar ALNIJRES
How to use java.util.logging
Editor Templates are provided for all these steps and more :)
Just type log and CTRL+SPACE Bar
**************************************************************
1-Get a logger
//After class declaration
private static Logger logger=Logger.getLogger("loggerName");
//or in a method
Logger logger=Logger.getLogger("loggerName");
2-Define a handler (if needed). Defaults ConsoleHandler
//FileHandler
try {
FileHandler fh=new FileHandler();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
//ConsoleHandler
ConsoleHandler ch=new ConsoleHandler();
3-Attach Handler(s) to logger (if needed). Defaults ConsoleHandler
logger.addHandler(ch);
4-Set levels for logger and handler (if needed). Defaults Logger : INFO, ConsoleHandler : INFO, FileHandler : ALL
logger.setLevel(Level.FINE);
handler.setLevel(Level.FINE);
5-SetFormatter for a handler if needed. Defaults ConsoleHandler : SimpleFormatter, FileHandler : XMLFormatter
6-You can use customized formatter if you like to
7-Use logger to output messages
//simple message
logger.fine("msg");
//message with level
logger.log(logger.log(Level.SEVERE,"Error");
//message with level and arguments
logger.log(Level.INFO,"Hello, {0}","World");
//logging method entring and exiting
//entering
logger.entering(SimpleLogger.class.getName(), "readFile",new Object[]{fichier,append});
//exiting
logger.exiting(SimpleLogger.class.getName(), "readFile", s);
*//*************************************************************
Copyright(c) 2008 Kaesar ALNIJRES
How to use java.util.logging
Editor Templates are provided for all these steps and more :)
Just type log and CTRL+SPACE Bar
**************************************************************
1-Get a logger
//After class declaration
private static Logger logger=Logger.getLogger("loggerName");
//or in a method
Logger logger=Logger.getLogger("loggerName");
2-Define a handler (if needed). Defaults ConsoleHandler
//FileHandler
try {
FileHandler fh=new FileHandler();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
//ConsoleHandler
ConsoleHandler ch=new ConsoleHandler();
3-Attach Handler(s) to logger (if needed). Defaults ConsoleHandler
logger.addHandler(ch);
4-Set levels for logger and handler (if needed). Defaults Logger : INFO, ConsoleHandler : INFO, FileHandler : ALL
logger.setLevel(Level.FINE);
handler.setLevel(Level.FINE);
5-SetFormatter for a handler if needed. Defaults ConsoleHandler : SimpleFormatter, FileHandler : XMLFormatter
6-You can use customized formatter if you like to
7-Use logger to output messages
//simple message
logger.fine("msg");
//message with level
logger.log(logger.log(Level.SEVERE,"Error");
//message with level and arguments
logger.log(Level.INFO,"Hello, {0}","World");
//logging method entring and exiting
//entering
logger.entering(SimpleLogger.class.getName(), "readFile",new Object[]{fichier,append});
//exiting
logger.exiting(SimpleLogger.class.getName(), "readFile", s);
*///log conditional log
// Check if the message will be logged
if(${logger:var(java.util.logging.Logger)}.isLoggable(Level.${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)}) )
${logger}.log(Level.${level},"${msg}");
${:import(java.util.logging.Logger,java.util.logging.Level,java.util.logging.SimpleFormatter,java.util.logging.XMLFormatter,java.util.logging.Formatter,java.util.logging.ConsoleHandler
)}
ConsoleHandler ${consoleHandler:newName(java.util.logging.ConsoleHandler)}=new ConsoleHandler();
//if needed. Defaults SimpleFormatter
${consoleHandler}.setFormatter(new ${}${formatter:link(SimpleFormatter,XMLFormatter)}());
${logger:var(java.util.logging.Logger)}.addHandler(${consoleHandler});
//set level for logger.Defaults INFO
${logger}.setLevel(Level.${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)});
//set level for ConsoleHandler.Defaults INFO
${consoleHandler}.setLevel(Level.${level2:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)});
${cursor}//You can put any information you like in the String returned by format
${:import(java.util.logging.LogRecord)};
${hadler:var(java.util.logging.Handler)}.setFormatter(new Formatter (){
public String format(LogRecord record) {
return
"Customized Formatter"+'\n'+
"====================="+'\n'+
"Level : " + record.getLevel() + '\n' +
"LoggerName : " + record.getLoggerName() + '\n' +
"Message : " + record.getMessage() + '\n'+
"Class : " + record.getSourceClassName() + '\n' +
"Method : " + record.getSourceMethodName()+"\n\n";
//add what else in your log message...
}});${:import(java.util.logging.FileHandler,java.util.logging.Logger,java.util.logging.Level,java.io.IOException,java.util.logging.SimpleFormatter,java.util.logging.XMLFormatter,java.util.logging.Formatter,java.util.logging.ConsoleHandler
)}
FileHandler ${fileHandler:newName(java.util.logging.FileHandler)}=null;
try {
//50000 bytes limit and 3 files (count) for rotation
${fileHandler}=new FileHandler("%${dirVar:link(h,t)}${fileName}%${rotationVar:link(g,u)}.${log}",50000,3);
//if needed. Defaults XMLFormatter
${fileHandler}.setFormatter(new ${}${formatter:link(SimpleFormatter,XMLFormatter)}());
${logger:var(java.util.logging.Logger)}.addHandler(${fileHandler});
} catch (SecurityException e) {
${logger}.log(Level.${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)},"Exception is launched {0}",${exception_variable_name}.getMessage());
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
${cursor}//GetLogger
//after class declaration
${:import(java.util.logging.Logger)}
private static Logger ${logger:newName(java.util.logging.Logger)}=Logger.getLogger(${enclosing_type}.class.getName());
//in a method
${:import(java.util.logging.Logger)}
Logger ${logger:newName(java.util.logging.Logger)}=Logger.getLogger(${enclosing_type}.class.getName());//GetLogger
//In a method
/* Note : when you want to log localized messages use logger.fine("key_defiend_in_resourceBundle") or logger.log(Level.level,"key_defined_in_resourceBundle");*/
${:import(java.util.logging.Logger)}
Logger ${logger:newName(java.util.logging.Logger)}=Logger.getLogger(${enclosing_type}.class.getName(),"${enclosing_package}.${resourceBundleName}");//GetLogger
//after class declaration
/* Note : when you want to log localized messages use logger.fine("key_defiend_in_resourceBundle") or logger.log(Level.level,"key_defined_in_resourceBundle");*/
${:import(java.util.logging.Logger)}
private static Logger ${logger:newName(java.util.logging.Logger)}=Logger.getLogger(${enclosing_type}.class.getName(),"${enclosing_package}.${resourceBundleName}");
//Get information TAB to select
${logger:var(java.util.logging.Logger)}.get${methode:link(Handlers,
Name,
Parent,
ResourceBundle,
ResourceBundleName,
UseParentHandlers)
}(); //output message with logp, precise class and method names
${logger:var(java.util.logging.Logger)}.logp(Level.${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)}, "${enclosing_type}", "${enclosing_method}", "${msg}");//output message with level
${logger:var(java.util.logging.Logger)}.log(Level.${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)},"${msg}");
//output message with level and arguments
${logger:var(java.util.logging.Logger)}.log(Level.${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)},"${msg} {0}","${arg0}");//output simple message
${logger:var(java.util.logging.Logger)}.${level:link(severe,warning,info,config,fine,finer,finest)}("${msg}");
//output entering a method
${logger:var(java.util.logging.Logger)}.entering(${enclosing_type}.class.getName(), "${enclosing_method}",new Object[]{${enclosing_method_arguments}});${logger:var(java.util.logging.Logger)}.log(Level.${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)},"${msg}${}{0}",${exception_variable_name}.getMessage());${logger:var(java.util.logging.Logger)}.exiting(${enclosing_type}.class.getName(), "${enclosing_method}");
${cursor}//set all messages off
${:import (java.util.logging.Level)};
${logger:var(java.util.logging.Logger)}.setLevel(Level.OFF);${logger:var(java.util.logging.Logger)}.setLevel(Level.${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)});${:import(java.util.logging.LogManager)}
LogManager ${lm:newName(java.util.logging.LogManager)} = LogManager.getLogManager();
System.out.println("${property} = "+${lm}.getProperty("${property:link(java.util.logging.FileHandler.pattern,java.util.logging.FileHandler.limit,java.util.logging.FileHandler.count,java.util.logging.FileHandler.level,
java.util.logging.FileHandler.formatter,java.util.logging.FileHandler.append,java.util.logging.ConsoleHandler.level,
java.util.logging.ConsoleHandler.formatter)}") );/* Informations about all the logging system
*/
${:import(java.util.logging.LogManager,java.util.logging.Logger,java.util.logging.Handler,java.util.Enumeration)}
LogManager ${lm:newName(LogManager)} = LogManager.getLogManager();
Enumeration<String> ${allLoggersNames:newName('Enumeration<String>')} = ${lm}.getLoggerNames();
System.out.println("***Informations***");
// For each logger: show name, level, handlers etc.
while (${allLoggersNames}.hasMoreElements()) {
String ${loggerName:newName(String)} = ${allLoggersNames}.nextElement();
Logger ${logger4Informations:newName(Logger)} = ${lm}.getLogger(${loggerName});
System.out.println("-----------------------");
System.out.println("Name : ["+${loggerName}+"]");
Level level= ${logger4Informations}.getLevel();
System.out.print("Level : ");
//level not defined so search parent(s) level
if(level == null)
{
Logger p=${logger4Informations}.getParent();
while(p.getLevel()==null)
{
p=p.getParent();
}
String stringParent=p.getName().equals("") ? "Root" : p.getName();
System.out.println(p.getLevel() + " inherited from "
+ stringParent);
}
else
System.out.println(""+level);
Logger parent = ${logger4Informations}.getParent();
System.out.print("Parent : ");
//test parent
if (parent == null)
System.out.println("Root has no parent");
else if(parent.getName().equals(""))
System.out.println("Root");
else
System.out.println(""+parent.getName());
System.out.println("Filter : "+${logger4Informations}.getFilter() );
System.out.println("ResourceBundle : "+${logger4Informations}.getResourceBundle());
System.out.println("ResourceBundle Name: "+${logger4Informations}.getResourceBundleName() );
System.out.println("Logger uses parent handler : "+${logger4Informations}.getUseParentHandlers() );
//get all handlers of logger and it's parent
// Les handlers du logger
Handler[] handlers = ${logger4Informations}.getHandlers();
for(Handler handler: handlers)
{
System.out.println("Handler : "+handler.getClass().getName() );
System.out.println("level par le handler: " + handler.getLevel());
}
}//Put class, method and resource bundle names, use key from resource bundle (key has argument this will be replaced by ${arg0}
${logger:var(java.util.logging.Logger)}.logrb(Level.${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)},"${enclosing_type}","${enclosing_method}","${resourceBundleName}","${msg}","${arg0}");
//Put class, method and resource bundle names, use key from resource bundle
${logger:var(java.util.logging.Logger)}.logrb(Level.${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)},"${enclosing_type}","${enclosing_method}","${resourceBundleName}","${msg}");
/* Reinitialize the logging properties and reread the logging configuration
*/
${:import(java.util.logging.LogManager)}
LogManager ${lm:newName(java.util.logging.LogManager)} = LogManager.getLogManager();
try{
${lm}.readConfiguration();
}
catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}/* Reinitialize the logging properties from a file
*/
${:import(java.util.logging.LogManager,java.io.File,java.io.FileInputStream,java.io.FileNotFoundException,java.io.IOException)}
LogManager ${lm:newName(LogManager)} = LogManager.getLogManager();
FileInputStream ${file:newName(FileInputStream)}=null;
try {
${file} = new FileInputStream(new File("fileName"));
${lm}.readConfiguration(${file});
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
if(${file} != null)
try {
${file}.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/* Rest all logging system properties :
-Close and remove all handlers
-Set all logger's level to null except root
-Set root's level to INFO
*/
${:import(java.util.logging.LogManager)}
LogManager ${lm:newName(java.util.logging.LogManager)} = LogManager.getLogManager();
${lm}.reset();${:import(java.io.BufferedWriter,java.io.FileWriter,java.io.IOException)}
BufferedWriter out=null;
try {
out = new BufferedWriter(new FileWriter("${propertiesFilename}"));
StringBuffer buffer=new StringBuffer();
buffer.append("############################################################\n");
buffer.append("# Custom Logging Configuration File \n");
buffer.append("# \n");
buffer.append("# You can use this file (thisFile) by invoking : \n");
buffer.append("# java -Djava.util.logging.config.file=thisFile \n");
buffer.append("# \n");
buffer.append("# In Eclipse : Right click on a file name -> Run As -> \n");
buffer.append("# Run configurations -> click on Arguments tab -> Enter in VM Arguments:\n");
buffer.append("# -Djava.util.logging.config.file=thisFile \n");
buffer.append("############################################################\n");
buffer.append("\n");
buffer.append("handlers= ${handler:link(java.util.logging.FileHandler, java.util.logging.ConsoleHandler)}\n");
buffer.append("#Default gloable logging level\n");
buffer.append(".level= ${level:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)} \n");
buffer.append("\n");
buffer.append("############################################################\n");
buffer.append("# Handler specific properties.\n");
buffer.append("# Describes specific configuration info for Handlers.\n");
buffer.append("############################################################\n");
buffer.append("\n");
buffer.append("# default file output is in user's home directory.\n");
buffer.append("# \"/\" the local pathname separator\n");
buffer.append("# \"%t\" the system temporary directory\n");
buffer.append("# \"%h\" the value of the \"user.home\" system property\n");
buffer.append("# \"%g\" the generation number to distinguish rotated logs\n");
buffer.append("# \"%u\" a unique number to resolve conflicts\n");
buffer.append("\n");
buffer.append("java.util.logging.FileHandler.pattern = %${dirVar:link(h,t)}/${fileName}%${rotationVar:link(g,u)}.${log}\n");
buffer.append("#Limit is in bytes - zero means no limit\n");
buffer.append("java.util.logging.FileHandler.limit = ${50000}\n");
buffer.append("# How many files for rotation\n");
buffer.append("java.util.logging.FileHandler.count = ${1}\n");
buffer.append("java.util.logging.FileHandler.formatter = java.util.logging.${fhformatter:link(SimpleFormatter,XMLFormatter,CustomFormatter_must_be_defined_before)}\n");
buffer.append("#(defaults to Level.ALL).\n");
buffer.append("java.util.logging.FileHandler.level=${fhlevel:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)}\n");
buffer.append("\n");
buffer.append("# Send several log applications to one file\n");
buffer.append("java.util.logging.FileHandler.append = ${appendValue:link(true,false)}\n");
buffer.append("\n");
buffer.append("#Defaults for Console Handler INFO and SimpleFormater\n");
buffer.append("java.util.logging.ConsoleHandler.level = ${chlevel:link(SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST)}\n");
buffer.append("java.util.logging.ConsoleHandler.formatter = java.util.logging.${chformatter:link(SimpleFormatter,XMLFormatter,CustomFormatter_must_be_defined_before)}\n");
out.write(buffer.toString() );
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
if(out != null)
try {
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}//To use or not parent(s) handler. Defaults true
${logger:var(java.util.logging.Logger)}.setUseParentHandlers(${useParentHandlers:link(true,false)} );