org.broadleafcommerce.common.persistence.transaction

Class TransactionLifecycleMonitor

java.lang.Object

org.broadleafcommerce.common.persistence.transaction.TransactionLifecycleMonitor

All Implemented Interfaces:

EventListener, BroadleafApplicationListener<TransactionLifecycleEvent>, SqlStatementLoggable, org.springframework.beans.factory.Aware, org.springframework.context.ApplicationContextAware, org.springframework.context.ApplicationListener<TransactionLifecycleEvent>, org.springframework.context.Lifecycle, org.springframework.context.Phased, org.springframework.context.SmartLifecycle

public class TransactionLifecycleMonitor
extends Object
implements BroadleafApplicationListener<TransactionLifecycleEvent>, org.springframework.context.ApplicationContextAware, org.springframework.context.SmartLifecycle, SqlStatementLoggable

Responsible for most of the work related to monitoring and logging transaction state. This class is notified via a LifecycleAwareJpaTransactionManager when a key TransactionLifecycleEvent occurs. Based on this information, this monitor attempts to detect transaction fault states and report them as part of SUPPORT level logging (SupportLogger).

Currently, the monitor attempts to recognize the following fault states:

• TRANSACTIONMONITOR(1) - Leaked Resource: The transaction thread is not considered stuck, but no queries have been issued againsted the tracked EntityManager in loggingReportingLagThreshold and the transaction info has been alive for loggingThreshold. This could indicate the thread has moved on and the transaction was not correctly finalized.
• TRANSACTIONMONITOR(2) - Long Running Transaction: The transaction thread is not considered stuck, but the transaction info has been alive for loggingThreshold. This is not necessarily a fault, but may warrant review. Long running or stuck transactions can account for long resource lock times. Note, this case can later become a stuck thread if the stuckThreshold has not elapsed.
• TRANSACTIONMONITOR(3) - Exception During Finalization: The transaction is attempting to finalize normally, but has experienced an exception during that finalization attempt. This could indicate a problem communicating with the backing database and may result in orphaned resources in the data tier.
• TRANSACTIONMONITOR(4) - Stuck Thread: The transaction thread is considered stuck with a transaction info alive for loggingThreshold and no change in thread stack for stuckThreshold. Long running or stuck transactions can account for long resource lock times.
• TRANSACTIONMONITOR(5) - Alive At Shutdown: The transaction info is considered active at the time of container shutdown. This is not necessarily a fault, but may warrant review. Items at shutdown may simply be waiting for final closure. However, subsequent system kill calls (if applicable) could prematurely exit these connections and they may be interesting for review.

This monitor is enabled or disabled per LifecycleAwareJpaTransactionManager via LifecycleAwareJpaTransactionManager.isEnabled(). If no enabled transaction manager is found, the monitor is fully disabled.

The loggingThreshold variable can be controlled via the 'log.transaction.lifecycle.logging.threshold.millis' property. The default value is 600000.

The stuckThreshold variable can be controlled via the 'log.transaction.lifecycle.stuck.threshold.millis' property. The default values is 300000.

The loggingPollingResolution variable can be controlled via the 'log.transaction.lifecycle.logging.polling.resolution.millis' property. The default value is 30000.

The loggingReportingLagThreshold variable can be controlled via the 'log.transaction.lifecycle.reporting.lag.threshold.millis' property. The default value is 300000.

The countMax variable can be controlled via the 'log.transaction.lifecycle.info.count.max' property. The default value is 5000.

The useCompression variable can be controlled via the 'log.transaction.lifecycle.use.compression' property. The default value is true.

This monitor is intended for temporary usage as part of transaction related debugging efforts. From both a heap utilization and performance standpoint, this monitor is suitable for production with default settings. Performance impacts should be minor and will generally be related to creation of the intial call stack, compression of that call stack and subsequent compression of sql statements. Compression can be turned off via the 'log.transaction.lifecycle.use.compression' for a minor performance benefit at the cost of additional heap usage. Heap usage can be capped via the 'log.transaction.lifecycle.info.count.max' property, but if the max happens to be reached, new transactions will not be monitored. This is more a safety net feature than anything and it's not anticipated that the default max count will be reached during normal usage. Set 'log.transaction.lifecycle.info.count.max' to -1 to uncap growth.

Author:

Jeff Fischer

Field Summary

Fields

Modifier and Type	Field and Description
protected int	countMax
protected boolean	enabled
protected Map<Integer,TransactionInfo>	infos
protected boolean	isStarted
protected long	loggingPollingResolution
protected long	loggingReportingLagThreshold
protected long	loggingThreshold
protected List<TransactionInfoCustomModifier>	modifiers
protected long	stuckThreshold
protected Timer	timer
protected List<LifecycleAwareJpaTransactionManager>	transactionManagers
protected boolean	useCompression

Constructor Summary

Constructors

Constructor and Description
TransactionLifecycleMonitor()

Method Summary

Modifier and Type	Method and Description
protected StackTraceElement[]	compileThreadInformation(long currentTime, TransactionInfo info, Thread thread)
protected void	detectExpiry(List<Integer> infosToRemove, Integer key, long currentTime, TransactionInfo info, StackTraceElement[] elements)
protected void	detectLeakage(List<Integer> infosToRemove, Integer key, long currentTime, TransactionInfo info)
protected void	finalizeTransaction(TransactionLifecycleEvent event)
protected TransactionInfo	getCurrentTransactionInfo()
protected javax.persistence.EntityManager	getEntityManagerFromTransactionObject(Object transactionObject)
static TransactionLifecycleMonitor	getInstance()
int	getPhase()
protected void	groomInProgressTransactionInfos()
void	init()
boolean	isAsynchronous() Indicates if this application listener should be run in a background thread if a TaskExecutor is configured.
protected boolean	isAtLeastOneTransactionManagerEnabled()
boolean	isAutoStartup()
boolean	isRunning()
void	log(String statement)
void	onApplicationEvent(TransactionLifecycleEvent event)
void	setApplicationContext(org.springframework.context.ApplicationContext applicationContext)
void	start()
void	stop()
void	stop(Runnable callback)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

transactionManagers

@Autowired(required=false)
protected List<LifecycleAwareJpaTransactionManager> transactionManagers

modifiers

@Autowired(required=false)
protected List<TransactionInfoCustomModifier> modifiers

loggingThreshold

@Value(value="${log.transaction.lifecycle.logging.threshold.millis:600000}")
protected long loggingThreshold

stuckThreshold

@Value(value="${log.transaction.lifecycle.stuck.threshold.millis:300000}")
protected long stuckThreshold

loggingPollingResolution

@Value(value="${log.transaction.lifecycle.logging.polling.resolution.millis:30000}")
protected long loggingPollingResolution

loggingReportingLagThreshold

@Value(value="${log.transaction.lifecycle.reporting.lag.threshold.millis:300000}")
protected long loggingReportingLagThreshold

countMax

@Value(value="${log.transaction.lifecycle.info.count.max:5000}")
protected int countMax

useCompression

@Value(value="${log.transaction.lifecycle.use.compression:true}")
protected boolean useCompression

infos

protected Map<Integer,TransactionInfo> infos

isStarted

protected boolean isStarted

enabled

protected boolean enabled

timer

protected Timer timer

Constructor Detail

TransactionLifecycleMonitor

public TransactionLifecycleMonitor()

Method Detail

getInstance

public static TransactionLifecycleMonitor getInstance()

init

@PostConstruct
public void init()

setApplicationContext

public void setApplicationContext(org.springframework.context.ApplicationContext applicationContext)
                           throws org.springframework.beans.BeansException

Specified by:

setApplicationContext in interface org.springframework.context.ApplicationContextAware

Throws:

org.springframework.beans.BeansException

isAutoStartup

public boolean isAutoStartup()

Specified by:

isAutoStartup in interface org.springframework.context.SmartLifecycle

stop

public void stop(Runnable callback)

Specified by:

stop in interface org.springframework.context.SmartLifecycle

start

public void start()

Specified by:

start in interface org.springframework.context.Lifecycle

stop

public void stop()

Specified by:

stop in interface org.springframework.context.Lifecycle

isRunning

public boolean isRunning()

Specified by:

isRunning in interface org.springframework.context.Lifecycle

getPhase

public int getPhase()

Specified by:

getPhase in interface org.springframework.context.Phased

isAsynchronous

public boolean isAsynchronous()

Description copied from interface: BroadleafApplicationListener

Indicates if this application listener should be run in a background thread if a TaskExecutor is configured. If no TaskExecutor is configure with a bean name of "blApplicationEventMulticastTaskExecutor" then this will be run synchronously regardless. Generally, this should return false as the default implementation has no reliability guarantees associated with Asynch processing. However, for convenience this allows asynch processing for situations that don't require guaranteed processing. For example, publishing statistics or log events in a background thread would be candidates for background processing. Handling important database updates would not.

Specified by:

isAsynchronous in interface BroadleafApplicationListener<TransactionLifecycleEvent>

Returns:

See Also:

BroadleafApplicationEventMulticaster

onApplicationEvent

public void onApplicationEvent(TransactionLifecycleEvent event)

Specified by:

onApplicationEvent in interface org.springframework.context.ApplicationListener<TransactionLifecycleEvent>

log

public void log(String statement)

Specified by:

log in interface SqlStatementLoggable

groomInProgressTransactionInfos

protected void groomInProgressTransactionInfos()

detectLeakage

protected void detectLeakage(List<Integer> infosToRemove,
                             Integer key,
                             long currentTime,
                             TransactionInfo info)

detectExpiry

protected void detectExpiry(List<Integer> infosToRemove,
                            Integer key,
                            long currentTime,
                            TransactionInfo info,
                            StackTraceElement[] elements)

compileThreadInformation

protected StackTraceElement[] compileThreadInformation(long currentTime,
                                                       TransactionInfo info,
                                                       Thread thread)

finalizeTransaction

protected void finalizeTransaction(TransactionLifecycleEvent event)

getEntityManagerFromTransactionObject

protected javax.persistence.EntityManager getEntityManagerFromTransactionObject(Object transactionObject)

getCurrentTransactionInfo

protected TransactionInfo getCurrentTransactionInfo()

isAtLeastOneTransactionManagerEnabled

protected boolean isAtLeastOneTransactionManagerEnabled()