Conditionally Print Stack Trace on Error Page Depending on Log Level using Facelets, Seam, and Logback

I would like to print the stack trace for the exception that was caught by pages.xml, but I only want to do so if the most granular logging level is more granular than warn. This way, testers can copy/paste the stack trace, but end users will never see it.

Environment details:

• IBM WebSphere Application Server 7 (logging level details)
• JBoss Seam 2.2.0.GA
• JSF Facelets 1.1.15
• Logback 0.9.21
  • SLF4J 1.6.0
    • Log4j over SLF4J
    • JCL over SLF4J

Here's how exceptions are currently being handled...

From pages.xml:

<?xml version="1.0" encoding="UTF-8"?>
<pages xmlns="http://jboss.com/products/seam/pages" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://jboss.com/products/seam/pages http://jboss.com/products/seam/pages-2.2.xsd">

    <!-- ... -->

    <exception class="javax.faces.application.ViewExpiredException">
        <end-conversation />
        <redirect view-id="/exceptionSessionTimeout.xhtml" />
    </exception>

    <!--
         Prevent the Facelets error page from appearing.
         This is where I want to conditionally print the stack trace.
         Currently it's more or less just a generic error page.
    -->
    <exception>
        <end-conversation />
        <redirect view-id="/exception.xhtml" />
    </exception>
</pages>

From web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.5" 
        xmlns="http://java.sun.com/xml/ns/javaee" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <!-- ... -->

    <!-- Fallback static HTML page -->
    <error-page>
        <exception-type>java.lang.Exception</exception-ty开发者_运维问答pe>
        <location>/unhandledException.html</location>
    </error-page>
</web-app>

From logback.xml:

<?xml version="1.0" encoding="UTR-8"?>
<configuration scan="true">
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>[%date] [%thread] [%level] [%mdc] [%logger:%method:%line]: %msg%n</pattern>
        </encoder>
    </appender>

    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>/path/to/app-logs-dir/AppName.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>/path/to/app-logs-dir/AppName.%d{yyyy-MM-dd-a}.gz</fileNamePattern>
        </rollingPolicy>
        <encoder>
            <pattern>[%date] [%thread] [%level] [%mdc] [%logger:%method:%line]: %msg%n</pattern>
        </encoder>
    </appender>

    <logger name="com.example" level="trace" />
    <logger name="com.example.auth" level="error" />

    <root level="warn">
        <appender-ref ref="FILE" />
        <appender-ref ref="CONSOLE" />
    </root>
</configuration>

With the ideal solution to this problem, this would cause a stack trace to be printed on /error.xhtml (from pages.xml):

<logger name="com.example" level="trace" />

Whereas this would not:

<logger name="com.example" level="warn" />

Using Facelets with Seam, is there a way to determine Logback's log levels?

Without Seam it's possible with an error handler servlet:

web.xml:

<servlet>
    <servlet-name>ErrorHandlerServlet</servlet-name>
    <servlet-class>com.example.ErrorHandlerServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>ErrorHandlerServlet</servlet-name>
    <url-pattern>/ErrorHandlerServlet</url-pattern>
</servlet-mapping>

<error-page>
    <exception-type>java.lang.Exception</exception-type>
    <location>/ErrorHandlerServlet</location>
</error-page>

'ErrorHandlerServlet.java':

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

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

public class ErrorHandlerServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    private static final Logger logger = LoggerFactory
            .getLogger(ErrorHandlerServlet.class);

    @Override
    protected void doGet(final HttpServletRequest request,
            final HttpServletResponse response)
            throws ServletException, IOException {
        logger.info("handler");

        final Object errorMessage = request
                .getAttribute(RequestDispatcher.ERROR_MESSAGE);
        final Object throwableObj = request
                .getAttribute(RequestDispatcher.ERROR_EXCEPTION);
        logger.warn("error message: {}", errorMessage, throwableObj);

        final Logger appLogger = LoggerFactory
                .getLogger("com.example");
        if (!appLogger.isInfoEnabled()) {
            final RequestDispatcher requestDispatcher = 
                    request.getRequestDispatcher("/error.html");
            requestDispatcher.forward(request, response);
            return;
        }

        final PrintWriter writer = response.getWriter();
        writer.println("<pre>");

        if (throwableObj != null && throwableObj instanceof Throwable) {
            final Throwable throwable = (Throwable) throwableObj;
            throwable.printStackTrace(writer);
        }
        writer.println("</pre>");
    }
}

Anyway, I don't think this would be a good practice, very few people expect that changing the logging configuration influence the behaviour of the application. It could be problematic to have this kind of side effects in a production environment. A show-stacktraces web.xml context parameter maybe a better approach.