Introduce `TransactionExecutionListener` callback API

[cdalexndr]

Affects: 5.3.10

Please provide a method to register a listener to be notified when a transaction is created/committed/rolledback/finished.

[quaff]

You can wrap TransacationManager.

import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionStatus;

import lombok.AllArgsConstructor;
import lombok.Getter;

@AllArgsConstructor
@Getter
public class WrappedTransactionManager implements PlatformTransactionManager {

	private final PlatformTransactionManager underlying;

	@Override
	public TransactionStatus getTransaction(TransactionDefinition transactionDefinition) throws TransactionException {
		// TODO
		return this.underlying.getTransaction(transactionDefinition);
	}

	@Override
	public void commit(TransactionStatus transactionStatus) throws TransactionException {
		// TODO
		this.underlying.commit(transactionStatus);
	}

	@Override
	public void rollback(TransactionStatus transactionStatus) throws TransactionException {
		// TODO
		this.underlying.rollback(transactionStatus);
	}

}

[mdeinum]

You can register callbacks using the TransactionSynchronizationManager using the registerSynchronization method. This takes a TransactionSynchronization for which you can then implement the desired methods.

Another option is using the @TransactionalEventListener and make that run on the desired state.

[quaff]

@mdeinum TransactionSynchronization and @TransactionalEventListener does not know when transaction created.

[cdalexndr]

PlatformTransactionManager.getTransaction can retrieve existing transaction, but returned value can be checked TransactionStatus.isNewTransaction() to handle new transactions.

[cdalexndr]

It seems that commit/rollback is also called for stacked virtual transactions so I have to also check them:

public class WrappedTransactionManager implements PlatformTransactionManager {

	private final PlatformTransactionManager underlying;

	@Override
	public TransactionStatus getTransaction(TransactionDefinition transactionDefinition) throws TransactionException {
		TransactionStatus status = this.underlying.getTransaction(transactionDefinition);
                if(status.isNewTransaction()){
                   //TODO
                }
                return status;
	}

	@Override
	public void commit(TransactionStatus transactionStatus) throws TransactionException {
		this.underlying.commit(transactionStatus);
                if(transactionStatus.isNewTransaction()){
                   //TODO
                }
	}

	@Override
	public void rollback(TransactionStatus transactionStatus) throws TransactionException {
		this.underlying.rollback(transactionStatus);
                if(transactionStatus.isNewTransaction()){
                   //TODO
                }
	}
}

[cdalexndr]

WARNING registering a simple wrapper is not enough:

    //copy from org.springframework.boot.autoconfigure.orm.jpa.JpaBaseConfiguration
    @Bean
    public PlatformTransactionManager transactionManager(
            ObjectProvider<TransactionManagerCustomizers> transactionManagerCustomizers ) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManagerCustomizers.ifAvailable( ( customizers ) -> customizers.customize( transactionManager ) );
        return new WrappedTransactionManager ( transactionManager );  //<- WRAPPER HERE
    }

The original JpaTransactionManager implements some interfaces (ResourceTransactionManager, BeanFactoryAware, InitializingBean) used after bean creation, so if the wrapper doesn't forward those calls, erroneous behavior will arise. For example: in the same transaction EntityManager using one connection and JOOQ using another connection, because afterPropertiesSet() method was not forwarded.

Now, the wrapper can be made compatible, but what if, in a new spring version, another spring managed interface is added to JpaTransactionManager? I have to check at every version upgrade to make the wrapper compatible. Same for the non-trivial bean creation method that is a copy of the spring managed one. This becomes a maintenance hell.

This wrapper is a WORKAROUND only, and a spring managed solution must be provided for this feature.

[quaff]

You can try BeanPostProcessor

	@Bean
	static BeanPostProcessor transactionManagerPostProcessor() {
		return new BeanPostProcessor() {

			@Override
			public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
				if (bean instanceof PlatformTransactionManager) {
					ProxyFactory pf = new ProxyFactory(bean);
					pf.addAdvice(new MethodInterceptor() {
						@Override
						public Object invoke(MethodInvocation invocation) throws Throwable {
							Method m = invocation.getMethod();
							if (m.getDeclaringClass() == PlatformTransactionManager.class) {
								//TODO
							}
							return invocation.proceed();
						}
					});
					bean = pf.getProxy();
				}
				return bean;
			}
		};
	}

[snicoll]

@cdalexndr rather than asking for a technical solution like this, we'd very much prefer that you explain the use cases that you're trying to implement.

[cdalexndr]

My use case: I want to track database transactions (start-end) to dump them when the app health is DOWN, for debugging purposes.
I need to store postgres backend id together with the executing thread, so I can dump thread stacktrace with additional info like query and held/waiting database locks (query pg_stat_activity & pg_locks, filter by backend id).

[Cavva79]

This issue maybe related to this one #18297.