通过电子邮件记录servlet异常时需要更多信息

Question

The environment

I'm running a number of applications that use Servlets, including those based on JSF and JAX-WS and some of my own custom servlets. I'm using Tomcat 7.x as my web container. I'm using java.util.logging for logging messages.

Current Situation

For logging exceptions, I have been using SMTPHandler which has worked very well. Here are the relevant excerpts from my logging.properties file:

handlers = {... other handlers ...},08SMTP.smtphandler.SMTPHandler

08SMTP.smtphandler.SMTPHandler.level=SEVERE
08SMTP.smtphandler.SMTPHandler.smtpHost=smtp.somedomain.com
08SMTP.smtphandler.SMTPHandler.to=developers@somedomain.com
08SMTP.smtphandler.SMTPHandler.from=developers@somedomain.com
08SMTP.smtphandler.SMTPHandler.subject=MyApplication error message
08SMTP.smtphandler.SMTPHandler.bufferSize=512
08SMTP.smtphandler.SMTPHandler.formatter=java.util.logging.SimpleFormatter

The only problem with this setup is that the email only contains an exception. There is no other information about the context in which the error happened.

What I'd Like To See

I'd like the email to contain other contextual information from the ServletRequest / HttpServletRequest object such as:

• Who is the user that is logged in?
• What was the queryString, URL, URI, ContextPath, ServletPath, and getMethod of the request?
• What were the header parameters?
• What were the parameters?
• What were the attribute names/values?

The Attempted Solution

Logging Handler s configured by the logging.properties file don't have access to other parts of the application except through static variables, so I thought I'd try to create a logging Handler programatically. I've tried to make a handler, but there is not a way for it to know about the HttpServletRequest that is active at the time of the exception.

I've tried to create my own class that implements both ServletRequestListener and ServletContextListener , then registers a custom logging Handler that knows about a ThreadLocal<ServletRequest> variable, and then set and clear that ThreadLocal variable in the ServletRequestListener . After adding a <listener> reference in my web.xml file which correctly calls contextInitialized and requestInitialized , my logging Handler's publish method is never called when an exception happens .

The code for this is here.

public class LoggingWebListener
    implements ServletRequestListener, ServletContextListener
{
    public static class FtSmtpHandler
        extends Handler
    {
        private final ServletContext sc;
        private final ThreadLocal<ServletRequest> servletReqLocal;

        public FtSmtpHandler(ServletContext servletContext, ThreadLocal<ServletRequest> servletReqLocal)
        {
            this.sc = servletContext;
            this.servletReqLocal = servletReqLocal;
        }

        @Override public void publish(LogRecord record)
        {
            if (record.getLevel().intValue() < Level.WARNING.intValue())
                return;
            // Don't try to send email if the emailer fails and logs an exception
            if (record.getLoggerName().equals(MyEmailHelper.class.getName()))
                return;

            // CODE TO SEND EMAIL GOES HERE
        }

        @Override public void flush()
        {
        }

        @Override public void close()
            throws SecurityException
        {
        }
    }

    public static final Logger glogger = Logger.getGlobal();
    public static final Logger logger = Logger.getLogger(LoggingWebListener.class.getName());
    private final ThreadLocal<ServletRequest> servletReqLocal = new ThreadLocal<>();
    private FtSmtpHandler handler;

    public LoggingWebListener()
    {
    }

    @Override public void contextInitialized(ServletContextEvent evt)
    {
        logger.log(Level.INFO, "Initializing context for " + getClass().getName());
        ServletContext servletContext = evt.getServletContext();
        handler = new FtSmtpHandler(servletContext, servletReqLocal);
        glogger.addHandler(handler);
    }

    @Override public void contextDestroyed(ServletContextEvent arg0)
    {
        glogger.removeHandler(handler);
        handler = null;
    }

    @Override public void requestInitialized(ServletRequestEvent evt)
    {
        ServletRequest servletRequest = evt.getServletRequest();
        // logger.log(Level.INFO, "Initializing request for request " + servletRequest);
        servletReqLocal.set(servletRequest);
    }

    @Override public void requestDestroyed(ServletRequestEvent evt)
    {
        servletReqLocal.remove();
    }
}

Is there a small mistake in what I'm doing? Is it the totally wrong approach? Is there an already existing module that will do what I want that I haven't found? Is there another way to do what I want to do?

This post suggests an approach similar to what I've taken, but does not have the details.

Answer 1

Create a custom servlet filter that will be triggered for all calls the the application. Then create a custom formatter that knows how to format the properties of your request. Inside the filter, capture the current request and send it over to the custom formatter that you installed on the SMTPHandler to gain access to the request object.

    public class RequestContextFilter implements javax.servlet.Filter {

        private static final String CLASS_NAME = MdcFilter.class.getName();
        private static final Logger logger = Logger.getLogger("");
        private volatile Handler emailer;

        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            emailer = new SMTPHandler();
            //etc...
            emailer.setFormatter(new ContextFormatter());
            logger.addHandler(emailer);
        }

        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
            ContextFormatter.CTX.set(request);
            try {
                chain.doFilter(request, response);
            } finally {
                ContextFormatter.CTX.remove();
            }
        }

        @Override
        public void destroy() {
            logger.removeHandler(emailer);
            emailer.close();
        }

        private static class ContextFormatter extends Formatter {

            static final ThreadLocal<ServletRequest> CTX = new ThreadLocal();
            private final Formatter txt = new SimpleFormatter();

            @Override
            public String format(LogRecord record) {
                HttpServletRequest req = (HttpServletRequest) CTX.get();
                return req.getRequestURI() + " " + txt.format(record);
            }
        }
    }

Since this is using a thread local it won't work if there is a thread handoff between the logger and filter.