org.hibernate.stat.internal.StatisticsImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of hibernate-core-jakarta Show documentation
Show all versions of hibernate-core-jakarta Show documentation
Hibernate O/RM implementation of the Jakarta Persistence specification
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or .
*/
package org.hibernate.stat.internal;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;
import org.hibernate.boot.spi.SessionFactoryOptions;
import org.hibernate.cache.spi.CacheImplementor;
import org.hibernate.cache.spi.QueryResultsCache;
import org.hibernate.cache.spi.QueryResultsRegion;
import org.hibernate.cache.spi.Region;
import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.metamodel.model.domain.NavigableRole;
import org.hibernate.metamodel.spi.MetamodelImplementor;
import org.hibernate.persister.entity.EntityPersister;
import org.hibernate.service.Service;
import org.hibernate.service.spi.Manageable;
import org.hibernate.stat.Statistics;
import org.hibernate.stat.spi.StatisticsImplementor;
import static org.hibernate.internal.CoreLogging.messageLogger;
/**
* Implementation of {@link org.hibernate.stat.Statistics} based on the {@link java.util.concurrent} package.
*
* @author Alex Snaps
* @author Sanne Grinovero
*/
@SuppressWarnings({ "unchecked" })
public class StatisticsImpl implements StatisticsImplementor, Service, Manageable {
private static final CoreMessageLogger LOG = messageLogger( StatisticsImpl.class );
private final MetamodelImplementor metamodel;
private final CacheImplementor cache;
private final String cacheRegionPrefix;
private final boolean secondLevelCacheEnabled;
private final boolean queryCacheEnabled;
private volatile boolean isStatisticsEnabled;
private volatile long startTime;
private final LongAdder sessionOpenCount = new LongAdder();
private final LongAdder sessionCloseCount = new LongAdder();
private final LongAdder flushCount = new LongAdder();
private final LongAdder connectCount = new LongAdder();
private final LongAdder prepareStatementCount = new LongAdder();
private final LongAdder closeStatementCount = new LongAdder();
private final LongAdder entityLoadCount = new LongAdder();
private final LongAdder entityUpdateCount = new LongAdder();
private final LongAdder entityInsertCount = new LongAdder();
private final LongAdder entityDeleteCount = new LongAdder();
private final LongAdder entityFetchCount = new LongAdder();
private final LongAdder collectionLoadCount = new LongAdder();
private final LongAdder collectionUpdateCount = new LongAdder();
private final LongAdder collectionRemoveCount = new LongAdder();
private final LongAdder collectionRecreateCount = new LongAdder();
private final LongAdder collectionFetchCount = new LongAdder();
private final LongAdder secondLevelCacheHitCount = new LongAdder();
private final LongAdder secondLevelCacheMissCount = new LongAdder();
private final LongAdder secondLevelCachePutCount = new LongAdder();
private final LongAdder naturalIdCacheHitCount = new LongAdder();
private final LongAdder naturalIdCacheMissCount = new LongAdder();
private final LongAdder naturalIdCachePutCount = new LongAdder();
private final LongAdder naturalIdQueryExecutionCount = new LongAdder();
private final AtomicLong naturalIdQueryExecutionMaxTime = new AtomicLong();
private volatile String naturalIdQueryExecutionMaxTimeRegion;
private volatile String naturalIdQueryExecutionMaxTimeEntity;
private final LongAdder queryExecutionCount = new LongAdder();
private final AtomicLong queryExecutionMaxTime = new AtomicLong();
private volatile String queryExecutionMaxTimeQueryString;
private final LongAdder queryCacheHitCount = new LongAdder();
private final LongAdder queryCacheMissCount = new LongAdder();
private final LongAdder queryCachePutCount = new LongAdder();
private final LongAdder queryPlanCacheHitCount = new LongAdder();
private final LongAdder queryPlanCacheMissCount = new LongAdder();
private final LongAdder updateTimestampsCacheHitCount = new LongAdder();
private final LongAdder updateTimestampsCacheMissCount = new LongAdder();
private final LongAdder updateTimestampsCachePutCount = new LongAdder();
private final LongAdder committedTransactionCount = new LongAdder();
private final LongAdder transactionCount = new LongAdder();
private final LongAdder optimisticFailureCount = new LongAdder();
private final StatsNamedContainer entityStatsMap = new StatsNamedContainer();
private final StatsNamedContainer naturalIdQueryStatsMap = new StatsNamedContainer();
private final StatsNamedContainer collectionStatsMap = new StatsNamedContainer();
/**
* Keyed by query string
*/
private final StatsNamedContainer queryStatsMap;
/**
* Keyed by region name
*/
private final StatsNamedContainer l2CacheStatsMap = new StatsNamedContainer<>();
private final StatsNamedContainer deprecatedNaturalIdStatsMap = new StatsNamedContainer();
public StatisticsImpl(SessionFactoryImplementor sessionFactory) {
Objects.requireNonNull( sessionFactory );
SessionFactoryOptions sessionFactoryOptions = sessionFactory.getSessionFactoryOptions();
this.queryStatsMap = new StatsNamedContainer(
sessionFactory != null ?
sessionFactoryOptions.getQueryStatisticsMaxSize() :
Statistics.DEFAULT_QUERY_STATISTICS_MAX_SIZE,
20
);
resetStartTime();
metamodel = sessionFactory.getMetamodel();
cache = sessionFactory.getCache();
cacheRegionPrefix = sessionFactoryOptions.getCacheRegionPrefix();
secondLevelCacheEnabled = sessionFactoryOptions.isSecondLevelCacheEnabled();
queryCacheEnabled = sessionFactoryOptions.isQueryCacheEnabled();
}
/**
* reset all statistics
*/
public void clear() {
secondLevelCacheHitCount.reset();
secondLevelCacheMissCount.reset();
secondLevelCachePutCount.reset();
naturalIdCacheHitCount.reset();
naturalIdCacheMissCount.reset();
naturalIdCachePutCount.reset();
naturalIdQueryExecutionCount.reset();
naturalIdQueryExecutionMaxTime.set( 0L );
naturalIdQueryExecutionMaxTimeRegion = null;
naturalIdQueryExecutionMaxTimeEntity = null;
sessionCloseCount.reset();
sessionOpenCount.reset();
flushCount.reset();
connectCount.reset();
prepareStatementCount.reset();
closeStatementCount.reset();
entityDeleteCount.reset();
entityInsertCount.reset();
entityUpdateCount.reset();
entityLoadCount.reset();
entityFetchCount.reset();
collectionRemoveCount.reset();
collectionUpdateCount.reset();
collectionRecreateCount.reset();
collectionLoadCount.reset();
collectionFetchCount.reset();
queryExecutionCount.reset();
queryCacheHitCount.reset();
queryExecutionMaxTime.set( 0L );
queryExecutionMaxTimeQueryString = null;
queryCacheMissCount.reset();
queryCachePutCount.reset();
updateTimestampsCacheMissCount.reset();
updateTimestampsCacheHitCount.reset();
updateTimestampsCachePutCount.reset();
transactionCount.reset();
committedTransactionCount.reset();
optimisticFailureCount.reset();
entityStatsMap.clear();
collectionStatsMap.clear();
naturalIdQueryStatsMap.clear();
l2CacheStatsMap.clear();
queryStatsMap.clear();
deprecatedNaturalIdStatsMap.clear();
queryPlanCacheHitCount.reset();
queryPlanCacheMissCount.reset();
resetStartTime();
}
private void resetStartTime() {
startTime = System.currentTimeMillis();
}
@Override
public long getStartTime() {
return startTime;
}
@Override
public boolean isStatisticsEnabled() {
return isStatisticsEnabled;
}
@Override
public void setStatisticsEnabled(boolean b) {
isStatisticsEnabled = b;
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Entity stats
@Override
public String[] getEntityNames() {
return metamodel.getAllEntityNames();
}
@Override
public EntityStatisticsImpl getEntityStatistics(String entityName) {
return entityStatsMap.getOrCompute(
entityName,
this::instantiateEntityStatistics
);
}
@Override
public long getEntityLoadCount() {
return entityLoadCount.sum();
}
@Override
public long getEntityFetchCount() {
return entityFetchCount.sum();
}
@Override
public long getEntityDeleteCount() {
return entityDeleteCount.sum();
}
@Override
public long getEntityInsertCount() {
return entityInsertCount.sum();
}
@Override
public long getEntityUpdateCount() {
return entityUpdateCount.sum();
}
@Override
public long getOptimisticFailureCount() {
return optimisticFailureCount.sum();
}
@Override
public void loadEntity(String entityName) {
entityLoadCount.increment();
getEntityStatistics( entityName ).incrementLoadCount();
}
@Override
public void fetchEntity(String entityName) {
entityFetchCount.increment();
getEntityStatistics( entityName ).incrementFetchCount();
}
@Override
public void updateEntity(String entityName) {
entityUpdateCount.increment();
getEntityStatistics( entityName ).incrementUpdateCount();
}
@Override
public void insertEntity(String entityName) {
entityInsertCount.increment();
getEntityStatistics( entityName ).incrementInsertCount();
}
@Override
public void deleteEntity(String entityName) {
entityDeleteCount.increment();
getEntityStatistics( entityName ).incrementDeleteCount();
}
@Override
public void optimisticFailure(String entityName) {
optimisticFailureCount.increment();
getEntityStatistics( entityName ).incrementOptimisticFailureCount();
}
@Override
public void entityCachePut(NavigableRole entityName, String regionName) {
secondLevelCachePutCount.increment();
getDomainDataRegionStatistics( regionName ).incrementPutCount();
getEntityStatistics( entityName.getFullPath() ).incrementCachePutCount();
}
@Override
public void entityCacheHit(NavigableRole entityName, String regionName) {
secondLevelCacheHitCount.increment();
getDomainDataRegionStatistics( regionName ).incrementHitCount();
getEntityStatistics( entityName.getFullPath() ).incrementCacheHitCount();
}
@Override
public void entityCacheMiss(NavigableRole entityName, String regionName) {
secondLevelCacheMissCount.increment();
getDomainDataRegionStatistics( regionName ).incrementMissCount();
getEntityStatistics( entityName.getFullPath() ).incrementCacheMissCount();
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Collection stats
@Override
public String[] getCollectionRoleNames() {
return metamodel.getAllCollectionRoles();
}
@Override
public CollectionStatisticsImpl getCollectionStatistics(String role) {
return collectionStatsMap.getOrCompute(
role,
this::instantiateCollectionStatistics
);
}
@Override
public long getCollectionLoadCount() {
return collectionLoadCount.sum();
}
@Override
public long getCollectionFetchCount() {
return collectionFetchCount.sum();
}
@Override
public long getCollectionUpdateCount() {
return collectionUpdateCount.sum();
}
@Override
public long getCollectionRemoveCount() {
return collectionRemoveCount.sum();
}
@Override
public long getCollectionRecreateCount() {
return collectionRecreateCount.sum();
}
@Override
public void loadCollection(String role) {
collectionLoadCount.increment();
getCollectionStatistics( role ).incrementLoadCount();
}
@Override
public void fetchCollection(String role) {
collectionFetchCount.increment();
getCollectionStatistics( role ).incrementFetchCount();
}
@Override
public void updateCollection(String role) {
collectionUpdateCount.increment();
getCollectionStatistics( role ).incrementUpdateCount();
}
@Override
public void recreateCollection(String role) {
collectionRecreateCount.increment();
getCollectionStatistics( role ).incrementRecreateCount();
}
@Override
public void removeCollection(String role) {
collectionRemoveCount.increment();
getCollectionStatistics( role ).incrementRemoveCount();
}
@Override
public void collectionCachePut(NavigableRole collectionRole, String regionName) {
secondLevelCachePutCount.increment();
getDomainDataRegionStatistics( regionName ).incrementPutCount();
getCollectionStatistics( collectionRole.getFullPath() ).incrementCachePutCount();
}
@Override
public void collectionCacheHit(NavigableRole collectionRole, String regionName) {
secondLevelCacheHitCount.increment();
getDomainDataRegionStatistics( regionName ).incrementHitCount();
getCollectionStatistics( collectionRole.getFullPath() ).incrementCacheHitCount();
}
@Override
public void collectionCacheMiss(NavigableRole collectionRole, String regionName) {
secondLevelCacheMissCount.increment();
getDomainDataRegionStatistics( regionName ).incrementMissCount();
getCollectionStatistics( collectionRole.getFullPath() ).incrementCacheMissCount();
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Natural-id stats
@Override
public NaturalIdStatisticsImpl getNaturalIdStatistics(String rootEntityName) {
return naturalIdQueryStatsMap.getOrCompute(
rootEntityName,
this::instantiateNaturalStatistics
);
}
@Override
public DeprecatedNaturalIdCacheStatisticsImpl getNaturalIdCacheStatistics(String regionName) {
final String key = cache.unqualifyRegionName( regionName );
return deprecatedNaturalIdStatsMap.getOrCompute(
key,
this::instantiateDeprecatedNaturalIdCacheStatistics
);
}
@Override
public long getNaturalIdQueryExecutionCount() {
return naturalIdQueryExecutionCount.sum();
}
@Override
public long getNaturalIdQueryExecutionMaxTime() {
return naturalIdQueryExecutionMaxTime.get();
}
@Override
public String getNaturalIdQueryExecutionMaxTimeRegion() {
return naturalIdQueryExecutionMaxTimeRegion;
}
@Override
public String getNaturalIdQueryExecutionMaxTimeEntity() {
return naturalIdQueryExecutionMaxTimeEntity;
}
@Override
public long getNaturalIdCacheHitCount() {
return naturalIdCacheHitCount.sum();
}
@Override
public long getNaturalIdCacheMissCount() {
return naturalIdCacheMissCount.sum();
}
@Override
public long getNaturalIdCachePutCount() {
return naturalIdCachePutCount.sum();
}
@Override
public void naturalIdCachePut(
NavigableRole rootEntityName,
String regionName) {
naturalIdCachePutCount.increment();
getDomainDataRegionStatistics( regionName ).incrementPutCount();
getNaturalIdStatistics( rootEntityName.getFullPath() ).incrementCachePutCount();
getNaturalIdCacheStatistics( qualify( regionName ) ).incrementPutCount();
}
@Override
public void naturalIdCacheHit(
NavigableRole rootEntityName,
String regionName) {
naturalIdCacheHitCount.increment();
getDomainDataRegionStatistics( regionName ).incrementHitCount();
getNaturalIdStatistics( rootEntityName.getFullPath() ).incrementCacheHitCount();
getNaturalIdCacheStatistics( qualify( regionName ) ).incrementHitCount();
}
@Override
public void naturalIdCacheMiss(
NavigableRole rootEntityName,
String regionName) {
naturalIdCacheMissCount.increment();
getDomainDataRegionStatistics( regionName ).incrementMissCount();
getNaturalIdStatistics( rootEntityName.getFullPath() ).incrementCacheMissCount();
getNaturalIdCacheStatistics( qualify( regionName ) ).incrementMissCount();
}
private String qualify(final String regionName) {
return cacheRegionPrefix == null
? regionName
: cacheRegionPrefix + '.' + regionName;
}
@Override
public void naturalIdQueryExecuted(String rootEntityName, long time) {
naturalIdQueryExecutionCount.increment();
boolean isLongestQuery;
//noinspection StatementWithEmptyBody
for ( long old = naturalIdQueryExecutionMaxTime.get();
( isLongestQuery = time > old ) && ( !naturalIdQueryExecutionMaxTime.compareAndSet( old, time ) );
old = naturalIdQueryExecutionMaxTime.get() ) {
// nothing to do here given the odd loop structure...
}
if ( isLongestQuery ) {
naturalIdQueryExecutionMaxTimeEntity = rootEntityName;
}
final EntityPersister rootEntityPersister = metamodel.entityPersister( rootEntityName );
getNaturalIdStatistics( rootEntityName ).queryExecuted( time );
if ( rootEntityPersister.hasNaturalIdCache() ) {
final String naturalIdRegionName = rootEntityPersister.getNaturalIdCacheAccessStrategy()
.getRegion()
.getName();
getNaturalIdCacheStatistics( qualify( naturalIdRegionName ) ).queryExecuted( time );
if ( isLongestQuery ) {
naturalIdQueryExecutionMaxTimeRegion = naturalIdRegionName;
}
}
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Second-level cache region stats
@Override
public String[] getSecondLevelCacheRegionNames() {
return cache.getSecondLevelCacheRegionNames();
}
@Override
public CacheRegionStatisticsImpl getDomainDataRegionStatistics(String regionName) {
return l2CacheStatsMap.getOrCompute(
regionName,
this::instantiateCacheRegionStatistics
);
}
@Override
public CacheRegionStatisticsImpl getQueryRegionStatistics(final String regionName) {
return l2CacheStatsMap.getOrCompute( regionName, this::computeQueryRegionStatistics );
}
private CacheRegionStatisticsImpl computeQueryRegionStatistics(final String regionName) {
final QueryResultsCache regionAccess = cache.getQueryResultsCacheStrictly( regionName );
if ( regionAccess == null ) {
return null; //this null value will be cached
}
else {
return new CacheRegionStatisticsImpl( regionAccess.getRegion() );
}
}
@Override
public CacheRegionStatisticsImpl getCacheRegionStatistics(String regionName) {
if ( ! secondLevelCacheEnabled ) {
return null;
}
return l2CacheStatsMap.getOrCompute(
regionName,
this::createCacheRegionStatistics
);
}
@Override
public CacheRegionStatisticsImpl getSecondLevelCacheStatistics(String regionName) {
return getCacheRegionStatistics( cache.unqualifyRegionName( regionName ) );
}
@Override
public long getSecondLevelCacheHitCount() {
return secondLevelCacheHitCount.sum();
}
@Override
public long getSecondLevelCacheMissCount() {
return secondLevelCacheMissCount.sum();
}
@Override
public long getSecondLevelCachePutCount() {
return secondLevelCachePutCount.sum();
}
@Override
public long getUpdateTimestampsCacheHitCount() {
return updateTimestampsCacheHitCount.sum();
}
@Override
public long getUpdateTimestampsCacheMissCount() {
return updateTimestampsCacheMissCount.sum();
}
@Override
public long getUpdateTimestampsCachePutCount() {
return updateTimestampsCachePutCount.sum();
}
@Override
public void updateTimestampsCacheHit() {
updateTimestampsCacheHitCount.increment();
}
@Override
public void updateTimestampsCacheMiss() {
updateTimestampsCacheMissCount.increment();
}
@Override
public void updateTimestampsCachePut() {
updateTimestampsCachePutCount.increment();
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Query statistics
@Override
public String[] getQueries() {
return queryStatsMap.keysAsArray();
}
@Override
public QueryStatisticsImpl getQueryStatistics(String queryString) {
return queryStatsMap.getOrCompute(
queryString,
QueryStatisticsImpl::new
);
}
@Override
public long getQueryExecutionCount() {
return queryExecutionCount.sum();
}
@Override
public long getQueryCacheHitCount() {
return queryCacheHitCount.sum();
}
@Override
public long getQueryCacheMissCount() {
return queryCacheMissCount.sum();
}
@Override
public long getQueryCachePutCount() {
return queryCachePutCount.sum();
}
@Override
public String getQueryExecutionMaxTimeQueryString() {
return queryExecutionMaxTimeQueryString;
}
@Override
public long getQueryExecutionMaxTime() {
return queryExecutionMaxTime.get();
}
@Override
public void queryExecuted(String hql, int rows, long time) {
LOG.hql( hql, time, (long) rows );
queryExecutionCount.increment();
boolean isLongestQuery;
//noinspection StatementWithEmptyBody
for ( long old = queryExecutionMaxTime.get();
( isLongestQuery = time > old ) && ( ! queryExecutionMaxTime.compareAndSet( old, time ) );
old = queryExecutionMaxTime.get() ) {
// nothing to do here given the odd loop structure...
}
if ( isLongestQuery ) {
queryExecutionMaxTimeQueryString = hql;
}
if ( hql != null ) {
getQueryStatistics( hql ).executed( rows, time );
}
}
@Override
public void queryCacheHit(String hql, String regionName) {
LOG.tracef( "Statistics#queryCacheHit( `%s`, `%s` )", hql, regionName );
queryCacheHitCount.increment();
getQueryRegionStats( regionName ).incrementHitCount();
if ( hql != null ) {
getQueryStatistics( hql ).incrementCacheHitCount();
}
}
@Override
public void queryCacheMiss(String hql, String regionName) {
LOG.tracef( "Statistics#queryCacheMiss( `%s`, `%s` )", hql, regionName );
queryCacheMissCount.increment();
getQueryRegionStats( regionName ).incrementMissCount();
if ( hql != null ) {
getQueryStatistics( hql ).incrementCacheMissCount();
}
}
@Override
public void queryCachePut(String hql, String regionName) {
LOG.tracef( "Statistics#queryCachePut( `%s`, `%s` )", hql, regionName );
queryCachePutCount.increment();
getQueryRegionStats( regionName ).incrementPutCount();
if ( hql != null ) {
getQueryStatistics( hql ).incrementCachePutCount();
}
}
@Override
public long getQueryPlanCacheHitCount() {
return queryPlanCacheHitCount.sum();
}
@Override
public long getQueryPlanCacheMissCount() {
return queryPlanCacheMissCount.sum();
}
@Override
public void queryCompiled(String hql, long microseconds) {
queryPlanCacheMissCount.increment();
if ( hql != null ) {
getQueryStatistics( hql ).compiled( microseconds );
}
}
@Override
public void queryPlanCacheHit(String query) {
queryPlanCacheHitCount.increment();
if ( query != null ) {
getQueryStatistics( query ).incrementPlanCacheHitCount();
}
}
@Override
public void queryPlanCacheMiss(String query) {
queryPlanCacheMissCount.increment();
if ( query != null ) {
getQueryStatistics( query ).incrementPlanCacheMissCount();
}
}
private CacheRegionStatisticsImpl getQueryRegionStats(String regionName) {
return l2CacheStatsMap.getOrCompute(
regionName,
this::instantiateCacheRegionStatsForQueryResults
);
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Session/misc stats
@Override
public long getSessionOpenCount() {
return sessionOpenCount.sum();
}
@Override
public long getSessionCloseCount() {
return sessionCloseCount.sum();
}
@Override
public long getFlushCount() {
return flushCount.sum();
}
@Override
public long getConnectCount() {
return connectCount.sum();
}
@Override
public long getSuccessfulTransactionCount() {
return committedTransactionCount.sum();
}
@Override
public long getTransactionCount() {
return transactionCount.sum();
}
@Override
public long getCloseStatementCount() {
return closeStatementCount.sum();
}
@Override
public long getPrepareStatementCount() {
return prepareStatementCount.sum();
}
@Override
public void openSession() {
sessionOpenCount.increment();
}
@Override
public void closeSession() {
sessionCloseCount.increment();
}
@Override
public void flush() {
flushCount.increment();
}
@Override
public void connect() {
connectCount.increment();
}
@Override
public void prepareStatement() {
prepareStatementCount.increment();
}
@Override
public void closeStatement() {
closeStatementCount.increment();
}
@Override
public void endTransaction(boolean success) {
transactionCount.increment();
if ( success ) {
committedTransactionCount.increment();
}
}
@Override
public void logSummary() {
LOG.loggingStatistics();
LOG.startTime( startTime );
LOG.sessionsOpened( sessionOpenCount.sum() );
LOG.sessionsClosed( sessionCloseCount.sum() );
LOG.transactions( transactionCount.sum() );
LOG.successfulTransactions( committedTransactionCount.sum() );
LOG.optimisticLockFailures( optimisticFailureCount.sum() );
LOG.flushes( flushCount.sum() );
LOG.connectionsObtained( connectCount.sum() );
LOG.statementsPrepared( prepareStatementCount.sum() );
LOG.statementsClosed( closeStatementCount.sum() );
LOG.secondLevelCachePuts( secondLevelCachePutCount.sum() );
LOG.secondLevelCacheHits( secondLevelCacheHitCount.sum() );
LOG.secondLevelCacheMisses( secondLevelCacheMissCount.sum() );
LOG.entitiesLoaded( entityLoadCount.sum() );
LOG.entitiesUpdated( entityUpdateCount.sum() );
LOG.entitiesInserted( entityInsertCount.sum() );
LOG.entitiesDeleted( entityDeleteCount.sum() );
LOG.entitiesFetched( entityFetchCount.sum() );
LOG.collectionsLoaded( collectionLoadCount.sum() );
LOG.collectionsUpdated( collectionUpdateCount.sum() );
LOG.collectionsRemoved( collectionRemoveCount.sum() );
LOG.collectionsRecreated( collectionRecreateCount.sum() );
LOG.collectionsFetched( collectionFetchCount.sum() );
LOG.naturalIdCachePuts( naturalIdCachePutCount.sum() );
LOG.naturalIdCacheHits( naturalIdCacheHitCount.sum() );
LOG.naturalIdCacheMisses( naturalIdCacheMissCount.sum() );
LOG.naturalIdMaxQueryTime( naturalIdQueryExecutionMaxTime.get() );
LOG.naturalIdQueriesExecuted( naturalIdQueryExecutionCount.sum() );
LOG.queriesExecuted( queryExecutionCount.sum() );
LOG.queryCachePuts( queryCachePutCount.sum() );
LOG.timestampCachePuts( updateTimestampsCachePutCount.sum() );
LOG.timestampCacheHits( updateTimestampsCacheHitCount.sum() );
LOG.timestampCacheMisses( updateTimestampsCacheMissCount.sum() );
LOG.queryCacheHits( queryCacheHitCount.sum() );
LOG.queryCacheMisses( queryCacheMissCount.sum() );
LOG.maxQueryTime( queryExecutionMaxTime.get() );
LOG.queryPlanCacheHits( queryPlanCacheHitCount.sum() );
LOG.queryPlanCacheMisses( queryPlanCacheMissCount.sum() );
}
@Override
public String toString() {
return new StringBuilder()
.append( "Statistics[" )
.append( "start time=" ).append( startTime )
.append( ",sessions opened=" ).append( sessionOpenCount )
.append( ",sessions closed=" ).append( sessionCloseCount )
.append( ",transactions=" ).append( transactionCount )
.append( ",successful transactions=" ).append( committedTransactionCount )
.append( ",optimistic lock failures=" ).append( optimisticFailureCount )
.append( ",flushes=" ).append( flushCount )
.append( ",connections obtained=" ).append( connectCount )
.append( ",statements prepared=" ).append( prepareStatementCount )
.append( ",statements closed=" ).append( closeStatementCount )
.append( ",second level cache puts=" ).append( secondLevelCachePutCount )
.append( ",second level cache hits=" ).append( secondLevelCacheHitCount )
.append( ",second level cache misses=" ).append( secondLevelCacheMissCount )
.append( ",entities loaded=" ).append( entityLoadCount )
.append( ",entities updated=" ).append( entityUpdateCount )
.append( ",entities inserted=" ).append( entityInsertCount )
.append( ",entities deleted=" ).append( entityDeleteCount )
.append( ",entities fetched=" ).append( entityFetchCount )
.append( ",collections loaded=" ).append( collectionLoadCount )
.append( ",collections updated=" ).append( collectionUpdateCount )
.append( ",collections removed=" ).append( collectionRemoveCount )
.append( ",collections recreated=" ).append( collectionRecreateCount )
.append( ",collections fetched=" ).append( collectionFetchCount )
.append( ",naturalId queries executed to database=" ).append( naturalIdQueryExecutionCount )
.append( ",naturalId cache puts=" ).append( naturalIdCachePutCount )
.append( ",naturalId cache hits=" ).append( naturalIdCacheHitCount )
.append( ",naturalId cache misses=" ).append( naturalIdCacheMissCount )
.append( ",naturalId max query time=" ).append( naturalIdQueryExecutionMaxTime )
.append( ",queries executed to database=" ).append( queryExecutionCount )
.append( ",query cache puts=" ).append( queryCachePutCount )
.append( ",query cache hits=" ).append( queryCacheHitCount )
.append( ",query cache misses=" ).append( queryCacheMissCount )
.append(",update timestamps cache puts=").append(updateTimestampsCachePutCount)
.append(",update timestamps cache hits=").append(updateTimestampsCacheHitCount)
.append(",update timestamps cache misses=").append(updateTimestampsCacheMissCount)
.append( ",max query time=" ).append( queryExecutionMaxTime )
.append( ",query plan cache hits=" ).append( queryPlanCacheHitCount )
.append( ",query plan cache misses=" ).append( queryPlanCacheMissCount )
.append( ']' )
.toString();
}
private EntityStatisticsImpl instantiateEntityStatistics(final String entityName) {
return new EntityStatisticsImpl( metamodel.entityPersister( entityName ) );
}
private CollectionStatisticsImpl instantiateCollectionStatistics(final String role) {
return new CollectionStatisticsImpl( metamodel.collectionPersister( role ) );
}
private NaturalIdStatisticsImpl instantiateNaturalStatistics(final String entityName) {
final EntityPersister entityDescriptor = metamodel.entityPersister( entityName );
if ( !entityDescriptor.hasNaturalIdentifier() ) {
throw new IllegalArgumentException( "Given entity [" + entityName + "] does not define natural-id" );
}
return new NaturalIdStatisticsImpl( entityDescriptor );
}
private DeprecatedNaturalIdCacheStatisticsImpl instantiateDeprecatedNaturalIdCacheStatistics(final String unqualifiedRegionName) {
return new DeprecatedNaturalIdCacheStatisticsImpl(
unqualifiedRegionName,
cache.getNaturalIdAccessesInRegion( unqualifiedRegionName )
);
}
private CacheRegionStatisticsImpl instantiateCacheRegionStatistics(final String regionName) {
final Region region = cache.getRegion( regionName );
if ( region == null ) {
throw new IllegalArgumentException( "Unknown cache region : " + regionName );
}
if ( region instanceof QueryResultsRegion ) {
throw new IllegalArgumentException(
"Region name [" + regionName + "] referred to a query result region, not a domain data region"
);
}
return new CacheRegionStatisticsImpl( region );
}
private CacheRegionStatisticsImpl instantiateCacheRegionStatsForQueryResults(final String regionName) {
return new CacheRegionStatisticsImpl( cache.getQueryResultsCache( regionName ).getRegion() );
}
private CacheRegionStatisticsImpl createCacheRegionStatistics(final String regionName) {
Region region = cache.getRegion( regionName );
if ( region == null ) {
if ( !queryCacheEnabled ) {
return null;
}
// this is the pre-5.3 behavior. and since this is a pre-5.3 method it should behave consistently
// NOTE that this method is deprecated
region = cache.getQueryResultsCache( regionName ).getRegion();
}
return new CacheRegionStatisticsImpl( region );
}
}