Most of our Quarkus endpoints follow the standard practice in which they’re annotated with @Transactional, call into our business layer, and if an exception is thrown the entire transaction is rolled back.

However, for this scenario, we need to execute a database update even if the transaction is rolled back. Our database is MySQL 8.

// Quarkus Resource class
@POST
@Transactional
@Path("/document/generate")
public void generateDocument() {
  documentGeneratorComponent.generateDocument(...);
}

Our initial attempt was to use @Transactional(REQUIRES_NEW) to update the status. The problem we’re running into is we’re getting lock timeout exceptions as I believe both the outer transaction and the nested transaction are trying to update the same tracking record.

@ApplicationScoped
public class DocumentGeneratorComponent {


  public void generateDocument(...) {
    Long trackingId = null;
    try {
      trackingId = createTrackingRecord(DocGenStatus.STARTED);

      // error prone stuff that may throw
      var input = getInputData(...);
      docGenService.sendDocRequest(input);
    } catch (Exception ex) {
      if (trackingId != null) {
        updateStatusWithError(trackingId);
      }
      throw ex;
    }
  }

  // updates tracking record even if error
  @Transactional(REQUIRES_NEW)
  public void updateStatusWithError(var trackingId) {
    updateTrackingRecord(trackingId, DocGenStatus.EXCEPTION);
  }
}

Initially, we thought we can remove the @Transactional annotation from the Resource layer and handle the transaction in the component. The problem is other code in our business layer may also need to generate documents and they may do that within the scope of their transaction.

It would be incredibly convenient if there was a simple way to execute code in a callback like the following. Is there a best practice for doing this type of thing in Quarkus?

public void generateDocument(...) {
    Long trackingId = null;
    try {
    } finally {
       transactionManager.onCurrentTransactionRollback(() -> updateStatusWithError(trackingId));
    ...

I looked into @TransactionScoped beans, but the @PreDestroy is documented as being invoked before the transaction is rolled back and there’s an open defect in which it seems the behavior of when it’s executed is undefined or inconsistent with the documentation.

There’s also transaction listeners but it seems a bit inconvenient to use as they listen on all transactions and not a specific one.

void onAfterEndTransaction(@Observes @Destroyed(TransactionScoped.class) Object event) {
  // will be invoked for every transaction in the application, not just the code in question
}

What’s the recommended approach? Thanks!