io.netty.util.internal.logging.JdkLogger Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
/**
* Copyright (c) 2004-2011 QOS.ch
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
package io.netty.util.internal.logging;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
/**
* java.util.logging
* logger.
*/
class JdkLogger extends AbstractInternalLogger {
private static final long serialVersionUID = -1767272577989225979L;
final transient Logger logger;
JdkLogger(Logger logger) {
super(logger.getName());
this.logger = logger;
}
/**
* 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.isLoggable(Level.FINEST);
}
/**
* Log a message object at level FINEST.
*
* @param msg
* - the message object to be logged
*/
@Override
public void trace(String msg) {
if (logger.isLoggable(Level.FINEST)) {
log(SELF, Level.FINEST, msg, null);
}
}
/**
* Log a message at level FINEST according to the specified format and
* argument.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for level FINEST.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
@Override
public void trace(String format, Object arg) {
if (logger.isLoggable(Level.FINEST)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
log(SELF, Level.FINEST, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level FINEST according to the specified format and
* arguments.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the FINEST level.
*
*
* @param format
* the format string
* @param argA
* the first argument
* @param argB
* the second argument
*/
@Override
public void trace(String format, Object argA, Object argB) {
if (logger.isLoggable(Level.FINEST)) {
FormattingTuple ft = MessageFormatter.format(format, argA, argB);
log(SELF, Level.FINEST, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level FINEST according to the specified format and
* arguments.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the FINEST level.
*
*
* @param format
* the format string
* @param argArray
* an array of arguments
*/
@Override
public void trace(String format, Object... argArray) {
if (logger.isLoggable(Level.FINEST)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
log(SELF, Level.FINEST, 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 msg, Throwable t) {
if (logger.isLoggable(Level.FINEST)) {
log(SELF, Level.FINEST, 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.isLoggable(Level.FINE);
}
/**
* Log a message object at level FINE.
*
* @param msg
* - the message object to be logged
*/
@Override
public void debug(String msg) {
if (logger.isLoggable(Level.FINE)) {
log(SELF, Level.FINE, msg, null);
}
}
/**
* Log a message at level FINE according to the specified format and argument.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for level FINE.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
@Override
public void debug(String format, Object arg) {
if (logger.isLoggable(Level.FINE)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
log(SELF, Level.FINE, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level FINE according to the specified format and
* arguments.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the FINE level.
*
*
* @param format
* the format string
* @param argA
* the first argument
* @param argB
* the second argument
*/
@Override
public void debug(String format, Object argA, Object argB) {
if (logger.isLoggable(Level.FINE)) {
FormattingTuple ft = MessageFormatter.format(format, argA, argB);
log(SELF, Level.FINE, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level FINE according to the specified format and
* arguments.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the FINE level.
*
*
* @param format
* the format string
* @param argArray
* an array of arguments
*/
@Override
public void debug(String format, Object... argArray) {
if (logger.isLoggable(Level.FINE)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
log(SELF, Level.FINE, 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 msg, Throwable t) {
if (logger.isLoggable(Level.FINE)) {
log(SELF, Level.FINE, 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.isLoggable(Level.INFO);
}
/**
* Log a message object at the INFO level.
*
* @param msg
* - the message object to be logged
*/
@Override
public void info(String msg) {
if (logger.isLoggable(Level.INFO)) {
log(SELF, Level.INFO, msg, null);
}
}
/**
* Log a message at level INFO according to the specified format and argument.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the INFO level.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
@Override
public void info(String format, Object arg) {
if (logger.isLoggable(Level.INFO)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
log(SELF, Level.INFO, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at the INFO level according to the specified format and
* arguments.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the INFO level.
*
*
* @param format
* the format string
* @param argA
* the first argument
* @param argB
* the second argument
*/
@Override
public void info(String format, Object argA, Object argB) {
if (logger.isLoggable(Level.INFO)) {
FormattingTuple ft = MessageFormatter.format(format, argA, argB);
log(SELF, Level.INFO, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level INFO according to the specified format and
* arguments.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the INFO level.
*
*
* @param format
* the format string
* @param argArray
* an array of arguments
*/
@Override
public void info(String format, Object... argArray) {
if (logger.isLoggable(Level.INFO)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
log(SELF, Level.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 msg, Throwable t) {
if (logger.isLoggable(Level.INFO)) {
log(SELF, Level.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.isLoggable(Level.WARNING);
}
/**
* Log a message object at the WARNING level.
*
* @param msg
* - the message object to be logged
*/
@Override
public void warn(String msg) {
if (logger.isLoggable(Level.WARNING)) {
log(SELF, Level.WARNING, msg, null);
}
}
/**
* Log a message at the WARNING level according to the specified format and
* argument.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the WARNING level.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
@Override
public void warn(String format, Object arg) {
if (logger.isLoggable(Level.WARNING)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
log(SELF, Level.WARNING, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at the WARNING level according to the specified format and
* arguments.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the WARNING level.
*
*
* @param format
* the format string
* @param argA
* the first argument
* @param argB
* the second argument
*/
@Override
public void warn(String format, Object argA, Object argB) {
if (logger.isLoggable(Level.WARNING)) {
FormattingTuple ft = MessageFormatter.format(format, argA, argB);
log(SELF, Level.WARNING, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level WARNING according to the specified format and
* arguments.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the WARNING level.
*
*
* @param format
* the format string
* @param argArray
* an array of arguments
*/
@Override
public void warn(String format, Object... argArray) {
if (logger.isLoggable(Level.WARNING)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
log(SELF, Level.WARNING, 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 msg, Throwable t) {
if (logger.isLoggable(Level.WARNING)) {
log(SELF, Level.WARNING, 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.isLoggable(Level.SEVERE);
}
/**
* Log a message object at the SEVERE level.
*
* @param msg
* - the message object to be logged
*/
@Override
public void error(String msg) {
if (logger.isLoggable(Level.SEVERE)) {
log(SELF, Level.SEVERE, msg, null);
}
}
/**
* Log a message at the SEVERE level according to the specified format and
* argument.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the SEVERE level.
*
*
* @param format
* the format string
* @param arg
* the argument
*/
@Override
public void error(String format, Object arg) {
if (logger.isLoggable(Level.SEVERE)) {
FormattingTuple ft = MessageFormatter.format(format, arg);
log(SELF, Level.SEVERE, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at the SEVERE level according to the specified format and
* arguments.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the SEVERE level.
*
*
* @param format
* the format string
* @param argA
* the first argument
* @param argB
* the second argument
*/
@Override
public void error(String format, Object argA, Object argB) {
if (logger.isLoggable(Level.SEVERE)) {
FormattingTuple ft = MessageFormatter.format(format, argA, argB);
log(SELF, Level.SEVERE, ft.getMessage(), ft.getThrowable());
}
}
/**
* Log a message at level SEVERE according to the specified format and
* arguments.
*
*
* This form avoids superfluous object creation when the logger is disabled
* for the SEVERE level.
*
*
* @param format
* the format string
* @param arguments
* an array of arguments
*/
@Override
public void error(String format, Object... arguments) {
if (logger.isLoggable(Level.SEVERE)) {
FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
log(SELF, Level.SEVERE, 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 msg, Throwable t) {
if (logger.isLoggable(Level.SEVERE)) {
log(SELF, Level.SEVERE, msg, t);
}
}
/**
* Log the message at the specified level with the specified throwable if any.
* This method creates a LogRecord and fills in caller date before calling
* this instance's JDK14 logger.
*
* See bug report #13 for more details.
*/
private void log(String callerFQCN, Level level, String msg, Throwable t) {
// millis and thread are filled by the constructor
LogRecord record = new LogRecord(level, msg);
record.setLoggerName(name());
record.setThrown(t);
fillCallerData(callerFQCN, record);
logger.log(record);
}
static final String SELF = JdkLogger.class.getName();
static final String SUPER = AbstractInternalLogger.class.getName();
/**
* Fill in caller data if possible.
*
* @param record
* The record to update
*/
private static void fillCallerData(String callerFQCN, LogRecord record) {
StackTraceElement[] steArray = new Throwable().getStackTrace();
int selfIndex = -1;
for (int i = 0; i < steArray.length; i++) {
final String className = steArray[i].getClassName();
if (className.equals(callerFQCN) || className.equals(SUPER)) {
selfIndex = i;
break;
}
}
int found = -1;
for (int i = selfIndex + 1; i < steArray.length; i++) {
final String className = steArray[i].getClassName();
if (!(className.equals(callerFQCN) || className.equals(SUPER))) {
found = i;
break;
}
}
if (found != -1) {
StackTraceElement ste = steArray[found];
// setting the class name has the side effect of setting
// the needToInferCaller variable to false.
record.setSourceClassName(ste.getClassName());
record.setSourceMethodName(ste.getMethodName());
}
}
}