slf4j에서 런타임시 메시지의 로그 수준 설정

log4j를 사용하는 경우 Logger.log(Priority p, Object message)메서드를 사용할 수 있으며 런타임에 결정된 로그 수준에서 메시지를 기록하는 데 사용할 수 있습니다. 이 사실 과이 팁 을 사용하여 stderr를 특정 로그 수준의 로거로 리디렉션합니다.

slf4j에는 log()내가 찾을 수 있는 일반적인 방법 이 없습니다 . 위를 구현할 방법이 없다는 의미입니까?

으로이 작업을 수행 할 수있는 방법이 없습니다 slf4j.

이 기능이 누락 된 이유 는 파사드 뒤의 가능한 모든 로깅 구현에서 사용되는 (또는 동등한) 유형에 효율적으로 매핑 될 수 있는 Level유형 을 구성하는 것이 거의 불가능하기 때문이라고 생각합니다 . 또는 설계자들은 귀하의 사용 사례가 이를 지원하는 오버 헤드를 정당화 하기에는 너무 이례적 이라고 결정 했습니다.slf4jLevel

에 관한 @ ripper234 의 사용 사례 (단위 테스트), 나는 실용적인 솔루션은 단위 테스트를 실행할 때 로깅 시스템 ...을 SLF4J 외관 뒤에 무엇의 하드 와이어 지식 단위 테스트 (들)을 수정할 생각합니다.

Richard Fearn은 올바른 아이디어를 가지고 있으므로 그의 골격 코드를 기반으로 전체 클래스를 작성했습니다. 여기에 게시하기에 충분히 짧기를 바랍니다. 즐거움을 위해 복사 및 붙여 넣기. 마법 주문도 추가해야 할 것 같습니다. "이 코드는 공개 도메인에 공개되었습니다."

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 람다를 사용하여이를 구현할 수 있습니다.

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", ...);

logSLF4J의 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's 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

그만한 가치가 있습니까?

• Pro그것은 계속 소스 코드의 위치 (클래스 이름, 메소드 이름, 줄 번호를 가리 킵니다 당신의 코드)
• Pro변수 , 매개 변수 및 반환 유형을 다음과 같이 쉽게 정의 할 수 있습니다.LogLevel
• Pro비즈니스 코드는 짧고 읽기 쉬우 며 추가 종속성이 필요 하지 않습니다.

최소한의 예제 인 소스 코드는 GitHub에서 호스팅 됩니다 .

slf4j API로는 로그 레벨을 동적으로 변경할 수 없지만 로그 백 (사용하는 경우)은 직접 구성 할 수 있습니다. 이 경우 로거에 대한 팩토리 클래스를 만들고 필요한 구성으로 루트 로거를 구현하십시오.

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);

답변 확인 Ondrej Skopek

import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import org.slf4j.LoggerFactory;

var rootLogger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
rootLogger.setLevel(Level.TRACE);

결과를 얻을 수 있습니다.

2020-05-14 14 : 01 : 16,644 TRACE [] [oakcmMetrics] 테스트 작업자 MetricName이라는 등록 된 메트릭 [name = bufferpool-wait-time-total, group = producer-metrics, description = 어 펜더가 공간 할당을 기다리는 총 시간 ., tags = {client-id = producer-2}]

나는 방금 비슷한 요구에 직면했습니다. 제 경우에는 slf4j가 Java 로깅 어댑터 (jdk14 어댑터)로 구성되어 있습니다. 다음 코드 조각을 사용하여 런타임에 디버그 수준을 변경했습니다.

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의 답변을 기반으로 introspection을 사용하여 slf4j-log4j로도 처리했습니다. HTH.

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만큼 사용자 친화적이지 않은 람다 솔루션입니다 (레벨이 효과적으로 두 번 전달됨). 그러나 나는 (a) 사용자가 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 는 varargs param 내부에 Throwable (스택 추적이 기록되어야하는)을 허용 하므로 log다른 소비자를 위해 헬퍼 메서드를 오버로딩 할 필요가 없다고 생각 (String, Object[])합니다.

먼저 SLF4J Logger 인스턴스를 요청한 다음 바인딩 수준 을 설정 하여 JDK14 바인딩에 대해이를 수행 할 수있었습니다 . 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 Logger 인스턴스를 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 클래스를 확장하여 Level에 대해 가능한 모든 값을 볼 수 있습니다 .

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;
}

Java introspection을 사용하면 다음과 같이 할 수 있습니다.

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 () 등이 있습니다 (우선 순위 필드를 대체 함).

전체 Logger API 는 http://www.slf4j.org/api/org/slf4j/Logger.html 을 참조하십시오 .