I'm trying to log a request using Spring 5 WebClient. Do you have any idea how could I achieve that?
(I'm using Spring 5 and Spring boot 2)
The code looks like this at the moment:
try { return webClient.get().uri(url, urlParams).exchange().flatMap(response -> response.bodyToMono(Test.class)) .map(test -> xxx.set(test)); } catch (RestClientException e) { log.error("Cannot get counter from opus", e); throw e; }
Set the body of the request to the given BodyInserter and perform the request. Set the body of the request to the given Publisher and perform the request. Add the given, single header value under the given name. Copy the given headers into the entity's headers map.
WebClient Non-Blocking Client. On the other side, WebClient uses an asynchronous, non-blocking solution provided by the Spring Reactive framework. While RestTemplate uses the caller thread for each event (HTTP call), WebClient will create something like a “task” for each event.
You can easily do it using ExchangeFilterFunction
Just add the custom logRequest
filter when you create your WebClient
using WebClient.Builder
.
Here is the example of such filter and how to add it to the WebClient
.
@Slf4j @Component public class MyClient { private final WebClient webClient; // Create WebClient instance using builder. // If you use spring-boot 2.0, the builder will be autoconfigured for you // with the "prototype" scope, meaning each injection point will receive // a newly cloned instance of the builder. public MyClient(WebClient.Builder webClientBuilder) { webClient = webClientBuilder // you can also just use WebClient.builder() .baseUrl("https://httpbin.org") .filter(logRequest()) // here is the magic .build(); } // Just example of sending request. This method is NOT part of the answer public void send(String path) { ClientResponse clientResponse = webClient .get().uri(uriBuilder -> uriBuilder.path(path) .queryParam("param", "value") .build()) .exchange() .block(); log.info("Response: {}", clientResponse.toEntity(String.class).block()); } // This method returns filter function which will log request data private static ExchangeFilterFunction logRequest() { return ExchangeFilterFunction.ofRequestProcessor(clientRequest -> { log.info("Request: {} {}", clientRequest.method(), clientRequest.url()); clientRequest.headers().forEach((name, values) -> values.forEach(value -> log.info("{}={}", name, value))); return Mono.just(clientRequest); }); } }
Then just call myClient.send("get");
and log messages should be there.
Output example:
Request: GET https://httpbin.org/get?param=value header1=value1 header2=value2
Edit
Some people pointed out in comments that block()
is bad practice etc. I want to clarify: block()
call here is just for demo purposes. The request logging filter will work anyway. You will not need to add block()
to your code to make ExchangeFilterFunction
work. You can use WebClient
to perform a http-call in a usual way, chaining methods and returning Mono
up the stack until someone will subscribe to it. The only relevant part of the answer is logRequest()
filter. You can ignore send()
method altogether - it is not part of the solution - it just demonstrates that filter works.
Some people also asked how to log the response. To log the response you can write another ExchangeFilterFunction
and add it to WebClient
. You can use ExchangeFilterFunction.ofResponseProcessor
helper for this purpose just the same way as ExchangeFilterFunction.ofRequestProcessor
is used. You can use methods of ClientResponse
to get headers/cookies etc.
// This method returns filter function which will log response data private static ExchangeFilterFunction logResponse() { return ExchangeFilterFunction.ofResponseProcessor(clientResponse -> { log.info("Response status: {}", clientResponse.statusCode()); clientResponse.headers().asHttpHeaders().forEach((name, values) -> values.forEach(value -> log.info("{}={}", name, value))); return Mono.just(clientResponse); }); }
Don't forget to add it to your WebClient
:
.filter(logResponse())
But be careful and do not try to read the response body here in the filter. Because of the stream nature of it, the body can be consumed only once without some kind of buffering wrapper. So, if you will read it in the filter, you will not be able to read it in the subscriber.
If you really need to log the body, you can make the underlying layer (Netty) to do this. See Matthew Buckett's answer to get the idea.
You can have netty do logging of the request/responses with by asking it todo wiretaping, if you create your Spring WebClient like this then it enables the wiretap option.
WebClient webClient = WebClient.builder() .clientConnector(new ReactorClientHttpConnector( HttpClient.create().wiretap(true) )) .build()
and then have your logging setup:
logging.level.reactor.netty.http.client.HttpClient: DEBUG
this will log everything for the request/response (including bodies), but the format is not specific to HTTP so not very readable.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With