Customising error response format

[headly48]

Expected Behavior

Currently upgrading and running into an issue with applying custom formatting to error responses.

Prior to version 4.6.0 the ErrorResponseProcessor could be used to return a custom error response body for all errors however after upgrading to 4.6.0 the custom error formating is no longer being applied

Actual Behaviour

After upgrading to 4.6.0 the ErrorResponseProcessor is no longer called.

Steps To Reproduce

  package example.micronaut;
  
  import io.micronaut.context.annotation.Primary;
  import io.micronaut.core.annotation.NonNull;
  import io.micronaut.http.HttpMethod;
  import io.micronaut.http.HttpStatus;
  import io.micronaut.http.MediaType;
  import io.micronaut.http.MutableHttpResponse;
  import io.micronaut.http.server.exceptions.response.Error;
  import io.micronaut.http.server.exceptions.response.ErrorContext;
  import io.micronaut.http.server.exceptions.response.ErrorResponseProcessor;
  import io.micronaut.serde.annotation.Serdeable;
  import jakarta.inject.Singleton;
  
  import java.util.HashSet;
  import java.util.Set;
  import java.util.UUID;
  
  @Singleton
  @Primary
  public class CustomErrorResponseProcessor<E> implements ErrorResponseProcessor<CustomErrorResponseProcessor.Errors> {
  
      @Serdeable.Serializable
      public record Errors (Set<ErrorMessage> errors) {
  
      }
  
      @Serdeable.Serializable
      public record ErrorMessage (String id, String code, String details) {
  
      }
  
      @Override
      public @NonNull MutableHttpResponse<Errors> processResponse(@NonNull ErrorContext errorContext, @NonNull MutableHttpResponse<?> response) {
  
          if (errorContext.getRequest().getMethod() == HttpMethod.HEAD) {
              return (MutableHttpResponse<Errors>) response;
          }
  
          Set<ErrorMessage> errorMessages = new HashSet<>();
          if (!errorContext.hasErrors()) {
              ErrorMessage errorMessage = new ErrorMessage(getUUID(), HttpStatus.valueOf(response.code()).name(), response.reason());
              
              errorMessages.add(errorMessage);
          } else {
              for (Error e : errorContext.getErrors()) {
                  ErrorMessage errorMessage = new ErrorMessage(getUUID(), HttpStatus.valueOf(response.code()).name(), e.getMessage());
  
                  errorMessages.add(errorMessage);
              }
          }
          Errors errors = new Errors(errorMessages);
          return response.body(errors).contentType(MediaType.APPLICATION_JSON_TYPE);
      }
  
  
      private String getUUID() {
          return UUID.randomUUID().toString();
      }
  }

When making a request to an endpoint that does not exist with version=4.5.0 the response body is

{
    "errors": [
        {
            "id": "b6c34008-6dca-449f-b341-655a5bd0d0e6",
            "code": "NOT_FOUND",
            "details": "Page Not Found"
        }
    ]
}

with version=4.6.0 the response body is empty

Environment Information

No response

Example Application

No response

Version

=4.6.0

[graemerocher]

please upload a sample application

[headly48]

Have created sample application with a test showing the behaviour difference between micronaut versions.

4.5.0

4.6.0

[headly48]

To keep the same behaviour the workaround I am using is to create a custom provider and exception mapper

@Singleton
@Primary
public class CustomProvider implements Providers {
    Providers providers;
    CustomExceptionMapper customExceptionMapper;

    @Inject
    public CustomProvider(@Named("JaxRsProviders") Providers providers, CustomExceptionMapper customExceptionMapper) {
        this.providers = providers;
        this.customExceptionMapper = customExceptionMapper;
    }

    @Override
    public <T> MessageBodyReader<T> getMessageBodyReader(Class<T> aClass, Type type, Annotation[] annotations, MediaType mediaType) {
        return this.providers.getMessageBodyReader(aClass, type, annotations, mediaType);
    }

    @Override
    public <T> MessageBodyWriter<T> getMessageBodyWriter(Class<T> aClass, Type type, Annotation[] annotations, MediaType mediaType) {
        return this.providers.getMessageBodyWriter(aClass, type, annotations, mediaType);
    }

    @Override
    public <T extends Throwable> ExceptionMapper<T> getExceptionMapper(Class<T> aClass) {
        return (ExceptionMapper<T>) this.customExceptionMapper;
    }

    @Override
    public <T> ContextResolver<T> getContextResolver(Class<T> aClass, MediaType mediaType) {
        return this.providers.getContextResolver(aClass, mediaType);
    }
}

@Singleton
@Slf4j
public class CustomExceptionMapper<E extends Throwable> implements ExceptionMapper<WebApplicationException> {

    private final ErrorResponseProcessor<?> responseProcessor;

    @Inject
    public CustomExceptionMapper(ErrorResponseProcessor<?> responseProcessor) {
        this.responseProcessor = responseProcessor;
    }

    @Override
    public Response toResponse(WebApplicationException exception) {

        HttpRequest<Object> httpRequest = ServerRequestContext.currentRequest().orElse(null);

        ErrorContext errorContext =
                ErrorContext.builder(httpRequest).errorMessage(exception.getMessage()).cause(exception).build();

        MutableHttpResponse<?> errorResponse = HttpResponse.status(HttpStatus.valueOf(exception.getResponse().getStatus()));

        return convertToJaxRsResponse(this.responseProcessor.processResponse(errorContext, errorResponse));
    }

    private Response convertToJaxRsResponse(MutableHttpResponse<?> micronautResponse) {

        Object body = micronautResponse.getBody().orElseThrow(() -> new RuntimeException("Response body is missing from exception response"));

        Response.ResponseBuilder responseBuilder = Response.status(micronautResponse.getStatus().getCode()).entity(body);

        micronautResponse.getHeaders().forEach((name, values) -> values.forEach(value -> responseBuilder.header(name, value)));

        return responseBuilder.build();
    }
}