RestClient doesn't open a scope for the processing of the request

[KayWu]

RestTemplate opens the scope when handling requests, whereas RestClient does not.
This will cause the custom ClientHttpRequestInterceptor for RestClient to be unable to access the currently active scope within the intercept method.

spring-framework/spring-web/src/main/java/org/springframework/web/client/RestTemplate.java

Line 896 in 2eff5cb

try (Observation.Scope scope = observation.openScope()){

spring-framework/spring-web/src/main/java/org/springframework/web/client/DefaultRestClient.java

Line 541 in 2eff5cb

clientResponse = clientRequest.execute();

[prkksh]

@KayWu, I reviewed the restClient exchange call and see that observability is opened there just in a different way. Reviewing the code gives an idea that observability is managed in both places in similar manner just implemented differently. Did you find any specific use case that you could explain for better understanding of your issue?

https://github.com/spring-projects/spring-framework/blob/main/spring-web/src/main/java/org/springframework/web/client/DefaultRestClient.java#L531-L534

[KayWu]

Hi @prkksh , DefaultRestClient starts the observation, but not activate the scope in the current thread, while RestTemplate does both things.
We can see that both codes call observation.start(), but only RestTemplate calls observation.openScope.

spring-framework/spring-web/src/main/java/org/springframework/web/client/RestTemplate.java

Lines 892 to 904 in 2eff5cb

	Observation observation = ClientHttpObservationDocumentation.HTTP_CLIENT_EXCHANGES.observation(
	this.observationConvention, DEFAULT_OBSERVATION_CONVENTION,
	() -> observationContext, this.observationRegistry).start();
	ClientHttpResponse response = null;
	try (Observation.Scope scope = observation.openScope()){
	if (requestCallback != null) {
	requestCallback.doWithRequest(request);
	}
	response = request.execute();
	observationContext.setResponse(response);
	handleResponse(url, method, response);
	return (responseExtractor != null ? responseExtractor.extractData(response) : null);
	}

spring-framework/spring-web/src/main/java/org/springframework/web/client/DefaultRestClient.java

Lines 533 to 544 in 2eff5cb

	observation = ClientHttpObservationDocumentation.HTTP_CLIENT_EXCHANGES.observation(observationConvention,
	DEFAULT_OBSERVATION_CONVENTION, () -> observationContext, observationRegistry).start();
	if (this.body != null) {
	this.body.writeTo(clientRequest);
	}
	if (this.httpRequestConsumer != null) {
	this.httpRequestConsumer.accept(clientRequest);
	}
	clientResponse = clientRequest.execute();
	observationContext.setResponse(clientResponse);
	ConvertibleClientHttpResponse convertibleWrapper = new DefaultConvertibleClientHttpResponse(clientResponse, observation);
	return exchangeFunction.exchange(clientRequest, convertibleWrapper);

When observation.openScope() is called, it activates the observation in the current thread, making any code executed later in the same thread aware of this observation. If a new observation is created, the existing observation will be treated as the parent observation.

However, if an observation is started but not activated with openScope(), subsequent code execution will not be aware of this observation.

I have implemented a ClientHttpRequestInterceptor, which performs some operations that create new observations. Since these operations are executed sequentially, the observations should also be linked together in sequence.

This works fine with RestTemplate, but it doesn't work with RestClient because RestClient does not activate the scope, causing these observations to be independent rather than linked.

[prkksh]

PR for this