Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.nirima.jersey.filter;
  
  import java.net.URI;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 
 
 
 
 @SuppressWarnings("ClassWithMultipleLoggers")
 
     private static final String NOTIFICATION_PREFIX = "* ";
     private static final String REQUEST_PREFIX = "> ";
     private static final String RESPONSE_PREFIX = "< ";
     private static final String ENTITY_LOGGER_PROPERTY = LoggingFilter.class.getName() + ".entityLogger";
 
     private static final Comparator<Map.Entry<StringList<String>>> COMPARATOR =
             new Comparator<Map.Entry<StringList<String>>>() {
 
                 @Override
                 public int compare(final Map.Entry<StringList<String>> o1final Map.Entry<StringList<String>> o2) {
                     return ..compare(o1.getKey(), o2.getKey());
                 }
             };
 
 
     //
     @SuppressWarnings("NonConstantLogger")
     private final Logger logger;
     private final AtomicLong _id = new AtomicLong(0);
     private final boolean printEntity;
     private final int maxEntitySize;
 
     public Slf4jLoggingFilter(Logger loggerboolean printEntityint maxEntitySize) {
         this. = logger;
         this. = printEntity;
         this. = maxEntitySize;
     }
 
     public static class Builder {
 
         private Logger logger = LoggerFactory.getLogger(Slf4jLoggingFilter.class.getName());
         private boolean printEntity = true;
         private int maxEntitySize = 8*1024;
 
         public Slf4jLoggingFilter build() {
             return new Slf4jLoggingFilter();
         }
 
         public Builder logger(Logger logger) {
             Preconditions.checkNotNull(logger);
             this. = logger;
             return this;
         }
         public Builder printEntity(boolean printEntity) {
             this. = printEntity;
             return this;
         }
         public Builder maxEntitySize(int maxEntitySize) {
             this. = maxEntitySize;
             return this;
         }
     }
 
    public static Builder builder() { return new Builder(); }
    private void log(StringBuilder b) {
        if ( != null && .isDebugEnabled()) {
            .debug(b.toString());
        }
    }
    private StringBuilder prefixId(StringBuilder blong id) {
        b.append(Long.toString(id)).append(" ");
        return b;
    }
    private void printRequestLine(StringBuilder bString notelong idString methodURI uri) {
        prefixId(bid).append()
                .append(note)
                .append(" on thread ").append(Thread.currentThread().getName())
                .append("\n");
        prefixId(bid).append().append(method).append(" ").
                append(uri.toASCIIString()).append("\n");
    }
    private void printResponseLine(StringBuilder bString notelong idint status) {
        prefixId(bid).append()
                .append(note)
                .append(" on thread ").append(Thread.currentThread().getName()).append("\n");
        prefixId(bid).append().
                append(Integer.toString(status)).
                append("\n");
    }
    private void printPrefixedHeaders(StringBuilder blong idfinal String prefixMultivaluedMap<StringStringheaders) {
        for (final Map.Entry<StringList<String>> headerEntry : getSortedHeaders(headers.entrySet())) {
            List<?> val = headerEntry.getValue();
            String header = headerEntry.getKey();
            if (val.size() == 1) {
                prefixId(bid).append(prefix).append(header).append(": ").append(val.get(0)).append("\n");
            } else {
                StringBuilder sb = new StringBuilder();
                boolean add = false;
                for (Object s : val) {
                    if (add) {
                        sb.append(',');
                    }
                    add = true;
                    sb.append(s);
                }
                prefixId(bid).append(prefix).append(header).append(": ").append(sb.toString()).append("\n");
            }
        }
    }
    private Set<Map.Entry<StringList<String>>> getSortedHeaders(final Set<Map.Entry<StringList<String>>> headers) {
        final TreeSet<Map.Entry<StringList<String>>> sortedHeaders = Sets.newTreeSet();
        sortedHeaders.addAll(headers);
        return sortedHeaders;
    }
    private InputStream logInboundEntity(StringBuilder bInputStream streamthrows IOException {
        if (!stream.markSupported()) {
            stream = new BufferedInputStream(stream);
        }
        stream.mark( + 1);
        byte[] entity = new byte[ + 1];
        int entitySize = stream.read(entity);
        b.append(new String(entity, 0, Math.min(entitySize)));
        if (entitySize > ) {
            b.append("...more...");
        }
        b.append('\n');
        stream.reset();
        return stream;
    }
    @Override
    public void filter(ClientRequestContext contextthrows IOException {
        final long id = this..incrementAndGet();
        StringBuilder b = new StringBuilder();
        printRequestLine(b"Sending client request"idcontext.getMethod(), context.getUri());
        printPrefixedHeaders(bidcontext.getStringHeaders());
        if ( && context.hasEntity()) {
            OutputStream stream = new LoggingStream(bcontext.getEntityStream());
            context.setEntityStream(stream);
            context.setProperty(stream);
            // not calling log(b) here - it will be called by the interceptor
        } else {
            log(b);
        }
    }
    @Override
    public void filter(ClientRequestContext requestContextClientResponseContext responseContextthrows IOException {
        final long id = this..incrementAndGet();
        StringBuilder b = new StringBuilder();
        printResponseLine(b"Client response received"idresponseContext.getStatus());
        printPrefixedHeaders(bidresponseContext.getHeaders());
        if ( && responseContext.hasEntity()) {
            responseContext.setEntityStream(logInboundEntity(bresponseContext.getEntityStream()));
        }
        log(b);
    }
    @Override
    public void filter(ContainerRequestContext contextthrows IOException {
        final long id = this..incrementAndGet();
        StringBuilder b = new StringBuilder();
        printRequestLine(b"Server has received a request"idcontext.getMethod(), context.getUriInfo().getRequestUri());
        printPrefixedHeaders(bidcontext.getHeaders());
        if ( && context.hasEntity()) {
            context.setEntityStream(logInboundEntity(bcontext.getEntityStream()));
        }
        log(b);
    }
    @Override
    public void filter(ContainerRequestContext requestContextContainerResponseContext responseContextthrows IOException {
        final long id = this..incrementAndGet();
        StringBuilder b = new StringBuilder();
        printResponseLine(b"Server responded with a response"idresponseContext.getStatus());
        printPrefixedHeaders(bidresponseContext.getStringHeaders());
        if ( && responseContext.hasEntity()) {
            OutputStream stream = new LoggingStream(bresponseContext.getEntityStream());
            responseContext.setEntityStream(stream);
            requestContext.setProperty(stream);
            // not calling log(b) here - it will be called by the interceptor
        } else {
            log(b);
        }
    }
    @Override
    public void aroundWriteTo(WriterInterceptorContext writerInterceptorContextthrows IOExceptionWebApplicationException {
        LoggingStream stream = (LoggingStreamwriterInterceptorContext.getProperty();
        writerInterceptorContext.proceed();
        if (stream != null) {
            log(stream.getStringBuilder());
        }
    }
    private class LoggingStream extends OutputStream {
        private final StringBuilder b;
        private final OutputStream inner;
        private final ByteArrayOutputStream baos = new ByteArrayOutputStream();
        LoggingStream(StringBuilder bOutputStream inner) {
            this. = b;
            this. = inner;
        }
        StringBuilder getStringBuilder() {
            // write entity to the builder
            byte[] entity = .toByteArray();
            .append(new String(entity, 0, Math.min(entity.length)));
            if (entity.length > ) {
                .append("...more...");
            }
            .append('\n');
            return ;
        }
        @Override
        public void write(int ithrows IOException {
            if (.size() <= ) {
                .write(i);
            }
            .write(i);
        }
    }
New to GrepCode? Check out our FAQ X