Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /* ************************************************************************
   #
   #  DivConq
   #
   #  http://divconq.com/
   #
   #  Copyright:
   #    Copyright 2014 eTimeline, LLC. All rights reserved.
   #
  #  License:
  #    See the license.txt file in the project's top-level directory for details.
  #
  #  Authors:
  #    * Andy White
  #
  ************************************************************************ */
  package divconq.log;
  
  
  import java.io.File;
  import java.util.Locale;
  
  
  import divconq.hub.Hub;
When logging messages to the debug log each message has a debug level. The logger has a filter level and messages of lower priority than the current debug level will not be logged. Note that 99% of the time the "current" debug level is determined by the current TaskContext. The preferred way to log messages is through the TaskContext or through an OperationResult. Ultimately a filter is used to determine what should go in the log. In fact, when you call "void error(String message, String... tags)" and other logging methods, theses methods will lookup the current task context. So it is more efficient to work directly with task context, however, occasional calls to these global logger methods are fine.

Author(s):
Andy
  
  public class Logger {
      static protected DebugLevel globalLevel = .;
  	static protected String locale = Locale.getDefault().toString();
      
      // typically task logging is handled by a service on the bus, but on occasions
      // we want it to log to the file as well, from settings change this to 'true' 
      static protected boolean toFile = true;
      static protected boolean toConsole = true;
      
      static protected PrintWriter logWriter = null;
      static protected ReentrantLock writeLock = new ReentrantLock();  
      static protected long filestart = 0;
      
      static protected ILogHandler handler = null;
      
      static protected XElement config = null;
      
      static public DebugLevel getGlobalLevel() {
          return .
      }
      
      static public void setGlobalLevel(DebugLevel v) {
          . = v
          
          // keep hub context up to date
  		OperationContext.updateHubContext();
      }
      
      static public String getLocale() {
          return .
      }
      
      static public void setLocale(String v) {
          . = v
          
          // keep hub context up to date
  		OperationContext.updateHubContext();
      }
      
     static public void setLogHandler(ILogHandler v) {
     	. = v;
     }
     
     static public void setToConsole(boolean v) {
     	. = v;
     }
   
    
Called from Hub.start this method configures the logging features.

Parameters:
config xml holding the configuration
 
     static public void init(XElement config) {
     	. = config;
     	
     	// TODO return operation result
     	
     	// TODO load levels, path etc
     	// include a setting for startup logging - if present set the TC log level directly
     	
 		Logger.startNewLogFile();
     	
 		// set by operation context init 
     	//Logger.locale = LocaleUtil.getDefaultLocale();
 		
 		// From here on we can use netty and so we need the logger setup
 		
 		InternalLoggerFactory.setDefaultFactory(new InternalLoggerFactory() {			
 			protected InternalLogger newInstance(String arg0) {
 				return Logger.getNettyLogger();
 			}
 		});
     	
     	if (. != null) {
     		// set by operation context init 
     		//if (Logger.config.hasAttribute("Level"))
     	    //	Logger.globalLevel = DebugLevel.parse(Logger.config.getAttribute("Level"));
 		
     		if (..hasAttribute("NettyLevel")) {
     			ResourceLeakDetector.setLevel(Level.valueOf(..getAttribute("NettyLevel")));
     			
     			Logger.debug("Netty Level set to: " + ResourceLeakDetector.getLevel());    			
     		}
     		else if (!"none".equals(System.getenv("dcnet"))) {
     			// TODO anything more we should do here?  maybe paranoid isn't helpful?
     		}
     		
     		// set by operation context init 
     		//if (Logger.config.hasAttribute("Locale"))
     	    //	Logger.locale = Logger.config.getAttribute("Locale");
     	}
     }
     
     static protected void startNewLogFile() {
     	try {
     		File logfile = new File("./logs/" 
 					+ DateTimeFormat.forPattern("yyyyMMdd'_'HHmmss").print(new DateTime(.))
 					+ ".log"); 
     		
     		if (!logfile.getParentFile().exists())
     			if (!logfile.getParentFile().mkdirs())
     				Logger.error("Unable to create logs folder.");
     		
     		logfile.createNewFile();
 
     		if (. != null) {
     			..flush();
     			..close();
     		}
     		
     		Logger.trace("Opening log file: " + logfile.getCanonicalPath());
     		
 			. = new PrintWriter(logfile"utf-8");
 			
 		} 
     	catch (Exception x) {
 			Logger.error("Unable to create log file: " + x);
 		}
     }
     
     /*
      *  In a distributed setup, DivConq may route logging to certain Hubs and
      *  bypass the local log file.  During shutdown logging returns to local
      *  log file so that the dcBus can shutdown and stop routing the messages.
      * @param or 
      */
     static public void stop(OperationResult or) {
     	// TODO return operation result
     	
     	. = true;		// go back to logging to file
     	
     	// TODO say no to database
     }
     
     public static InternalLogger getNettyLogger() {
 		return new NettyLogger();
     }
 
     static public boolean isDebug() {
     	OperationContext ctx = OperationContext.get();
     	
     	DebugLevel setlevel = (ctx != null) ? ctx.getLevel() : .;
     	
     	return (setlevel.getCode() >= ..getCode());
     }
 
     static public boolean isTrace() {
     	OperationContext ctx = OperationContext.get();
     	
     	DebugLevel setlevel = (ctx != null) ? ctx.getLevel() : .;
     	
     	return (setlevel.getCode() >= ..getCode());
     }
     
     /*
      * Insert a (string) message into the log
      * 
      * @param message error text
      * @param tags searchable values associated with the message, key-value pairs can be created by putting two tags adjacent
      */
     static public void error(String messageString... tags) {
     	Logger.log(OperationContext.get(), .messagetags);
     }
     
     /*
      * Insert a (string) message into the log
      * 
      * @param message warning text
      * @param tags searchable values associated with the message, key-value pairs can be created by putting two tags adjacent
      */
     static public void warn(String messageString... tags) {
     	Logger.log(OperationContext.get(), .messagetags);
     }
     
     /*
      * Insert a (string) message into the log
      * 
      * @param message info text
      * @param tags searchable values associated with the message, key-value pairs can be created by putting two tags adjacent
      */
     static public void info(String messageString... tags) {
     	Logger.log(OperationContext.get(), .messagetags);
     }
     
     /*
      * Insert a (string) message into the log
      * 
      * @param accessCode to translate
      * @param locals for the translation
      */
     static public void debug(String messageString... tags) {
     	Logger.log(OperationContext.get(), .messagetags);
     }
     
     /*
      * Insert a (string) message into the log
      * 
      * @param accessCode to translate
      * @param locals for the translation
      */
     static public void trace(String messageString... tags) {
     	Logger.log(OperationContext.get(), .messagetags);
     }
     
     /*
      * Insert a (string) message into the log
      * 
      * @param code to translate
      * @param params for the translation
      */
     static public void errorTr(long codeObject... params) {
     	Logger.log(OperationContext.get(), .codeparams);
     }
     
     /*
      * Insert a (string) message into the log
      * 
      * @param code to translate
      * @param params for the translation
      */
     static public void warnTr(long codeObject... params) {
     	Logger.log(OperationContext.get(), .codeparams);
     }
     
     /*
      * Insert a (string) message into the log
      * 
      * @param code to translate
      * @param params for the translation
      */
     static public void infoTr(long codeObject... params) {
     	Logger.log(OperationContext.get(), .codeparams);
     }
     
     /*
      * Insert a (string) message into the log
      * 
      * @param code to translate
      * @param params for the translation
      */
     static public void traceTr(long codeObject... params) {
     	Logger.log(OperationContext.get(), .codeparams);
     }
     
     /*
      * Insert a (string) translated message into the log
      * 
      * @param ctx context for log settings, null for none
      * @param level message level
      * @param code to translate
      * @param params for the translation
      */
     static public void log(OperationContext ctxDebugLevel levellong codeObject... params) {
     	Logger.log(ctxlevel, LocaleUtil.tr(."_code_" + codeparams), "Code"code + "");
     }
     
     /*
      * Insert a (string) message into the log
      * 
      * @param ctx context for log settings, null for none
      * @param level message level
      * @param message text to store in log
      * @param tags searchable values associated with the message, key-value pairs can be created by putting two tags adjacent
      */
     static public void log(OperationContext ctxDebugLevel levelString messageString... tags) {
     	DebugLevel setlevel = (ctx != null) ? ctx.getLevel() : .;
     	
     	// do not log, is being filtered
     	if (setlevel.getCode() < level.getCode())
     		return;
     	
     	Logger.logWr((ctx != null) ? ctx.getOpId() : nulllevelmessagetags);
     }
     
     /*
      * Insert a (string) translated message into the log
      * 
      * @param ctx context for log settings, null for none
      * @param level message level
      * @param code to translate
      * @param params for the translation
      */
     static public void logWr(String taskidDebugLevel levellong codeObject... params) {
     	Logger.logWr(taskidlevel, LocaleUtil.tr(."_code_" + codeparams), "Code"code + "");
     }
     
     /*
      * don't check, just write
      *  
      * @param taskid
      * @param level
      * @param message
      * @param tags
      */
     static public void logWr(String taskidDebugLevel levelString messageString... tags) {
     	String indicate = "M" + level.getIndicator();
     	
 		/* TODO
     	if (Logger.toDatabase) {
 			Message lmsg = new Message("Logger");
 			lmsg.addHeader("Op", "Log");
 			lmsg.addHeader("Indicator", indicate);
 			lmsg.addHeader("Occurred", occur);
 			lmsg.addHeader("Tags", tagvalue);			
 			lmsg.addStringAttachment(message);
 	        Hub.instance.getBus().sendMessage(lmsg);
     	}
     	*/
 
     	// write to file if not a Task or if File Tasks is flagged
     	if (. || .) {
     		if (message != null)
     			message = message.replace("\n""\n\t");		// tab sub-lines
 	
 	        Logger.write(taskidindicatemessagetags);
     	}
     }
 
     /*
      * Insert a chunk of hex encoded memory into the log
      * 
      * @param ctx context for log settings, null for none
      * @param level message level
      * @param data memory to hex encode and store
      * @param tags searchable values associated with the message, key-value pairs can be created by putting two tags adjacent
      */
     static public void log(OperationContext ctxDebugLevel levelMemory dataString... tags) {
     	DebugLevel setlevel = (ctx != null) ? ctx.getLevel() : .;
     	
     	// do not log, is being filtered
     	if (setlevel.getCode() < level.getCode())
     		return;
     	
     	String indicate = "H" + level.getIndicator();
     	
 		/* TODO
     	if (tc != null) {
 			Message lmsg = new Message("Logger");
 			lmsg.addHeader("Op", "Log");
 			lmsg.addHeader("Indicator", indicate);
 			lmsg.addHeader("Occurred", occur);
 			lmsg.addHeader("Tags", tagvalue);			
 			lmsg.addAttachment(data);
 	        Hub.instance.getBus().sendMessage(lmsg);
     	}
     	*/
 
     	// write to file if not a Task or if File Tasks is flagged
     	if (. || .
 	        Logger.write((ctx != null) ? ctx.getOpId() : nullindicate, HexUtil.bufferToHex(data), tags);
     }
 
     /*
      * A boundary delineates in section of a task log from another, making it
      * easier for a log viewer to organize the content.  Boundary's are treated
      * like "info" messages, if only errors or warnings are being logged then 
      * the boundary entry will be skipped.
      *  
      * @param ctx context for log settings, null for none
      * @param tags searchable values associated with the message, key-value pairs can be created by putting two tags adjacent
      */
     static public void boundary(OperationContext ctxString... tags) {
     	DebugLevel setlevel = (ctx != null) ? ctx.getLevel() : .;
     	
     	// do not log, is being filtered
     	if (setlevel.getCode() < ..getCode())
     		return;
     	
     	Logger.boundaryWr((ctx != null) ? ctx.getOpId() : nulltags);
     }
     
     /*
      * Don't check, just write 
      * 
      * @param taskid
      * @param tags
      */
     static public void boundaryWr(String taskidString... tags) {
 		/* TODO
     	if (tc != null) {
 			Message lmsg = new Message("Logger");
 			lmsg.addHeader("Op", "Log");
 			lmsg.addHeader("Indicator", "B");
 			lmsg.addHeader("Occurred", occur);
 			lmsg.addHeader("Tags", tagvalue);			
 	        Hub.instance.getBus().sendMessage(lmsg);
     	}
     	*/
 
     	// write to file if not a Task or if File Tasks is flagged
     	if (. || .
 	        Logger.write(taskid"B  """tags);
     }
     
     static protected void write(String taskidString indicatorString messageString... tags) {
     	if (taskid == null)
     		taskid = "00000_19700101T000000000Z_000000000000000";
     	
     	DateTime occur = new DateTime(.);
     	String tagvalue = "";
     	
 		if ((tags != null) && tags.length > 0) {
 	        tagvalue = "|";
 	
 	        for (String tag : tags
 	        	tagvalue += tag + "|";
 		}
     	
 		if (. != null)
 			..write(occur.toString(), taskidindicatortagvaluemessage);
 		
 		if (tagvalue.length() > 0)
 			tagvalue += " ";
 		
         Logger.write(occur  + " " + taskid + " " + indicator + " " + tagvalue +  message);
     }
     
     static protected void write(String msg) {
     	if (.)
     		..println(msg);
     	
     	if (!. || (. == null))
     		return;
     	
     	..lock();
     	
     	// start a new log file every 24 hours
     	if (System.currentTimeMillis() - . > 86400000)
     		Logger.startNewLogFile();
     	
         try {
         	..println(msg);
         	..flush();
         }
         catch (Exception x) {
             // ignore, logger is broken  
         }
         
         ..unlock();
     }
     
     static public class NettyLogger extends AbstractInternalLogger {
     	/*
 		 * 
 		 */
 		private static final long serialVersionUID = 8748850640482801893L;
 
 		public NettyLogger() {
     		super("dcLogger");
     	}
     	
 
         /*
          * Is this logger instance enabled for the FINEST level?
          *
          * @return True if this Logger is enabled for level FINEST, false otherwise.
          */
         @Override
         public boolean isTraceEnabled() {
             return ..getCode() <= ..getCode();
         }
 
         /*
          * Log a message object at level FINEST.
          *
          * @param msg
          *          - the message object to be logged
          */
         @Override
         public void trace(String msg) {
         	Logger.trace(msg"Netty");
         }
 
         /*
          * Log a message at level FINEST according to the specified format and
          * argument.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for level FINEST.
          * </p>
          *
          * @param format
          *          the format string
          * @param arg
          *          the argument
          */
         @Override
         public void trace(String formatObject arg) {
                 FormattingTuple ft = MessageFormatter.format(formatarg);
             	Logger.trace(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log a message at level FINEST according to the specified format and
          * arguments.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the FINEST level.
          * </p>
          *
          * @param format
          *          the format string
          * @param argA
          *          the first argument
          * @param argB
          *          the second argument
          */
         @Override
         public void trace(String formatObject argAObject argB) {
                 FormattingTuple ft = MessageFormatter.format(formatargAargB);
             	Logger.trace(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log a message at level FINEST according to the specified format and
          * arguments.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the FINEST level.
          * </p>
          *
          * @param format
          *          the format string
          * @param argArray
          *          an array of arguments
          */
         @Override
         public void trace(String formatObject... argArray) {
                 FormattingTuple ft = MessageFormatter.arrayFormat(formatargArray);
             	Logger.trace(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log an exception (throwable) at level FINEST with an accompanying message.
          *
          * @param msg
          *          the message accompanying the exception
          * @param t
          *          the exception (throwable) to log
          */
         @Override
         public void trace(String msgThrowable t) {
         	Logger.trace(msg + " - " + t);
         }
 
         /*
          * Is this logger instance enabled for the FINE level?
          *
          * @return True if this Logger is enabled for level FINE, false otherwise.
          */
         @Override
         public boolean isDebugEnabled() {
             return ..getCode() <= ..getCode();
         }
 
         /*
          * Log a message object at level FINE.
          *
          * @param msg
          *          - the message object to be logged
          */
         @Override
         public void debug(String msg) {
         	Logger.debug(msg"Netty");
         }
 
         /*
          * Log a message at level FINE according to the specified format and argument.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for level FINE.
          * </p>
          *
          * @param format
          *          the format string
          * @param arg
          *          the argument
          */
         @Override
         public void debug(String formatObject arg) {
                 FormattingTuple ft = MessageFormatter.format(formatarg);
                 this.debug(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log a message at level FINE according to the specified format and
          * arguments.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the FINE level.
          * </p>
          *
          * @param format
          *          the format string
          * @param argA
          *          the first argument
          * @param argB
          *          the second argument
          */
         @Override
         public void debug(String formatObject argAObject argB) {
                 FormattingTuple ft = MessageFormatter.format(formatargAargB);
                 this.debug(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log a message at level FINE according to the specified format and
          * arguments.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the FINE level.
          * </p>
          *
          * @param format
          *          the format string
          * @param argArray
          *          an array of arguments
          */
         @Override
         public void debug(String formatObject... argArray) {
                 FormattingTuple ft = MessageFormatter.arrayFormat(formatargArray);
                 this.debug(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log an exception (throwable) at level FINE with an accompanying message.
          *
          * @param msg
          *          the message accompanying the exception
          * @param t
          *          the exception (throwable) to log
          */
         @Override
         public void debug(String msgThrowable t) {
         	this.debug(msg + " - " + t);
         }
 
         /*
          * Is this logger instance enabled for the INFO level?
          *
          * @return True if this Logger is enabled for the INFO level, false otherwise.
          */
         @Override
         public boolean isInfoEnabled() {
             return ..getCode() <= ..getCode();
         }
 
         /*
          * Log a message object at the INFO level.
          *
          * @param msg
          *          - the message object to be logged
          */
         @Override
         public void info(String msg) {
         	Logger.info(msg"Netty");
         }
 
         /*
          * Log a message at level INFO according to the specified format and argument.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the INFO level.
          * </p>
          *
          * @param format
          *          the format string
          * @param arg
          *          the argument
          */
         @Override
         public void info(String formatObject arg) {
                 FormattingTuple ft = MessageFormatter.format(formatarg);
                 this.info(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log a message at the INFO level according to the specified format and
          * arguments.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the INFO level.
          * </p>
          *
          * @param format
          *          the format string
          * @param argA
          *          the first argument
          * @param argB
          *          the second argument
          */
         @Override
         public void info(String formatObject argAObject argB) {
                 FormattingTuple ft = MessageFormatter.format(formatargAargB);
                 this.info(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log a message at level INFO according to the specified format and
          * arguments.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the INFO level.
          * </p>
          *
          * @param format
          *          the format string
          * @param argArray
          *          an array of arguments
          */
         @Override
         public void info(String formatObject... argArray) {
                 FormattingTuple ft = MessageFormatter.arrayFormat(formatargArray);
                 this.info(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log an exception (throwable) at the INFO level with an accompanying
          * message.
          *
          * @param msg
          *          the message accompanying the exception
          * @param t
          *          the exception (throwable) to log
          */
         @Override
         public void info(String msgThrowable t) {
         	this.info(msg + " - " + t);
         }
 
         /*
          * Is this logger instance enabled for the WARNING level?
          *
          * @return True if this Logger is enabled for the WARNING level, false
          *         otherwise.
          */
         @Override
         public boolean isWarnEnabled() {
             return ..getCode() <= ..getCode();
         }
 
         /*
          * Log a message object at the WARNING level.
          *
          * @param msg
          *          - the message object to be logged
          */
         @Override
         public void warn(String msg) {
     		..getCountManager().countObjects("nettyWarn"msg);
     		
         	Logger.warn(msg"Netty");
         }
 
         /*
          * Log a message at the WARNING level according to the specified format and
          * argument.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the WARNING level.
          * </p>
          *
          * @param format
          *          the format string
          * @param arg
          *          the argument
          */
         @Override
         public void warn(String formatObject arg) {
                 FormattingTuple ft = MessageFormatter.format(formatarg);
                 this.warn(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log a message at the WARNING level according to the specified format and
          * arguments.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the WARNING level.
          * </p>
          *
          * @param format
          *          the format string
          * @param argA
          *          the first argument
          * @param argB
          *          the second argument
          */
         @Override
         public void warn(String formatObject argAObject argB) {
                 FormattingTuple ft = MessageFormatter.format(formatargAargB);
                 this.warn(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log a message at level WARNING according to the specified format and
          * arguments.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the WARNING level.
          * </p>
          *
          * @param format
          *          the format string
          * @param argArray
          *          an array of arguments
          */
         @Override
         public void warn(String formatObject... argArray) {
                 FormattingTuple ft = MessageFormatter.arrayFormat(formatargArray);
                 this.warn(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log an exception (throwable) at the WARNING level with an accompanying
          * message.
          *
          * @param msg
          *          the message accompanying the exception
          * @param t
          *          the exception (throwable) to log
          */
         @Override
         public void warn(String msgThrowable t) {
         	this.warn(msg + " - " + t);
         }
 
         /*
          * Is this logger instance enabled for level SEVERE?
          *
          * @return True if this Logger is enabled for level SEVERE, false otherwise.
          */
         @Override
         public boolean isErrorEnabled() {
             return ..getCode() <= ..getCode();
         }
 
         /*
          * Log a message object at the SEVERE level.
          *
          * @param msg
          *          - the message object to be logged
          */
         @Override
         public void error(String msg) {
     		..getCountManager().countObjects("nettyError"msg);
     		
     		if (msg.contains("LEAK:"))
         		..getCountManager().countObjects("nettyLeakError"msg);
         	
         	Logger.error(msg"Netty");
         }
 
         /*
          * Log a message at the SEVERE level according to the specified format and
          * argument.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the SEVERE level.
          * </p>
          *
          * @param format
          *          the format string
          * @param arg
          *          the argument
          */
         @Override
         public void error(String formatObject arg) {
             FormattingTuple ft = MessageFormatter.format(formatarg);
             this.error(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log a message at the SEVERE level according to the specified format and
          * arguments.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the SEVERE level.
          * </p>
          *
          * @param format
          *          the format string
          * @param argA
          *          the first argument
          * @param argB
          *          the second argument
          */
         @Override
         public void error(String formatObject argAObject argB) {
             FormattingTuple ft = MessageFormatter.format(formatargAargB);
             this.error(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log a message at level SEVERE according to the specified format and
          * arguments.
          *
          * <p>
          * This form avoids superfluous object creation when the logger is disabled
          * for the SEVERE level.
          * </p>
          *
          * @param format
          *          the format string
          * @param arguments
          *          an array of arguments
          */
         @Override
         public void error(String formatObject... arguments) {
             FormattingTuple ft = MessageFormatter.arrayFormat(formatarguments);
             this.error(ft.getMessage() + " - " + ft.getThrowable());
         }
 
         /*
          * Log an exception (throwable) at the SEVERE level with an accompanying
          * message.
          *
          * @param msg
          *          the message accompanying the exception
          * @param t
          *          the exception (throwable) to log
          */
         @Override
        public void error(String msgThrowable t) {
        	this.error(msg + " - " + t);
        }
   }
New to GrepCode? Check out our FAQ X