Menyetel tingkat log pesan saat runtime di slf4j

Saat menggunakan log4j, Logger.log(Priority p, Object message)metode ini tersedia dan dapat digunakan untuk mencatat pesan pada tingkat log yang ditentukan saat runtime. Kami menggunakan fakta ini dan tip ini untuk mengarahkan stderr ke logger pada tingkat log tertentu.

slf4j tidak memiliki log()metode umum yang dapat saya temukan. Apakah itu berarti tidak ada cara untuk menerapkan hal di atas?

Tidak ada cara untuk melakukan ini dengan slf4j.

Saya membayangkan bahwa alasan mengapa fungsi ini hilang adalah karena hampir tidak mungkin untuk membangun Leveltipe slf4jyang dapat secara efisien dipetakan ke tipe Level(atau setara) yang digunakan di semua kemungkinan implementasi logging di belakang fasad. Alternatifnya, perancang memutuskan bahwa kasus penggunaan Anda terlalu tidak biasa untuk membenarkan biaya tambahan untuk mendukungnya.

Mengenai @ ripper234 's penggunaan-kasus (unit testing), saya pikir solusi pragmatis adalah memodifikasi tes unit (s) ke hard-kawat pengetahuan tentang apa sistem logging yang ada di balik fasad slf4j ... ketika menjalankan unit test.

Richard Fearn memiliki ide yang tepat, jadi saya menulis kelas lengkapnya berdasarkan kode kerangkanya. Semoga cukup singkat untuk memposting di sini. Salin & tempel untuk kesenangan. Saya mungkin harus menambahkan beberapa mantra ajaib juga: "Kode ini dilepaskan ke domain publik"

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

Coba beralih ke Logback dan gunakan

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

Saya yakin ini akan menjadi satu-satunya panggilan ke Logback dan kode Anda lainnya tidak akan berubah. Logback menggunakan SLF4J dan migrasi tidak akan menimbulkan rasa sakit, hanya file konfigurasi xml yang harus diubah.

Ingatlah untuk menyetel kembali level log setelah Anda selesai.

Anda bisa mengimplementasikan ini menggunakan Java 8 lambda.

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

Ini bisa dilakukan dengan metode an enumand helper:

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

Anda dapat menambahkan varian lain dari log, katakanlah jika Anda menginginkan persamaan generik dari 1-parameter SLF4J atau 2-parameter warn/ error/ etc. metode.

Siapa pun yang menginginkan solusi drop-in yang sepenuhnya kompatibel dengan SLF4J untuk masalah ini mungkin ingin melihat Ekstensi Lidalia SLF4J - ada di Maven Central.

Saya baru saja membutuhkan sesuatu seperti itu dan muncul dengan:

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

pemakaian:

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

Pencatat diteruskan selama pemanggilan, jadi info kelas akan baik-baik saja, dan bekerja dengan baik dengan anotasi @ Slf4j lombok.

Hal ini tidak mungkin untuk menentukan tingkat log di sjf4j 1.xkeluar dari kotak. Tetapi ada harapan bagi slf4j 2.0untuk memperbaiki masalah tersebut . Dalam 2.0 mungkin terlihat seperti ini:

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

Sementara itu, untuk slf4j 1.x, Anda dapat menggunakan solusi ini:

Salin kelas ini ke classpath Anda:

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

Kemudian Anda bisa menggunakannya seperti ini:

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

Ini akan mengeluarkan log seperti ini:

[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

Apakah itu layak?

• ProItu membuat lokasi kode sumber (nama kelas, nama metode, nomor baris akan mengarah ke Anda kode )
• ProAnda dapat dengan mudah mendefinisikan variabel , parameter, dan tipe kembalian sebagaiLogLevel
• ProKode bisnis Anda tetap pendek dan mudah dibaca, dan tidak diperlukan ketergantungan tambahan .

Kode sumber sebagai contoh minimal dihosting di GitHub .

Slf4j API tidak mungkin mengubah level log secara dinamis, tetapi Anda dapat mengonfigurasi logback (jika Anda menggunakannya) sendiri. Dalam hal ini, buat kelas pabrik untuk logger Anda dan implementasikan root logger dengan konfigurasi yang Anda perlukan.

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

Setelah Anda mengkonfigurasi root logger (hanya sekali saja sudah cukup), Anda dapat mendelegasikan mendapatkan logger baru dengan

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

Ingatlah untuk menggunakan yang sama loggerContext .

Mengubah level log mudah dilakukan dengan root logger yang diberikan dari loggerContext.

root.setLevel(Level.DEBUG);

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

Anda akan mendapatkan hasil:

2020-05-14 14: 01: 16,644 TRACE [] [oakcmMetrics] Pekerja pengujian Metrik terdaftar bernama MetricName [name = bufferpool-wait-time-total, group = producer-metrics, description = Total waktu appender menunggu alokasi ruang ., tag = {client-id = producer-2}]

Saya baru saja menemukan kebutuhan yang serupa. Dalam kasus saya, slf4j dikonfigurasi dengan adaptor pencatatan java (yang jdk14). Dengan menggunakan cuplikan kode berikut, saya berhasil mengubah level debug saat runtime:

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

Berdasarkan jawaban massimo virgilio, saya juga berhasil melakukannya dengan slf4j-log4j menggunakan introspeksi. 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());
}

Berikut adalah solusi lambda yang tidak semudah @Paul Croarkin dalam satu hal (levelnya dilewati secara efektif dua kali). Tapi saya pikir (a) pengguna harus melewati Logger; dan (b) AFAIU pertanyaan awal tidak menanyakan cara yang nyaman untuk semua tempat dalam aplikasi, hanya situasi dengan sedikit penggunaan di dalam perpustakaan.

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

Karena slf4j memungkinkan Throwable (yang jejak tumpukannya harus dicatat) di dalam parameter varargs , menurut saya tidak perlu membebani logmetode pembantu untuk konsumen lain selain (String, Object[]).

Saya dapat melakukan ini untuk pengikatan JDK14 dengan terlebih dahulu meminta instans SLF4J Logger dan kemudian menyetel level pada pengikatan - Anda dapat mencoba ini untuk pengikatan 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);
}

Metode yang saya gunakan adalah mengimpor modul ch.qos.logback dan kemudian mengetikkan instance Logger slf4j ke ch.qos.logback.classic.Logger. Instance ini menyertakan metode 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 );

Untuk mengetahui kemungkinan level Logging, Anda dapat meledakkan kelas ch.qos.logback untuk melihat semua kemungkinan nilai untuk Level :

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

Hasilnya adalah sebagai berikut:

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

menggunakan introspeksi java Anda dapat melakukannya, misalnya:

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

}

tidak, ini memiliki sejumlah metode, info (), debug (), warn (), dll (ini menggantikan bidang prioritas)

lihat di http://www.slf4j.org/api/org/slf4j/Logger.html untuk logger api lengkap.