Définition du niveau de journalisation du message lors de l'exécution dans slf4j

Lors de l'utilisation de log4j, la Logger.log(Priority p, Object message)méthode est disponible et peut être utilisée pour consigner un message à un niveau de journal déterminé lors de l'exécution. Nous utilisons ce fait et cette astuce pour rediriger stderr vers un enregistreur à un niveau de journal spécifique.

slf4j n'a pas de log()méthode générique que je puisse trouver. Cela signifie-t-il qu'il n'y a aucun moyen de mettre en œuvre ce qui précède?

Il n'y a aucun moyen de faire cela avec slf4j.

J'imagine que la raison pour laquelle cette fonctionnalité est manquante est qu'il est pratiquement impossible de construire un Leveltype pour slf4jqui peut être mappé efficacement au type Level(ou équivalent) utilisé dans toutes les implémentations de journalisation possibles derrière la façade. Alternativement, les concepteurs ont décidé que votre cas d'utilisation était trop inhabituel pour justifier les frais généraux liés à sa prise en charge.

Concernant le cas d' utilisation de @ ripper234 (tests unitaires), je pense que la solution pragmatique est de modifier le (s) test (s) unitaire pour connaître en dur le système de journalisation derrière la façade slf4j ... lors de l'exécution des tests unitaires.

Richard Fearn a la bonne idée, alors j'ai rédigé le cours complet en me basant sur son squelette de code. J'espère que c'est assez court pour être publié ici. Copiez et collez pour le plaisir. Je devrais probablement ajouter une incantation magique aussi: "Ce code est publié dans le domaine public"

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

Essayez de passer à Logback et utilisez

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

Je crois que ce sera le seul appel à Logback et le reste de votre code restera inchangé. Logback utilise SLF4J et la migration sera sans problème, seuls les fichiers de configuration xml devront être modifiés.

N'oubliez pas de redéfinir le niveau de journalisation une fois que vous avez terminé.

Vous pouvez l'implémenter à l'aide de lambdas 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);
    }
}

Cela peut être fait avec une enumméthode et une aide:

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

Vous pouvez ajouter d'autres variantes de log, par exemple si vous vouliez des équivalents génériques du paramètre 1 ou 2 paramètres de SLF4J warn/ error/ etc. méthodes.

Quiconque souhaite une solution entièrement compatible SLF4J à ce problème pourrait vouloir consulter les extensions Lidalia SLF4J - c'est sur Maven Central.

J'ai juste besoin de quelque chose comme ça et j'ai trouvé:

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

usage:

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

Logger est passé lors de l'invocation, donc les informations de classe devraient être correctes, et cela fonctionne bien avec l'annotation @ Slf4j lombok.

Il n'est pas possible de spécifier un niveau de journalisation dans sjf4j 1.xhors de la boîte. Mais il y a de l'espoir pour slf4j 2.0de résoudre le problème . En 2.0, cela pourrait ressembler à ceci:

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

En attendant, pour slf4j 1.x, vous pouvez utiliser cette solution de contournement:

Copiez cette classe dans votre chemin de classe:

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

Ensuite, vous pouvez l'utiliser comme ceci:

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

Cela produira un journal comme celui-ci:

[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

Est-ce que ça vaut le coup?

• ProIl conserve l' emplacement du code source (les noms de classe, les noms de méthode, les numéros de ligne pointeront vers votre code)
• ProVous pouvez facilement définir des variables , des paramètres et des types de retour commeLogLevel
• ProVotre code d'entreprise reste court et facile à lire, et aucune dépendance supplémentaire n'est requise.

Le code source comme exemple minimal est hébergé sur GitHub .

Il n'est pas possible avec l'API slf4j de modifier dynamiquement le niveau de journalisation, mais vous pouvez configurer la connexion (si vous l'utilisez) par vous-même. Dans ce cas, créez une classe d'usine pour votre enregistreur et implémentez l'enregistreur racine avec la configuration dont vous avez besoin.

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

Après avoir configuré l'enregistreur racine (une seule fois suffit), vous pouvez déléguer l'obtention d'un nouvel enregistreur en

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

N'oubliez pas d'utiliser la même chose loggerContext.

Changer le niveau de journalisation est facile à faire avec l'enregistreur racine fourni par loggerContext.

root.setLevel(Level.DEBUG);

Confirmer la réponse 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);

Vous obtiendrez le résultat:

2020-05-14 14: 01: 16,644 TRACE [] [oakcmMetrics] Test worker Métrique enregistrée nommée MetricName [name = bufferpool-wait-time-total, group = Producer-metrics, description = Le temps total pendant lequel un ajouteur attend l'allocation d'espace ., tags = {client-id = producteur-2}]

Je viens de rencontrer un besoin similaire. Dans mon cas, slf4j est configuré avec l'adaptateur de journalisation java (le jdk14). À l'aide de l'extrait de code suivant, j'ai réussi à modifier le niveau de débogage au moment de l'exécution:

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

Sur la base de la réponse de massimo virgilio, j'ai également réussi à le faire avec slf4j-log4j en utilisant l'introspection. 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());
}

Voici une solution lambda pas aussi conviviale que celle de @Paul Croarkin dans un sens (le niveau est effectivement passé deux fois). Mais je pense que (a) l'utilisateur devrait passer le Logger; et (b) AFAIU la question initiale ne demandait pas un moyen pratique pour partout dans l'application, seulement une situation avec peu d'utilisations à l'intérieur d'une bibliothèque.

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

Étant donné que slf4j autorise un Throwable (dont la trace de la pile doit être enregistrée) dans le paramètre varargs , je pense qu'il n'est pas nécessaire de surcharger la logméthode d'assistance pour d'autres consommateurs que (String, Object[]).

J'ai pu le faire pour la liaison JDK14 en demandant d'abord l'instance SLF4J Logger, puis en définissant le niveau de la liaison - vous pouvez essayer ceci pour la liaison 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);
}

La méthode que j'utilise consiste à importer les modules ch.qos.logback, puis à transtyper l'instance de slf4j Logger en ch.qos.logback.classic.Logger. Cette instance inclut une méthode 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 );

Pour connaître les niveaux de journalisation possibles, vous pouvez exploser la classe ch.qos.logback pour voir toutes les valeurs possibles pour Level :

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

Les résultats sont les suivants:

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

en utilisant l'introspection java, vous pouvez le faire, par exemple:

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

}

non, il a un certain nombre de méthodes, info (), debug (), warn (), etc. (cela remplace le champ de priorité)

jetez un œil à http://www.slf4j.org/api/org/slf4j/Logger.html pour consulter l'API Logger complète.