Ведение журнала не работает для более низких уровней

Question

Я использую java.util.logging, который отлично работает для более высоких уровней выше FINE, но не работает для более низких уровней, хотя я установил уровень как FINEST. Я попытался дать ему Level.ALL также. У меня есть пользовательский класс следующим образом.

public class Tracer extends Logger {
    public Tracer(String name) {
        super(name, null);
        addFileHandler();
        addConsoleHandler();
    }

    private void addConsoleHandler() {
        SSFormatter ssFormatter = new SSFormatter();
        ConsoleHandler consoleHandler = new ConsoleHandler();
        consoleHandler.setFormatter(ssFormatter);
        consoleHandler.setLevel(Level.FINEST);
        this.addHandler(consoleHandler);
    }

    private void addFileHandler() {
        try {
            FileHandler fileHandler = new FileHandler("log.txt", false);
            fileHandler.setFormatter(new SSFormatter());
            fileHandler.setLevel(Level.FINEST);
            this.addHandler(fileHandler);
        } catch (SecurityException e) {
            e.printStackTrace();
            this.warning("SecurityException occurred while adding FileHandler");
        } catch (IOException e) {
            e.printStackTrace();
            this.warning("IOException occurred while adding FileHandler");
        }
    }

    private class SSFormatter extends Formatter {

        @Override
        public String format(LogRecord paramLogRecord) {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(paramLogRecord.getLoggerName()).append("|")
                    .append(paramLogRecord.getSourceClassName()).append("|")
                    .append(paramLogRecord.getSourceMethodName()).append(":::")
                    .append(paramLogRecord.getMessage()).append("\n");
            return stringBuilder.toString();
        }
    }
    public static void main(String[] args) {
        Tracer tracer = new Tracer("ss.tracer");
        tracer.info("This is to test my tracer");
        tracer.warning("This is warning from my tracer");
        tracer.severe("This is severe from my tracer");
        tracer.fine("this is fine");
        tracer.finer("this is finer");
        tracer.finest("this is finest");
    }
}

Когда я запускаю метод main, я получаю вывод консоли и файла следующим образом

ss.tracer|screen.seizer.trace.Tracer|main:::This is to test my tracer
ss.tracer|screen.seizer.trace.Tracer|main:::This is warning from my tracer
ss.tracer|screen.seizer.trace.Tracer|main:::This is severe from my tracer

Спасибо, надеюсь, я ясно изложил свой вопрос.

Answer 1

Я использую java.util.logging, который отлично работает для более высоких уровней выше FINE, но не работает для более низких уровней, хотя я установил уровень как FINEST.

у обработчиков есть уровни, но у Logger также есть уровень, который по умолчанию равен INFO.Вот строка из конструктора Logger:

levelValue = Level.INFO.intValue();

Даже если уровень в обработчиках ниже, чем INFO, если уровень регистратора выше, то ни одно из этих сообщений журнала не попадет вобработчики.В каждом из fine и других методах есть проверки вроде:

if (Level.FINE.intValue() < levelValue) {
    return;
}

Если вы вызовете что-то вроде следующего в вашем main, тогда будут напечатаны все сообщения уровня.

tracer.setLevel(Level.ALL);

Answer 2

Вам необходимо установить уровень регистрации как на обработчиках в регистраторе, так и на самом регистраторе.Регистрация ведется только на самом грубом из двух уровней.Вот класс ведения журнала, который делает эту работу.

import java.io.PrintWriter;
import java.io.StringWriter;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.logging.ConsoleHandler;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

public class Log {

    private static final Logger logger = Logger.getGlobal();

    private static Level logLevel = Level.INFO;
    static {
        // Remove all the default handlers (usually just one console handler)
        Logger rootLogger = Logger.getLogger("");
        Handler[] rootHandlers = rootLogger.getHandlers();
        for (Handler handler : rootHandlers) {
            rootLogger.removeHandler(handler);
        }

        // Add our own handler
        ConsoleHandler handler = new ConsoleHandler();
        handler.setLevel(logLevel);
        handler.setFormatter(new LogFormatter());
        logger.addHandler(handler);
        logger.setLevel(logLevel);
    }

    public static class LogFormatter extends Formatter {
        @Override
        public String format(L    ogRecord record) {
            String stackTrace = "";
            Throwable thrown = record.getThrown();
            if (thrown != null) {
                StringWriter stacktraceWriter = new StringWriter();
                try (PrintWriter writer = new PrintWriter(stacktraceWriter)) {
                    thrown.printStackTrace(writer);
                }
                stackTrace = stacktraceWriter.toString();
            }
            return ZonedDateTime.ofInstant(Instant.ofEpochMilli(record.getMillis()), ZoneId.of("UTC")).format(DateTimeFormatter.ISO_ZONED_DATE_TIME) + "\t" + record.getLevel()
                    + "\t" + record.getMessage() + "\n" + stackTrace;
        }
    }

    private static final String classname = Log.class.getName();

    private static String callerRef() {
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        if (stackTraceElements.length < 4) {
            return "";
        } else {
            int i = 1;
            for (; i < stackTraceElements.length; i++) {
                if (stackTraceElements[i].getClassName().equals(classname)) {
                    break;
                }
            }
            for (; i < stackTraceElements.length; i++) {
                if (!stackTraceElements[i].getClassName().equals(classname)) {
                    break;
                }
            }
            if (i < stackTraceElements.length) {
                return stackTraceElements[i].toString();
            } else {
                return "[in unknown method]";
            }
        }
    }

    public static void setLogLevel(Level newLogLevel) {
        logLevel = newLogLevel;
        for (Handler handler : logger.getHandlers()) {
            handler.setLevel(newLogLevel);
        }
        Log.logger.setLevel(newLogLevel);
    }

    public static int getLevelNum() {
        return logLevel.intValue();
    }

    public static int getLevelNum(Level level) {
        return level.intValue();
    }

    public static void fine(String msg) {
        logger.log(Level.FINE, msg);
    }

    public static void info(String msg) {
        logger.log(Level.INFO, msg);
    }

    public static void warning(String msg) {
        logger.log(Level.WARNING, msg + "\t " + callerRef());
    }

    public static void error(String msg) {
        logger.log(Level.SEVERE, msg + "\t " + callerRef());
    }

    public static void exception(String msg, Throwable cause) {
        logger.log(Level.SEVERE, msg + "\t " + callerRef(), cause);
    }

}