Migrate RequestLoggingFilter to new implementation

The RequestLoggingFilter is the originally provided filter of the module.
Goal of the refactoring was, to provide its functionality by several stand-alone filters.
To enable backwards-compatibility and ease of use, the original filter was
reimplemented as composite filter.

This can be used as an example for custom filter configurations and implementations.

Author: KarstenSchnitter

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

@@ -1,5 +1,7 @@
 package com.sap.hcp.cf.logging.servlet.filter;
 
+import static com.sap.hcp.cf.logging.common.customfields.CustomField.customField;
+
 import java.util.UUID;
 
 import javax.servlet.http.HttpServletRequest;
@@ -27,7 +29,7 @@ public class CorrelationIdFilter extends AbstractLoggingFilter {
     public CorrelationIdFilter() {
         this(HttpHeaders.CORRELATION_ID);
     }
-    
+
     public CorrelationIdFilter(HttpHeader correlationHeader) {
         this.correlationHeader = correlationHeader;
     }
@@ -43,7 +45,10 @@ private String determineCorrelationId(HttpServletRequest request) {
         String correlationId = HttpHeaderUtilities.getHeaderValue(request, correlationHeader);
         if (correlationId == null || correlationId.isEmpty() || correlationId.equals(Defaults.UNKNOWN)) {
             correlationId = String.valueOf(UUID.randomUUID());
-            LOG.debug("Generated new correlation-id <{}>", correlationId);
+            // add correlation-id as custom field, since it is added to MDC only
+            // in the next step
+            LOG.debug("Generated new correlation-id <{}>", correlationId, customField(correlationHeader.getField(),
+                                                                                      correlationId));
         }
         return correlationId;
     }
@@ -53,7 +58,7 @@ private void addCorrelationIdHeader(HttpServletResponse response, String correla
             response.setHeader(correlationHeader.getName(), correlationId);
         }
     }
-    
+
     @Override
     protected void postProcess(HttpServletRequest request, HttpServletResponse response) {
         LogContext.remove(correlationHeader.getField());

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

@@ -1,32 +1,16 @@
 package com.sap.hcp.cf.logging.servlet.filter;
 
-import java.io.IOException;
-import java.util.Optional;
-
-import javax.servlet.FilterChain;
-import javax.servlet.ServletException;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import org.apache.commons.lang3.concurrent.ConcurrentException;
-import org.apache.commons.lang3.concurrent.ConcurrentInitializer;
-import org.apache.commons.lang3.concurrent.LazyInitializer;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.sap.hcp.cf.logging.servlet.dynlog.DynamicLogLevelConfiguration;
-import com.sap.hcp.cf.logging.servlet.dynlog.DynLogEnvironment;
-import com.sap.hcp.cf.logging.servlet.dynlog.DynamicLogLevelProcessor;
+import org.slf4j.MDC;
 
 /**
  * <p>
- * A simple servlet filter that logs HTTP request processing info. It will read
- * several HTTP Headers and store them in the SLF4J MDC, so that all log
- * messages created during request handling will have those additional fields.
- * It will also instrument the request to generate a request log containing
- * metrics such as request and response sizes and response time. This
- * instrumentation can be disabled by denying logs from {@link RequestLogger}
- * with marker "request".
+ * THe {@link RequestLoggingFilter} extracts information from HTTP requests and
+ * can create request logs. It will read several HTTP Headers and store them in
+ * the SLF4J MDC, so that all log messages created during request handling will
+ * have those additional fields. It will also instrument the request to generate
+ * a request log containing metrics such as request and response sizes and
+ * response time. This instrumentation can be disabled by denying logs from
+ * {@link RequestLogger} with marker "request".
  * </p>
  * <p>
  * This filter will generate a correlation id, from the HTTP header
@@ -37,116 +21,37 @@
  * <p>
  * This filter supports dynamic log levels activated by JWT tokens in HTTP
  * headers. Setup and processing of these tokens can be changed with own
- * implementations of {@link DynLogEnvironment} and
- * {@link DynamicLogLevelProcessor}. For integration provide a subclass of
- * {@link RequestLoggingFilter} and overwrite
- * {@link RequestLoggingFilter#getDynLogConfiguration()} and
- * {@link RequestLoggingFilter#getDynLogLevelProcessor()}.
+ * implementations of {@link DynamicLogLevelFilter}.
  * </p>
  * <p>
  * To use the filter, it needs to be added to the servlet configuration. It has
- * a default constructor to support web.xml configuration. There are several
- * other constructors that support some customization, in case dynamic
- * configuration (e.g. Spring Boot) is used. You can add further customization
- * by subclassing the filter and overwrite its methods.
+ * a default constructor to support web.xml configuration. You can customize the
+ * filter by creating your own subclass of {@link CompositeFilter} and mix and
+ * match any of the provided filters and add your own implementation:
+ * <ul>
+ * <li>{@link AddVcapEnvironmentToLogContextFilter} provide application metadata
+ * (app_id, app_name, ...) from environment</li>
+ * <li>{@link AddHttpHeadersToLogContextFilter} provides certain HTTP headers to
+ * {@link MDC}</li>
+ * <li>{@link CorrelationIdFilter} extracts "X-CorrelationId" HTTP header or
+ * generates new to add to {@link MDC}</li>
+ * <li>{@link DynamicLogLevelFilter} supports JWT based dynamic changes of log
+ * level per request</li>
+ * <li>{@link GenerateRequestLogFilter} instruments the request to generate the
+ * final request log</li>
+ * </ul>
  * </p>
  */
-public class RequestLoggingFilter extends RequestLoggingBaseFilter {
-
-    private static final Logger LOG = LoggerFactory.getLogger(RequestLoggingFilter.class);
-
-    public static final String LOG_PROVIDER = RequestLoggingBaseFilter.LOG_PROVIDER;
-    public static final String WRAP_RESPONSE_INIT_PARAM = RequestLoggingBaseFilter.WRAP_REQUEST_INIT_PARAM;
-    public static final String WRAP_REQUEST_INIT_PARAM = RequestLoggingBaseFilter.WRAP_REQUEST_INIT_PARAM;
-
-    private ConcurrentInitializer<DynamicLogLevelConfiguration> dynLogEnvironment;
-    private ConcurrentInitializer<DynamicLogLevelProcessor> dynamicLogLevelProcessor;
+public class RequestLoggingFilter extends CompositeFilter {
 
     public RequestLoggingFilter() {
-        this(createDefaultRequestRecordFactory());
+        super(new AddVcapEnvironmentToLogContextFilter(), new AddHttpHeadersToLogContextFilter(),
+              new CorrelationIdFilter(), new DynamicLogLevelFilter(), new GenerateRequestLogFilter());
     }
 
     public RequestLoggingFilter(RequestRecordFactory requestRecordFactory) {
-        this(requestRecordFactory, createDefaultDynLogEnvironment());
-    }
-
-    private static ConcurrentInitializer<DynamicLogLevelConfiguration> createDefaultDynLogEnvironment() {
-        DynLogEnvironment environment = new DynLogEnvironment();
-        return () -> environment;
-    }
-
-    public RequestLoggingFilter(ConcurrentInitializer<DynamicLogLevelConfiguration> dynLogEnvironment) {
-        this(createDefaultRequestRecordFactory(), dynLogEnvironment);
-    }
-    
-    public RequestLoggingFilter(RequestRecordFactory requestRecordFactory,
-                                ConcurrentInitializer<DynamicLogLevelConfiguration> dynLogEnvironment) {
-        super(requestRecordFactory);
-        this.dynLogEnvironment = dynLogEnvironment;
-        this.dynamicLogLevelProcessor = new LazyInitializer<DynamicLogLevelProcessor>() {
-
-            @Override
-            protected DynamicLogLevelProcessor initialize() throws ConcurrentException {
-                return getDynLogConfiguration().map(DynamicLogLevelConfiguration::getRsaPublicKey).map(DynamicLogLevelProcessor::new)
-                                             .get();
-            }
-        };
-    }
-
-    public RequestLoggingFilter(ConcurrentInitializer<DynamicLogLevelConfiguration> dynLogEnvironment,
-                                ConcurrentInitializer<DynamicLogLevelProcessor> dynamicLogLevelProcessor) {
-        this(createDefaultRequestRecordFactory(), dynLogEnvironment, dynamicLogLevelProcessor);
+        super(new AddVcapEnvironmentToLogContextFilter(), new AddHttpHeadersToLogContextFilter(),
+              new CorrelationIdFilter(), new DynamicLogLevelFilter(), new GenerateRequestLogFilter(
+                                                                                                   requestRecordFactory));
     }
-
-    public RequestLoggingFilter(RequestRecordFactory requestRecordFactory,
-                                ConcurrentInitializer<DynamicLogLevelConfiguration> dynLogEnvironment,
-                                ConcurrentInitializer<DynamicLogLevelProcessor> dynamicLogLevelProcessor) {
-        super(requestRecordFactory);
-        this.dynLogEnvironment = dynLogEnvironment;
-        this.dynamicLogLevelProcessor = dynamicLogLevelProcessor;
-    }
-
-    protected Optional<DynamicLogLevelConfiguration> getDynLogConfiguration() {
-        try {
-            return Optional.of(dynLogEnvironment.get());
-        } catch (ConcurrentException cause) {
-            LOG.debug("Cannot initialize dynamic log level environment. Will continue without this feature", cause);
-            return Optional.empty();
-        }
-    }
-
-    protected Optional<DynamicLogLevelProcessor> getDynLogLevelProcessor() {
-        try {
-            if (getDynLogConfiguration().map(DynamicLogLevelConfiguration::getRsaPublicKey).isPresent()) {
-                return Optional.of(dynamicLogLevelProcessor.get());
-            }
-        } catch (ConcurrentException cause) {
-            LOG.debug("Cannot initialize dynamic log level processor. Will continue without this feature", cause);
-        }
-        return Optional.empty();
-    }
-
-    @Override
-    protected void doFilterRequest(HttpServletRequest httpRequest, HttpServletResponse httpResponse, FilterChain chain)
-                                                                                                                        throws IOException,
-                                                                                                                        ServletException {
-        activateDynamicLogLevels(httpRequest);
-        try {
-            super.doFilterRequest(httpRequest, httpResponse, chain);
-        } finally {
-            deactivateDynamicLogLevels();
-        }
-    }
-
-    private void activateDynamicLogLevels(HttpServletRequest httpRequest) {
-        getDynLogLevelProcessor().ifPresent(processor -> {
-            getDynLogConfiguration().map(env -> env.getDynLogHeaderValue(httpRequest)).ifPresent(
-                                                                                               processor::copyDynamicLogLevelToMDC);
-        });
-    }
-
-    private void deactivateDynamicLogLevels() {
-        getDynLogLevelProcessor().ifPresent(DynamicLogLevelProcessor::removeDynamicLogLevelFromMDC);
-    }
-
 }