gini / dropwizard-gelf / 83

pending completion

Build # 83

Build Type

Pull #13

travis-ci

Committed by

Trundle

Commit Message

<a href="https://github.com/gini/dropwizard-gelf/commit/<a class=hub.com/gini/dropwizard-gelf/commit/<a class="double-link" href="https://git"><a class=hub.com/gini/dropwizard-gelf/commit/<a class="double-link" href="https://git"><a class=hub.com/gini/dropwizard-gelf/commit/<a class="double-link" href="https://git"><a class=hub.com/gini/dropwizard-gelf/commit/be7306921227131bd9251b64a2dfe9ea7d252b3b">be7306921<a href="https://github.com/gini/dropwizard-gelf/commit/be7306921227131bd9251b64a2dfe9ea7d252b3b">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/gini/dropwizard-gelf/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/gini/dropwizard-gelf/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/gini/dropwizard-gelf/commit/be7306921227131bd9251b64a2dfe9ea7d252b3b&quot;&gt;be7306921&lt;/a&gt;&lt;a href=&quot;https://github.com/gini/dropwizard-gelf/commit/be7306921227131bd9251b64a2dfe9ea7d252b3b&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/gini/dropwizard-gelf/commit/be7306921227131bd9251b64a2dfe9ea7d252b3b&amp;quot;&amp;gt;&amp;amp;quot;&amp;amp;gt;Add a new UncaughtExceptionHandler that inits a GELF appender before logging

Since Dropwizard 0.8, the logging system is shut down when the run method of
a ConfiguredCommand is left (see
https://github.com/dro&lt;/a>pwizard/dropwizard/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/gini/dropwizard-gelf/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/gini/dropwizard-gelf/commit/<a class="double-link" href="https://github.com/gini/dropwizard-gelf/commit/cebfb632b71e3524a678e7c1f1df64264de7dcae">cebfb632b</a>&quot;&gt;cebfb632b&lt;/a&gt;&quot;&gt;cebfb632b&lt;/a&gt;&lt;a href=&quot;https://github.com/gini/dropwizard-gelf/commit/be7306921227131bd9251b64a2dfe9ea7d252b3b&quot;&gt;)
Unfortunately, that also means that the GELF appender we bootstraped before
entering the run method is stopped as well. Th</a>e new exception handler
(re-)adds a GELF appender before doing the actual logging call.

Pull Request Pull Request #13: New UncaughtExceptionHandler: LoggingSystemExit

Run Details

37 of 37 new or added lines in 1 file covered. (100.0%)

54 of 240 relevant lines covered (22.5%)

0.63 hits per line

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

0.0

/src/main/java/net/gini/dropwizard/gelf/logging/UncaughtExceptionHandlers.java

package net.gini.dropwizard.gelf.logging;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static java.lang.String.format;
import static java.util.Objects.requireNonNull;

/**
 * Simple factory for a {@link Thread.UncaughtExceptionHandler} which logs the last uncaught exception with a SLF4J {@link
 * Logger} on ERROR level.
 */
public final class UncaughtExceptionHandlers {

    private UncaughtExceptionHandlers() {
    }

    /**
     * Returns a builder for an exception handler that bootstraps a GELF log appender, logs the uncaught exception
     * and then exits the system. This is particularly useful for the main thread, which may start up other,
     * non-daemon threads, but fail to fully initialize the application successfully.
     * <br>
     * Example usage:
     * <pre>public static void main(String[] args) {
     *   Thread.currentThread().setUncaughtExceptionHandler(
     *       UncaughtExceptionHandlers.loggingSystemExitBuilder("some-service", "log.example.com").build());
     *   ...
     * </pre>
     *
     * @param facility The facility to use in the GELF messages
     * @param host     The host of the Graylog server
     * @return builder object for building the exception handler
     */
    public static LoggingSystemExitBuilder loggingSystemExitBuilder(final String facility, final String host) {
        return new LoggingSystemExitBuilder(facility, host);
    }

    /**
     * Returns an exception handler that logs the uncaught exception to {@code System.err} and then exits the system.
     * This is particularly useful for the main thread, which may start up other, non-daemon threads, but fail to fully
     * initialize the application successfully. <br> Example usage:
     * <pre>public static void main(String[] args) {
     *   Thread.currentThread().setUncaughtExceptionHandler(
     *       UncaughtExceptionHandlers.systemExit());
     *   ...
     * </pre>
     *
     * @return exception handler
     */
    public static Thread.UncaughtExceptionHandler systemExit() {
        return new Exiter(Runtime.getRuntime());
    }

    public static final class LoggingSystemExitBuilder {

        private String facility;
        private String host;
        private int port = 12201;
        private boolean cleanRootLogger = false;
        private boolean logToStderr = true;

        LoggingSystemExitBuilder(final String facility, final String host) {
            this.facility = requireNonNull(facility);
            this.host = requireNonNull(host);
        }

        /**
         * Sets the port of the Graylog server.
         *
         * @param port The port of the Graylog server.
         * @return {@link LoggingSystemExitBuilder} instance
         */
        public LoggingSystemExitBuilder port(final int port) {
            this.port = port;
            return this;
        }

        /**
         * Sets whether all existing appenders should be detached from the root logger.
         *
         * @param cleanRootLogger If true, detach and stop all other appenders from the root logger
         * @return {@link LoggingSystemExitBuilder} instance
         */
        public LoggingSystemExitBuilder cleanRootLogger(final boolean cleanRootLogger) {
            this.cleanRootLogger = cleanRootLogger;
            return this;
        }

        /**
         * Sets whether the stacktrace of the uncaught exception should be printed to {@code System.err}.
         *
         * @param logToStderr If true, print the stacktrace to {@code System.err}
         * @return {@link LoggingSystemExitBuilder} instance
         */
        public LoggingSystemExitBuilder logToStderr(final boolean logToStderr) {
            this.logToStderr = logToStderr;
            return this;
        }

        public Thread.UncaughtExceptionHandler build() {
            return new LoggingExiter(Runtime.getRuntime(), facility, host, port, cleanRootLogger, logToStderr);
        }
    }

    /**
     * Exception handler that exits the system. Bootstrap a GELF log appender and logs the uncaught exception.
     * Optionally prints the stacktrace to {@code System.err} as well.
     */
    private static final class LoggingExiter implements Thread.UncaughtExceptionHandler {

        private static final Logger LOGGER = LoggerFactory.getLogger(Exiter.class);

        private final Runtime runtime;
        private final String name;
        private final String host;
        private final int port;
        private final boolean cleanRootLogger;
        private final boolean logToStderr;

        private LoggingExiter(final Runtime runtime, final String name, final String host, final int port,
                              final boolean cleanRootLogger, final boolean logToStderr) {
            this.runtime = runtime;
            this.name = name;
            this.host = host;
            this.port = port;
            this.cleanRootLogger = cleanRootLogger;
            this.logToStderr = logToStderr;
        }

        @Override
        public void uncaughtException(final Thread t, final Throwable e) {
            // Re-initialize logging system (as dropwizard likely has stopped it)
            GelfBootstrap.bootstrap(name, host, port, cleanRootLogger);
            // Log the exception
            final String msg = format("Caught an exception in %s.  Shutting down", t);
            LOGGER.error(msg, e);
            if (logToStderr) {
                System.err.print(msg);
                System.err.print("! ");
                e.printStackTrace(System.err);
            }
            // Stop appenders (should flush all existing messages)
            getRootLogger().detachAndStopAllAppenders();
            // Terminate the JVM
            runtime.exit(1);
        }

        private ch.qos.logback.classic.Logger getRootLogger() {
            return (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
        }
    }

    private static final class Exiter implements Thread.UncaughtExceptionHandler {

        private final Runtime runtime;

        private Exiter(final Runtime runtime) {
            this.runtime = requireNonNull(runtime);
        }

        @Override
        public void uncaughtException(final Thread t, final Throwable e) {
            System.err.print(format("Caught an exception in %s.  Shutting down! ", t));
            e.printStackTrace(System.err);
            runtime.exit(1);
        }
    }
}

1	package net.gini.dropwizard.gelf.logging;
2
3	import org.slf4j.Logger;
4	import org.slf4j.LoggerFactory;
5
6	import static java.lang.String.format;
7	import static java.util.Objects.requireNonNull;
8
9	/**
10	* Simple factory for a {@link Thread.UncaughtExceptionHandler} which logs the last uncaught exception with a SLF4J {@link
11	* Logger} on ERROR level.
12	*/
13	public final class UncaughtExceptionHandlers {
14
15	private UncaughtExceptionHandlers() {	×
16	}	×
17
18	/**
19	* Returns a builder for an exception handler that bootstraps a GELF log appender, logs the uncaught exception
20	* and then exits the system. This is particularly useful for the main thread, which may start up other,
21	* non-daemon threads, but fail to fully initialize the application successfully.
22	* <br>
23	* Example usage:
24	* <pre>public static void main(String[] args) {
25	* Thread.currentThread().setUncaughtExceptionHandler(
26	* UncaughtExceptionHandlers.loggingSystemExitBuilder("some-service", "log.example.com").build());
27	* ...
28	* </pre>
29	*
30	* @param facility The facility to use in the GELF messages
31	* @param host The host of the Graylog server
32	* @return builder object for building the exception handler
33	*/
34	public static LoggingSystemExitBuilder loggingSystemExitBuilder(final String facility, final String host) {
35	return new LoggingSystemExitBuilder(facility, host);	×
36	}
37
38	/**
39	* Returns an exception handler that logs the uncaught exception to {@code System.err} and then exits the system.
40	* This is particularly useful for the main thread, which may start up other, non-daemon threads, but fail to fully
41	* initialize the application successfully. <br> Example usage:
42	* <pre>public static void main(String[] args) {
43	* Thread.currentThread().setUncaughtExceptionHandler(
44	* UncaughtExceptionHandlers.systemExit());
45	* ...
46	* </pre>
47	*
48	* @return exception handler
49	*/
50	public static Thread.UncaughtExceptionHandler systemExit() {
51	return new Exiter(Runtime.getRuntime());	×
52	}
53
54	public static final class LoggingSystemExitBuilder {
55
56	private String facility;
57	private String host;
58	private int port = 12201;	×
59	private boolean cleanRootLogger = false;	×
60	private boolean logToStderr = true;	×
61
62	LoggingSystemExitBuilder(final String facility, final String host) {	×
63	this.facility = requireNonNull(facility);	×
64	this.host = requireNonNull(host);	×
65	}	×
66
67	/**
68	* Sets the port of the Graylog server.
69	*
70	* @param port The port of the Graylog server.
71	* @return {@link LoggingSystemExitBuilder} instance
72	*/
73	public LoggingSystemExitBuilder port(final int port) {
74	this.port = port;	×
75	return this;	×
76	}
77
78	/**
79	* Sets whether all existing appenders should be detached from the root logger.
80	*
81	* @param cleanRootLogger If true, detach and stop all other appenders from the root logger
82	* @return {@link LoggingSystemExitBuilder} instance
83	*/
84	public LoggingSystemExitBuilder cleanRootLogger(final boolean cleanRootLogger) {
85	this.cleanRootLogger = cleanRootLogger;	×
86	return this;	×
87	}
88
89	/**
90	* Sets whether the stacktrace of the uncaught exception should be printed to {@code System.err}.
91	*
92	* @param logToStderr If true, print the stacktrace to {@code System.err}
93	* @return {@link LoggingSystemExitBuilder} instance
94	*/
95	public LoggingSystemExitBuilder logToStderr(final boolean logToStderr) {
96	this.logToStderr = logToStderr;	×
97	return this;	×
98	}
99
100	public Thread.UncaughtExceptionHandler build() {
101	return new LoggingExiter(Runtime.getRuntime(), facility, host, port, cleanRootLogger, logToStderr);	×
102	}
103	}
104
105	/**
106	* Exception handler that exits the system. Bootstrap a GELF log appender and logs the uncaught exception.
107	* Optionally prints the stacktrace to {@code System.err} as well.
108	*/
109	private static final class LoggingExiter implements Thread.UncaughtExceptionHandler {
110
111	private static final Logger LOGGER = LoggerFactory.getLogger(Exiter.class);	×
112
113	private final Runtime runtime;
114	private final String name;
115	private final String host;
116	private final int port;
117	private final boolean cleanRootLogger;
118	private final boolean logToStderr;
119
120	private LoggingExiter(final Runtime runtime, final String name, final String host, final int port,
121	final boolean cleanRootLogger, final boolean logToStderr) {	×
122	this.runtime = runtime;	×
123	this.name = name;	×
124	this.host = host;	×
125	this.port = port;	×
126	this.cleanRootLogger = cleanRootLogger;	×
127	this.logToStderr = logToStderr;	×
128	}	×
129
130	@Override
131	public void uncaughtException(final Thread t, final Throwable e) {
132	// Re-initialize logging system (as dropwizard likely has stopped it)
133	GelfBootstrap.bootstrap(name, host, port, cleanRootLogger);	×
134	// Log the exception
135	final String msg = format("Caught an exception in %s. Shutting down", t);	×
136	LOGGER.error(msg, e);	×
137	if (logToStderr) {	×
138	System.err.print(msg);	×
139	System.err.print("! ");	×
140	e.printStackTrace(System.err);	×
141	}
142	// Stop appenders (should flush all existing messages)
143	getRootLogger().detachAndStopAllAppenders();	×
144	// Terminate the JVM
145	runtime.exit(1);	×
146	}	×
147
148	private ch.qos.logback.classic.Logger getRootLogger() {
149	return (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);	×
150	}
151	}
152
153	private static final class Exiter implements Thread.UncaughtExceptionHandler {
154
155	private final Runtime runtime;
156
157	private Exiter(final Runtime runtime) {	×
158	this.runtime = requireNonNull(runtime);	×
159	}	×
160
161	@Override
162	public void uncaughtException(final Thread t, final Throwable e) {
163	System.err.print(format("Caught an exception in %s. Shutting down! ", t));	×
164	e.printStackTrace(System.err);	×
165	runtime.exit(1);	×
166	}	×
167	}
168	}

gini / dropwizard-gelf / 83

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