From 48f2911502e41d72e975ef1e003ac8f892fec584 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Mon, 14 Jul 2025 14:11:02 +0200 Subject: [PATCH 1/4] introduce JtaLogging --- .../hibernate/internal/CoreMessageLogger.java | 8 - .../FallbackBeanInstanceProducer.java | 2 +- .../AbstractLogicalConnectionImplementor.java | 6 +- .../jta/internal/JtaIsolationDelegate.java | 13 +- .../backend/jta/internal/JtaLogging.java | 179 ++++++++++++++++++ ...nsactionAdapterTransactionManagerImpl.java | 27 ++- ...TransactionAdapterUserTransactionImpl.java | 29 ++- .../JtaTransactionCoordinatorImpl.java | 26 ++- .../RegisteredSynchronization.java | 8 +- ...ionCallbackCoordinatorNonTrackingImpl.java | 21 +- ...zationCallbackCoordinatorTrackingImpl.java | 23 +-- 11 files changed, 249 insertions(+), 93 deletions(-) create mode 100644 hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaLogging.java diff --git a/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java b/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java index 7b3d03c9ae5c..eacb77929b0b 100644 --- a/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java +++ b/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java @@ -557,14 +557,6 @@ void cannotResolveNonNullableTransientDependencies( ) void nonCompliantMapConversion(String collectionRole); - @LogMessage(level = WARN) - @Message( - id = 451, - value = "Transaction afterCompletion called by a background thread; " + - "delaying afterCompletion processing until the original thread can handle it. [status=%s]" - ) - void rollbackFromBackgroundThread(int status); - // 458-466 reserved for use by main branch (ORM 5.0.0) @LogMessage(level = DEBUG) diff --git a/hibernate-core/src/main/java/org/hibernate/resource/beans/internal/FallbackBeanInstanceProducer.java b/hibernate-core/src/main/java/org/hibernate/resource/beans/internal/FallbackBeanInstanceProducer.java index 2443a76eef8e..9c933b13fa3a 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/beans/internal/FallbackBeanInstanceProducer.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/beans/internal/FallbackBeanInstanceProducer.java @@ -34,7 +34,7 @@ private FallbackBeanInstanceProducer() { @Override public B produceBeanInstance(Class beanType) { - log.tracef( "Creating ManagedBean(%s) using direct instantiation", beanType.getName() ); + log.tracef( "Creating ManagedBean [%s] using direct instantiation", beanType.getName() ); try { final Constructor constructor = beanType.getDeclaredConstructor(); constructor.setAccessible( true ); diff --git a/hibernate-core/src/main/java/org/hibernate/resource/jdbc/internal/AbstractLogicalConnectionImplementor.java b/hibernate-core/src/main/java/org/hibernate/resource/jdbc/internal/AbstractLogicalConnectionImplementor.java index fae31e7fc7ac..01606a9d4551 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/jdbc/internal/AbstractLogicalConnectionImplementor.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/jdbc/internal/AbstractLogicalConnectionImplementor.java @@ -108,7 +108,7 @@ protected void afterCompletion() { protected void resetConnection(boolean initiallyAutoCommit) { try { if ( initiallyAutoCommit ) { - log.trace( "re-enabling auto-commit on JDBC Connection after completion of JDBC-based transaction" ); + log.trace( "Re-enabling auto-commit on JDBC Connection after completion of JDBC-based transaction" ); getConnectionForTransactionManagement().setAutoCommit( true ); status = TransactionStatus.NOT_ACTIVE; } @@ -121,7 +121,7 @@ protected void resetConnection(boolean initiallyAutoCommit) { @Override public void rollback() { try { - log.trace( "Preparing to rollback transaction via JDBC Connection.rollback()" ); + log.trace( "Preparing to roll back transaction via JDBC Connection.rollback()" ); status = TransactionStatus.ROLLING_BACK; if ( isPhysicallyConnected() ) { getConnectionForTransactionManagement().rollback(); @@ -130,7 +130,7 @@ public void rollback() { errorIfClosed(); } status = TransactionStatus.ROLLED_BACK; - log.trace( "Transaction rolled-back via JDBC Connection.rollback()" ); + log.trace( "Transaction rolled back via JDBC Connection.rollback()" ); } catch( SQLException e ) { status = TransactionStatus.FAILED_ROLLBACK; diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaIsolationDelegate.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaIsolationDelegate.java index 055aa7828839..a225c5e0b394 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaIsolationDelegate.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaIsolationDelegate.java @@ -21,20 +21,19 @@ import org.hibernate.exception.internal.SQLStateConversionDelegate; import org.hibernate.resource.jdbc.spi.JdbcSessionOwner; import org.hibernate.resource.transaction.spi.IsolationDelegate; -import org.hibernate.internal.CoreLogging; -import org.hibernate.internal.CoreMessageLogger; import org.hibernate.internal.util.ExceptionHelper; import org.hibernate.jdbc.WorkExecutor; import org.hibernate.jdbc.WorkExecutorVisitable; import org.hibernate.resource.transaction.spi.TransactionCoordinatorOwner; +import static org.hibernate.resource.transaction.backend.jta.internal.JtaLogging.JTA_LOGGER; + /** * An isolation delegate for JTA environments. * * @author Andrea Boriero */ public class JtaIsolationDelegate implements IsolationDelegate { - private static final CoreMessageLogger LOG = CoreLogging.messageLogger( JtaIsolationDelegate.class ); private final JdbcConnectionAccess connectionAccess; private final BiFunction sqlExceptionConverter; @@ -115,7 +114,7 @@ private T doInSuspendedTransaction(HibernateCallable callable) { // First we suspend any current JTA transaction final Transaction surroundingTransaction = transactionManager.suspend(); if ( surroundingTransaction != null ) { - LOG.tracef( "Surrounding JTA transaction suspended [%s]", surroundingTransaction ); + JTA_LOGGER.transactionSuspended( surroundingTransaction ); } try { @@ -128,7 +127,7 @@ private T doInSuspendedTransaction(HibernateCallable callable) { try { if ( surroundingTransaction != null ) { transactionManager.resume( surroundingTransaction ); - LOG.tracef( "Surrounding JTA transaction resumed [%s]", surroundingTransaction ); + JTA_LOGGER.transactionResumed( surroundingTransaction ); } } catch ( Throwable t2 ) { @@ -165,7 +164,7 @@ private T doInNewTransaction(HibernateCallable callable, TransactionManag transactionManager.rollback(); } catch ( Exception exception ) { - LOG.unableToRollbackIsolatedTransaction( e, exception ); + JTA_LOGGER.unableToRollbackIsolatedTransaction( e, exception ); } throw new HibernateException( "Could not apply work", e ); } @@ -195,7 +194,7 @@ private T doTheWork(WorkExecutorVisitable work) { jdbcConnectionAccess().releaseConnection( connection ); } catch ( Throwable throwable ) { - LOG.unableToReleaseIsolatedConnection( throwable ); + JTA_LOGGER.unableToReleaseIsolatedConnection( throwable ); } } } diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaLogging.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaLogging.java new file mode 100644 index 000000000000..324585c6abd1 --- /dev/null +++ b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaLogging.java @@ -0,0 +1,179 @@ +/* + * SPDX-License-Identifier: Apache-2.0 + * Copyright Red Hat Inc. and Hibernate Authors + */ +package org.hibernate.resource.transaction.backend.jta.internal; + +import org.hibernate.Internal; +import org.hibernate.internal.log.SubSystemLogging; + +import org.jboss.logging.BasicLogger; +import org.jboss.logging.Logger; +import org.jboss.logging.annotations.Cause; +import org.jboss.logging.annotations.LogMessage; +import org.jboss.logging.annotations.Message; +import org.jboss.logging.annotations.MessageLogger; +import org.jboss.logging.annotations.ValidIdRange; + +import java.lang.invoke.MethodHandles; + +import static org.jboss.logging.Logger.Level.TRACE; +import static org.jboss.logging.Logger.Level.WARN; + +/** + * Logging interface for JTA transaction operations. + * + * @author Gavin King + */ +@MessageLogger(projectCode = "HHH") +@ValidIdRange(min = 90007001, max = 90008000) +@SubSystemLogging( + name = JtaLogging.LOGGER_NAME, + description = "Logging related to JTA transaction management" +) +@Internal +public interface JtaLogging extends BasicLogger { + String LOGGER_NAME = SubSystemLogging.BASE + ".jta"; + + JtaLogging JTA_LOGGER = Logger.getMessageLogger(MethodHandles.lookup(), JtaLogging.class, LOGGER_NAME); + + int NAMESPACE = 90007000; + + // TransactionManager methods + + @LogMessage(level = TRACE) + @Message( + value = "Calling TransactionManager.begin() to start a new JTA transaction", + id = NAMESPACE + 1 + ) + void callingTransactionManagerBegin(); + + @LogMessage(level = TRACE) + @Message( + value = "Successfully called TransactionManager.begin()", + id = NAMESPACE + 2 + ) + void calledTransactionManagerBegin(); + + @LogMessage(level = TRACE) + @Message( + value = "Skipping TransactionManager.begin() since there is an active transaction", + id = NAMESPACE + 3 + ) + void skippingTransactionManagerBegin(); + + @LogMessage(level = TRACE) + @Message( + value = "Calling TransactionManager.commit() to commit the JTA transaction", + id = NAMESPACE + 4 + ) + void callingTransactionManagerCommit(); + + @LogMessage(level = TRACE) + @Message( + value = "Successfully called TransactionManager.commit()", + id = NAMESPACE + 5 + ) + void calledTransactionManagerCommit(); + + @LogMessage(level = TRACE) + @Message( + value = "Skipping TransactionManager.commit() since the transaction was not initiated here", + id = NAMESPACE + 6 + ) + void skippingTransactionManagerCommit(); + + @LogMessage(level = TRACE) + @Message( + value = "Calling TransactionManager.rollback() to roll back the JTA transaction", + id = NAMESPACE + 7 + ) + void callingTransactionManagerRollback(); + + @LogMessage(level = TRACE) + @Message( + value = "Successfully called TransactionManager.rollback()", + id = NAMESPACE + 8 + ) + void calledTransactionManagerRollback(); + + // UserTransaction methods + + @LogMessage(level = TRACE) + @Message( + value = "Calling UserTransaction.begin() to start a new JTA transaction", + id = NAMESPACE + 9 + ) + void callingUserTransactionBegin(); + + @LogMessage(level = TRACE) + @Message( + value = "Successfully called UserTransaction.begin()", + id = NAMESPACE + 10 + ) + void calledUserTransactionBegin(); + + @LogMessage(level = TRACE) + @Message( + value = "Calling UserTransaction.commit() to commit the JTA transaction", + id = NAMESPACE + 11 + ) + void callingUserTransactionCommit(); + + @LogMessage(level = TRACE) + @Message( + value = "Successfully called UserTransaction.commit()", + id = NAMESPACE + 12 + ) + void calledUserTransactionCommit(); + + @LogMessage(level = TRACE) + @Message( + value = "Calling UserTransaction.rollback() to roll back the JTA transaction", + id = NAMESPACE + 13 + ) + void callingUserTransactionRollback(); + + @LogMessage(level = TRACE) + @Message( + value = "Successfully called UserTransaction.rollback()", + id = NAMESPACE + 14 + ) + void calledUserTransactionRollback(); + + @LogMessage(level = TRACE) + @Message( + value = "Surrounding JTA transaction suspended [%s]", + id = NAMESPACE + 15 + ) + void transactionSuspended(Object transaction); + + @LogMessage(level = TRACE) + @Message( + value = "Surrounding JTA transaction resumed [%s]", + id = NAMESPACE + 16 + ) + void transactionResumed(Object transaction); + + @LogMessage(level = Logger.Level.INFO) + @Message( + value = "Unable to roll back isolated transaction on error [%s] : [%s]", + id = NAMESPACE + 17 + ) + void unableToRollbackIsolatedTransaction(Exception e, Exception ignore); + + @LogMessage(level = Logger.Level.INFO) + @Message( + value = "Unable to release isolated connection", + id = NAMESPACE + 18 + ) + void unableToReleaseIsolatedConnection(@Cause Throwable ignore); + + @LogMessage(level = WARN) + @Message( + id = NAMESPACE + 20, + value = "Transaction afterCompletion called by a background thread; " + + "delaying afterCompletion processing until the original thread can handle it. [status=%s]" + ) + void rollbackFromBackgroundThread(int status); +} diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionAdapterTransactionManagerImpl.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionAdapterTransactionManagerImpl.java index f60dd5c422db..2cecc8b7cd18 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionAdapterTransactionManagerImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionAdapterTransactionManagerImpl.java @@ -7,18 +7,17 @@ import jakarta.transaction.SystemException; import jakarta.transaction.TransactionManager; -import org.jboss.logging.Logger; - import org.hibernate.TransactionException; import org.hibernate.resource.transaction.spi.TransactionStatus; +import static org.hibernate.resource.transaction.backend.jta.internal.JtaLogging.JTA_LOGGER; + /** * JtaTransactionAdapter for coordinating with the JTA TransactionManager * * @author Steve Ebersole */ public class JtaTransactionAdapterTransactionManagerImpl implements JtaTransactionAdapter { - private static final Logger log = Logger.getLogger( JtaTransactionAdapterTransactionManagerImpl.class ); private final TransactionManager transactionManager; @@ -32,17 +31,17 @@ public JtaTransactionAdapterTransactionManagerImpl(TransactionManager transactio public void begin() { try { if ( getStatus() == TransactionStatus.NOT_ACTIVE ) { - log.trace( "Calling TransactionManager#begin" ); + JTA_LOGGER.callingTransactionManagerBegin(); transactionManager.begin(); initiator = true; - log.trace( "Called TransactionManager#begin" ); + JTA_LOGGER.calledTransactionManagerBegin(); } else { - log.trace( "Skipping TransactionManager#begin due to already active transaction" ); + JTA_LOGGER.skippingTransactionManagerBegin(); } } catch (Exception e) { - throw new TransactionException( "JTA TransactionManager#begin failed", e ); + throw new TransactionException( "JTA TransactionManager.begin() failed", e ); } } @@ -51,16 +50,16 @@ public void commit() { try { if ( initiator ) { initiator = false; - log.trace( "Calling TransactionManager#commit" ); + JTA_LOGGER.callingTransactionManagerCommit(); transactionManager.commit(); - log.trace( "Called TransactionManager#commit" ); + JTA_LOGGER.calledTransactionManagerCommit(); } else { - log.trace( "Skipping TransactionManager#commit due to not being initiator" ); + JTA_LOGGER.skippingTransactionManagerCommit(); } } catch (Exception e) { - throw new TransactionException( "JTA TransactionManager#commit failed", e ); + throw new TransactionException( "JTA TransactionManager.commit() failed", e ); } } @@ -69,16 +68,16 @@ public void rollback() { try { if ( initiator ) { initiator = false; - log.trace( "Calling TransactionManager#rollback" ); + JTA_LOGGER.callingTransactionManagerRollback(); transactionManager.rollback(); - log.trace( "Called TransactionManager#rollback" ); + JTA_LOGGER.calledTransactionManagerRollback(); } else { markRollbackOnly(); } } catch (Exception e) { - throw new TransactionException( "JTA TransactionManager#rollback failed", e ); + throw new TransactionException( "JTA TransactionManager.rollback() failed", e ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionAdapterUserTransactionImpl.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionAdapterUserTransactionImpl.java index 362f40944d50..4e2b1b977401 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionAdapterUserTransactionImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionAdapterUserTransactionImpl.java @@ -7,18 +7,17 @@ import jakarta.transaction.SystemException; import jakarta.transaction.UserTransaction; -import org.jboss.logging.Logger; - import org.hibernate.TransactionException; import org.hibernate.resource.transaction.spi.TransactionStatus; +import static org.hibernate.resource.transaction.backend.jta.internal.JtaLogging.JTA_LOGGER; + /** * JtaTransactionAdapter for coordinating with the JTA UserTransaction * * @author Steve Ebersole */ public class JtaTransactionAdapterUserTransactionImpl implements JtaTransactionAdapter { - private static final Logger log = Logger.getLogger( JtaTransactionAdapterUserTransactionImpl.class ); private final UserTransaction userTransaction; @@ -33,17 +32,17 @@ public JtaTransactionAdapterUserTransactionImpl(UserTransaction userTransaction) public void begin() { try { if ( getStatus() == TransactionStatus.NOT_ACTIVE ) { - log.trace( "Calling UserTransaction#begin" ); + JTA_LOGGER.callingUserTransactionBegin(); userTransaction.begin(); initiator = true; - log.trace( "Called UserTransaction#begin" ); + JTA_LOGGER.calledUserTransactionBegin(); } else { - log.trace( "Skipping TransactionManager#begin due to already active transaction" ); + JTA_LOGGER.skippingTransactionManagerBegin(); } } catch (Exception e) { - throw new TransactionException( "JTA UserTransaction#begin failed", e ); + throw new TransactionException( "JTA UserTransaction.begin() failed", e ); } } @@ -52,16 +51,16 @@ public void commit() { try { if ( initiator ) { initiator = false; - log.trace( "Calling UserTransaction#commit" ); + JTA_LOGGER.callingUserTransactionCommit(); userTransaction.commit(); - log.trace( "Called UserTransaction#commit" ); + JTA_LOGGER.calledUserTransactionCommit(); } else { - log.trace( "Skipping TransactionManager#commit due to not being initiator" ); + JTA_LOGGER.skippingTransactionManagerCommit(); } } catch (Exception e) { - throw new TransactionException( "JTA UserTransaction#commit failed", e ); + throw new TransactionException( "JTA UserTransaction.commit() failed", e ); } } @@ -70,16 +69,16 @@ public void rollback() { try { if ( initiator ) { initiator = false; - log.trace( "Calling UserTransaction#rollback" ); + JTA_LOGGER.callingUserTransactionRollback(); userTransaction.rollback(); - log.trace( "Called UserTransaction#rollback" ); + JTA_LOGGER.calledUserTransactionRollback(); } else { markRollbackOnly(); } } catch (Exception e) { - throw new TransactionException( "JTA UserTransaction#rollback failed", e ); + throw new TransactionException( "JTA UserTransaction.rollback() failed", e ); } } @@ -93,7 +92,7 @@ public TransactionStatus getStatus() { return status; } catch (SystemException e) { - throw new TransactionException( "JTA UserTransaction#getStatus failed", e ); + throw new TransactionException( "JTA UserTransaction.getStatus() failed", e ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionCoordinatorImpl.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionCoordinatorImpl.java index e825c8bbb1cf..26f7469b611a 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionCoordinatorImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/JtaTransactionCoordinatorImpl.java @@ -28,11 +28,10 @@ import org.hibernate.resource.transaction.spi.TransactionObserver; import org.hibernate.resource.transaction.spi.TransactionStatus; -import org.jboss.logging.Logger; import static java.util.Collections.addAll; import static java.util.Collections.emptyList; -import static org.hibernate.internal.CoreLogging.logger; +import static org.hibernate.resource.transaction.backend.jta.internal.JtaLogging.JTA_LOGGER; import static org.hibernate.resource.transaction.spi.TransactionStatus.ACTIVE; import static org.hibernate.resource.transaction.spi.TransactionStatus.NOT_ACTIVE; @@ -42,7 +41,6 @@ * @author Steve Ebersole */ public class JtaTransactionCoordinatorImpl implements TransactionCoordinator, SynchronizationCallbackTarget { - private static final Logger log = logger( JtaTransactionCoordinatorImpl.class ); private final TransactionCoordinatorBuilder transactionCoordinatorBuilder; private final TransactionCoordinatorOwner transactionCoordinatorOwner; @@ -139,7 +137,7 @@ public void pulse() { if ( autoJoinTransactions && !synchronizationRegistered ) { // Can we register a synchronization according to the JtaPlatform? if ( !jtaPlatform.canRegisterSynchronization() ) { - log.trace( "JTA platform says we cannot currently register synchronization; skipping" ); + JTA_LOGGER.trace( "JTA platform says we cannot currently register synchronization; skipping" ); } else { joinJtaTransaction(); @@ -157,7 +155,7 @@ private void joinJtaTransaction() { new RegisteredSynchronization( getSynchronizationCallbackCoordinator() ) ); getSynchronizationCallbackCoordinator().synchronizationRegistered(); synchronizationRegistered = true; - log.trace( "Hibernate RegisteredSynchronization successfully registered with JTA platform" ); + JTA_LOGGER.trace( "Hibernate RegisteredSynchronization successfully registered with JTA platform" ); // report entering into a "transactional context" getTransactionCoordinatorOwner().startTransactionBoundary(); } @@ -166,7 +164,7 @@ private void joinJtaTransaction() { @Override public void explicitJoin() { if ( synchronizationRegistered ) { - log.trace( "JTA transaction was already joined (RegisteredSynchronization already registered)" ); + JTA_LOGGER.trace( "JTA transaction was already joined (RegisteredSynchronization already registered)" ); } else { if ( getTransactionDriverControl().getStatus() != ACTIVE ) { @@ -229,7 +227,7 @@ private TransactionDriverControlImpl makePhysicalTransactionDelegate() { private JtaTransactionAdapter getTransactionAdapterPreferringTransactionManager() { final JtaTransactionAdapter adapter = makeTransactionManagerAdapter(); if ( adapter == null ) { - log.debug( "Unable to access TransactionManager, attempting to use UserTransaction instead" ); + JTA_LOGGER.debug( "Unable to access TransactionManager, attempting to use UserTransaction instead" ); return makeUserTransactionAdapter(); } return adapter; @@ -238,7 +236,7 @@ private JtaTransactionAdapter getTransactionAdapterPreferringTransactionManager( private JtaTransactionAdapter getTransactionAdapterPreferringUserTransaction() { final JtaTransactionAdapter adapter = makeUserTransactionAdapter(); if ( adapter == null ) { - log.debug( "Unable to access UserTransaction, attempting to use TransactionManager instead" ); + JTA_LOGGER.debug( "Unable to access UserTransaction, attempting to use TransactionManager instead" ); return makeTransactionManagerAdapter(); } return adapter; @@ -248,7 +246,7 @@ private JtaTransactionAdapter makeUserTransactionAdapter() { try { final UserTransaction userTransaction = jtaPlatform.retrieveUserTransaction(); if ( userTransaction == null ) { - log.debug( "JtaPlatform#retrieveUserTransaction returned null" ); + JTA_LOGGER.debug( "JtaPlatform.retrieveUserTransaction() returned null" ); return null; } else { @@ -256,7 +254,7 @@ private JtaTransactionAdapter makeUserTransactionAdapter() { } } catch ( Exception exception ) { - log.debugf( "JtaPlatform#retrieveUserTransaction threw an exception [%s]", exception.getMessage() ); + JTA_LOGGER.debugf( "JtaPlatform.retrieveUserTransaction() threw an exception [%s]", exception.getMessage() ); return null; } } @@ -265,7 +263,7 @@ private JtaTransactionAdapter makeTransactionManagerAdapter() { try { final TransactionManager transactionManager = jtaPlatform.retrieveTransactionManager(); if ( transactionManager == null ) { - log.debug( "JtaPlatform#retrieveTransactionManager returned null" ); + JTA_LOGGER.debug( "JtaPlatform.retrieveTransactionManager() returned null" ); return null; } else { @@ -273,7 +271,7 @@ private JtaTransactionAdapter makeTransactionManagerAdapter() { } } catch ( Exception exception ) { - log.debugf( "JtaPlatform#retrieveTransactionManager threw an exception [%s]", exception.getMessage() ); + JTA_LOGGER.debugf( "JtaPlatform.retrieveTransactionManager() threw an exception [%s]", exception.getMessage() ); return null; } } @@ -325,7 +323,7 @@ public void invalidate() { @Override public void beforeCompletion() { - log.trace( "Notifying JTA transaction observers before completion" ); + JTA_LOGGER.trace( "Notifying JTA transaction observers before completion" ); try { transactionCoordinatorOwner.beforeTransactionCompletion(); } @@ -344,7 +342,7 @@ public void beforeCompletion() { @Override public void afterCompletion(boolean successful, boolean delayed) { if ( transactionCoordinatorOwner.isActive() ) { - log.trace( "Notifying JTA transaction observers after completion" ); + JTA_LOGGER.trace( "Notifying JTA transaction observers after completion" ); final int statusToSend = successful ? Status.STATUS_COMMITTED : Status.STATUS_UNKNOWN; synchronizationRegistry.notifySynchronizationsAfterTransactionCompletion( statusToSend ); diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/RegisteredSynchronization.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/RegisteredSynchronization.java index baf7840aa33a..7f8d09014e16 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/RegisteredSynchronization.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/RegisteredSynchronization.java @@ -6,9 +6,8 @@ import jakarta.transaction.Synchronization; -import org.jboss.logging.Logger; -import static org.hibernate.internal.CoreLogging.logger; +import static org.hibernate.resource.transaction.backend.jta.internal.JtaLogging.JTA_LOGGER; /** * The JTA {@link jakarta.transaction.Synchronization} Hibernate registers when needed for JTA callbacks. @@ -20,7 +19,6 @@ * @author Steve Ebersole */ public class RegisteredSynchronization implements Synchronization { - private static final Logger log = logger( RegisteredSynchronization.class ); private final SynchronizationCallbackCoordinator synchronizationCallbackCoordinator; @@ -30,14 +28,14 @@ public RegisteredSynchronization(SynchronizationCallbackCoordinator synchronizat @Override public void beforeCompletion() { - log.trace( "Registered JTA Synchronization : beforeCompletion()" ); + JTA_LOGGER.trace( "Registered JTA Synchronization: beforeCompletion()" ); synchronizationCallbackCoordinator.beforeCompletion(); } @Override public void afterCompletion(int status) { - log.tracef( "Registered JTA Synchronization : afterCompletion(%s)", status ); + JTA_LOGGER.tracef( "Registered JTA Synchronization: afterCompletion(%s)", status ); synchronizationCallbackCoordinator.afterCompletion( status ); } diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/SynchronizationCallbackCoordinatorNonTrackingImpl.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/SynchronizationCallbackCoordinatorNonTrackingImpl.java index 1fc1f6df3b6f..6b3f1c93f867 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/SynchronizationCallbackCoordinatorNonTrackingImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/SynchronizationCallbackCoordinatorNonTrackingImpl.java @@ -5,8 +5,8 @@ package org.hibernate.resource.transaction.backend.jta.internal.synchronization; import org.hibernate.engine.transaction.internal.jta.JtaStatusHelper; -import org.hibernate.internal.CoreLogging; -import org.hibernate.internal.CoreMessageLogger; + +import static org.hibernate.resource.transaction.backend.jta.internal.JtaLogging.JTA_LOGGER; /** * Manages callbacks from the {@link jakarta.transaction.Synchronization} registered by Hibernate. @@ -14,9 +14,6 @@ * @author Steve Ebersole */ public class SynchronizationCallbackCoordinatorNonTrackingImpl implements SynchronizationCallbackCoordinator { - private static final CoreMessageLogger log = CoreLogging.messageLogger( - SynchronizationCallbackCoordinatorNonTrackingImpl.class - ); private final SynchronizationCallbackTarget target; @@ -37,23 +34,21 @@ public void synchronizationRegistered() { @Override public void beforeCompletion() { - log.trace( "Synchronization coordinator: beforeCompletion()" ); - - if ( !target.isActive() ) { - return; + JTA_LOGGER.trace( "Synchronization coordinator: beforeCompletion()" ); + if ( target.isActive() ) { + target.beforeCompletion(); } - target.beforeCompletion(); } @Override public void afterCompletion(int status) { - log.tracef( "Synchronization coordinator: afterCompletion(status=%s)", status ); + JTA_LOGGER.tracef( "Synchronization coordinator: afterCompletion(status=%s)", status ); doAfterCompletion( JtaStatusHelper.isCommitted( status ), false ); } protected void doAfterCompletion(boolean successful, boolean delayed) { - log.tracef( "Synchronization coordinator: doAfterCompletion(successful=%s, delayed=%s)", successful, delayed ); - + JTA_LOGGER.tracef( "Synchronization coordinator: doAfterCompletion(successful=%s, delayed=%s)", + successful, delayed ); try { target.afterCompletion( successful, delayed ); } diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/SynchronizationCallbackCoordinatorTrackingImpl.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/SynchronizationCallbackCoordinatorTrackingImpl.java index 267454963b1a..0e9019ce7c32 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/SynchronizationCallbackCoordinatorTrackingImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jta/internal/synchronization/SynchronizationCallbackCoordinatorTrackingImpl.java @@ -6,9 +6,8 @@ import org.hibernate.HibernateException; import org.hibernate.engine.transaction.internal.jta.JtaStatusHelper; -import org.hibernate.internal.CoreMessageLogger; -import static org.hibernate.internal.CoreLogging.messageLogger; +import static org.hibernate.resource.transaction.backend.jta.internal.JtaLogging.JTA_LOGGER; /** * Extension of SynchronizationCallbackCoordinatorNonTrackingImpl that adds checking of whether a rollback comes from @@ -18,7 +17,6 @@ * @author Brett Meyer */ public class SynchronizationCallbackCoordinatorTrackingImpl extends SynchronizationCallbackCoordinatorNonTrackingImpl { - private static final CoreMessageLogger log = messageLogger( SynchronizationCallbackCoordinatorTrackingImpl.class ); private volatile long registrationThreadId; private volatile boolean delayedCompletionHandling; @@ -31,7 +29,7 @@ public SynchronizationCallbackCoordinatorTrackingImpl(SynchronizationCallbackTar @Override public void reset() { super.reset(); - // NOTE : reset is typically called: + // NOTE: reset is typically called: // 1) on initialization, and // 2) after "after completion" handling is finished. // @@ -44,24 +42,23 @@ public void reset() { @Override public void afterCompletion(int status) { - log.tracef( "Synchronization coordinator: afterCompletion(status=%s)", status ); + JTA_LOGGER.tracef( "Synchronization coordinator: afterCompletion(status=%s)", status ); // The whole concept of "tracking" comes down to this code block. - // Essentially we need to see if we can process the callback immediately. So here we check whether the + // Essentially, we need to see if we can process the callback immediately. So here we check whether the // current call is happening on the same thread as the thread under which we registered the Synchronization. // As far as we know, this can only ever happen in the rollback case where the transaction had been rolled - // back on a separate "reaper" thread. Since we know the transaction status and that check is not as heavy + // back on a separate "reaper" thread. Since we know the transaction status and that check is not as heavy // as accessing the current thread, we check that first if ( JtaStatusHelper.isRollback( status ) ) { - // we are processing a rollback, see if it is the same thread + // We are processing a rollback, see if it is the same thread final long currentThreadId = Thread.currentThread().getId(); final boolean isRegistrationThread = currentThreadId == registrationThreadId; if ( ! isRegistrationThread ) { - // so we do have the condition of a rollback initiated from a separate thread. Set the flag here and - // check for it in SessionImpl. See HHH-7910. + // So we do have the condition of a rollback initiated from a separate thread. + // Set the flag here and check for it in SessionImpl. See HHH-7910. delayedCompletionHandling = true; - - log.rollbackFromBackgroundThread( status ); + JTA_LOGGER.rollbackFromBackgroundThread( status ); return; } } @@ -84,7 +81,7 @@ public void processAnyDelayedAfterCompletion() { // the delayed logic should only ever occur during rollback doAfterCompletion( false, true ); - // NOTE : doAfterCompletion calls reset + // NOTE: doAfterCompletion calls reset throw new HibernateException( "Transaction was rolled back in a different thread" ); } } From a62360134d3fe6bfacc50b9ca0cf6bf65aafded1 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Mon, 14 Jul 2025 14:29:08 +0200 Subject: [PATCH 2/4] use JDBC_LOGGER for logging resource-local tx management just like we now use JTA_LOGGER for JTA tx management --- .../hibernate/engine/jdbc/JdbcLogging.java | 4 ++++ .../hibernate/internal/CoreMessageLogger.java | 4 ---- .../jdbc/internal/JdbcIsolationDelegate.java | 13 ++++------- ...ocalTransactionCoordinatorBuilderImpl.java | 6 ++--- ...sourceLocalTransactionCoordinatorImpl.java | 23 +++++++++---------- 5 files changed, 23 insertions(+), 27 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/JdbcLogging.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/JdbcLogging.java index c4f3a0fac767..78acc31947ec 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/JdbcLogging.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/JdbcLogging.java @@ -138,4 +138,8 @@ public interface JdbcLogging extends BasicLogger { JDBC version: %s.%s""", id = 100018) void logDriverInfo(String name, String version, int major, int minor, int jdbcMajor, int jdbcMinor); + + @LogMessage(level = WARN) + @Message(value = "Called joinTransaction() on a non-JTA EntityManager (ignoring)", id = 100020) + void callingJoinTransactionOnNonJtaEntityManager(); } diff --git a/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java b/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java index eacb77929b0b..aa2349eb529b 100644 --- a/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java +++ b/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java @@ -71,10 +71,6 @@ public interface CoreMessageLogger extends BasicLogger { @Message(value = "Second-level cache disabled", id = 26) void noRegionFactory(); - @LogMessage(level = WARN) - @Message(value = "Calling joinTransaction() on a non JTA EntityManager", id = 27) - void callingJoinTransactionOnNonJtaEntityManager(); - @LogMessage(level = DEBUG) @Message(value = "Instantiating factory [%s] with settings: %s", id = 30) void instantiatingFactory(String uuid, Map settings); diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcIsolationDelegate.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcIsolationDelegate.java index 24b5c4c1753e..c06aedfa40e3 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcIsolationDelegate.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcIsolationDelegate.java @@ -23,7 +23,7 @@ * @author Andrea Boriero */ public class JdbcIsolationDelegate implements IsolationDelegate { - private static final CoreMessageLogger LOG = CoreLogging.messageLogger( JdbcIsolationDelegate.class ); + private static final CoreMessageLogger log = CoreLogging.messageLogger( JdbcIsolationDelegate.class ); private final JdbcConnectionAccess connectionAccess; private final SqlExceptionHelper sqlExceptionHelper; @@ -33,10 +33,7 @@ public JdbcIsolationDelegate(TransactionCoordinatorOwner transactionCoordinatorO } public JdbcIsolationDelegate(JdbcSessionOwner jdbcSessionOwner) { - this( - jdbcSessionOwner.getJdbcConnectionAccess(), - jdbcSessionOwner.getSqlExceptionHelper() - ); + this( jdbcSessionOwner.getJdbcConnectionAccess(), jdbcSessionOwner.getSqlExceptionHelper() ); } public JdbcIsolationDelegate(JdbcConnectionAccess connectionAccess, SqlExceptionHelper sqlExceptionHelper) { @@ -80,7 +77,7 @@ public T delegateWork(WorkExecutorVisitable work, boolean transacted) thr } } catch ( Exception exception ) { - LOG.unableToRollbackConnection( exception ); + log.unableToRollbackConnection( exception ); } if ( e instanceof HibernateException ) { @@ -99,14 +96,14 @@ else if ( e instanceof SQLException sqle ) { connection.setAutoCommit( true ); } catch ( Exception ignore ) { - LOG.trace( "was unable to reset connection back to auto-commit" ); + log.trace( "Unable to reset connection back to auto-commit" ); } } try { jdbcConnectionAccess().releaseConnection( connection ); } catch ( Exception ignore ) { - LOG.unableToReleaseIsolatedConnection( ignore ); + log.unableToReleaseIsolatedConnection( ignore ); } } } diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorBuilderImpl.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorBuilderImpl.java index b79d94ef7b17..e2a08e6da5fe 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorBuilderImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorBuilderImpl.java @@ -26,15 +26,15 @@ public class JdbcResourceLocalTransactionCoordinatorBuilderImpl implements Trans /** * Singleton access */ - public static final JdbcResourceLocalTransactionCoordinatorBuilderImpl INSTANCE = new JdbcResourceLocalTransactionCoordinatorBuilderImpl(); + public static final TransactionCoordinatorBuilder INSTANCE = new JdbcResourceLocalTransactionCoordinatorBuilderImpl(); @Override public TransactionCoordinator buildTransactionCoordinator(TransactionCoordinatorOwner owner, Options options) { - if ( owner instanceof JdbcResourceTransactionAccess ) { + if ( owner instanceof JdbcResourceTransactionAccess transactionAccess ) { return new JdbcResourceLocalTransactionCoordinatorImpl( this, owner, - (JdbcResourceTransactionAccess) owner + transactionAccess ); } diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorImpl.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorImpl.java index 9b9be0d23bac..290a5cb48594 100644 --- a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorImpl.java @@ -12,7 +12,6 @@ import jakarta.transaction.Status; import org.hibernate.resource.transaction.spi.IsolationDelegate; -import org.hibernate.internal.CoreMessageLogger; import org.hibernate.jpa.spi.JpaCompliance; import org.hibernate.resource.transaction.backend.jdbc.spi.JdbcResourceTransaction; import org.hibernate.resource.transaction.backend.jdbc.spi.JdbcResourceTransactionAccess; @@ -25,7 +24,8 @@ import org.hibernate.resource.transaction.spi.TransactionStatus; import static java.util.Collections.emptyList; -import static org.hibernate.internal.CoreLogging.messageLogger; +import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_LOGGER; +import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER; /** * An implementation of {@link TransactionCoordinator} based on managing a @@ -36,7 +36,6 @@ * @see JdbcResourceTransaction */ public class JdbcResourceLocalTransactionCoordinatorImpl implements TransactionCoordinator { - private static final CoreMessageLogger log = messageLogger( JdbcResourceLocalTransactionCoordinatorImpl.class ); private final TransactionCoordinatorBuilder transactionCoordinatorBuilder; private final JdbcResourceTransactionAccess jdbcResourceTransactionAccess; @@ -92,7 +91,7 @@ public TransactionDriver getTransactionDriverControl() { @Override public void explicitJoin() { // nothing to do here, but log a warning - log.callingJoinTransactionOnNonJtaEntityManager(); + JDBC_MESSAGE_LOGGER.callingJoinTransactionOnNonJtaEntityManager(); } @Override @@ -151,7 +150,7 @@ private void afterBeginCallback() { // report entering into a "transactional context" transactionCoordinatorOwner.startTransactionBoundary(); - log.trace( "Notifying resource-local transaction observers after begin" ); + JDBC_LOGGER.trace( "Notifying resource-local transaction observers after begin" ); // trigger the Transaction-API-only after-begin callback transactionCoordinatorOwner.afterTransactionBegin(); @@ -163,7 +162,7 @@ private void afterBeginCallback() { } private void beforeCompletionCallback() { - log.trace( "Notifying resource-local transaction observers before completion" ); + JDBC_LOGGER.trace( "Notifying resource-local transaction observers before completion" ); try { transactionCoordinatorOwner.beforeTransactionCompletion(); synchronizationRegistry.notifySynchronizationsBeforeTransactionCompletion(); @@ -181,7 +180,7 @@ private void beforeCompletionCallback() { } private void afterCompletionCallback(boolean successful) { - log.trace( "Notifying resource-local transaction observers after completion" ); + JDBC_LOGGER.trace( "Notifying resource-local transaction observers after completion" ); final int statusToSend = successful ? Status.STATUS_COMMITTED : Status.STATUS_ROLLEDBACK; synchronizationRegistry.notifySynchronizationsAfterTransactionCompletion( statusToSend ); transactionCoordinatorOwner.afterTransactionCompletion( successful, false ); @@ -231,7 +230,7 @@ public void begin() { protected void errorIfInvalid() { if ( invalid ) { - throw new IllegalStateException( "Physical-transaction delegate is no longer valid" ); + throw new IllegalStateException( "Physical transaction delegate is no longer valid" ); } } @@ -263,14 +262,14 @@ private void commitNoRollbackOnly() { } catch (RuntimeException e2) { e.addSuppressed( e2 ); - log.debug( "Encountered failure rolling back failed commit", e2 ); + JDBC_LOGGER.debug( "Encountered failure rolling back failed commit", e2 ); } throw e; } } private void commitRollbackOnly() { - log.trace( "On commit, transaction was marked for rollback only, rolling back" ); + JDBC_LOGGER.trace( "On commit, transaction was marked for rollback only, rolling back" ); rollback(); if ( jpaCompliance.isJpaTransactionComplianceEnabled() ) { throw new RollbackException( "Transaction was marked for rollback only" ); @@ -301,8 +300,8 @@ public TransactionStatus getStatus() { @Override public void markRollbackOnly() { if ( getStatus() != TransactionStatus.ROLLED_BACK ) { - if ( log.isTraceEnabled() ) { - log.trace( "JDBC transaction marked for rollback only (exception provided for stack trace)", + if ( JDBC_LOGGER.isTraceEnabled() ) { + JDBC_LOGGER.trace( "JDBC transaction marked for rollback only (exception provided for stack trace)", new Exception( "exception just for purpose of providing stack trace" ) ); } rollbackOnly = true; From ca6ce923346e0070e11fde002d7c2671b27d8f77 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Mon, 14 Jul 2025 14:29:37 +0200 Subject: [PATCH 3/4] misc very minor improvements to log messages --- .../exec/internal/JdbcSelectExecutorStandardImpl.java | 6 +++--- .../hibernate/sql/results/internal/ResultsHelper.java | 11 ++--------- .../schema/UniqueConstraintSchemaUpdateStrategy.java | 2 +- 3 files changed, 6 insertions(+), 13 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/sql/exec/internal/JdbcSelectExecutorStandardImpl.java b/hibernate-core/src/main/java/org/hibernate/sql/exec/internal/JdbcSelectExecutorStandardImpl.java index 3c7e7a0fbc9b..93def9713749 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/exec/internal/JdbcSelectExecutorStandardImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/exec/internal/JdbcSelectExecutorStandardImpl.java @@ -273,13 +273,13 @@ private JdbcValues resolveJdbcValuesSource( final QueryKey queryResultsCacheKey; final List cachedResults; if ( cacheable && cacheMode.isGetEnabled() ) { - SQL_EXEC_LOGGER.tracef( "Reading Query result cache data per CacheMode#isGetEnabled [%s]", cacheMode.name() ); + SQL_EXEC_LOGGER.tracef( "Reading query result cache data [%s]", cacheMode.name() ); final Set querySpaces = jdbcSelect.getAffectedTableNames(); if ( querySpaces == null || querySpaces.isEmpty() ) { - SQL_EXEC_LOGGER.tracef( "Unexpected querySpaces is empty" ); + SQL_EXEC_LOGGER.tracef( "Affected query spaces unexpectedly empty" ); } else { - SQL_EXEC_LOGGER.tracef( "querySpaces is `%s`", querySpaces ); + SQL_EXEC_LOGGER.tracef( "Affected query spaces %s", querySpaces ); } final QueryResultsCache queryCache = factory.getCache() diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/internal/ResultsHelper.java b/hibernate-core/src/main/java/org/hibernate/sql/results/internal/ResultsHelper.java index 49751c32af96..b10f882f62e8 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/internal/ResultsHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/internal/ResultsHelper.java @@ -109,15 +109,8 @@ public static void finalizeCollectionLoading( } if ( LOG.isTraceEnabled() ) { - LOG.tracef( - "Collection fully initialized: %s", - collectionInfoString( - collectionDescriptor, - collectionInstance, - key, - session - ) - ); + LOG.trace( "Collection fully initialized: " + + collectionInfoString( collectionDescriptor, collectionInstance, key, session ) ); } final StatisticsImplementor statistics = session.getFactory().getStatistics(); diff --git a/hibernate-core/src/main/java/org/hibernate/tool/schema/UniqueConstraintSchemaUpdateStrategy.java b/hibernate-core/src/main/java/org/hibernate/tool/schema/UniqueConstraintSchemaUpdateStrategy.java index 14a4cd3abc9c..fd3468fd0136 100644 --- a/hibernate-core/src/main/java/org/hibernate/tool/schema/UniqueConstraintSchemaUpdateStrategy.java +++ b/hibernate-core/src/main/java/org/hibernate/tool/schema/UniqueConstraintSchemaUpdateStrategy.java @@ -45,7 +45,7 @@ public static UniqueConstraintSchemaUpdateStrategy byName(String name) { } public static UniqueConstraintSchemaUpdateStrategy interpret(Object setting) { - log.tracef( "Interpreting UniqueConstraintSchemaUpdateStrategy from setting : %s", setting ); + log.tracef( "Interpreting UniqueConstraintSchemaUpdateStrategy from setting: %s", setting ); if ( setting == null ) { // default From 463d3f650fba930bf74ccee10f71008276d510ba Mon Sep 17 00:00:00 2001 From: Gavin King Date: Mon, 14 Jul 2025 14:57:01 +0200 Subject: [PATCH 4/4] remove unnecessary check this log message is already done by the JDBC-specific TransactionCoordinator --- .../AbstractSharedSessionContract.java | 20 ++++++++----------- 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/internal/AbstractSharedSessionContract.java b/hibernate-core/src/main/java/org/hibernate/internal/AbstractSharedSessionContract.java index a986bbb1e625..bb8a28d3ea5d 100644 --- a/hibernate-core/src/main/java/org/hibernate/internal/AbstractSharedSessionContract.java +++ b/hibernate-core/src/main/java/org/hibernate/internal/AbstractSharedSessionContract.java @@ -644,19 +644,15 @@ protected void pulseTransactionCoordinator() { @Override public void joinTransaction() { checkOpen(); - if ( !transactionCoordinator.getTransactionCoordinatorBuilder().isJta() ) { - log.callingJoinTransactionOnNonJtaEntityManager(); + try { + // For a non-JTA TransactionCoordinator, this just logs a WARNing + transactionCoordinator.explicitJoin(); } - else { - try { - transactionCoordinator.explicitJoin(); - } - catch ( TransactionRequiredForJoinException e ) { - throw new TransactionRequiredException( e.getMessage() ); - } - catch ( HibernateException he ) { - throw getExceptionConverter().convert( he ); - } + catch ( TransactionRequiredForJoinException e ) { + throw new TransactionRequiredException( e.getMessage() ); + } + catch ( HibernateException he ) { + throw getExceptionConverter().convert( he ); } }