How to figure out original exception responsible for transaction rollback in the JAX-RS exception mapper

What the circumstances are: There is a REST API and a EJB server bean deployed on Wildfly 15. The REST call starts a transaction and fires a custom CDI event. In my server bean, there is a transactional observer method with transaction phase BEFORE_COMPLETION. Under some conditions, inside of this method a runtime exception of a custom type with a specific message is intentionally thrown. I expect the transaction to be rolled back in this case (which also correctly happens). The exception which has triggered the rollback, I want to handle in a JAX-RS exception mapper and finally send a specific HTTP response code and message from the exception.

Now, almost everything works as I want: the transaction is rolled back, the exception mapper method jumps in and handles the exception.

But my big problem is: the exception which I receive as argument in exception mapper, is of type javax.transaction.RollbackException and not of my expected custom type which was initially thrown. The exact message is: "javax.transaction.RollbackException: ARJUNA016053: Could not commit transaction." Also, my exception seems not to be nested anywhere e.g. as cause or in the call stack of the received exception, so I cannot figure out, what is my message, and also I would not be able to distinguish this rollback from another potential rollbacks due to other reasons (like database errors etc.)

Question: is my desired idea described above possible at all? Maybe I completely misunderstand how the framework acts due to my lack of Java EE experience and this scenario fundamentally cannot work this way? To know this would already be helpful to me. Otherwise, what should I do to get it work or how could I achieve the desired result with an other approach?

Here is my current code:

Server Bean

import javax.ejb.Stateless;
import javax.enterprise.event.Observes;
import javax.enterprise.event.TransactionPhase;
import javax.transaction.Transactional;

import my.custom.package.CustomRuntimeException

@Stateless
@Transactional
public class CustomBean
{
    public void onNewCustomEvent(
        @Observes( during = TransactionPhase.BEFORE_COMPLETION ) CustomEvent event )
    {
        // do something
        
        if ( isSomeError )
        {
            throw new CustomRuntimeException("Some important detail message.");
        }
    }
}

Exception Mapper

import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;

@Provider
public class CustomRuntimeExceptionMapper implements ExceptionMapper< Throwable >
{
    @Override
    public Response toResponse( Throwable e ) // <--- Expect: CustomRuntimeException, receive: RollbackException
    {
        // evaluate the exception and send proper HTTP code
        return Response.status( Response.Status.NOT_FOUND ).build();
    }
}

Exception Class

public class CustomRuntimeException extends RuntimeException
{
    public CustomRuntimeException(String errorReason)
    {
        super (errorReason);
    }
}

2020-08-17. Additional remark.
In the server logs I noticed this error message, maybe it is helpful to better understand the reason. I googled for this, but could not figure out anything useful.

WELD-000401: Failure while notifying an observer [UnbackedAnnotatedMethod] public CustomBean.onCustomEvent(@Observes CustomEvent) of event null.
 CustomRuntimeException

Actually you can put this annotation on your custom exception

@javax.ejb.ApplicationException(rollback=true)
public class CustomRuntimeException extends RuntimeException{...}

So that the exception will be reported to the client directly (unwrapped).

By default, the EJB Container will wrap your custom exception by EJBException, and by using this annotation the exception will not be wrapped.

But in your case may be there another exception or a rollback is the cause, not the CustomAppException try debugging your code execution to find out what actually is going on or provide the full code so we can try to help.