Feature: option to retrieve original json body if parse exception occurred

java-client/src/main/java/co/elastic/clients/transport/DefaultTransportOptions.java

@@ -88,6 +88,11 @@ public Function<List<String>, Boolean> onWarnings() {
         return onWarnings;
     }
 
+    @Override
+    public boolean retrieveOriginalJsonResponseOnException() {
+        return false;
+    }
+
     @Override
     public Builder toBuilder() {
         return new Builder(this);
@@ -111,6 +116,7 @@ public abstract static class AbstractBuilder<BuilderT extends AbstractBuilder<Bu
         private HeaderMap headers;
         private Map<String, String> parameters;
         private Function<List<String>, Boolean> onWarnings;
+        private boolean retrieveOriginalJsonResponseOnException;
 
         public AbstractBuilder() {
         }
@@ -119,10 +125,17 @@ public AbstractBuilder(DefaultTransportOptions options) {
             this.headers = new HeaderMap(options.headers);
             this.parameters = copyOrNull(options.parameters);
             this.onWarnings = options.onWarnings;
+            this.retrieveOriginalJsonResponseOnException = options.retrieveOriginalJsonResponseOnException();
         }
 
         protected abstract BuilderT self();
 
+        @Override
+        public BuilderT retrieveOriginalJsonResponseOnException(boolean value){
+            this.retrieveOriginalJsonResponseOnException = value;
+            return self();
+        }
+
         @Override
         public BuilderT addHeader(String name, String value) {
             if (name.equalsIgnoreCase(HeaderMap.CLIENT_META)) {

java-client/src/main/java/co/elastic/clients/transport/ElasticsearchTransportBase.java

@@ -45,6 +45,8 @@
 import jakarta.json.stream.JsonParser;
 
 import javax.annotation.Nullable;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.ByteBuffer;
@@ -377,28 +379,42 @@ private <ResponseT> ResponseT decodeTransportResponse(
     ) throws IOException {
 
         if (endpoint instanceof JsonEndpoint) {
+
+            // Expecting a body
+            if (entity == null) {
+                throw new TransportException(
+                    clientResp,
+                    "Expecting a response body, but none was sent",
+                    endpoint.id()
+                );
+            }
+            InputStream content = entity.asInputStream();
+            InputStream contentForException = null;
+
+            // if the option to print the original body has been set, the body has to be
+            // copied first to another stream to be read again by the exception class
+            if(options().retrieveOriginalJsonResponseOnException()) {
+                try(ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
+                    entity.writeTo(baos);
+                    content = new ByteArrayInputStream(baos.toByteArray());
+                    contentForException = new ByteArrayInputStream(baos.toByteArray());
+                }
+            }
+
             @SuppressWarnings("unchecked")
             JsonEndpoint<?, ResponseT, ?> jsonEndpoint = (JsonEndpoint<?, ResponseT, ?>) endpoint;
             // Successful response
             ResponseT response = null;
             JsonpDeserializer<ResponseT> responseParser = jsonEndpoint.responseDeserializer();
             if (responseParser != null) {
-                // Expecting a body
-                if (entity == null) {
-                    throw new TransportException(
-                        clientResp,
-                        "Expecting a response body, but none was sent",
-                        endpoint.id()
-                    );
-                }
                 checkJsonContentType(entity.contentType(), clientResp, endpoint);
                 try (
-                    InputStream content = entity.asInputStream();
                     JsonParser parser = mapper.jsonProvider().createParser(content)
                 ) {
                     response = responseParser.deserialize(parser, mapper);
                 } catch (Exception e) {
-                    throw new TransportException(
+                    throw new TransportBodyResponseException(
+                        contentForException,
                         clientResp,
                         "Failed to decode response",
                         endpoint.id(),

java-client/src/main/java/co/elastic/clients/transport/TransportBodyResponseException.java

@@ -0,0 +1,47 @@
+package co.elastic.clients.transport;
+
+import co.elastic.clients.transport.http.TransportHttpClient;
+
+import javax.annotation.Nullable;
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+public class TransportBodyResponseException extends TransportException {
+
+    private String originalBody;
+
+    public TransportBodyResponseException(InputStream originalBody,TransportHttpClient.Response response, String message, String endpointId,
+                              Throwable cause) {
+        super(response, message, endpointId, cause);
+        try {
+            if (originalBody != null) {
+                StringBuilder sb = new StringBuilder();
+                BufferedReader br = new BufferedReader(new InputStreamReader(originalBody));
+                String read;
+
+                while ((read=br.readLine()) != null) {
+                    sb.append(read);
+                }
+
+                br.close();
+                this.originalBody = sb.toString();
+                // Closing original body input stream
+                originalBody.close();
+            }
+
+            // Make sure the response is closed to free up resources.
+            response.close();
+        } catch (Exception e) {
+            this.addSuppressed(e);
+        }
+    }
+
+    /**
+     * The original response body, before json deserialization.
+     */
+    @Nullable
+    public String originalBody() {
+        return originalBody;
+    }
+}

java-client/src/main/java/co/elastic/clients/transport/TransportOptions.java

@@ -38,6 +38,8 @@ public interface TransportOptions {
 
     Function<List<String>, Boolean> onWarnings();
 
+    boolean retrieveOriginalJsonResponseOnException();
+
     Builder toBuilder();
 
     default TransportOptions with(Consumer<Builder> fn) {
@@ -59,5 +61,7 @@ interface Builder extends ObjectBuilder<TransportOptions> {
         Builder removeParameter(String name);
 
         Builder onWarnings(Function<List<String>, Boolean> listener);
+
+        Builder retrieveOriginalJsonResponseOnException(boolean value);
     }
 }

java-client/src/main/java/co/elastic/clients/transport/rest_client/RestClientOptions.java

@@ -42,6 +42,8 @@ public class RestClientOptions implements TransportOptions {
 
     private final RequestOptions options;
 
+    boolean retrieveOriginalJsonResponseOnException;
+
     @VisibleForTesting
     static final String CLIENT_META_VALUE = getClientMeta();
     @VisibleForTesting
@@ -99,6 +101,15 @@ public Function<List<String>, Boolean> onWarnings() {
         return warnings -> options.getWarningsHandler().warningsShouldFailRequest(warnings);
     }
 
+    @Override
+    public boolean retrieveOriginalJsonResponseOnException() {
+        return this.retrieveOriginalJsonResponseOnException;
+    }
+
+    public void setRetrieveOriginalJsonResponseOnException(boolean retrieveOriginalJsonResponseOnException) {
+        this.retrieveOriginalJsonResponseOnException = retrieveOriginalJsonResponseOnException;
+    }
+
     @Override
     public Builder toBuilder() {
         return new Builder(options.toBuilder());
@@ -181,6 +192,11 @@ public TransportOptions.Builder onWarnings(Function<List<String>, Boolean> liste
             return this;
         }
 
+        @Override
+        public TransportOptions.Builder retrieveOriginalJsonResponseOnException(boolean value) {
+            return this;
+        }
+
         @Override
         public RestClientOptions build() {
             return new RestClientOptions(addBuiltinHeaders(builder).build());

java-client/src/test/java/co/elastic/clients/documentation/DocTestsTransport.java

@@ -64,6 +64,11 @@ public Function<List<String>, Boolean> onWarnings() {
             return null;
         }
 
+        @Override
+        public boolean retrieveOriginalJsonResponseOnException() {
+            return false;
+        }
+
         @Override
         public Builder toBuilder() {
             return null;

java-client/src/test/java/co/elastic/clients/transport/TransportTest.java

@@ -21,9 +21,11 @@
 
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
 import co.elastic.clients.json.jackson.JacksonJsonpMapper;
+import co.elastic.clients.transport.rest_client.RestClientOptions;
 import co.elastic.clients.transport.rest_client.RestClientTransport;
 import com.sun.net.httpserver.HttpServer;
 import org.apache.http.HttpHost;
+import org.elasticsearch.client.RequestOptions;
 import org.elasticsearch.client.Response;
 import org.elasticsearch.client.RestClient;
 import org.junit.jupiter.api.Assertions;
@@ -33,6 +35,9 @@
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+
+import static co.elastic.clients.util.ContentType.APPLICATION_JSON;
 
 public class TransportTest extends Assertions {
 
@@ -72,4 +77,58 @@ public void testXMLResponse() throws Exception {
         Response restClientResponse = (Response)ex.response().originalResponse();
         assertEquals(401, restClientResponse.getStatusLine().getStatusCode());
     }
+
+
+    @Test
+    public void testOriginalJsonBodyRetrievalException() throws Exception {
+        HttpServer httpServer = HttpServer.create(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0), 0);
+
+        httpServer.createContext("/_cat/indices", exchange -> {
+            exchange.getResponseHeaders().put("Content-Type", Collections.singletonList(APPLICATION_JSON));
+            exchange.getResponseHeaders().put("X-Elastic-Product", Collections.singletonList("Elasticsearch"));
+            exchange.sendResponseHeaders(200, 0);
+            OutputStream out = exchange.getResponseBody();
+            out.write(
+                "definitely not json".getBytes(StandardCharsets.UTF_8)
+            );
+            out.close();
+        });
+
+        httpServer.start();
+        InetSocketAddress address = httpServer.getAddress();
+
+        RestClient restClient = RestClient
+            .builder(new HttpHost(address.getHostString(), address.getPort(), "http"))
+            .build();
+
+        // no transport options, should throw TransportBodyResponseException, but with an empty originalBody
+        ElasticsearchClient esClient = new ElasticsearchClient(new RestClientTransport(restClient, new JacksonJsonpMapper()));
+
+        TransportBodyResponseException ex = Assertions.assertThrows(
+            TransportBodyResponseException.class,
+            () -> esClient.cat().indices()
+        );
+
+        assertEquals(200, ex.statusCode());
+        assertEquals(null, ex.originalBody());
+
+        // setting transport option
+        RestClientOptions options = new RestClientOptions(RequestOptions.DEFAULT);
+        options.setRetrieveOriginalJsonResponseOnException(true);
+
+        ElasticsearchTransport transport = new RestClientTransport(
+            restClient, new JacksonJsonpMapper(), options);
+
+        ElasticsearchClient esClientOptions = new ElasticsearchClient(transport);
+
+        ex = Assertions.assertThrows(
+            TransportBodyResponseException.class,
+            () -> esClientOptions.cat().indices()
+        );
+
+        httpServer.stop(0);
+
+        assertEquals(200, ex.statusCode());
+        assertEquals( "definitely not json", ex.originalBody());
+    }
 }