reference/logging-filter/logging-filter-base/src/main/java/org/onap/logging/filter/base/PayloadLoggingServletFilter.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - Logging
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Modifications Copyright (C) 2018 IBM.
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.logging.filter.base;
  24
  25 import java.io.BufferedReader;
  26 import java.io.ByteArrayInputStream;
  27 import java.io.ByteArrayOutputStream;
  28 import java.io.IOException;
  29 import java.io.InputStream;
  30 import java.io.InputStreamReader;
  31 import java.io.PrintWriter;
  32 import java.util.Enumeration;
  33 import java.util.zip.GZIPInputStream;
  34 import javax.servlet.Filter;
  35 import javax.servlet.FilterChain;
  36 import javax.servlet.FilterConfig;
  37 import javax.servlet.ReadListener;
  38 import javax.servlet.ServletException;
  39 import javax.servlet.ServletInputStream;
  40 import javax.servlet.ServletOutputStream;
  41 import javax.servlet.ServletRequest;
  42 import javax.servlet.ServletResponse;
  43 import javax.servlet.WriteListener;
  44 import javax.servlet.http.HttpServletRequest;
  45 import javax.servlet.http.HttpServletRequestWrapper;
  46 import javax.servlet.http.HttpServletResponse;
  47 import javax.servlet.http.HttpServletResponseWrapper;
  48 import javax.ws.rs.core.HttpHeaders;
  49
  50 public class PayloadLoggingServletFilter implements Filter {
  51
  52     private static org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(PayloadLoggingServletFilter.class);
  53     private static final String REDACTED = "***REDACTED***";
  54
  55     private static class ByteArrayServletStream extends ServletOutputStream {
  56         ByteArrayOutputStream baos;
  57
  58         ByteArrayServletStream(ByteArrayOutputStream baos) {
  59             this.baos = baos;
  60         }
  61
  62         @Override
  63         public void write(int param) throws IOException {
  64             baos.write(param);
  65         }
  66
  67         @Override
  68         public boolean isReady() {
  69             return true;
  70         }
  71
  72         @Override
  73         public void setWriteListener(WriteListener arg0) {
  74             // this method does nothing
  75         }
  76     }
  77
  78     private static class ByteArrayPrintWriter extends PrintWriter {
  79         private ByteArrayOutputStream baos;
  80         private int errorCode = -1;
  81         private String errorMsg = "";
  82         private boolean errored = false;
  83
  84         public ByteArrayPrintWriter(ByteArrayOutputStream out) {
  85             super(out);
  86             this.baos = out;
  87         }
  88
  89         public ServletOutputStream getStream() {
  90             return new ByteArrayServletStream(baos);
  91         }
  92
  93         public Boolean hasErrored() {
  94             return errored;
  95         }
  96
  97         public int getErrorCode() {
  98             return errorCode;
  99         }
 100
 101         public String getErrorMsg() {
 102             return errorMsg;
 103         }
 104
 105         public void setError(int code) {
 106             errorCode = code;
 107             errored = true;
 108         }
 109
 110         public void setError(int code, String msg) {
 111             errorMsg = msg;
 112             errorCode = code;
 113             errored = true;
 114         }
 115
 116     }
 117
 118     private class BufferedServletInputStream extends ServletInputStream {
 119         ByteArrayInputStream bais;
 120
 121         public BufferedServletInputStream(ByteArrayInputStream bais) {
 122             this.bais = bais;
 123         }
 124
 125         @Override
 126         public int available() {
 127             return bais.available();
 128         }
 129
 130         @Override
 131         public int read() {
 132             return bais.read();
 133         }
 134
 135         @Override
 136         public int read(byte[] buf, int off, int len) {
 137             return bais.read(buf, off, len);
 138         }
 139
 140         @Override
 141         public boolean isFinished() {
 142             return available() < 1;
 143         }
 144
 145         @Override
 146         public boolean isReady() {
 147             return true;
 148         }
 149
 150         @Override
 151         public void setReadListener(ReadListener arg0) {
 152             // this method does nothing
 153         }
 154
 155     }
 156
 157     private class BufferedRequestWrapper extends HttpServletRequestWrapper {
 158         ByteArrayInputStream bais;
 159         ByteArrayOutputStream baos;
 160         BufferedServletInputStream bsis;
 161         byte[] buffer;
 162
 163         public BufferedRequestWrapper(HttpServletRequest req) throws IOException {
 164             super(req);
 165
 166             InputStream is = req.getInputStream();
 167             baos = new ByteArrayOutputStream();
 168             byte[] buf = new byte[1024];
 169             int letti;
 170             while ((letti = is.read(buf)) > 0) {
 171                 baos.write(buf, 0, letti);
 172             }
 173             buffer = baos.toByteArray();
 174         }
 175
 176         @Override
 177         public ServletInputStream getInputStream() {
 178             try {
 179                 bais = new ByteArrayInputStream(buffer);
 180                 bsis = new BufferedServletInputStream(bais);
 181             } catch (Exception ex) {
 182                 log.error("Exception in getInputStream", ex);
 183             }
 184             return bsis;
 185         }
 186
 187         public byte[] getBuffer() {
 188             return buffer;
 189         }
 190     }
 191
 192     @Override
 193     public void init(FilterConfig filterConfig) throws ServletException {
 194         // this method does nothing
 195     }
 196
 197     @Override
 198     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
 199             throws IOException, ServletException {
 200         final HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
 201         BufferedRequestWrapper bufferedRequest = new BufferedRequestWrapper(httpRequest);
 202
 203         StringBuilder requestHeaders = new StringBuilder("REQUEST|");
 204         requestHeaders.append(httpRequest.getMethod());
 205         requestHeaders.append(":");
 206         requestHeaders.append(httpRequest.getRequestURL().toString());
 207         requestHeaders.append("|");
 208         String header;
 209         for (Enumeration<String> e = httpRequest.getHeaderNames(); e.hasMoreElements();) {
 210             header = e.nextElement();
 211             requestHeaders.append(header);
 212             requestHeaders.append(":");
 213             if (header.equalsIgnoreCase(HttpHeaders.AUTHORIZATION)) {
 214                 requestHeaders.append(REDACTED);
 215             } else {
 216                 requestHeaders.append(httpRequest.getHeader(header));
 217             }
 218             requestHeaders.append(";");
 219         }
 220         log.info(requestHeaders.toString());
 221
 222         log.info("REQUEST BODY|" + new String(bufferedRequest.getBuffer()));
 223
 224         final HttpServletResponse response = (HttpServletResponse) servletResponse;
 225         final ByteArrayOutputStream baos = new ByteArrayOutputStream();
 226         final ByteArrayPrintWriter pw = new ByteArrayPrintWriter(baos);
 227
 228         HttpServletResponse wrappedResp = new HttpServletResponseWrapper(response) {
 229             @Override
 230             public PrintWriter getWriter() {
 231                 return pw;
 232             }
 233
 234             @Override
 235             public ServletOutputStream getOutputStream() {
 236                 return pw.getStream();
 237             }
 238
 239             @Override
 240             public void sendError(int sc) throws IOException {
 241                 super.sendError(sc);
 242                 pw.setError(sc);
 243
 244             }
 245
 246             @Override
 247             public void sendError(int sc, String msg) throws IOException {
 248                 super.sendError(sc, msg);
 249                 pw.setError(sc, msg);
 250             }
 251         };
 252
 253         try {
 254             filterChain.doFilter(bufferedRequest, wrappedResp);
 255         } catch (Exception e) {
 256             log.error("Chain Exception", e);
 257             throw e;
 258         } finally {
 259             try {
 260                 byte[] bytes = baos.toByteArray();
 261                 StringBuilder responseHeaders = new StringBuilder("RESPONSE HEADERS|");
 262
 263                 for (String headerName : response.getHeaderNames()) {
 264                     responseHeaders.append(headerName);
 265                     responseHeaders.append(":");
 266                     responseHeaders.append(response.getHeader(headerName));
 267                     responseHeaders.append(";");
 268                 }
 269                 responseHeaders.append("Status:");
 270                 responseHeaders.append(response.getStatus());
 271                 responseHeaders.append(";IsCommited:" + wrappedResp.isCommitted());
 272
 273                 log.info(responseHeaders.toString());
 274
 275                 if ("gzip".equals(response.getHeader("Content-Encoding"))) {
 276                     log.info("UNGZIPED RESPONSE BODY|" + decompressGZIPByteArray(bytes));
 277                 } else {
 278                     log.info("RESPONSE BODY|" + new String(bytes));
 279                 }
 280
 281                 if (pw.hasErrored()) {
 282                     log.info("ERROR RESPONSE|" + pw.getErrorCode() + ":" + pw.getErrorMsg());
 283                 } else {
 284                     if (!wrappedResp.isCommitted()) {
 285                         response.getOutputStream().write(bytes);
 286                         response.getOutputStream().flush();
 287                     }
 288                 }
 289             } catch (Exception e) {
 290                 log.error("Exception in response filter", e);
 291             }
 292         }
 293     }
 294
 295     @Override
 296     public void destroy() {
 297         // this method does nothing
 298     }
 299
 300     private String decompressGZIPByteArray(byte[] bytes) {
 301         BufferedReader in = null;
 302         InputStreamReader inR = null;
 303         ByteArrayInputStream byteS = null;
 304         GZIPInputStream gzS = null;
 305         StringBuilder str = new StringBuilder();
 306         try {
 307             byteS = new ByteArrayInputStream(bytes);
 308             gzS = new GZIPInputStream(byteS);
 309             inR = new InputStreamReader(gzS);
 310             in = new BufferedReader(inR);
 311
 312             if (in != null) {
 313                 String content;
 314                 while ((content = in.readLine()) != null) {
 315                     str.append(content);
 316                 }
 317             }
 318
 319         } catch (Exception e) {
 320             log.error("Failed get read GZIPInputStream", e);
 321         } finally {
 322             if (byteS != null)
 323                 try {
 324                     byteS.close();
 325                 } catch (IOException e1) {
 326                     log.error("Failed to close ByteStream", e1);
 327                 }
 328             if (gzS != null)
 329                 try {
 330                     gzS.close();
 331                 } catch (IOException e2) {
 332                     log.error("Failed to close GZStream", e2);
 333                 }
 334             if (inR != null)
 335                 try {
 336                     inR.close();
 337                 } catch (IOException e3) {
 338                     log.error("Failed to close InputReader", e3);
 339                 }
 340             if (in != null)
 341                 try {
 342                     in.close();
 343                 } catch (IOException e) {
 344                     log.error("Failed to close BufferedReader", e);
 345                 }
 346         }
 347         return str.toString();
 348     }
 349 }