CODEWITHSUNDEEP
javaspringtransactional
cometta
cometta

Reputation: 35689

Showing a Spring transaction in log

I configured spring with transactional support. Is there any way to log transactions just to ensure I set up everything correctly? Showing in the log is a good way to see what is happening.

Upvotes: 146

Views: 169170

Answers (9)

Diego dos Santos
Diego dos Santos

Reputation: 128

For some reason, the only config that woked for me was

logging.level.org.springframework.transaction.interceptor = TRACE

Found here: https://www.baeldung.com/spring-transaction-active#using-spring-transaction-logging

Upvotes: 0

swyrik
swyrik

Reputation: 314

For this who are looking for xml based configuration

<Logger name="org.springframework.transaction.interceptor" level="trace" additivity="false">
    <AppenderRef ref="Console"/>
</Logger>
<Logger name="org.springframework.orm.jpa" level="debug" additivity="false">
    <AppenderRef ref="Console"/>
</Logger>

Upvotes: 0

Sander S.
Sander S.

Reputation: 899

For me, a good logging config to add was:

log4j.logger.org.springframework.transaction.interceptor = trace

It will show me log like that:

2012-08-22 18:50:00,031 TRACE - Getting transaction for [com.MyClass.myMethod]

[my own log statements from method com.MyClass.myMethod]

2012-08-22 18:50:00,142 TRACE - Completing transaction for [com.MyClass.myMethod]

Upvotes: 89

Michel Gokan Khan
Michel Gokan Khan

Reputation: 2625

Because you can access Spring classes at runtime, you can determine transaction status.

Upvotes: 6

MariuszS
MariuszS

Reputation: 31577

For Spring Boot application with application.properties

logging.level.ROOT=INFO
logging.level.org.springframework.orm.jpa=DEBUG
logging.level.org.springframework.transaction=DEBUG

or if you prefer Yaml (application.yaml)

logging:
   level:
      org.springframework.orm.jpa: DEBUG
      org.springframework.transaction: DEBUG

Upvotes: 97

David Tonhofer
David Tonhofer

Reputation: 15316

Here is some code I use in my Logback Layout implementation derived from ch.qos.logback.core.LayoutBase.

I create a thread-local variable to store the reference to the method org.springframework.transaction.support.TransactionSynchronizationManager.isActualTransactionActive(). Whenever a new log line is printed out, getSpringTransactionInfo() is called and it returns a one-character string that will go into the log.

References:

Code:

private static ThreadLocal<Method> txCheckMethod;

private static String getSpringTransactionInfo() {
    if (txCheckMethod == null) {
        txCheckMethod = new ThreadLocal<Method>() {
            @Override public Method initialValue() {           
                try {
                    ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
                    Class<?> tsmClass = contextClassLoader.loadClass("org.springframework.transaction.support.TransactionSynchronizationManager");
                    return tsmClass.getMethod("isActualTransactionActive", (Class<?>[])null);
                } catch (Exception e) {
                    e.printStackTrace();
                    return null;
                }                      
            }
         };    
    }
    assert txCheckMethod != null;
    Method m = txCheckMethod.get();
    String res;
    if (m == null) {
        res = " "; // there is no Spring here
    }
    else {
        Boolean isActive = null;
        try {
            isActive = (Boolean) m.invoke((Object)null);
            if (isActive) {
                res = "T"; // transaction active                    
            }
            else {
                res = "~"; // transaction inactive
            }
        }
        catch (Exception exe) {
            // suppress 
            res = "?";
        }
    }
    return res;
}

Upvotes: 6

Pep
Pep

Reputation: 101

You could enable JDBC logging as well:

log4j.logger.org.springframework.jdbc=DEBUG

Upvotes: 10

Pascal Thivent
Pascal Thivent

Reputation: 570365

Most interesting log informations of JtaTransactionManager.java (if this question is still about the JtaTransactionManager) are logged at DEBUG priority. Assuming you have a log4j.properties somewhere on the classpath, I'd thus suggest to use:

log4j.logger.org.springframework.transaction=DEBUG

Upvotes: 9

Bozho
Bozho

Reputation: 597106

in your log4j.properties (for alternative loggers, or log4j's xml format, check the docs)

Depending on your transaction manager, you can set the logging level of the spring framework so that it gives you more info about transactions. For example, in case of using JpaTransactionManager, you set

log4j.logger.org.springframework.orm.jpa=INFO

(this is the package of the your transaction manager), and also

log4j.logger.org.springframework.transaction=INFO

If INFO isn't enough, use DEBUG

Upvotes: 124

Related Questions