#114

Committed 07 Aug 2024 11:00PM UTC coverage: 88.672% (-0.03%) from 88.704%

Build # #114

Build Type

push

Committed by

Commit Message

Regenerate JavaDoc

Run Details

5691 of 6418 relevant lines covered (88.67%)

0.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.37

/logevents/src/main/java/org/logevents/core/JavaUtilLoggingAdapter.java

package org.logevents.core;

import org.logevents.LogEventFactory;
import org.slf4j.spi.LocationAwareLogger;

import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
import java.util.stream.Stream;

/**
 * An adapter from java.util.logging to LogEvents. Automatically installed by {@link LogEventFactory}
 */
public class JavaUtilLoggingAdapter extends Handler {
    private final LogEventFactory factory;

    // Ensure that the weak reference is not finalized
    @SuppressWarnings({"FieldCanBeLocal", "unused"})
    private final Logger julLogger;
    private final SimpleFormatter simpleFormatter = new SimpleFormatter();

    public JavaUtilLoggingAdapter(LogEventFactory factory, LoggerDelegator loggerDelegator, Logger julLogger) {
        this.factory = factory;
        this.julLogger = julLogger;
        julLogger.setLevel(toJavaUtilLoggingLevel(loggerDelegator.getEffectiveFilter().getThreshold()));
        julLogger.setUseParentHandlers(false);
    }

    /**
     * Ensures that logging to {@link java.util.logging.Logger} is intercepted. Removes existing java.util.logging
     * handlers and adds a new {@link JavaUtilLoggingAdapter}
     */

    public static void installHandler(LogEventFactory factory, LoggerDelegator logger) {
        java.util.logging.Logger julLogger = java.util.logging.Logger.getLogger(getName(logger));
        Stream.of(julLogger.getHandlers()).forEach(julLogger::removeHandler);
        julLogger.addHandler(new JavaUtilLoggingAdapter(factory, logger, julLogger));
    }

    private static String getName(LoggerDelegator logger) {
        return logger.getName().equals("ROOT") ? "" : logger.getName();
    }

    private static Level toJavaUtilLoggingLevel(org.slf4j.event.Level level) {
        if (level==null) {
            return Level.OFF;
        }
        switch (level) {
            case ERROR: return Level.SEVERE;
            case WARN: return Level.WARNING;
            case INFO: return Level.INFO;
            case DEBUG: return Level.FINE;
            case TRACE: return Level.ALL;
            default:
                throw new IllegalArgumentException();
        }
    }

    @Override
    public void publish(LogRecord record) {
        if (record != null) {
            LogEventGenerator generator = getLogEventGenerator(record);
            if (generator.isEnabled()) {
                if (record.getThrown() != null) {
                    generator.log(simpleFormatter.formatMessage(record), record.getThrown());
                } else {
                    generator.log(simpleFormatter.formatMessage(record));
                }
            }
        }
    }

    private LogEventGenerator getLogEventGenerator(LogRecord record) {
        org.slf4j.event.Level level = LoggerDelegator.getLevel(fromJavaUtilLoggingLevel(record.getLevel()));
        return factory.getLogger(record.getLoggerName()).getLogger(level);
    }

    private int fromJavaUtilLoggingLevel(Level level) {
        if (level.intValue() <= Level.FINER.intValue()) {
            return LocationAwareLogger.TRACE_INT;
        } else if (level.intValue() <= Level.FINE.intValue()) {
            return LocationAwareLogger.DEBUG_INT;
        } else if (level.intValue() <= Level.INFO.intValue()) {
            return LocationAwareLogger.INFO_INT;
        } else if (level.intValue() <= Level.WARNING.intValue()) {
            return LocationAwareLogger.WARN_INT;
        } else {
            return LocationAwareLogger.ERROR_INT;
        }
    }

    @Override
    public void flush() {

    }

    @Override
    public void close() throws SecurityException {

    }
}

1	package org.logevents.core;
2
3	import org.logevents.LogEventFactory;
4	import org.slf4j.spi.LocationAwareLogger;
5
6	import java.util.logging.Handler;
7	import java.util.logging.Level;
8	import java.util.logging.LogRecord;
9	import java.util.logging.Logger;
10	import java.util.logging.SimpleFormatter;
11	import java.util.stream.Stream;
12
13	/**
14	* An adapter from java.util.logging to LogEvents. Automatically installed by {@link LogEventFactory}
15	*/
16	public class JavaUtilLoggingAdapter extends Handler {
17	private final LogEventFactory factory;
18
19	// Ensure that the weak reference is not finalized
20	@SuppressWarnings({"FieldCanBeLocal", "unused"})
21	private final Logger julLogger;
22	private final SimpleFormatter simpleFormatter = new SimpleFormatter();	1✔
23
24	public JavaUtilLoggingAdapter(LogEventFactory factory, LoggerDelegator loggerDelegator, Logger julLogger) {	1✔
25	this.factory = factory;	1✔
26	this.julLogger = julLogger;	1✔
27	julLogger.setLevel(toJavaUtilLoggingLevel(loggerDelegator.getEffectiveFilter().getThreshold()));	1✔
28	julLogger.setUseParentHandlers(false);	1✔
29	}	1✔
30
31	/**
32	* Ensures that logging to {@link java.util.logging.Logger} is intercepted. Removes existing java.util.logging
33	* handlers and adds a new {@link JavaUtilLoggingAdapter}
34	*/
35
36	public static void installHandler(LogEventFactory factory, LoggerDelegator logger) {
37	java.util.logging.Logger julLogger = java.util.logging.Logger.getLogger(getName(logger));	1✔
38	Stream.of(julLogger.getHandlers()).forEach(julLogger::removeHandler);	1✔
39	julLogger.addHandler(new JavaUtilLoggingAdapter(factory, logger, julLogger));	1✔
40	}	1✔
41
42	private static String getName(LoggerDelegator logger) {
43	return logger.getName().equals("ROOT") ? "" : logger.getName();	1✔
44	}
45
46	private static Level toJavaUtilLoggingLevel(org.slf4j.event.Level level) {
47	if (level==null) {	1✔
48	return Level.OFF;	×
49	}
50	switch (level) {	1✔
51	case ERROR: return Level.SEVERE;	1✔
52	case WARN: return Level.WARNING;	1✔
53	case INFO: return Level.INFO;	1✔
54	case DEBUG: return Level.FINE;	1✔
55	case TRACE: return Level.ALL;	1✔
56	default:
57	throw new IllegalArgumentException();	×
58	}
59	}
60
61	@Override
62	public void publish(LogRecord record) {
63	if (record != null) {	1✔
64	LogEventGenerator generator = getLogEventGenerator(record);	1✔
65	if (generator.isEnabled()) {	1✔
66	if (record.getThrown() != null) {	1✔
67	generator.log(simpleFormatter.formatMessage(record), record.getThrown());	×
68	} else {
69	generator.log(simpleFormatter.formatMessage(record));	1✔
70	}
71	}
72	}
73	}	1✔
74
75	private LogEventGenerator getLogEventGenerator(LogRecord record) {
76	org.slf4j.event.Level level = LoggerDelegator.getLevel(fromJavaUtilLoggingLevel(record.getLevel()));	1✔
77	return factory.getLogger(record.getLoggerName()).getLogger(level);	1✔
78	}
79
80	private int fromJavaUtilLoggingLevel(Level level) {
81	if (level.intValue() <= Level.FINER.intValue()) {	1✔
82	return LocationAwareLogger.TRACE_INT;	1✔
83	} else if (level.intValue() <= Level.FINE.intValue()) {	1✔
84	return LocationAwareLogger.DEBUG_INT;	1✔
85	} else if (level.intValue() <= Level.INFO.intValue()) {	1✔
86	return LocationAwareLogger.INFO_INT;	×
87	} else if (level.intValue() <= Level.WARNING.intValue()) {	1✔
88	return LocationAwareLogger.WARN_INT;	×
89	} else {
90	return LocationAwareLogger.ERROR_INT;	1✔
91	}
92	}
93
94	@Override
95	public void flush() {
96
97	}	×
98
99	@Override
100	public void close() throws SecurityException {
101
102	}	1✔
103	}

jhannes / logevents / #114

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous