Festlegen der Protokollstufe der Nachricht zur Laufzeit in slf4j

Bei Verwendung von log4j ist die Logger.log(Priority p, Object message)Methode verfügbar und kann zum Protokollieren einer Nachricht auf einer zur Laufzeit festgelegten Protokollebene verwendet werden. Wir nutzen diese Tatsache und diesen Tipp , um stderr zu einem Logger auf einer bestimmten Log-Ebene umzuleiten.

slf4j hat keine generische log()Methode, die ich finden kann. Bedeutet das, dass es keine Möglichkeit gibt, das oben Genannte umzusetzen?

Es gibt keine Möglichkeit, dies zu tun slf4j.

Ich stelle mir vor, dass der Grund dafür, dass diese Funktionalität fehlt, darin besteht, dass es nahezu unmöglich ist, einen LevelTyp zu slf4jerstellen, der effizient dem Level(oder einem gleichwertigen) Typ zugeordnet werden kann, der in allen möglichen Protokollierungsimplementierungen hinter der Fassade verwendet wird. Alternativ haben die Designer entschieden, dass Ihr Anwendungsfall zu ungewöhnlich ist , um den Aufwand für die Unterstützung zu rechtfertigen.

Über Bezug auf den Anwendungsfall von @ ripper234 ( Komponententests ) denke ich, dass die pragmatische Lösung darin besteht, die Komponententests so zu ändern , dass sie genau wissen, welches Protokollierungssystem sich hinter der slf4j-Fassade befindet ... wenn die Komponententests ausgeführt werden.

Richard Fearn hat die richtige Idee, also habe ich die ganze Klasse basierend auf seinem Skelettcode geschrieben. Es ist hoffentlich kurz genug, um hier zu posten. Kopieren und einfügen zum Genießen. Ich sollte wahrscheinlich auch eine magische Beschwörung hinzufügen: "Dieser Code ist gemeinfrei"

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

Versuchen Sie, zu Logback zu wechseln, und verwenden Sie

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

Ich glaube, dies ist der einzige Aufruf von Logback und der Rest Ihres Codes bleibt unverändert. Logback verwendet SLF4J und die Migration ist problemlos, nur die XML-Konfigurationsdateien müssen geändert werden.

Denken Sie daran, die Protokollstufe zurückzusetzen, nachdem Sie fertig sind.

Sie können dies mit Java 8 Lambdas implementieren.

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

Dies kann mit einer enumund einer Hilfsmethode erfolgen:

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

Sie können andere Varianten hinzufügen log, beispielsweise wenn Sie generische Äquivalente von SLF4Js 1-Parameter oder 2-Parameter warn/ error/ etc. Methoden.

Wenn Sie eine vollständig SLF4J-kompatible Lösung für dieses Problem suchen, sollten Sie sich die Lidalia SLF4J-Erweiterungen ansehen - sie befinden sich in Maven Central.

Ich habe gerade so etwas gebraucht und mir Folgendes ausgedacht:

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

Verwendung:

    LogLevel level = LogLevel.TRACE;
    level.log(logger, "message");

Der Logger wird während des Aufrufs übergeben, daher sollten die Klasseninformationen in Ordnung sein und funktionieren gut mit der @ Slf4j-Lombok-Annotation.

Es ist nicht möglich, eine Protokollstufe in sjf4j sofort anzugeben 1.x. Es besteht jedoch die Hoffnung, dass slf4j das Problem2.0 beheben kann . In 2.0 könnte es so aussehen:

// 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!");

In der Zwischenzeit können Sie für slf4j 1.x diese Problemumgehung verwenden:

Kopieren Sie diese Klasse in Ihren Klassenpfad:

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

Dann können Sie es so verwenden:

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

Dies gibt ein Protokoll wie folgt aus:

[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

Lohnt es sich?

• ProDer Quellcode-Speicherort bleibt erhalten (Klassennamen, Methodennamen und Zeilennummern verweisen auf Ihren Code).
• ProSie können Variablen , Parameter und Rückgabetypen einfach als definierenLogLevel
• ProIhr Geschäftscode bleibt kurz und leicht zu lesen, und es sind keine zusätzlichen Abhängigkeiten erforderlich.

Der Quellcode als minimales Beispiel wird auf GitHub gehostet .

Mit der slf4j-API ist es nicht möglich, die Protokollstufe dynamisch zu ändern, aber Sie können die Protokollierung (falls Sie diese verwenden) selbst konfigurieren. In diesem Fall erstellen Sie eine Factory-Klasse für Ihren Logger und implementieren den Root-Logger mit der von Ihnen benötigten Konfiguration.

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

Nachdem Sie den Root-Logger konfiguriert haben (nur einmal reicht aus), können Sie das Abrufen eines neuen Loggers an delegieren

final ch.qos.logback.classic.Logger logger = loggerContext.getLogger(clazz);

Denken Sie daran, dasselbe zu verwenden loggerContext .

Das Ändern der Protokollstufe ist mit dem Root-Logger von einfach loggerContext.

root.setLevel(Level.DEBUG);

Antwort bestätigen 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);

Sie erhalten Ergebnis:

2020-05-14 14: 01: 16,644 TRACE [] [oakcmMetrics] Testarbeiter Registrierte Metrik mit dem Namen MetricName [Name = Pufferpool-Wartezeit-Summe, Gruppe = Hersteller-Metriken, Beschreibung = Die Gesamtzeit, die ein Appender auf die Speicherplatzzuweisung wartet ., tags = {client-id = Producer-2}]

Ich bin gerade auf ein ähnliches Bedürfnis gestoßen. In meinem Fall wird slf4j mit dem Java-Protokollierungsadapter (dem jdk14-Adapter) konfiguriert. Mit dem folgenden Code-Snippet konnte ich die Debug-Ebene zur Laufzeit ändern:

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

Basierend auf der Antwort von massimo virgilio habe ich es auch geschafft, es mit slf4j-log4j unter Verwendung von Selbstbeobachtung zu tun. 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());
}

Hier ist eine Lambda-Lösung, die in einer Hinsicht nicht so benutzerfreundlich ist wie die von @Paul Croarkin (das Level wird effektiv zweimal bestanden). Aber ich denke (a) der Benutzer sollte den Logger übergeben; und (b) AFAIU die ursprüngliche Frage lautete nicht nach einem bequemen Weg für überall in der Anwendung, sondern nur nach einer Situation mit wenigen Verwendungen innerhalb einer Bibliothek.

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

Da slf4j ein Throwable (dessen Stack-Trace protokolliert werden soll) innerhalb des varargs-Parameters zulässt , besteht meines Erachtens keine Notwendigkeit, die Hilfsmethodelog für andere Benutzer als zu überladen (String, Object[]).

Ich konnte dies für die JDK14-Bindung tun, indem ich zuerst die SLF4J-Logger-Instanz anforderte und dann die Ebene für die Bindung festlegte. Sie können dies für die Log4J-Bindung versuchen.

private void setLevel(Class loggerClass, java.util.logging.Level level) {
  org.slf4j.LoggerFactory.getLogger(loggerClass);
  java.util.logging.Logger.getLogger(loggerClass.getName()).setLevel(level);
}

Die Methode, die ich verwende, besteht darin, die ch.qos.logback-Module zu importieren und dann die slf4j Logger-Instanz in einen ch.qos.logback.classic.Logger zu typisieren. Diese Instanz enthält eine setLevel () -Methode.

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

Um die möglichen Protokollierungsstufen herauszufinden, können Sie die Klasse ch.qos.logback auflösen, um alle möglichen Werte für Stufe anzuzeigen :

prompt$ javap -cp logback-classic-1.2.3.jar ch.qos.logback.classic.Level

Die Ergebnisse sind die folgenden:

{
   // ...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;
}

Mit Java Introspection können Sie dies zum Beispiel tun:

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

}

Nein, es gibt eine Reihe von Methoden, info (), debug (), warn () usw. (dies ersetzt das Prioritätsfeld).

hat einen Blick auf http://www.slf4j.org/api/org/slf4j/Logger.html für den vollen Logger api.