Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package divconq.log.netty;
  
  import divconq.hub.Hub;
  import divconq.log.Logger;
  
 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 Logger.getGlobalLevel().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 Logger.getGlobalLevel().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 Logger.getGlobalLevel().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 Logger.getGlobalLevel().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 Logger.getGlobalLevel().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