এসএলএফ 4 জে রানটাইমে বার্তার লগ স্তরের সেট করা

Question 1

লগ 4 জ ব্যবহার করার সময়, Logger.log(Priority p, Object message)পদ্ধতিটি উপলব্ধ থাকে এবং রানটাইম নির্ধারিত লগ স্তরে কোনও বার্তা লগ করতে ব্যবহার করা যেতে পারে। আমরা স্ট্যান্ডারকে একটি নির্দিষ্ট লগ স্তরে লগারে পুনর্নির্দেশ করতে এই সত্য এবং এই টিপটি ব্যবহার করছি ।

slf4j এর একটি জেনেরিক log()পদ্ধতি নেই যা আমি খুঁজে পেতে পারি। তার মানে কি উপরোক্ত প্রয়োগের কোনও উপায় নেই?

Question 2

এটি করার কোনও উপায় নেই slf4j।

আমি কল্পনা যে কারণে যে এই কার্যকারিতা হারিয়েছে যে এটা অসম্ভব পরবর্তী একটি গঠন করা হয় Levelটাইপ জন্য slf4jযে দক্ষতার ম্যাপ করা যেতে পারে Level(অথবা সমতুল্য) ছদ্মরূপ পিছনে সম্ভব লগিং বাস্তবায়নের সব ব্যবহৃত প্রকার। বিকল্পভাবে, ডিজাইনাররা সিদ্ধান্ত নিয়েছেন যে আপনার ব্যবহারের ক্ষেত্রে এটি সমর্থন করার ওভারহেডগুলি ন্যায়সঙ্গত করার পক্ষে খুব অস্বাভাবিক ।

বিষয়ে @ ripper234 এর ব্যবহার-কেস (একক পরীক্ষামূলক), আমি মনে করি বাস্তবমুখী সমাধান কি লগিং সিস্টেম slf4j ছদ্মরূপ পিছনে ... যখন ইউনিট পরীক্ষা চলমান হার্ড টেলিগ্রাম জ্ঞান ইউনিট পরীক্ষা (গুলি) সংশোধন করা হয়।

Question 3

রিচার্ড ফার্নের সঠিক ধারণা আছে, তাই আমি তার কঙ্কালের কোডের ভিত্তিতে পূর্ণাঙ্গ ক্লাসটি লিখেছিলাম। আশা করি এখানে পোস্ট করার পক্ষে যথেষ্ট সংক্ষিপ্ত উপভোগের জন্য অনুলিপি করুন এবং আটকান। আমারও সম্ভবত কিছু যাদু জাগ্রত হওয়া উচিত: "এই কোডটি পাবলিক ডোমেনে প্রকাশিত হয়েছে"

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

Question 4

আপনি জাভা 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);
    }
}

Question 5

লগব্যাক এবং স্যুইচ করার চেষ্টা করুন

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

আমি বিশ্বাস করি এটি কেবলমাত্র লগব্যাকের কল হবে এবং আপনার বাকী কোডটি অপরিবর্তিত থাকবে। লগব্যাক এসএলএফ 4 জে ব্যবহার করে এবং মাইগ্রেশন ব্যথাহীন হবে, কেবল এক্সএমএল কনফিগারেশন ফাইলগুলি পরিবর্তন করতে হবে।

আপনার কাজ শেষ করার পরে লগ স্তরটি সেট করতে মনে রাখবেন।

Question 6

এটি একটি 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, যদি আপনি এসএলএফ 4 জ এর 1-পরামিতি বা 2-পরামিতি warn/ error/ ইত্যাদির জেনেরিক সমতুল্য চান তবে বলুন । পদ্ধতি।

Question 7

যে কেউ এই সমস্যার পুরোপুরি এসএলএফ 4 জে সামঞ্জস্যপূর্ণ সমাধান চাইছেন তিনি লিডালিয়া এসএলএফ 4 জ এক্সটেনশনগুলি চেক করে দেখতে চাইতে পারেন - এটি ম্যাভেন সেন্ট্রালে রয়েছে।

Question 8

আমার সবেমাত্র এরকম কিছু দরকার ছিল এবং নিয়ে এসেছি:

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

আমন্ত্রণের সময় লগার পাস করা হয়, সুতরাং শ্রেণীর তথ্যটি ঠিক হওয়া উচিত, এবং এটি @ এসএলএফ 4 জে লম্বোক এনোটোটেশনের সাথে দুর্দান্তভাবে কাজ করে।

Question 9

এটা না sjf4j মধ্যে একটি লগ স্তর উল্লেখ করা সম্ভব 1.xবাক্সের বাইরে। তবে সমস্যাটি2.0 সমাধানের জন্য slf4j এর আশা রয়েছে । 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আপনার ব্যবসায়ের কোডটি ছোট এবং পড়তে সহজ এবং কোন অতিরিক্ত নির্ভরতার প্রয়োজন নেই required

সর্বনিম্ন উদাহরণ হিসাবে উত্স কোডটি গিটহাবটিতে হোস্ট করা হয়েছে ।

Question 10

আমি যে পদ্ধতিটি ব্যবহার করি তা হ'ল ch.qos.logback মডিউলগুলি আমদানি করা এবং তারপরে একটি ch.qos.logback.classic.Logger এ slf4j লগার উদাহরণ টাইপ করুন। এই উদাহরণে একটি সেটলিভেল () পদ্ধতি অন্তর্ভুক্ত রয়েছে।

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

Question 11

গতিবেগে লগ স্তর পরিবর্তন করা slf4j এপিআই দিয়ে সম্ভব নয় তবে আপনি নিজেরাই লগব্যাক কনফিগার করতে পারেন (যদি আপনি এটি ব্যবহার করেন)। সেক্ষেত্রে আপনার লগারের জন্য ফ্যাক্টরি ক্লাস তৈরি করুন এবং আপনার প্রয়োজনীয় কনফিগারেশন সহ রুট লগার প্রয়োগ করুন।

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

Question 12

উত্তরটি নিশ্চিত করুন ওন্দ্রেজ স্কোপেক

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 ট্র্যাক [] [ওকসিএমমেট্রিক্স] পরীক্ষক কর্মী নিবন্ধিত মেট্রিক নামক মেট্রিকনাম [নাম = বাফারপুল-ওয়েট-টাইম-মোট, গ্রুপ = প্রযোজক-মেট্রিকস, বিবরণ = মোট কোনও সময় স্থান বরাদ্দের জন্য অপেক্ষা করেন ।, ট্যাগগুলি = {ক্লায়েন্ট-আইডি = প্রযোজক -২}]

Question 13

আমি সবেমাত্র একটি অনুরূপ প্রয়োজনের মুখোমুখি হয়েছি। আমার ক্ষেত্রে, slf4j জাভা লগিং অ্যাডাপ্টারের (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");

Question 14

ম্যাসিমো ভার্জিলিওর উত্তরের উপর ভিত্তি করে, আমি অন্তর্দৃষ্টি ব্যবহার করে 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());
}

Question 15

এখানে একটি ল্যাম্বদা সমাধানটি ব্যবহারকারী হিসাবে বন্ধুত্বপূর্ণ নয় যেমন @ পল ক্রোয়ারকিনের এক উপায়ে রয়েছে (স্তরটি কার্যকরভাবে দুইবার পাস হয়েছে)। তবে আমি মনে করি (ক) ব্যবহারকারীর লগার পাস করা উচিত; এবং (খ) এএএআইএইউ-র মূল প্রশ্নটি অ্যাপ্লিকেশনের যে কোনও জায়গাতেই কোনও সুবিধাজনক উপায়ের জন্য জিজ্ঞাসা করছিল না, কেবলমাত্র একটি লাইব্রেরির ভিতরে কয়েকটি ব্যবহারের ব্যবস্থা রয়েছে।

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 একটি ভারসাম্য (যার স্ট্যাক ট্রেস লগ করা উচিত) ভারারাগস পরমের অভ্যন্তরে অনুমতি দেয় , তাই আমি মনে করি এর logচেয়ে অন্য গ্রাহকদের জন্য সহায়ক পদ্ধতি ওভারলোড করার দরকার নেই (String, Object[])।

Question 16

আমি প্রথমে এসএলএফ 4 জে লগার দৃষ্টান্তটি অনুরোধ করে এবং তারপরে বাঁধার উপর স্তর নির্ধারণ করে জেডকে 14 জনের জন্য এটি করতে পেরেছিলাম - আপনি লগ 4 জাই বাইন্ডিংয়ের জন্য এটি চেষ্টা করতে পারেন।

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

Question 17

জাভা আত্মনির্মাণ ব্যবহার করে আপনি এটি করতে পারেন, উদাহরণস্বরূপ:

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

}

Question 18

না, এর বেশ কয়েকটি পদ্ধতি, তথ্য (), ডিবাগ (), সতর্কতা () ইত্যাদি রয়েছে (এটি অগ্রাধিকার ক্ষেত্রটি প্রতিস্থাপন করে)

সম্পূর্ণ লগার এপিআইয়ের জন্য http://www.slf4j.org/api/org/slf4j/Logger.html দেখুন ।