Merge pull request #88 from SAP/refactor-servlet-filters

Refactor Servlet Filters

Author: KarstenSchnitter

cf-java-logging-support-servlet/src/main/java/com/sap/hcp/cf/logging/servlet/dynlog/DynLogEnvironment.java

@@ -10,7 +10,7 @@
 
 import com.sap.hcp.cf.logging.common.helper.Environment;
 
-public class DynLogEnvironment implements DynLogConfiguration {
+public class DynLogEnvironment implements DynamicLogLevelConfiguration {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(DynLogEnvironment.class);
     private final RSAPublicKey rsaPublicKey;

cf-java-logging-support-servlet/src/main/java/com/sap/hcp/cf/logging/servlet/dynlog/DynLogConfiguration.java renamed to cf-java-logging-support-servlet/src/main/java/com/sap/hcp/cf/logging/servlet/dynlog/DynamicLogLevelConfiguration.java

@@ -4,12 +4,15 @@
 
 import javax.servlet.http.HttpServletRequest;
 
-public interface DynLogConfiguration {
-
-    String getDynLogHeaderKey();
+@FunctionalInterface
+public interface DynamicLogLevelConfiguration {
 
     RSAPublicKey getRsaPublicKey();
 
+    default String getDynLogHeaderKey() {
+        return "SAP-LOG-LEVEL";
+    };
+
     default String getDynLogHeaderValue(HttpServletRequest httpRequest) {
         return httpRequest.getHeader(getDynLogHeaderKey());
     }

cf-java-logging-support-servlet/src/main/java/com/sap/hcp/cf/logging/servlet/dynlog/DynamicLogLevelProcessor.java

@@ -32,11 +32,11 @@ public class DynamicLogLevelProcessor {
      *             {@link DynamicLogLevelProcessor#DynamicLogLevelProcessor(RSAPublicKey)}
      *             instead.
      * @param dynLogConfig
-     *            the {@link DynLogConfiguration} to read the public RSA key for
+     *            the {@link DynamicLogLevelConfiguration} to read the public RSA key for
      *            JWT validation from.
      */
     @Deprecated
-    public DynamicLogLevelProcessor(DynLogConfiguration dynLogConfig) {
+    public DynamicLogLevelProcessor(DynamicLogLevelConfiguration dynLogConfig) {
         this(dynLogConfig.getRsaPublicKey());
     }
 

cf-java-logging-support-servlet/src/main/java/com/sap/hcp/cf/logging/servlet/filter/AbstractLoggingFilter.java

@@ -0,0 +1,95 @@
+package com.sap.hcp.cf.logging.servlet.filter;
+
+import java.io.IOException;
+
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+public abstract class AbstractLoggingFilter implements Filter {
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,
+                                                                                              ServletException {
+        if (request instanceof HttpServletRequest && response instanceof HttpServletResponse) {
+            doFilterRequest((HttpServletRequest) request, (HttpServletResponse) response, chain);
+        } else {
+            chain.doFilter(request, response);
+        }
+    }
+
+    /**
+     * Provides a default implementation for handling servlet requests already
+     * cast to {@link HttpServletRequest} and {@link HttpServletResponse}.
+     * Custom implementations of {@link AbstractLoggingFilter} should overwrite
+     * {@link #beforeFilter(HttpServletRequest, HttpServletResponse)} and/or
+     * {@link #cleanup(HttpServletRequest, HttpServletResponse)}.
+     * 
+     * @param request
+     *            cast as {@link HttpServletRequest}
+     * @param response
+     *            cast as {@link HttpServletResponse}
+     * @param chain
+     *            the {@link FilterChain} to continue request handling
+     * @throws IOException
+     * @throws ServletException
+     */
+    protected void doFilterRequest(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
+                                                                                                                throws IOException,
+                                                                                                                ServletException {
+        try {
+            beforeFilter(request, response);
+            chain.doFilter(request, response);
+        } finally {
+            cleanup(request, response);
+
+        }
+    }
+
+    /**
+     * Processes the request/response before it is passed along the filter
+     * chain. Even if {@link #beforeFilter} fails, {@link #cleanup} will be
+     * executed.
+     * 
+     * @param request
+     * @param response
+     */
+    protected void beforeFilter(HttpServletRequest request, HttpServletResponse response) {
+    }
+
+    /**
+     * Cleanup after the request/response was handled by the filter chain. This
+     * is executed even in cases of failures during handling or
+     * {@link #beforeFilter}. Use this method to reset or clean-up state, e.g.
+     * MDC. Be aware, that there may be partially initalized state from
+     * {@link #beforeFilter}.
+     * 
+     * @param request
+     * @param response
+     */
+    protected void cleanup(HttpServletRequest request, HttpServletResponse response) {
+    }
+
+    /**
+     * This is an empty implementation for filters, that do not require
+     * initialization.
+     */
+    @Override
+    public void init(FilterConfig filterConfig) throws ServletException {
+        // nothing to do
+    }
+
+    /**
+     * this is an empty implementation for tolters, that do not require clean-up
+     * of state.
+     */
+    @Override
+    public void destroy() {
+        // nothing to do
+    }
+}

cf-java-logging-support-servlet/src/main/java/com/sap/hcp/cf/logging/servlet/filter/AddHttpHeadersToLogContextFilter.java

@@ -0,0 +1,75 @@
+package com.sap.hcp.cf.logging.servlet.filter;
+
+import static java.util.Collections.unmodifiableList;
+import static java.util.stream.Collectors.toList;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import com.sap.hcp.cf.logging.common.LogContext;
+import com.sap.hcp.cf.logging.common.request.HttpHeader;
+import com.sap.hcp.cf.logging.common.request.HttpHeaders;
+
+/**
+ * Extracts the HTTP headers from the request and adds them to the logging
+ * context. It defaults to {@link HttpHeaders#propagated()}. Custom headers can
+ * be used.
+ */
+public class AddHttpHeadersToLogContextFilter extends AbstractLoggingFilter {
+
+    private List<HttpHeader> headers;
+    private List<String> fields;
+
+    /**
+     * The default constructor uses {@link HttpHeaders#propagated()} to define
+     * the HTTP headers, that are added to the logging context.
+     */
+    public AddHttpHeadersToLogContextFilter() {
+        this(HttpHeaders.propagated());
+    }
+
+    public AddHttpHeadersToLogContextFilter(HttpHeader... headers) {
+        this(Collections.emptyList(), headers);
+    }
+
+    /**
+     * Use this constructor to add your own HTTP headers to the default list.
+     * You need to implement {@link HttpHeader}. Note, that
+     * {@link HttpHeader#isPropagated} needs to be true. All other headers will
+     * be ignored. Usage to add your own header would be:
+     * {@code new AddHttpHeadersToLogContextFilter(HttpHeaders.propagated, yourHeader)}
+     * 
+     * @param list
+     *            a list of {@link HttpHeader}, can be default
+     *            {@link HttpHeaders#propagated()}
+     * @param custom
+     *            a single {@link HttpHeader} to add to the list
+     */
+    public AddHttpHeadersToLogContextFilter(List<? extends HttpHeader> list, HttpHeader... custom) {
+        Stream<HttpHeader> allHeaders = Stream.concat(list.stream(), Arrays.stream(custom));
+        this.headers = unmodifiableList(allHeaders.filter(HttpHeader::isPropagated).collect(toList()));
+        this.fields = unmodifiableList(headers.stream().map(HttpHeader::getField).filter(Objects::nonNull).collect(
+                                                                                                                   toList()));
+    }
+
+    @Override
+    protected void beforeFilter(HttpServletRequest request, HttpServletResponse response) {
+        for (HttpHeader header: headers) {
+            String headerValue = HttpHeaderUtilities.getHeaderValue(request, header);
+            if (header.getField() != null && headerValue != null) {
+                LogContext.add(header.getField(), headerValue);
+            }
+        }
+    }
+
+    @Override
+    protected void cleanup(HttpServletRequest request, HttpServletResponse response) {
+        fields.forEach(LogContext::remove);
+    }
+}

cf-java-logging-support-servlet/src/main/java/com/sap/hcp/cf/logging/servlet/filter/AddVcapEnvironmentToLogContextFilter.java

@@ -0,0 +1,34 @@
+package com.sap.hcp.cf.logging.servlet.filter;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import com.sap.hcp.cf.logging.common.LogContext;
+
+/**
+ * <p>
+ * The {@link AddVcapEnvironmentToLogContextFilter} extracts CF specific
+ * metadata about the running application and adds it to the log context. The
+ * metadata includes the app, org and space names and ids. This allows to
+ * attribute a generated log message to the correct source from the message
+ * alone.
+ * </p>
+ * 
+ * <p>
+ * <b>Note:</b> This metadata can usually also be obtained from the CF channel
+ * shipping the logs, e.g. syslog structured data. Hence, depending on the
+ * use-case, it may not be required to add the metadata with this filter.
+ * </p>
+ */
+public class AddVcapEnvironmentToLogContextFilter extends AbstractLoggingFilter {
+
+    @Override
+    protected void beforeFilter(HttpServletRequest request, HttpServletResponse response) {
+        LogContext.loadContextFields();
+    }
+
+    @Override
+    protected void cleanup(HttpServletRequest request, HttpServletResponse response) {
+        LogContext.resetContextFields();
+    }
+}

cf-java-logging-support-servlet/src/main/java/com/sap/hcp/cf/logging/servlet/filter/CompositeFilter.java

@@ -0,0 +1,91 @@
+package com.sap.hcp.cf.logging.servlet.filter;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+
+/**
+ * <p>
+ * The {@link CompositeFilter} allows to group several servlet {@link Filter}
+ * into one. This is used to allow customizable filters and provide a backwards
+ * compatible {@link RequestLoggingFilter}. The {@link FilterConfig} is
+ * forwarded to all filters, that are grouped. This may lead to
+ * incompatibilities between those shared configurations.
+ * </p>
+ * 
+ * <p>
+ * You can easily create a subclass of {@link CompositeFilter} and add all the
+ * filters from com.sap.hcp.cf.logging.servlet.filter you wish. You can even
+ * bring your own filters. Make sure, there are no incompatible
+ * {@link FilterConfig} initializations.
+ * </p>
+ */
+public class CompositeFilter implements Filter {
+
+    private final List<Filter> filters;
+
+    public CompositeFilter(Filter... filters) {
+        this.filters = new ArrayList<>(filters.length);
+        Collections.addAll(this.filters, filters);
+    }
+
+    public List<Filter> getFilters() {
+        return Collections.unmodifiableList(filters);
+    }
+
+    /**
+     * Forwards the {@link FilterConfig} to all grouped filters. Be care to use
+     * only filters, that are compatible to each other.
+     */
+    @Override
+    public void init(FilterConfig config) throws ServletException {
+        for (Filter filter: this.filters) {
+            filter.init(config);
+        }
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,
+                                                                                              ServletException {
+        new InternalFilterChain(chain, this.filters).doFilter(request, response);
+    }
+
+    @Override
+    public void destroy() {
+        for (int i = this.filters.size() - 1; i >= 0; i--) {
+            Filter filter = this.filters.get(i);
+            filter.destroy();
+        }
+    }
+
+    private static class InternalFilterChain implements FilterChain {
+
+        private final FilterChain originalChain;
+        private final Iterator<? extends Filter> current;
+
+        public InternalFilterChain(FilterChain chain, List<? extends Filter> additionalFilters) {
+            this.originalChain = chain;
+            this.current = additionalFilters.iterator();
+        }
+
+        @Override
+        public void doFilter(final ServletRequest request, final ServletResponse response) throws IOException,
+                                                                                           ServletException {
+            if (current.hasNext()) {
+                current.next().doFilter(request, response, this);
+            } else {
+                originalChain.doFilter(request, response);
+            }
+        }
+    }
+
+}

cf-java-logging-support-servlet/src/main/java/com/sap/hcp/cf/logging/servlet/filter/ContentLengthTrackingResponseWrapper.java

@@ -19,7 +19,7 @@ public class ContentLengthTrackingResponseWrapper extends HttpServletResponseWra
     private WrappedOutputStream wrappedOS = null;
     private WrappedPrintWriter wrappedWriter = null;
 
-    public ContentLengthTrackingResponseWrapper(HttpServletResponse response) throws IOException {
+    public ContentLengthTrackingResponseWrapper(HttpServletResponse response) {
         super(response);
         this.response = response;
     }