Log response body in case of exception

问题

I am using retrofit for http calls with gson as a converter. In some cases I get exceptions thrown when gson tries to convert response to object and I would like to know what is the actual response in such case.
For example: This is the exception message I get: Expected a string but was BEGIN_OBJECT at line 1 column 26 path $[0].date

The code that execute the call is like this:

Gson gson = gsonBuilder.create();
Retrofit retrofit = (new retrofit2.Retrofit.Builder()).baseUrl(baseUrl).addConverterFactory(GsonConverterFactory.create(gson)).client(httpClient).build();
MyService service = retrofit.create(clazz);
...
Response<T> response = service.call().execute();

When this code throws exception I would like to log the raw response body somehow. How can I do that?

回答1:

I don't think it can be accomplished easily. Retrofit does not seem to provide an easy way of tracking input streams (the most natural place I was thinking of was CallAdapter.Factory but it does not allow invalid response tracking).

Basically, illegal response conversion should be detected in a particular converter whose only responsibility is logging invalid payloads. Sounds pretty much like the Decorator design pattern. Since Java (unlike Kotlin?) does not support decorators as a first-class citizen, forwarding implementations can be implemented similarly to Google Guava Forwarding*** classes:

ForwardingInputStream.java

@SuppressWarnings("resource")
abstract class ForwardingInputStream
        extends InputStream {

    protected abstract InputStream inputStream();

    // @formatter:off
    @Override public int read() throws IOException { return inputStream().read(); }
    // @formatter:on

    // @formatter:off
    @Override public int read(final byte[] b) throws IOException { return inputStream().read(b); }
    @Override public int read(final byte[] b, final int off, final int len) throws IOException { return inputStream().read(b, off, len); }
    @Override public long skip(final long n) throws IOException { return inputStream().skip(n); }
    @Override public int available() throws IOException { return inputStream().available(); }
    @Override public void close() throws IOException { inputStream().close(); }
    @Override public void mark(final int readlimit) { inputStream().mark(readlimit); }
    @Override public void reset() throws IOException { inputStream().reset(); }
    @Override public boolean markSupported() { return inputStream().markSupported(); }
    // @formatter:on

}

ForwardingResponseBody.java

@SuppressWarnings("resource")
abstract class ForwardingResponseBody
        extends ResponseBody {

    protected abstract ResponseBody responseBody();

    // @formatter:off
    @Override public MediaType contentType() { return responseBody().contentType(); }
    @Override public long contentLength() { return responseBody().contentLength(); }
    @Override public BufferedSource source() { return responseBody().source(); }
    // @formatter:on

    // @formatter:off
    @Override public void close() { super.close(); }
    // @formatter:on

}

ForwardingBufferedSource.java

abstract class ForwardingBufferedSource
        implements BufferedSource {

    protected abstract BufferedSource bufferedSource();

    // @formatter:off
    @Override public Buffer buffer() { return bufferedSource().buffer(); }
    @Override public boolean exhausted() throws IOException { return bufferedSource().exhausted(); }
    @Override public void require(final long byteCount) throws IOException { bufferedSource().require(byteCount); }
    @Override public boolean request(final long byteCount) throws IOException { return bufferedSource().request(byteCount); }
    @Override public byte readByte() throws IOException { return bufferedSource().readByte(); }
    @Override public short readShort() throws IOException { return bufferedSource().readShort(); }
    @Override public short readShortLe() throws IOException { return bufferedSource().readShortLe(); }
    @Override public int readInt() throws IOException { return bufferedSource().readInt(); }
    @Override public int readIntLe() throws IOException { return bufferedSource().readIntLe(); }
    @Override public long readLong() throws IOException { return bufferedSource().readLong(); }
    @Override public long readLongLe() throws IOException { return bufferedSource().readLongLe(); }
    @Override public long readDecimalLong() throws IOException { return bufferedSource().readDecimalLong(); }
    @Override public long readHexadecimalUnsignedLong() throws IOException { return bufferedSource().readHexadecimalUnsignedLong(); }
    @Override public void skip(final long byteCount) throws IOException { bufferedSource().skip(byteCount); }
    @Override public ByteString readByteString() throws IOException { return bufferedSource().readByteString(); }
    @Override public ByteString readByteString(final long byteCount) throws IOException { return bufferedSource().readByteString(byteCount); }
    @Override public int select(final Options options) throws IOException { return bufferedSource().select(options); }
    @Override public byte[] readByteArray() throws IOException { return bufferedSource().readByteArray(); }
    @Override public byte[] readByteArray(final long byteCount) throws IOException { return bufferedSource().readByteArray(byteCount); }
    @Override public int read(final byte[] sink) throws IOException { return bufferedSource().read(sink); }
    @Override public void readFully(final byte[] sink) throws IOException { bufferedSource().readFully(sink); }
    @Override public int read(final byte[] sink, final int offset, final int byteCount) throws IOException { return bufferedSource().read(sink, offset, byteCount); }
    @Override public void readFully(final Buffer sink, final long byteCount) throws IOException { bufferedSource().readFully(sink, byteCount); }
    @Override public long readAll(final Sink sink) throws IOException { return bufferedSource().readAll(sink); }
    @Override public String readUtf8() throws IOException { return bufferedSource().readUtf8(); }
    @Override public String readUtf8(final long byteCount) throws IOException { return bufferedSource().readUtf8(byteCount); }
    @Override public String readUtf8Line() throws IOException { return bufferedSource().readUtf8Line(); }
    @Override public String readUtf8LineStrict() throws IOException { return bufferedSource().readUtf8LineStrict(); }
    @Override public int readUtf8CodePoint() throws IOException { return bufferedSource().readUtf8CodePoint(); }
    @Override public String readString(final Charset charset) throws IOException { return bufferedSource().readString(charset); }
    @Override public String readString(final long byteCount, final Charset charset) throws IOException { return bufferedSource().readString(byteCount, charset); }
    @Override public long indexOf(final byte b) throws IOException { return bufferedSource().indexOf(b); }
    @Override public long indexOf(final byte b, final long fromIndex) throws IOException { return bufferedSource().indexOf(b, fromIndex); }
    @Override public long indexOf(final ByteString bytes) throws IOException { return bufferedSource().indexOf(bytes); }
    @Override public long indexOf(final ByteString bytes, final long fromIndex) throws IOException { return bufferedSource().indexOf(bytes, fromIndex); }
    @Override public long indexOfElement(final ByteString targetBytes) throws IOException { return bufferedSource().indexOfElement(targetBytes); }
    @Override public long indexOfElement(final ByteString targetBytes, final long fromIndex) throws IOException { return bufferedSource().indexOfElement(targetBytes, fromIndex); }
    @Override public InputStream inputStream() { return bufferedSource().inputStream(); }
    @Override public long read(final Buffer sink, final long byteCount) throws IOException { return bufferedSource().read(sink, byteCount); }
    @Override public Timeout timeout() { return bufferedSource().timeout(); }
    @Override public void close() throws IOException { bufferedSource().close(); }
    // @formatter:on

}

Trivial forwarding implementations just override all methods of their parent classes and delegate the job to a delegated object. Once a forwarding class is extended, some of the parent methods can be overridden again.

IConversionThrowableConsumer.java

This is just a listener used below.

interface IConversionThrowableConsumer {

    /**
     * Instantiating {@link okhttp3.ResponseBody} can be not easy due to the way of how {@link okio.BufferedSource} is designed -- too heavy.
     * Deconstructing its components to "atoms" with some lack of functionality may be acceptable.
     * However, this consumer may need some improvements on demand.
     */
    void accept(MediaType contentType, long contentLength, InputStream inputStream, Throwable ex)
            throws IOException;

}

ErrorReportingConverterFactory.java

The next step is implementating the error-reporting converter factory that can be injected to Retrofit.Builder and listen to any errors occurring in downstream converters. Note how it works:

For every response converter an intermediate converter is injected. It allows to listen to any error in downstream converters.
Downstream converters obtain a non-closeable resources in order not to close underlaying I/O resources prematurely...
Downstream converters convert whilst the intermediate converter collects the real input stream content into a buffer in order to respond with an input stream that may cause GsonConverter fail. This should be considered a bottleneck here due to possibly large size of the grown buffer (however, it may be limited), its internal array is copied when requested from the converter and so on.
If IOException or RuntimeException occur, the intermediate converter concatenates the buffered input stream content and the real input stream in order to let a consumer to accept input streams from the very beginning.
The intermediate converter takes care of closing resources itself.

final class ErrorReportingConverterFactory
        extends Factory {

    private final IConversionThrowableConsumer consumer;

    private ErrorReportingConverterFactory(final IConversionThrowableConsumer consumer) {
        this.consumer = consumer;
    }

    static Factory getErrorReportingConverterFactory(final IConversionThrowableConsumer listener) {
        return new ErrorReportingConverterFactory(listener);
    }

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(final Type type, final Annotation[] annotations, final Retrofit retrofit) {
        return (Converter<ResponseBody, Object>) responseBody -> {
            final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            final InputStream realInputStream = responseBody.byteStream();
            try {
                final ForwardingResponseBody bufferingResponseBody = new BufferingNoCloseResponseBOdy(responseBody, byteArrayOutputStream);
                final Converter<ResponseBody, Object> converter = retrofit.nextResponseBodyConverter(this, type, annotations);
                return converter.convert(bufferingResponseBody);
            } catch ( final RuntimeException | IOException ex ) {
                final InputStream inputStream = concatInputStreams(new ByteArrayInputStream(byteArrayOutputStream.toByteArray()), realInputStream);
                consumer.accept(responseBody.contentType(), responseBody.contentLength(), inputStream, ex);
                throw ex;
            } finally {
                responseBody.close();
            }
        };
    }

    private static class BufferingInputStream
            extends ForwardingInputStream {

        private final InputStream inputStream;
        private final ByteArrayOutputStream byteArrayOutputStream;

        private BufferingInputStream(final InputStream inputStream, final ByteArrayOutputStream byteArrayOutputStream) {
            this.inputStream = inputStream;
            this.byteArrayOutputStream = byteArrayOutputStream;
        }

        @Override
        protected InputStream inputStream() {
            return inputStream;
        }

        @Override
        public int read()
                throws IOException {
            final int read = super.read();
            if ( read != -1 ) {
                byteArrayOutputStream.write(read);
            }
            return read;
        }

        @Override
        public int read(final byte[] b)
                throws IOException {
            final int read = super.read(b);
            if ( read != -1 ) {
                byteArrayOutputStream.write(b, 0, read);
            }
            return read;
        }

        @Override
        public int read(final byte[] b, final int off, final int len)
                throws IOException {
            final int read = super.read(b, off, len);
            if ( read != -1 ) {
                byteArrayOutputStream.write(b, off, read);
            }
            return read;
        }

    }

    private static class BufferingNoCloseResponseBOdy
            extends ForwardingResponseBody {

        private final ResponseBody responseBody;
        private final ByteArrayOutputStream byteArrayOutputStream;

        private BufferingNoCloseResponseBOdy(final ResponseBody responseBody, final ByteArrayOutputStream byteArrayOutputStream) {
            this.responseBody = responseBody;
            this.byteArrayOutputStream = byteArrayOutputStream;
        }

        @Override
        protected ResponseBody responseBody() {
            return responseBody;
        }

        @Override
        @SuppressWarnings("resource")
        public BufferedSource source() {
            final BufferedSource source = super.source();
            return new ForwardingBufferedSource() {
                @Override
                protected BufferedSource bufferedSource() {
                    return source;
                }

                @Override
                public InputStream inputStream() {
                    return new BufferingInputStream(super.inputStream(), byteArrayOutputStream);
                }
            };
        }

        /**
         * Suppressing close due to automatic close in {@link ErrorReportingConverterFactory#responseBodyConverter(Type, Annotation[], Retrofit)}
         */
        @Override
        public void close() {
            // do nothing
        }

    }

}

Note that this implementation uses forwarding classes heavily and only overrides what's necessary.

Also there are some utilities like concatenating input streams and adapting iterators to enumerations.

IteratorEnumeration.java

final class IteratorEnumeration<T>
        implements Enumeration<T> {

    private final Iterator<? extends T> iterator;

    private IteratorEnumeration(final Iterator<? extends T> iterator) {
        this.iterator = iterator;
    }

    static <T> Enumeration<T> iteratorEnumeration(final Iterator<? extends T> iterator) {
        return new IteratorEnumeration<>(iterator);
    }

    @Override
    public boolean hasMoreElements() {
        return iterator.hasNext();
    }

    @Override
    public T nextElement() {
        return iterator.next();
    }

}

InputStreams.java

final class InputStreams {

    private InputStreams() {
    }

    static InputStream concatInputStreams(final InputStream... inputStreams) {
        return inputStreams.length == 2
                ? new SequenceInputStream(inputStreams[0], inputStreams[1])
                : new SequenceInputStream(iteratorEnumeration((Iterator<? extends InputStream>) asList(inputStreams).iterator()));
}

}

OutputStreamConversionThrowableConsumer.java

Trivial logging implementation.

final class OutputStreamConversionThrowableConsumer
        implements IConversionThrowableConsumer {

    private static final int BUFFER_SIZE = 512;

    private final PrintStream printStream;

    private OutputStreamConversionThrowableConsumer(final PrintStream printStream) {
        this.printStream = printStream;
    }

    static IConversionThrowableConsumer getOutputStreamConversionThrowableConsumer(final OutputStream outputStream) {
        return new OutputStreamConversionThrowableConsumer(new PrintStream(outputStream));
    }

    static IConversionThrowableConsumer getSystemOutConversionThrowableConsumer() {
        return getOutputStreamConversionThrowableConsumer(System.out);
    }

    static IConversionThrowableConsumer getSystemErrConversionThrowableConsumer() {
        return getOutputStreamConversionThrowableConsumer(System.err);
    }

    @Override
    public void accept(final MediaType contentType, final long contentLength, final InputStream inputStream, final Throwable ex)
            throws IOException {
        printStream.print("Content type:   ");
        printStream.println(contentType);
        printStream.print("Content length: ");
        printStream.println(contentLength);
        printStream.print("Content:        ");
        final byte[] buffer = new byte[BUFFER_SIZE];
        int read;
        while ( (read = inputStream.read(buffer)) != -1 ) {
            printStream.write(buffer, 0, read);
        }
        printStream.println();
    }

}

Put all together

final Gson gson = new Gson();
final Retrofit retrofit = new Retrofit.Builder()
        .baseUrl(...)
        .addConverterFactory(getErrorReportingConverterFactory(getSystemOutConversionThrowableConsumer()))
        .addConverterFactory(GsonConverterFactory.create(gson))
        .build();
final IWhateverService service = retrofit.create(IWhateverService.class);
final Call<...> call = service.getWhatever("test.json");
call.enqueue(new Callback<...>() {
    @Override
    public void onResponse(final Call<...> call, final Response<...> response) {
        System.out.println(response.body());
    }

    @Override
    public void onFailure(final Call<...> call, final Throwable throwable) {
        throwable.printStackTrace(System.err);
    }
});

Note that ErrorReportingConverterFactory must registered before the GsonConverterFactory. Let's assume the service requests for a JSON that's eventually illegal:

{"foo":1,###"bar":2}

In such case, the error reporting converter will produce the following dump to stdout:

Content type:   application/json  
Content length: -1  
Content:        {"foo":1,###"bar":2}

I'm not an expert in Log4j, and could not find an efficient way to get the output streams to redirect the input stream to. Here is the closest thing what I've found:

final class Log4jConversionThrowableConsumer
        implements IConversionThrowableConsumer {

    private static final int BUFFER_SIZE = 512;

    private final Logger logger;

    private Log4jConversionThrowableConsumer(final Logger logger) {
        this.logger = logger;
    }

    static IConversionThrowableConsumer getLog4jConversionThrowableConsumer(final Logger logger) {
        return new Log4jConversionThrowableConsumer(logger);
    }

    @Override
    public void accept(final MediaType contentType, final long contentLength, final InputStream inputStream, final Throwable ex) {
        try {
            final StringBuilder builder = new StringBuilder(BUFFER_SIZE)
                    .append("Content type=")
                    .append(contentType)
                    .append("; Content length=")
                    .append(contentLength)
                    .append("; Input stream content=");
            readInputStreamFirstChunk(builder, inputStream);
            logger.error(builder.toString(), ex);
        } catch ( final IOException ioex ) {
            throw new RuntimeException(ioex);
        }
    }

    private static void readInputStreamFirstChunk(final StringBuilder builder, final InputStream inputStream)
            throws IOException {
        final Reader reader = new InputStreamReader(inputStream);
        final char[] buffer = new char[512];
        final int read = reader.read(buffer);
        if ( read >= 0 ) {
            builder.append(buffer, 0, read);
        }
    }

}

Unfortunately, collecting the whole string may be expensive, so it only takes the very first 512 bytes. This may require callibrating the joined streams in the intermediate converter in order to "shift" the content "to the left" a bit.

来源：https://stackoverflow.com/questions/42200023/log-response-body-in-case-of-exception

标签

gson

retrofit2