web-dev-qa-db-ja.com

POSTのペイロードをTomcatに記録する

Conf/server.xmlを編集し、org.Apache.catalina.valves.AccessLogValve Valveのエントリのコメントを解除することで、Tomcatでアクセスロギングを有効にすることができました。 POSTのペイロードの内容をダンプできるようにしたいと思います。パターン内のどのオプションもこれを行うようには見えません。これを行うための組み込みの方法はありますか? AccessLogValveを使用しますか?

19
Tim

POSTペイロードを取得するための組み込みの方法の提案がなかったので、先に進んで、ペイロードの内容をダンプするカスタムフィルターを作成しました。具体的には:

public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
                     FilterChain chain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) servletRequest;
    LOG.debug("payload: " + requestWrapper.getRequestBody());

およびweb.xml:

<filter>
    <filter-name>PayloadLoggingFilter</filter-name>
    <filter-class>com.Host.PayloadLoggingFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>PayloadLoggingFilter</filter-name>
    <url-pattern>/resources/*</url-pattern>
</filter-mapping>
8
Tim

投稿がフォーム(application/x-www-urlencoded)の場合は、ExtendedAccessLogValveを使用できます。

http://Tomcat.Apache.org/Tomcat-6.0-doc/api/org/Apache/catalina/valves/ExtendedAccessLogValve.html

このようなパターンで個々のパラメータを選択する必要があります、

  x-P(param_name)
4
ZZ Coder
  1. Webapp web.xmlに以下を追加します:

    <filter>
      <filter-name>PayloadLoggingFilter</filter-name>
      <filter-class>your.MyLogFilter</filter-class>
    </filter>
    <filter-mapping>
      <filter-name>PayloadLoggingFilter</filter-name>
      <url-pattern>/path/*</url-pattern>
    </filter-mapping>
    
  2. フィルタを作成します。

    import Java.io.BufferedReader;
    import Java.io.ByteArrayInputStream;
    import Java.io.ByteArrayOutputStream;
    import Java.io.IOException;
    import Java.io.InputStream;
    import Java.io.InputStreamReader;
    import Java.io.OutputStream;
    import Java.io.OutputStreamWriter;
    import Java.io.PrintWriter;
    import Java.util.Enumeration;
    import Java.util.HashMap;
    import Java.util.Locale;
    import Java.util.Map;
    
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletInputStream;
    import javax.servlet.ServletOutputStream;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.Cookie;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletRequestWrapper;
    import javax.servlet.http.HttpServletResponse;
    
    import org.Apache.commons.io.output.TeeOutputStream;
    
    import com.liferay.portal.kernel.log.Log;
    import com.liferay.portal.kernel.log.LogFactoryUtil;
    import com.liferay.util.servlet.ServletInputStreamWrapper;
    
    public class MyLogFilter implements Filter {
    
        private static final Log logger = LogFactoryUtil.getLog(MyLogFilter.class);
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
        }
    
        @Override
        public void doFilter(ServletRequest request, ServletResponse response,
                FilterChain chain) throws IOException, ServletException {
            try {
                HttpServletRequest httpServletRequest = (HttpServletRequest) request;
                HttpServletResponse httpServletResponse = (HttpServletResponse) response;
    
                Map<String, String> requestMap = this.getTypesafeRequestMap(httpServletRequest);
                BufferedRequestWrapper bufferedReqest = new BufferedRequestWrapper(httpServletRequest);
                BufferedResponseWrapper bufferedResponse = new BufferedResponseWrapper(httpServletResponse);
    
                chain.doFilter(bufferedReqest, bufferedResponse);
    
                if(bufferedResponse.getContent()!=null){    //Response
                    final StringBuilder resMessage = new StringBuilder();
                    resMessage.append(" [RESPONSE:")
                            .append(bufferedResponse.getContent() )
                            .append("]");
                    logger.info(resMessage);
                }
                else{ //Request
                    final StringBuilder reqMessage = new StringBuilder(
                            "REST Request - ").append("[HTTP METHOD:")
                            .append(httpServletRequest.getMethod())
                            .append("] [PATH INFO:")
                            .append(httpServletRequest.getPathInfo())
                            .append("] [REQUEST PARAMETERS:").append(requestMap)
                            .append("] [REQUEST BODY:")
                            .append(bufferedReqest.getRequestBody())
                            .append("] [REMOTE ADDRESS:")
                            .append(httpServletRequest.getRemoteAddr()).append("]");
                    logger.info(reqMessage);
                }
    
    
            } catch (Throwable a) {
                logger.error(a);
            }
        }
    
        private Map<String, String> getTypesafeRequestMap(HttpServletRequest request) {
            Map<String, String> typesafeRequestMap = new HashMap<String, String>();
            Enumeration<?> requestParamNames = request.getParameterNames();
            while (requestParamNames.hasMoreElements()) {
                String requestParamName = (String) requestParamNames.nextElement();
                String requestParamValue = request.getParameter(requestParamName);
                typesafeRequestMap.put(requestParamName, requestParamValue);
            }
            return typesafeRequestMap;
        }
    
        @Override
        public void destroy() {
        }
    
        private static final class BufferedRequestWrapper extends
                HttpServletRequestWrapper {
    
            private ByteArrayInputStream bais = null;
            private ByteArrayOutputStream baos = null;
            private BufferedServletInputStream bsis = null;
            private byte[] buffer = null;
    
            public BufferedRequestWrapper(HttpServletRequest req)
                    throws IOException {
                super(req);
                // Read InputStream and store its content in a buffer.
                InputStream is = req.getInputStream();
                this.baos = new ByteArrayOutputStream();
                byte buf[] = new byte[1024];
                int letti;
                while ((letti = is.read(buf)) > 0) {
                    this.baos.write(buf, 0, letti);
                }
                this.buffer = this.baos.toByteArray();
            }
    
            @Override
            public ServletInputStream getInputStream() {
                this.bais = new ByteArrayInputStream(this.buffer);
                this.bsis = new BufferedServletInputStream(this.bais);
    
                return this.bsis;
            }
    
            @Override
            public BufferedReader getReader() throws IOException {
                return new BufferedReader(new InputStreamReader(this.getInputStream()));
            }
    
            String getRequestBody() throws IOException {
                BufferedReader reader = new BufferedReader(new InputStreamReader(
                        this.getInputStream()));
                String line = null;
                StringBuilder inputBuffer = new StringBuilder();
                do {
                    line = reader.readLine();
                    if (null != line) {
                        inputBuffer.append(line.trim());
                    }
                } while (line != null);
                reader.close();
                return inputBuffer.toString().trim();
            }
    
        }
    
        private static final class BufferedServletInputStream extends
                ServletInputStream {
    
            private ByteArrayInputStream bais;
    
            public BufferedServletInputStream(ByteArrayInputStream bais) {
                this.bais = bais;
            }
    
            @Override
            public int available() {
                return this.bais.available();
            }
    
            @Override
            public int read() {
                return this.bais.read();
            }
    
            @Override
            public int read(byte[] buf, int off, int len) {
                return this.bais.read(buf, off, len);
            }
    
        }
    
        public class TeeServletOutputStream extends ServletOutputStream {
    
            private final TeeOutputStream targetStream;
    
            public TeeServletOutputStream(OutputStream one, OutputStream two) {
                targetStream = new TeeOutputStream(one, two);
            }
    
            @Override
            public void write(int arg0) throws IOException {
                this.targetStream.write(arg0);
            }
    
            public void flush() throws IOException {
                super.flush();
                this.targetStream.flush();
            }
    
            public void close() throws IOException {
                super.close();
                this.targetStream.close();
            }
        }
    
        public class BufferedResponseWrapper implements HttpServletResponse {
    
            HttpServletResponse original;
            TeeServletOutputStream teeStream;
            PrintWriter teeWriter;
            ByteArrayOutputStream bos;
    
            public BufferedResponseWrapper(HttpServletResponse response) {
                original = response;
            }
    
            public String getContent() {
                if(bos == null){
                    return null;
                }
                return bos.toString();
            }
    
            @Override
            public PrintWriter getWriter() throws IOException {
    
                if (this.teeWriter == null) {
                    this.teeWriter = new PrintWriter(new OutputStreamWriter(
                            getOutputStream()));
                }
                return this.teeWriter;
            }
    
            @Override
            public ServletOutputStream getOutputStream() throws IOException {
    
                if (teeStream == null) {
                    bos = new ByteArrayOutputStream();
                    teeStream = new TeeServletOutputStream(
                            original.getOutputStream(), bos);
                }
                return teeStream;
            }
    
            @Override
            public String getCharacterEncoding() {
                return original.getCharacterEncoding();
            }
    
            @Override
            public String getContentType() {
                return original.getContentType();
            }
    
            @Override
            public void setCharacterEncoding(String charset) {
                original.setCharacterEncoding(charset);
            }
    
            @Override
            public void setContentLength(int len) {
                original.setContentLength(len);
            }
    
            @Override
            public void setContentType(String type) {
                original.setContentType(type);
            }
    
            @Override
            public void setBufferSize(int size) {
                original.setBufferSize(size);
            }
    
            @Override
            public int getBufferSize() {
                return original.getBufferSize();
            }
    
            @Override
            public void flushBuffer() throws IOException {
                if (teeStream != null) {
                    teeStream.flush();
                }
                if (this.teeWriter != null) {
                    this.teeWriter.flush();
                }
            }
    
            @Override
            public void resetBuffer() {
                original.resetBuffer();
            }
    
            @Override
            public boolean isCommitted() {
                return original.isCommitted();
            }
    
            @Override
            public void reset() {
                original.reset();
            }
    
            @Override
            public void setLocale(Locale loc) {
                original.setLocale(loc);
            }
    
            @Override
            public Locale getLocale() {
                return original.getLocale();
            }
    
            @Override
            public void addCookie(Cookie cookie) {
                original.addCookie(cookie);
            }
    
            @Override
            public boolean containsHeader(String name) {
                return original.containsHeader(name);
            }
    
            @Override
            public String encodeURL(String url) {
                return original.encodeURL(url);
            }
    
            @Override
            public String encodeRedirectURL(String url) {
                return original.encodeRedirectURL(url);
            }
    
            @SuppressWarnings("deprecation")
            @Override
            public String encodeUrl(String url) {
                return original.encodeUrl(url);
            }
    
            @SuppressWarnings("deprecation")
            @Override
            public String encodeRedirectUrl(String url) {
                return original.encodeRedirectUrl(url);
            }
    
            @Override
            public void sendError(int sc, String msg) throws IOException {
                original.sendError(sc, msg);
            }
    
            @Override
            public void sendError(int sc) throws IOException {
                original.sendError(sc);
            }
    
            @Override
            public void sendRedirect(String location) throws IOException {
                original.sendRedirect(location);
            }
    
            @Override
            public void setDateHeader(String name, long date) {
                original.setDateHeader(name, date);
            }
    
            @Override
            public void addDateHeader(String name, long date) {
                original.addDateHeader(name, date);
            }
    
            @Override
            public void setHeader(String name, String value) {
                original.setHeader(name, value);
            }
    
            @Override
            public void addHeader(String name, String value) {
                original.addHeader(name, value);
            }
    
            @Override
            public void setIntHeader(String name, int value) {
                original.setIntHeader(name, value);
            }
    
            @Override
            public void addIntHeader(String name, int value) {
                original.addIntHeader(name, value);
            }
    
            @Override
            public void setStatus(int sc) {
                original.setStatus(sc);
            }
    
            @SuppressWarnings("deprecation")
            @Override
            public void setStatus(int sc, String sm) {
                original.setStatus(sc, sm);
            }
    
        }
    
    }
    
4
Hao Deng

ここでRequestDumperValveまたはRequestDumperFilterを参照してください: http://Tomcat.Apache.org/Tomcat-5.5-doc/config/Valve.html#Request_Dumper_Valve それはあなたが望むことをします。

1
Janning