filters/provider/src/main/java/org/onap/ccsdk/sli/core/filters/RequestResponseLoggingFilter.java

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