Hi, I'd used that you said it's doesn't works, I put the code that I used.

public class LoggingOutInterceptor extends AbstractPhaseInterceptor
{
        private static final String LOG_SETUP =
LoggingOutInterceptor.class.getName() + ".log-setup";

        private static final Logger LOG =
LogUtils.getL7dLogger(LoggingOutInterceptor.class);

        private int limit = 100 * 1024;
        private PrintWriter writer;

        public LoggingOutInterceptor(String phase)
        {
                super(phase);
                addBefore(SAAJOutEndingInterceptor.class.getName());
        }

        public LoggingOutInterceptor()
        {
                super(Phase.PRE_PROTOCOL_ENDING);
                addBefore(SAAJOutEndingInterceptor.class.getName());
        }

        public LoggingOutInterceptor(int lim)
        {
                this();
                limit = lim;
        }

        public LoggingOutInterceptor(PrintWriter w)
        {
                this();
                this.writer = w;
        }

        public void setLimit(int lim)
        {
                limit = lim;
        }

        public int getLimit()
        {
                return limit;
        }

        public void handleMessage(Message message) throws Fault
        {
                final CachedOutputStream os = new CachedOutputStream();
                SOAPMessage is = message.getContent(SOAPMessage.class);
                if (is == null)
                {
                        return;
                }
                
                try
                {
                        is.writeTo(os);
                }
                catch (SOAPException e)
                {
                        return;
                }
                catch (IOException e)
                {
                        return;
                }

                if (LOG.isLoggable(Level.INFO) || writer != null)
                {
                        // Write the output while caching it for the log message
                        boolean hasLogged = message.containsKey(LOG_SETUP);
                        if (!hasLogged)
                        {
                                message.put(LOG_SETUP, Boolean.TRUE);
                                final CacheAndWriteOutputStream newOut = new
CacheAndWriteOutputStream(os);
                                message.setContent(OutputStream.class, newOut);
                                newOut.registerCallback(new 
LoggingCallback(message, os));
                        }
                }
        }

        /**
         * Transform the string before display. The implementation in this class
         * does nothing. Override this method if you want to change the 
contents of
         * the logged message before it is delivered to the output. For example,
you
         * can use this to masking out sensitive information.
         * 
         * @param originalLogString
         *            the raw log message.
         * @return transformed data
         */
        protected String transform(String originalLogString)
        {
                return originalLogString;
        }

        class LoggingCallback implements CachedOutputStreamCallback
        {

                private final Message message;
                private final OutputStream origStream;

                public LoggingCallback(final Message msg, final OutputStream os)
                {
                        this.message = msg;
                        this.origStream = os;
                }

                public void onFlush(CachedOutputStream cos)
                {

                }

                public void onClose(CachedOutputStream cos)
                {
                        String id = 
(String)message.getExchange().get(LoggingMessage.ID_KEY);
                        if (id == null)
                        {
                                id = LoggingMessage.nextId();
                                
message.getExchange().put(LoggingMessage.ID_KEY, id);
                        }
                        final LoggingMessage buffer = new 
LoggingMessage("Outbound
Message\n---------------------------", id);

                        Integer responseCode = 
(Integer)message.get(Message.RESPONSE_CODE);
                        if (responseCode != null)
                        {
                                buffer.getResponseCode().append(responseCode);
                        }

                        String encoding = (String)message.get(Message.ENCODING);

                        if (encoding != null)
                        {
                                buffer.getEncoding().append(encoding);
                        }

                        String address = 
(String)message.get(Message.ENDPOINT_ADDRESS);
                        if (address != null)
                        {
                                buffer.getAddress().append(address);
                        }
                        String ct = (String)message.get(Message.CONTENT_TYPE);
                        if (ct != null)
                        {
                                buffer.getContentType().append(ct);
                        }
                        Object headers = message.get(Message.PROTOCOL_HEADERS);
                        if (headers != null)
                        {
                                buffer.getHeader().append(headers);
                        }

                        if (cos.getTempFile() == null)
                        {
                                // buffer.append("Outbound Message:\n");
                                if (cos.size() > limit)
                                {
                                        buffer.getMessage().append("(message 
truncated to " + limit + "
bytes)\n");
                                }
                        }
                        else
                        {
                                buffer.getMessage().append("Outbound Message 
(saved to tmp file):\n");
                                buffer.getMessage().append("Filename: " +
cos.getTempFile().getAbsolutePath() + "\n");
                                if (cos.size() > limit)
                                {
                                        buffer.getMessage().append("(message 
truncated to " + limit + "
bytes)\n");
                                }
                        }
                        try
                        {
                                cos.writeCacheTo(buffer.getPayload(), limit);
                        }
                        catch (Exception ex)
                        {
                                // ignore
                        }

                        if (writer != null)
                        {
                                writer.println(transform(buffer.toString()));
                        }
                        else if (LOG.isLoggable(Level.INFO))
                        {
                                LOG.info(transform(buffer.toString()));
                        }
                        try
                        {
                                // empty out the cache
                                cos.lockOutputStream();
                                cos.resetOut(null, false);
                        }
                        catch (Exception ex)
                        {
                                // ignore
                        }
                        message.setContent(OutputStream.class, origStream);
                }
        }

}

Regards

--
View this message in context: 
http://cxf.547215.n5.nabble.com/Log-SoapMessage-After-WSS4J-tp4305812p4313815.html
Sent from the cxf-user mailing list archive at Nabble.com.

Reply via email to