При использовании log4j доступен метод Logger.log(Priority p, Object message) и может использоваться для регистрации сообщения на уровне журнала, определенном во время выполнения. Мы используем этот факт и этот совет для перенаправления stderr на регистратор на определенном уровне журнала.
slf4j не имеет общего метода log(), который я могу найти. Означает ли это, что нет способа реализовать вышеперечисленное?
Нет никакого способа сделать это с slf4j.
Я предполагаю, что причина, по которой эта функциональность отсутствует, заключается в том, что практически невозможно создать тип Level для slf4j который можно эффективно сопоставить с типом Level (или эквивалентным), используемым во всех возможных реализациях ведения журналов за фасадом. В качестве альтернативы дизайнеры решили, что ваш вариант использования слишком необычен, чтобы оправдать затраты на его поддержку.
Что касается варианта использования @ripper234 (модульное тестирование), я думаю, что прагматичное решение состоит в том, чтобы модифицировать модульные тесты, чтобы получить твердое представление о том, какая система логирования находится за фасадом slf4j... при запуске модульных тестов.
У Ричарда Ферна есть правильная идея, поэтому я написал полный класс на основе его кода скелета. Он, надеюсь, достаточно короткий, чтобы публиковать здесь. Скопируйте и вставьте для удовольствия. Возможно, я должен добавить магическое заклинание: "Этот код выпущен в общественное достояние"
import org.slf4j.Logger;
public class LogLevel {
/**
* Allowed levels, as an enum. Import using "import [package].LogLevel.Level"
* Every logging implementation has something like this except SLF4J.
*/
public static enum Level {
TRACE, DEBUG, INFO, WARN, ERROR
}
/**
* This class cannot be instantiated, why would you want to?
*/
private LogLevel() {
// Unreachable
}
/**
* Log at the specified level. If the "logger" is null, nothing is logged.
* If the "level" is null, nothing is logged. If the "txt" is null,
* behaviour depends on the SLF4J implementation.
*/
public static void log(Logger logger, Level level, String txt) {
if (logger != null && level != null) {
switch (level) {
case TRACE:
logger.trace(txt);
break;
case DEBUG:
logger.debug(txt);
break;
case INFO:
logger.info(txt);
break;
case WARN:
logger.warn(txt);
break;
case ERROR:
logger.error(txt);
break;
}
}
}
/**
* Log at the specified level. If the "logger" is null, nothing is logged.
* If the "level" is null, nothing is logged. If the "format" or the "argArray"
* are null, behaviour depends on the SLF4J-backing implementation.
*/
public static void log(Logger logger, Level level, String format, Object[] argArray) {
if (logger != null && level != null) {
switch (level) {
case TRACE:
logger.trace(format, argArray);
break;
case DEBUG:
logger.debug(format, argArray);
break;
case INFO:
logger.info(format, argArray);
break;
case WARN:
logger.warn(format, argArray);
break;
case ERROR:
logger.error(format, argArray);
break;
}
}
}
/**
* Log at the specified level, with a Throwable on top. If the "logger" is null,
* nothing is logged. If the "level" is null, nothing is logged. If the "format" or
* the "argArray" or the "throwable" are null, behaviour depends on the SLF4J-backing
* implementation.
*/
public static void log(Logger logger, Level level, String txt, Throwable throwable) {
if (logger != null && level != null) {
switch (level) {
case TRACE:
logger.trace(txt, throwable);
break;
case DEBUG:
logger.debug(txt, throwable);
break;
case INFO:
logger.info(txt, throwable);
break;
case WARN:
logger.warn(txt, throwable);
break;
case ERROR:
logger.error(txt, throwable);
break;
}
}
}
/**
* Check whether a SLF4J logger is enabled for a certain loglevel.
* If the "logger" or the "level" is null, false is returned.
*/
public static boolean isEnabledFor(Logger logger, Level level) {
boolean res = false;
if (logger != null && level != null) {
switch (level) {
case TRACE:
res = logger.isTraceEnabled();
break;
case DEBUG:
res = logger.isDebugEnabled();
break;
case INFO:
res = logger.isInfoEnabled();
break;
case WARN:
res = logger.isWarnEnabled();
break;
case ERROR:
res = logger.isErrorEnabled();
break;
}
}
return res;
}
}
Попробуйте переключиться на Logback и используйте
ch.qos.logback.classic.Logger rootLogger = (ch.qos.logback.classic.Logger)LoggerFactory.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
rootLogger.setLevel(Level.toLevel("info"));
Я считаю, что это будет единственный вызов Logback, а остальная часть вашего кода останется неизменной. Logback использует SLF4J, и миграция будет безболезненной, нужно будет изменить только файлы конфигурации xml.
Не забудьте установить уровень журнала после завершения.
Вы можете реализовать это, используя Java 8 lambdas.
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.event.Level;
public class LevelLogger {
private static final Logger LOGGER = LoggerFactory.getLogger(LevelLogger.class);
private static final Map<Level, LoggingFunction> map;
static {
map = new HashMap<>();
map.put(Level.TRACE, (o) -> LOGGER.trace(o));
map.put(Level.DEBUG, (o) -> LOGGER.debug(o));
map.put(Level.INFO, (o) -> LOGGER.info(o));
map.put(Level.WARN, (o) -> LOGGER.warn(o));
map.put(Level.ERROR, (o) -> LOGGER.error(o));
}
public static void log(Level level, String s) {
map.get(level).log(s);
}
@FunctionalInterface
private interface LoggingFunction {
public void log(String arg);
}
}
Это можно сделать с помощью enum и вспомогательного метода:
enum LogLevel {
TRACE,
DEBUG,
INFO,
WARN,
ERROR,
}
public static void log(Logger logger, LogLevel level, String format, Object[] argArray) {
switch (level) {
case TRACE:
logger.trace(format, argArray);
break;
case DEBUG:
logger.debug(format, argArray);
break;
case INFO:
logger.info(format, argArray);
break;
case WARN:
logger.warn(format, argArray);
break;
case ERROR:
logger.error(format, argArray);
break;
}
}
// example usage:
private static final Logger logger = ...
final LogLevel level = ...
log(logger, level, "Something bad happened", ...);
Вы можете добавить другие варианты log, скажем, если вам нужны общие эквиваленты SLF4J 1-параметра или 2-параметра warn/error/etc. Методы.
Любой, кто хочет получить полностью совместимое с SLF4J решение этой проблемы, может попробовать Lidalia SLF4J Extensions - его на Maven Central.
Мне просто нужно что-то подобное и придумал:
@RequiredArgsConstructor //lombok annotation
public enum LogLevel{
TRACE(l -> l::trace),
INFO (l -> l::info),
WARN (l -> l::warn),
ERROR(l -> l::error);
private final Function<Logger, Consumer<String>> function;
public void log(Logger logger, String message) {
function.apply(logger).accept(message);
}
}
использование:
LogLevel level = LogLevel.TRACE;
level.log(logger, "message");
Logger передается во время вызова, поэтому информация о классе должна быть в порядке, и она прекрасно работает с аннотацией @Slf4j lombok.
Это не представляется возможным определить уровень протоколирования в sjf4j 1.x из коробки. Но есть надежда, что slf4j 2.0 решит проблему. В 2.0 это может выглядеть так:
// POTENTIAL 2.0 SOLUTION
import org.slf4j.helpers.Util;
import static org.slf4j.spi.LocationAwareLogger.*;
// does not work with slf4j 1.x
Util.log(logger, DEBUG_INT, "hello world!");
Между тем, для slf4j 1.x вы можете использовать этот обходной путь:
Скопируйте этот класс в ваш путь к классам:
import org.slf4j.Logger;
import java.util.function.Function;
public enum LogLevel {
TRACE(l -> l::trace, Logger::isTraceEnabled),
DEBUG(l -> l::debug, Logger::isDebugEnabled),
INFO(l -> l::info, Logger::isInfoEnabled),
WARN(l -> l::warn, Logger::isWarnEnabled),
ERROR(l -> l::error, Logger::isErrorEnabled);
interface LogMethod {
void log(String format, Object... arguments);
}
private final Function<Logger, LogMethod> logMethod;
private final Function<Logger, Boolean> isEnabledMethod;
LogLevel(Function<Logger, LogMethod> logMethod, Function<Logger, Boolean> isEnabledMethod) {
this.logMethod = logMethod;
this.isEnabledMethod = isEnabledMethod;
}
public LogMethod prepare(Logger logger) {
return logMethod.apply(logger);
}
public boolean isEnabled(Logger logger) {
return isEnabledMethod.apply(logger);
}
}
Тогда вы можете использовать это так:
Logger logger = LoggerFactory.getLogger(Application.class);
LogLevel level = LogLevel.ERROR;
level.prepare(logger).log("It works!"); // just message, without parameter
level.prepare(logger).log("Hello {}!", "world"); // with slf4j parameter replacing
try {
throw new RuntimeException("Oops");
} catch (Throwable t) {
level.prepare(logger).log("Exception", t);
}
if (level.isEnabled(logger)) {
level.prepare(logger).log("logging is enabled");
}
Это выведет журнал следующим образом:
[main] ERROR Application - It works!
[main] ERROR Application - Hello world!
[main] ERROR Application - Exception
java.lang.RuntimeException: Oops
at Application.main(Application.java:14)
[main] ERROR Application - logging is enabled
Стоит ли оно того?
LogLevelИсходный код в качестве минимального примера размещен на GitHub.
Я только что столкнулся с подобной потребностью. В моем случае slf4j настроен с помощью java logging adapter (jdk14 one). Используя следующий фрагмент кода, мне удалось изменить уровень отладки во время выполнения:
Logger logger = LoggerFactory.getLogger("testing");
java.util.logging.Logger julLogger = java.util.logging.Logger.getLogger("testing");
julLogger.setLevel(java.util.logging.Level.FINE);
logger.debug("hello world");
Основываясь на ответе massimo virgilio, мне также удалось сделать это с помощью slf4j-log4j, используя интроспекцию. НТН.
Logger LOG = LoggerFactory.getLogger(MyOwnClass.class);
org.apache.logging.slf4j.Log4jLogger LOGGER = (org.apache.logging.slf4j.Log4jLogger) LOG;
try {
Class loggerIntrospected = LOGGER.getClass();
Field fields[] = loggerIntrospected.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
String fieldName = fields[i].getName();
if (fieldName.equals("logger")) {
fields[i].setAccessible(true);
org.apache.logging.log4j.core.Logger loggerImpl = (org.apache.logging.log4j.core.Logger) fields[i].get(LOGGER);
loggerImpl.setLevel(Level.DEBUG);
}
}
} catch (Exception e) {
System.out.println("ERROR :" + e.getMessage());
}
Здесь лямбда-решение не так удобно, как @Paul Croarkin одним способом (уровень эффективно передается дважды). Но я думаю: (а) пользователь должен пройти Logger; и (b) AFAIU исходный вопрос не требует удобного способа для повсеместно в приложении, только ситуация с несколькими обычаями внутри библиотеки.
package test.lambda;
import java.util.function.*;
import org.slf4j.*;
public class LoggerLambda {
private static final Logger LOG = LoggerFactory.getLogger(LoggerLambda.class);
private LoggerLambda() {}
public static void log(BiConsumer<? super String, ? super Object[]> logFunc, Supplier<Boolean> logEnabledPredicate,
String format, Object... args) {
if (logEnabledPredicate.get()) {
logFunc.accept(format, args);
}
}
public static void main(String[] args) {
int a = 1, b = 2, c = 3;
Throwable e = new Exception("something went wrong", new IllegalArgumentException());
log(LOG::info, LOG::isInfoEnabled, "a = {}, b = {}, c = {}", a, b, c);
// warn(String, Object...) instead of warn(String, Throwable), but prints stacktrace nevertheless
log(LOG::warn, LOG::isWarnEnabled, "error doing something: {}", e, e);
}
}
Так как slf4j позволяет Throwable (трассировка стека стека) в параметре varargs, я думаю, что нет необходимости перегружать log для других потребителей, чем (String, Object[]).
Я смог сделать это для привязки JDK14, сначала запросив экземпляр Logger SLF4J, а затем установив уровень на привязке - вы можете попробовать это для привязки Log4J.
private void setLevel(Class loggerClass, java.util.logging.Level level) {
org.slf4j.LoggerFactory.getLogger(loggerClass);
java.util.logging.Logger.getLogger(loggerClass.getName()).setLevel(level);
}
Метод, который я использую, состоит в том, чтобы импортировать модули ch.qos.logback и затем преобразовать тип экземпляра регистратора slf4j в ch.qos.logback.classic.Logger. Этот экземпляр включает метод setLevel().
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
Logger levelSet = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
// Now you can set the desired logging-level
levelSet.setLevel( Level.OFF );
Чтобы выяснить возможные уровни ведения журнала, вы можете разобрать класс ch.qos.logback, чтобы увидеть все возможные значения для уровня:
prompt$ javap -cp logback-classic-1.2.3.jar ch.qos.logback.classic.Level
Результаты следующие:
{
// ...skipping
public static final ch.qos.logback.classic.Level OFF;
public static final ch.qos.logback.classic.Level ERROR;
public static final ch.qos.logback.classic.Level WARN;
public static final ch.qos.logback.classic.Level INFO;
public static final ch.qos.logback.classic.Level DEBUG;
public static final ch.qos.logback.classic.Level TRACE;
public static final ch.qos.logback.classic.Level ALL;
}
В API-интерфейсе slf4j невозможно динамически изменить уровень журнала, но вы можете настроить logback (если вы его используете) самостоятельно. В этом случае создайте класс фабрики для вашего регистратора и внедрите корневой регистратор с необходимой вам конфигурацией.
LoggerContext loggerContext = new LoggerContext();
ch.qos.logback.classic.Logger root = loggerContext.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
// Configure appender
final TTLLLayout layout = new TTLLLayout();
layout.start(); // default layout of logging messages (the form that message displays
// e.g. 10:26:49.113 [main] INFO com.yourpackage.YourClazz - log message
final LayoutWrappingEncoder<ILoggingEvent> encoder = new LayoutWrappingEncoder<>();
encoder.setCharset(StandardCharsets.UTF_8);
encoder.setLayout(layout);
final ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<>();
appender.setContext(loggerContext);
appender.setEncoder(encoder);
appender.setName("console");
appender.start();
root.addAppender(appender);
После настройки корневого регистратора (достаточно только одного раза) вы можете делегировать получение нового регистратора с помощью.
final ch.qos.logback.classic.Logger logger = loggerContext.getLogger(clazz);
Не забудьте использовать тот же loggerContext.
Изменение уровня журнала легко сделать с помощью корневого регистратора, полученного из loggerContext.
root.setLevel(Level.DEBUG);
используя java-интроспекцию, вы можете это сделать, например:
private void changeRootLoggerLevel(int level) {
if (logger instanceof org.slf4j.impl.Log4jLoggerAdapter) {
try {
Class loggerIntrospected = logger.getClass();
Field fields[] = loggerIntrospected.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
String fieldName = fields[i].getName();
if (fieldName.equals("logger")) {
fields[i].setAccessible(true);
org.apache.log4j.Logger loggerImpl = (org.apache.log4j.Logger) fields[i]
.get(logger);
if (level == DIAGNOSTIC_LEVEL) {
loggerImpl.setLevel(Level.DEBUG);
} else {
loggerImpl.setLevel(org.apache.log4j.Logger.getRootLogger().getLevel());
}
// fields[i].setAccessible(false);
}
}
} catch (Exception e) {
org.apache.log4j.Logger.getLogger(LoggerSLF4JImpl.class).error("An error was thrown while changing the Logger level", e);
}
}
}
нет, он имеет несколько методов: info(), debug(), warn() и т.д. (это заменяет поле приоритета)
посмотрите http://www.slf4j.org/api/org/slf4j/Logger.html для полного входа в систему Logger.