Fix Tee Filter

ecs-logging-access/build.gradle

@@ -4,6 +4,7 @@ dependencies {
     implementation("ch.qos.logback.access:tomcat:2.0.3"){
         exclude group: 'org.apache.tomcat'
     }
+    implementation('org.apache.commons:commons-io:1.3.2')
     compileOnly("org.springframework.boot:spring-boot-starter-web")
     compileOnly("org.springframework.boot:spring-boot-starter-webflux")
 

ecs-logging-access/src/main/java/com/raynigon/ecs/logging/access/server/AccessLogFilterConfiguration.java

@@ -1,6 +1,5 @@
 package com.raynigon.ecs.logging.access.server;
 
-import ch.qos.logback.access.common.servlet.TeeFilter;
 import com.raynigon.ecs.logging.access.AccessLogProperties;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.autoconfigure.AutoConfigureBefore;
@@ -28,7 +27,7 @@ public class AccessLogFilterConfiguration {
     @Bean
     @NonNull
     @ConditionalOnProperty(value = "raynigon.logging.access.export-body", havingValue = "true")
-    public FilterRegistrationBean<TeeFilter> requestLoggingFilter() {
-        return new FilterRegistrationBean<>(new TeeFilter());
+    public FilterRegistrationBean<CustomTeeFilter> requestLoggingFilter() {
+        return new FilterRegistrationBean<>(new CustomTeeFilter());
     }
 }

ecs-logging-access/src/main/java/com/raynigon/ecs/logging/access/server/CustomTeeFilter.java

@@ -0,0 +1,114 @@
+package com.raynigon.ecs.logging.access.server;
+
+import ch.qos.logback.access.common.AccessConstants;
+import jakarta.servlet.*;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CustomTeeFilter implements Filter {
+    boolean active;
+
+    @Override
+    public void destroy() {
+        // NOP
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
+            throws IOException, ServletException {
+
+        if (active && request instanceof HttpServletRequest) {
+            try {
+                TeeHttpServletRequest teeRequest = new TeeHttpServletRequest((HttpServletRequest) request);
+                TeeHttpServletResponse teeResponse = new TeeHttpServletResponse((HttpServletResponse) response);
+
+                filterChain.doFilter(teeRequest, teeResponse);
+
+                teeResponse.finish();
+                // let the output contents be available for later use by
+                // logback-access-logging
+                teeRequest.setAttribute(AccessConstants.LB_OUTPUT_BUFFER, teeResponse.getOutputBuffer());
+            } catch (IOException e) {
+                e.printStackTrace();
+                throw e;
+            } catch (ServletException e) {
+                e.printStackTrace();
+                throw e;
+            }
+        } else {
+            filterChain.doFilter(request, response);
+        }
+
+    }
+
+    @Override
+    public void init(FilterConfig filterConfig) throws ServletException {
+        String includeListAsStr = filterConfig.getInitParameter(AccessConstants.TEE_FILTER_INCLUDES_PARAM);
+        String excludeListAsStr = filterConfig.getInitParameter(AccessConstants.TEE_FILTER_EXCLUDES_PARAM);
+        String localhostName = getLocalhostName();
+
+        active = computeActivation(localhostName, includeListAsStr, excludeListAsStr);
+        // Log the activation status on stdout, because loggers cannot be used here
+        if (active) {
+            System.out.println("TeeFilter will be ACTIVE on this host [" + localhostName + "]");
+        } else {
+            System.out.println("TeeFilter will be DISABLED on this host [" + localhostName + "]");
+        }
+    }
+
+    public static List<String> extractNameList(String nameListAsStr) {
+        List<String> nameList = new ArrayList<String>();
+        if (nameListAsStr == null) {
+            return nameList;
+        }
+
+        nameListAsStr = nameListAsStr.trim();
+        if (nameListAsStr.length() == 0) {
+            return nameList;
+        }
+
+        String[] nameArray = nameListAsStr.split("[,;]");
+        for (String n : nameArray) {
+            n = n.trim();
+            nameList.add(n);
+        }
+        return nameList;
+    }
+
+    static String getLocalhostName() {
+        String hostname = "127.0.0.1";
+
+        try {
+            hostname = InetAddress.getLocalHost().getHostName();
+        } catch (UnknownHostException uhe) {
+            uhe.printStackTrace();
+        }
+        return hostname;
+    }
+
+    public static boolean computeActivation(String hostname, String includeListAsStr, String excludeListAsStr) {
+        List<String> includeList = extractNameList(includeListAsStr);
+        List<String> excludeList = extractNameList(excludeListAsStr);
+        boolean inIncludesList = matchesIncludesList(hostname, includeList);
+        boolean inExcludesList = matchesExcludesList(hostname, excludeList);
+        return inIncludesList && (!inExcludesList);
+    }
+
+    static boolean matchesIncludesList(String hostname, List<String> includeList) {
+        if (includeList.isEmpty())
+            return true;
+        return includeList.contains(hostname);
+    }
+
+    static boolean matchesExcludesList(String hostname, List<String> excludesList) {
+        if (excludesList.isEmpty())
+            return false;
+        return excludesList.contains(hostname);
+    }
+}

ecs-logging-access/src/main/java/com/raynigon/ecs/logging/access/server/TeeHttpServletRequest.java

@@ -0,0 +1,64 @@
+package com.raynigon.ecs.logging.access.server;
+
+import ch.qos.logback.access.common.AccessConstants;
+import ch.qos.logback.access.common.servlet.Util;
+import jakarta.servlet.ServletInputStream;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequestWrapper;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class TeeHttpServletRequest extends HttpServletRequestWrapper {
+
+    private TeeServletInputStream inStream;
+    private BufferedReader reader;
+    boolean postedParametersMode = false;
+
+    TeeHttpServletRequest(HttpServletRequest request) {
+        super(request);
+        // we can't access the input stream and access the request parameters
+        // at the same time
+        if (Util.isFormUrlEncoded(request)) {
+            postedParametersMode = true;
+        } else {
+            inStream = new TeeServletInputStream(request);
+            // add the contents of the input buffer as an attribute of the request
+            request.setAttribute(AccessConstants.LB_INPUT_BUFFER, inStream.getInputBuffer());
+            reader = new BufferedReader(new InputStreamReader(inStream));
+        }
+
+    }
+
+    byte[] getInputBuffer() {
+        if (postedParametersMode) {
+            throw new IllegalStateException("Call disallowed in postedParametersMode");
+        }
+        return inStream.getInputBuffer();
+    }
+
+    @Override
+    public ServletInputStream getInputStream() throws IOException {
+        if (!postedParametersMode) {
+            return inStream;
+        } else {
+            return super.getInputStream();
+        }
+    }
+
+    //
+
+    @Override
+    public BufferedReader getReader() throws IOException {
+        if (!postedParametersMode) {
+            return reader;
+        } else {
+            return super.getReader();
+        }
+    }
+
+    public boolean isPostedParametersMode() {
+        return postedParametersMode;
+    }
+}

ecs-logging-access/src/main/java/com/raynigon/ecs/logging/access/server/TeeHttpServletResponse.java

@@ -0,0 +1,63 @@
+package com.raynigon.ecs.logging.access.server;
+
+
+import jakarta.servlet.ServletOutputStream;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpServletResponseWrapper;
+
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class TeeHttpServletResponse extends HttpServletResponseWrapper {
+
+    TeeServletOutputStream teeServletOutputStream;
+    PrintWriter teeWriter;
+
+    public TeeHttpServletResponse(HttpServletResponse httpServletResponse) {
+        super(httpServletResponse);
+    }
+
+    @Override
+    public ServletOutputStream getOutputStream() throws IOException {
+        if (teeServletOutputStream == null) {
+            teeServletOutputStream = new TeeServletOutputStream(this.getResponse());
+        }
+        return teeServletOutputStream;
+    }
+
+    @Override
+    public PrintWriter getWriter() throws IOException {
+        if (this.teeWriter == null) {
+            this.teeWriter = new PrintWriter(
+                    new OutputStreamWriter(getOutputStream(), this.getResponse().getCharacterEncoding()), true);
+        }
+        return this.teeWriter;
+    }
+
+    @Override
+    public void flushBuffer() {
+        if (this.teeWriter != null) {
+            this.teeWriter.flush();
+        }
+    }
+
+    public byte[] getOutputBuffer() {
+        // teeServletOutputStream can be null if the getOutputStream method is never
+        // called.
+        if (teeServletOutputStream != null) {
+            return teeServletOutputStream.getOutputStreamAsByteArray();
+        } else {
+            return null;
+        }
+    }
+
+    void finish() throws IOException {
+        if (this.teeWriter != null) {
+            this.teeWriter.close();
+        }
+        if (this.teeServletOutputStream != null) {
+            this.teeServletOutputStream.close();
+        }
+    }
+}

ecs-logging-access/src/main/java/com/raynigon/ecs/logging/access/server/TeeServletInputStream.java

@@ -0,0 +1,67 @@
+package com.raynigon.ecs.logging.access.server;
+
+import jakarta.servlet.ReadListener;
+import jakarta.servlet.ServletInputStream;
+import jakarta.servlet.http.HttpServletRequest;
+import org.apache.commons.io.IOUtils;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+
+public class TeeServletInputStream extends ServletInputStream {
+
+    private byte[] content;
+    private ByteArrayInputStream in;
+
+    TeeServletInputStream(HttpServletRequest request) {
+        duplicateInputStream(request);
+    }
+
+    private void duplicateInputStream(HttpServletRequest request) {
+        ServletInputStream originalSIS = null;
+        try {
+            originalSIS = request.getInputStream();
+            content = IOUtils.toByteArray(request.getInputStream());
+            in = new ByteArrayInputStream(content);
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            closeStream(originalSIS);
+        }
+    }
+
+    @Override
+    public int read() throws IOException {
+        return in.read();
+    }
+
+    void closeStream(ServletInputStream is) {
+        if (is != null) {
+            try {
+                is.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    byte[] getInputBuffer() {
+        return content;
+    }
+
+    @Override
+    public boolean isFinished() {
+        throw new RuntimeException("Not yet implemented");
+    }
+
+    @Override
+    public boolean isReady() {
+        throw new RuntimeException("Not yet implemented");
+    }
+
+    @Override
+    public void setReadListener(ReadListener listener) {
+        throw new RuntimeException("Not yet implemented");
+    }
+}
+