Example usage for org.hibernate.stat Statistics getSuccessfulTransactionCount

List of usage examples for org.hibernate.stat Statistics getSuccessfulTransactionCount

Introduction

In this page you can find the example usage for org.hibernate.stat Statistics getSuccessfulTransactionCount.

Prototype

long getSuccessfulTransactionCount();

Source Link

Document

The number of transactions we know to have been successful

Usage

From source file:com.francetelecom.clara.cloud.commons.HibernateStatsHelper.java

License:Apache License

/**
 * Ensure no regression higher than 5%// ww w  .j  av a 2  s. c  o  m
 * @param assertDuration if true durations are verified, if false durations are not verified
 */
private static void checkStats(Map<HibernateStatsReferenceType, Long> refs, long duration, Statistics stats,
        boolean assertDuration) throws ObjectNotFoundException, MalformedURLException {
    List<AssertionError> failedAsserts = new ArrayList<AssertionError>();

    // Reference values: these must be updated when you optimize your code
    // or if new values are explained and normal.
    final long DURATION = refs.get(HibernateStatsReferenceType.DURATION);
    final int QUERY_COUNT = refs.get(HibernateStatsReferenceType.QUERY_COUNT).intValue();
    final int QUERY_MAX_TIME_MS = refs.get(HibernateStatsReferenceType.QUERY_MAX_TIME_MS).intValue();

    final int ENTITY_FETCH_COUNT = refs.get(HibernateStatsReferenceType.ENTITY_FETCH_COUNT).intValue();
    final int ENTITY_LOAD_COUNT = refs.get(HibernateStatsReferenceType.ENTITY_LOAD_COUNT).intValue();
    final int ENTITY_INSERT_COUNT = refs.get(HibernateStatsReferenceType.ENTITY_INSERT_COUNT).intValue();
    final int ENTITY_DELETE_COUNT = refs.get(HibernateStatsReferenceType.ENTITY_DELETE_COUNT).intValue();
    final int ENTITY_UPDATE_COUNT = refs.get(HibernateStatsReferenceType.ENTITY_UPDATE_COUNT).intValue();

    final int COLLECTION_FETCH_COUNT = refs.get(HibernateStatsReferenceType.COLLECTION_FETCH_COUNT).intValue();
    final int COLLECTION_LOAD_COUNT = refs.get(HibernateStatsReferenceType.COLLECTION_LOAD_COUNT).intValue();
    final int COLLECTION_RECREATE_COUNT = refs.get(HibernateStatsReferenceType.COLLECTION_RECREATE_COUNT)
            .intValue();
    final int COLLECTION_REMOVE_COUNT = refs.get(HibernateStatsReferenceType.COLLECTION_REMOVE_COUNT)
            .intValue();
    final int COLLECTION_UPDATE_COUNT = refs.get(HibernateStatsReferenceType.COLLECTION_UPDATE_COUNT)
            .intValue();

    // The number of completed transactions (failed and successful) must
    // match number of transactions completed without failure
    preAssertEquals("There are transaction failures", stats.getTransactionCount(),
            stats.getSuccessfulTransactionCount(), failedAsserts);

    // Total number of queries executed.
    preAssertTrue(
            "Total number of queries executed increased more than 5% (ref=" + QUERY_COUNT + "): "
                    + stats.getQueryExecutionCount(),
            stats.getQueryExecutionCount() <= (QUERY_COUNT * 1.05), failedAsserts);
    if (stats.getQueryExecutionCount() < (QUERY_COUNT * 0.95))
        logger.warn("/!\\ You should update reference value QUERY_COUNT (ref=" + QUERY_COUNT + ") to "
                + stats.getQueryExecutionCount());

    preAssertTrue(
            "ENTITY_DELETE_COUNT increased more than 5% (ref=" + ENTITY_DELETE_COUNT + "): "
                    + stats.getEntityDeleteCount(),
            stats.getEntityDeleteCount() <= (ENTITY_DELETE_COUNT * 1.05), failedAsserts);
    if (stats.getEntityDeleteCount() < (ENTITY_DELETE_COUNT * 0.95))
        logger.warn("/!\\ You should update reference value ENTITY_DELETE_COUNT (ref=" + ENTITY_DELETE_COUNT
                + ") to " + stats.getEntityDeleteCount());
    preAssertTrue(
            "ENTITY_UPDATE_COUNT increased more than 5% (ref=" + ENTITY_UPDATE_COUNT + "): "
                    + stats.getEntityUpdateCount(),
            stats.getEntityUpdateCount() <= (ENTITY_UPDATE_COUNT * 1.05), failedAsserts);
    if (stats.getEntityUpdateCount() < (ENTITY_UPDATE_COUNT * 0.95))
        logger.warn("/!\\ You should update reference value ENTITY_UPDATE_COUNT (ref=" + ENTITY_UPDATE_COUNT
                + ") to " + stats.getEntityUpdateCount());

    if (stats.getCollectionRecreateCount() < (COLLECTION_RECREATE_COUNT * 0.95))
        logger.warn("/!\\ You should update reference value COLLECTION_RECREATE_COUNT (ref="
                + COLLECTION_RECREATE_COUNT + ") to " + stats.getCollectionRecreateCount());
    preAssertTrue(
            "COLLECTION_REMOVE_COUNT increased more than 5% (ref=" + COLLECTION_REMOVE_COUNT + "): "
                    + stats.getCollectionRemoveCount(),
            stats.getCollectionRemoveCount() <= (COLLECTION_REMOVE_COUNT * 1.05), failedAsserts);
    if (stats.getCollectionRemoveCount() < (COLLECTION_REMOVE_COUNT * 0.95))
        logger.warn("/!\\ You should update reference value COLLECTION_REMOVE_COUNT (ref="
                + COLLECTION_REMOVE_COUNT + ") to " + stats.getCollectionRemoveCount());
    preAssertTrue(
            "COLLECTION_UPDATE_COUNT increased more than 5% (ref=" + COLLECTION_UPDATE_COUNT + "): "
                    + stats.getCollectionUpdateCount(),
            stats.getCollectionUpdateCount() <= (COLLECTION_UPDATE_COUNT * 1.05), failedAsserts);
    if (stats.getCollectionUpdateCount() < (COLLECTION_UPDATE_COUNT * 0.95))
        logger.warn("/!\\ You should update reference value COLLECTION_UPDATE_COUNT (ref="
                + COLLECTION_UPDATE_COUNT + ") to " + stats.getCollectionUpdateCount());

    // Entities statistics
    preAssertTrue(
            "ENTITY_FETCH_COUNT increased more than 5% (ref=" + ENTITY_FETCH_COUNT + "): "
                    + stats.getEntityFetchCount(),
            stats.getEntityFetchCount() < (ENTITY_FETCH_COUNT * 1.05), failedAsserts);
    if (stats.getEntityFetchCount() < (ENTITY_FETCH_COUNT * 0.95))
        logger.warn("/!\\ You should update reference value ENTITY_FETCH_COUNT (ref=" + ENTITY_FETCH_COUNT
                + ") to " + stats.getEntityFetchCount());
    preAssertTrue(
            "ENTITY_LOAD_COUNT increased more than 5% (ref=" + ENTITY_LOAD_COUNT + "): "
                    + stats.getEntityLoadCount(),
            stats.getEntityLoadCount() <= (ENTITY_LOAD_COUNT * 1.05), failedAsserts);
    if (stats.getEntityLoadCount() < (ENTITY_LOAD_COUNT * 0.95))
        logger.warn("/!\\ You should update reference value ENTITY_LOAD_COUNT (ref=" + ENTITY_LOAD_COUNT
                + ") to " + stats.getEntityLoadCount());
    preAssertTrue(
            "ENTITY_INSERT_COUNT increased more than 5% (ref=" + ENTITY_INSERT_COUNT + "): "
                    + stats.getEntityInsertCount(),
            stats.getEntityInsertCount() <= (ENTITY_INSERT_COUNT * 1.05), failedAsserts);
    if (stats.getEntityInsertCount() < (ENTITY_INSERT_COUNT * 0.95))
        logger.warn("/!\\ You should update reference value ENTITY_INSERT_COUNT (ref=" + ENTITY_INSERT_COUNT
                + ") to " + stats.getEntityInsertCount());

    // Collections statistics
    preAssertTrue(
            "COLLECTION_FETCH_COUNT increased more than 5% (ref=" + COLLECTION_FETCH_COUNT + "): "
                    + stats.getCollectionFetchCount(),
            stats.getCollectionFetchCount() <= (COLLECTION_FETCH_COUNT * 1.05), failedAsserts);
    if (stats.getCollectionFetchCount() < (COLLECTION_FETCH_COUNT * 0.95))
        logger.warn("/!\\ You should update reference value COLLECTION_FETCH_COUNT (ref="
                + COLLECTION_FETCH_COUNT + ") to " + stats.getCollectionFetchCount());
    preAssertTrue(
            "COLLECTION_LOAD_COUNT increased more than 5% (ref=" + COLLECTION_LOAD_COUNT + "): "
                    + stats.getCollectionLoadCount(),
            stats.getCollectionLoadCount() <= (COLLECTION_LOAD_COUNT * 1.05), failedAsserts);
    if (stats.getCollectionLoadCount() < (COLLECTION_LOAD_COUNT * 0.95))
        logger.warn("/!\\ You should update reference value COLLECTION_LOAD_COUNT (ref=" + COLLECTION_LOAD_COUNT
                + ") to " + stats.getCollectionLoadCount());
    preAssertTrue(
            "COLLECTION_RECREATE_COUNT increased more than 5% (ref=" + COLLECTION_RECREATE_COUNT + "): "
                    + stats.getCollectionRecreateCount(),
            stats.getCollectionRecreateCount() <= (COLLECTION_RECREATE_COUNT * 1.05), failedAsserts);

    if (assertDuration) {
        // Time of the slowest query executed.
        preAssertTrue(
                "Time of the slowest query executed increased more than 50% (ref=" + QUERY_MAX_TIME_MS + "): "
                        + stats.getQueryExecutionMaxTime(),
                stats.getQueryExecutionMaxTime() <= (QUERY_MAX_TIME_MS * 1.50), failedAsserts);
        if (stats.getQueryExecutionMaxTime() < (QUERY_MAX_TIME_MS * 0.50))
            logger.warn("/!\\ You should update reference value QUERY_MAX_TIME_MS (ref=" + QUERY_MAX_TIME_MS
                    + ") to " + stats.getQueryExecutionMaxTime());

        // Check test duration
        preAssertTrue("Total duration of the test increased more than 5% (ref=" + DURATION + "): " + duration,
                duration < (DURATION * 1.05), failedAsserts);
        if (duration <= (DURATION * 0.85))
            logger.warn(
                    "/!\\ You should update reference value DURATION (ref=" + DURATION + ") to " + duration);
    }

    StringBuffer formattedFailedAsserts = new StringBuffer();
    for (AssertionError failedAssert : failedAsserts) {
        formattedFailedAsserts.append(failedAssert.getMessage());
        formattedFailedAsserts.append("\n");
    }
    String advice = "Analyse the code with your favorite profiler, then see where performances decrease and optimize the code. If you consider this new value as 'normal' then set a new reference value.";

    assertTrue(failedAsserts.size() + " Hibernate stats violations: \n" + formattedFailedAsserts.toString()
            + advice, failedAsserts.isEmpty());
}

From source file:com.francetelecom.clara.cloud.scalability.helper.StatisticsHelper.java

License:Apache License

/**
 * Log the current statistics/* w w  w .j a  v a  2 s . c o  m*/
 *
 * @param stats hibernate statistics
 */
public static void logStats(Statistics stats) {

    logger.info("Database statistics");

    logger.info("  Number of connection requests : " + stats.getConnectCount());
    logger.info("  Session flushes : " + stats.getFlushCount());
    logger.info("  Transactions : " + stats.getTransactionCount());
    logger.info("  Successful transactions : " + stats.getSuccessfulTransactionCount());
    logger.info("  Sessions opened : " + stats.getSessionOpenCount());
    logger.info("  Sessions closed : " + stats.getSessionCloseCount());
    logger.info("  Queries executed : " + stats.getQueryExecutionCount());
    logger.info("  Max query time : " + stats.getQueryExecutionMaxTime());
    logger.info("  Max time query : " + stats.getQueryExecutionMaxTimeQueryString());

    logger.info("Collection statistics");

    logger.info("  Collections fetched : " + stats.getCollectionFetchCount());
    logger.info("  Collections loaded : " + stats.getCollectionLoadCount());
    logger.info("  Collections rebuilt : " + stats.getCollectionRecreateCount());
    logger.info("  Collections batch deleted : " + stats.getCollectionRemoveCount());
    logger.info("  Collections batch updated : " + stats.getCollectionUpdateCount());

    logger.info("Object statistics");

    logger.info("  Objects fetched : " + stats.getEntityFetchCount());
    logger.info("  Objects loaded : " + stats.getEntityLoadCount());
    logger.info("  Objects inserted : " + stats.getEntityInsertCount());
    logger.info("  Objects deleted : " + stats.getEntityDeleteCount());
    logger.info("  Objects updated : " + stats.getEntityUpdateCount());

    logger.info("Cache statistics");

    double chit = stats.getQueryCacheHitCount();
    double cmiss = stats.getQueryCacheMissCount();

    logger.info("  Cache hit count : " + chit);
    logger.info("  Cache miss count : " + cmiss);
    logger.info("  Cache hit ratio : " + (chit / (chit + cmiss)));

    String[] entityNames = stats.getEntityNames();
    Arrays.sort(entityNames);
    for (String entityName : entityNames) {
        Class<?> entityClass = null;
        try {
            entityClass = Class.forName(entityName);
        } catch (ClassNotFoundException e) {
            logger.error("Unable to load class for " + entityName, e);
        }
        entityStats(stats, entityClass);
    }
    //Uncomment these lines to trace every query (can generate a lot of logs)
    String[] qs = stats.getQueries();
    for (String q : qs) {
        queryStats(stats, q);
    }

    String[] slcrn = stats.getSecondLevelCacheRegionNames();
    for (String s : slcrn) {
        secondLevelStats(stats, s);
    }
}

From source file:com.openkm.servlet.admin.HibernateStatsServlet.java

License:Open Source License

/**
 * Refresh stats/*from w  w  w .j a va  2s. c o m*/
 */
private synchronized void refresh() {
    Statistics statistics = HibernateUtil.getSessionFactory().getStatistics();
    generalStatistics.set(0, statistics.getConnectCount());
    generalStatistics.set(1, statistics.getFlushCount());
    generalStatistics.set(2, statistics.getPrepareStatementCount());
    generalStatistics.set(3, statistics.getCloseStatementCount());
    generalStatistics.set(4, statistics.getSessionCloseCount());
    generalStatistics.set(5, statistics.getSessionOpenCount());
    generalStatistics.set(6, statistics.getTransactionCount());
    generalStatistics.set(7, statistics.getSuccessfulTransactionCount());
    generalStatistics.set(8, statistics.getOptimisticFailureCount());
    queryStatistics.clear();
    String[] names = statistics.getQueries();

    if (names != null && names.length > 0) {
        for (int i = 0; i < names.length; i++) {
            queryStatistics.put(names[i], statistics.getQueryStatistics(names[i]));
        }
    }

    entityStatistics.clear();
    names = statistics.getEntityNames();

    if (names != null && names.length > 0) {
        for (int i = 0; i < names.length; i++) {
            entityStatistics.put(names[i], statistics.getEntityStatistics(names[i]));
        }
    }

    collectionStatistics.clear();
    names = statistics.getCollectionRoleNames();

    if (names != null && names.length > 0) {
        for (int i = 0; i < names.length; i++) {
            collectionStatistics.put(names[i], statistics.getCollectionStatistics(names[i]));
        }
    }

    secondLevelCacheStatistics.clear();
    names = statistics.getSecondLevelCacheRegionNames();

    if (names != null && names.length > 0) {
        for (int i = 0; i < names.length; i++) {
            secondLevelCacheStatistics.put(names[i], statistics.getSecondLevelCacheStatistics(names[i]));
        }
    }
}

From source file:com.thoughtworks.go.server.service.support.HibernateInformationProvider.java

License:Apache License

@Override
public Map<String, Object> asJson() {
    LinkedHashMap<String, Object> json = new LinkedHashMap<>();
    Statistics statistics = sessionFactory.getStatistics();
    if (!statistics.isStatisticsEnabled()) {
        return json;
    }// www. j a  v a 2 s. c om
    json.put("EntityDeleteCount", statistics.getEntityDeleteCount());
    json.put("EntityInsertCount", statistics.getEntityInsertCount());
    json.put("EntityLoadCount", statistics.getEntityLoadCount());
    json.put("EntityFetchCount", statistics.getEntityFetchCount());
    json.put("EntityUpdateCount", statistics.getEntityUpdateCount());
    json.put("QueryExecutionCount", statistics.getQueryExecutionCount());
    json.put("QueryExecutionMaxTime", statistics.getQueryExecutionMaxTime());
    json.put("QueryExecutionMaxTimeQueryString", statistics.getQueryExecutionMaxTimeQueryString());
    json.put("QueryCacheHitCount", statistics.getQueryCacheHitCount());
    json.put("QueryCacheMissCount", statistics.getQueryCacheMissCount());
    json.put("QueryCachePutCount", statistics.getQueryCachePutCount());
    json.put("FlushCount", statistics.getFlushCount());
    json.put("ConnectCount", statistics.getConnectCount());
    json.put("SecondLevelCacheHitCount", statistics.getSecondLevelCacheHitCount());
    json.put("SecondLevelCacheMissCount", statistics.getSecondLevelCacheMissCount());
    json.put("SecondLevelCachePutCount", statistics.getSecondLevelCachePutCount());
    json.put("SessionCloseCount", statistics.getSessionCloseCount());
    json.put("SessionOpenCount", statistics.getSessionOpenCount());
    json.put("CollectionLoadCount", statistics.getCollectionLoadCount());
    json.put("CollectionFetchCount", statistics.getCollectionFetchCount());
    json.put("CollectionUpdateCount", statistics.getCollectionUpdateCount());
    json.put("CollectionRemoveCount", statistics.getCollectionRemoveCount());
    json.put("CollectionRecreateCount", statistics.getCollectionRecreateCount());
    json.put("StartTime", statistics.getStartTime());
    json.put("SecondLevelCacheRegionNames", statistics.getSecondLevelCacheRegionNames());
    json.put("SuccessfulTransactionCount", statistics.getSuccessfulTransactionCount());
    json.put("TransactionCount", statistics.getTransactionCount());
    json.put("PrepareStatementCount", statistics.getPrepareStatementCount());
    json.put("CloseStatementCount", statistics.getCloseStatementCount());
    json.put("OptimisticFailureCount", statistics.getOptimisticFailureCount());

    LinkedHashMap<String, Object> queryStats = new LinkedHashMap<>();
    json.put("Queries", queryStats);

    String[] queries = statistics.getQueries();
    for (String query : queries) {
        queryStats.put(query, statistics.getQueryStatistics(query));
    }

    LinkedHashMap<String, Object> entityStatistics = new LinkedHashMap<>();
    json.put("EntityStatistics", entityStatistics);

    String[] entityNames = statistics.getEntityNames();
    for (String entityName : entityNames) {
        entityStatistics.put(entityName, statistics.getEntityStatistics(entityName));
    }

    LinkedHashMap<String, Object> roleStatistics = new LinkedHashMap<>();
    json.put("RoleStatistics", roleStatistics);

    String[] roleNames = statistics.getCollectionRoleNames();
    for (String roleName : roleNames) {
        roleStatistics.put(roleName, statistics.getCollectionStatistics(roleName));
    }

    return json;
}

From source file:dao.proyectoHelper.java

public static void reportConeciones() {
    Statistics stats = HibernateUtil.getSessionFactory().getStatistics();
    stats.setStatisticsEnabled(true);/*from  ww  w .j  ava  2 s . c  om*/

    System.out.println("recuento de conexin: " + stats.getConnectCount());

    //Numero de transacciones completadas (falladas y satisfactorias)
    System.out.println("recuento Trx: " + stats.getTransactionCount());

    //Numero de transacciones completadas (solo satisfactorias)
    System.out.println("Succ trx count: " + stats.getSuccessfulTransactionCount());

    // Numero de sesiones que el codigo ha abierto
    System.out.println("sesiones abiertas: " + stats.getSessionOpenCount());

    // Numero de sesiones que el codigo ha cerrado
    System.out.println("sesiones  cerradas: " + stats.getSessionCloseCount());

    // Numero total de queries ejecutados
    System.out.println("No. queries: " + stats.getQueryExecutionCount());
    //            esta();
}

From source file:de.iew.framework.hibernate.statistics.StatisticsLogger.java

License:Apache License

public void logStatistics() {
    Statistics statistics = this.sessionFactory.getStatistics();
    statistics.setStatisticsEnabled(true);
    StringBuilder sb = new StringBuilder("\nStatistics");
    sb.append("\nCloseStatementCount: ").append(statistics.getCloseStatementCount());

    sb.append("\nEntityDeleteCount: ").append(statistics.getEntityDeleteCount());
    sb.append("\nEntityInsertCount: ").append(statistics.getEntityInsertCount());
    sb.append("\nEntityLoadCount: ").append(statistics.getEntityLoadCount());
    sb.append("\nEntityFetchCount: ").append(statistics.getEntityFetchCount());
    sb.append("\nEntityUpdateCount: ").append(statistics.getEntityUpdateCount());
    sb.append("\nQueryExecutionCount: ").append(statistics.getQueryExecutionCount());
    sb.append("\nQueryExecutionMaxTime: ").append(statistics.getQueryExecutionMaxTime());
    sb.append("\nQueryExecutionMaxTimeQueryString: ").append(statistics.getQueryExecutionMaxTimeQueryString());
    sb.append("\nQueryCacheHitCount: ").append(statistics.getQueryCacheHitCount());
    sb.append("\nQueryCacheMissCount: ").append(statistics.getQueryCacheMissCount());
    sb.append("\nQueryCachePutCount: ").append(statistics.getQueryCachePutCount());
    sb.append("\nNaturalIdQueryExecutionCount: ").append(statistics.getNaturalIdQueryExecutionCount());
    sb.append("\nNaturalIdQueryExecutionMaxTime: ").append(statistics.getNaturalIdQueryExecutionMaxTime());
    sb.append("\nNaturalIdQueryExecutionMaxTimeRegion: ")
            .append(statistics.getNaturalIdQueryExecutionMaxTimeRegion());
    sb.append("\nNaturalIdCacheHitCount: ").append(statistics.getNaturalIdCacheHitCount());
    sb.append("\nNaturalIdCacheMissCount: ").append(statistics.getNaturalIdCacheMissCount());
    sb.append("\nNaturalIdCachePutCount: ").append(statistics.getNaturalIdCachePutCount());
    sb.append("\nUpdateTimestampsCacheHitCount: ").append(statistics.getUpdateTimestampsCacheHitCount());
    sb.append("\nUpdateTimestampsCacheMissCount: ").append(statistics.getUpdateTimestampsCacheMissCount());
    sb.append("\nUpdateTimestampsCachePutCount: ").append(statistics.getUpdateTimestampsCachePutCount());
    sb.append("\nFlushCount: ").append(statistics.getFlushCount());
    sb.append("\nConnectCount: ").append(statistics.getConnectCount());
    sb.append("\nSecondLevelCacheHitCount: ").append(statistics.getSecondLevelCacheHitCount());
    sb.append("\nSecondLevelCacheMissCount: ").append(statistics.getSecondLevelCacheMissCount());
    sb.append("\nSecondLevelCachePutCount: ").append(statistics.getSecondLevelCachePutCount());
    sb.append("\nSessionCloseCount: ").append(statistics.getSessionCloseCount());
    sb.append("\nSessionOpenCount: ").append(statistics.getSessionOpenCount());
    sb.append("\nCollectionLoadCount: ").append(statistics.getCollectionLoadCount());
    sb.append("\nCollectionFetchCount: ").append(statistics.getCollectionFetchCount());
    sb.append("\nCollectionUpdateCount: ").append(statistics.getCollectionUpdateCount());
    sb.append("\nCollectionRemoveCount: ").append(statistics.getCollectionRemoveCount());
    sb.append("\nCollectionRecreateCount: ").append(statistics.getCollectionRecreateCount());
    sb.append("\nStartTime: ").append(statistics.getStartTime());
    sb.append("\nQueries: ").append(statistics.getQueries());
    sb.append("\nEntityNames: ").append(statistics.getEntityNames());
    sb.append("\nCollectionRoleNames: ").append(statistics.getCollectionRoleNames());
    sb.append("\nSecondLevelCacheRegionNames: ").append(statistics.getSecondLevelCacheRegionNames());
    sb.append("\nSuccessfulTransactionCount: ").append(statistics.getSuccessfulTransactionCount());
    sb.append("\nTransactionCount: ").append(statistics.getTransactionCount());
    sb.append("\nPrepareStatementCount: ").append(statistics.getPrepareStatementCount());
    sb.append("\nCloseStatementCount: ").append(statistics.getCloseStatementCount());
    sb.append("\nOptimisticFailureCount: ").append(statistics.getOptimisticFailureCount());

    if (log.isDebugEnabled()) {
        log.debug(sb);//www  . j  a  v  a 2  s.  c  o m
    }

}

From source file:es.ua.datos.cad.CAD.java

public void writeStatisticsLog(Statistics stats) {

    // Number of connection requests. Note that this number represents 
    // the number of times Hibernate asked for a connection, and 
    // NOT the number of connections (which is determined by your 
    // pooling mechanism).
    Date date = new Date();
    System.out.println("HORA: " + date);
    System.out.println("getConnectCount(): " + stats.getConnectCount());
    // Number of flushes done on the session (either by client code or 
    // by hibernate).
    System.out.println("getFlushCount(): " + stats.getFlushCount());
    // The number of completed transactions (failed and successful).
    System.out.println("getTransactionCount(): " + stats.getTransactionCount());
    // The number of transactions completed without failure
    System.out.println("getSuccessfulTransactionCount(): " + stats.getSuccessfulTransactionCount());
    // The number of sessions your code has opened.
    System.out.println("getSessionOpenCount(): " + stats.getSessionOpenCount());
    // The number of sessions your code has closed.
    System.out.println("getSessionCloseCount(): " + stats.getSessionCloseCount());
    // All of the queries that have executed.
    System.out.println("getQueries(): " + stats.getQueries());
    // Total number of queries executed.
    System.out.println("getQueryExecutionCount(): " + stats.getQueryExecutionCount());
    // Time of the slowest query executed.
    System.out.println("getQueryExecutionMaxTime(): " + stats.getQueryExecutionMaxTime());
}

From source file:net.firejack.platform.processor.statistics.StatisticsProcessor.java

License:Apache License

@Scheduled(cron = "0 0/5 * * * *")
public void schedulerStatisticsHandler() {
    if (templates != null) {
        for (HibernateTemplate template : templates) {
            SessionFactory sessionFactory = template.getSessionFactory();
            Statistics statistics = sessionFactory.getStatistics();
            if (statistics.isStatisticsEnabled()) {
                LogTransaction logTransaction = new LogTransaction();
                logTransaction.setPackageLookup(OpenFlameSecurityConstants.getPackageLookup());
                logTransaction.setTransactions(statistics.getSuccessfulTransactionCount());
                logTransaction.setEntitiesLoaded(statistics.getEntityLoadCount());
                logTransaction.setEntitiesInserted(statistics.getEntityInsertCount());
                logTransaction.setEntitiesUpdated(statistics.getEntityUpdateCount());
                logTransaction.setEntitiesDeleted(statistics.getEntityDeleteCount());
                logTransaction.setEntitiesFetched(statistics.getEntityFetchCount());
                logTransaction.setCollectionsLoaded(statistics.getCollectionLoadCount());
                logTransaction.setCollectionsRecreated(statistics.getCollectionRecreateCount());
                logTransaction.setCollectionsUpdated(statistics.getCollectionUpdateCount());
                logTransaction.setCollectionsRemoved(statistics.getCollectionRemoveCount());
                logTransaction.setCollectionsFetched(statistics.getCollectionFetchCount());
                logTransaction.setMaxQueryTime(statistics.getQueryExecutionMaxTime());

                Date hourlyDate = new Date();
                logTransaction.setHourPeriod(DateUtils.truncate(hourlyDate, Calendar.HOUR).getTime());
                logTransaction.setDayPeriod(DateUtils.truncate(hourlyDate, Calendar.DAY_OF_MONTH).getTime());
                logTransaction.setWeekPeriod(DateUtils.truncateDateToWeek(hourlyDate).getTime());
                logTransaction.setMonthPeriod(DateUtils.truncate(hourlyDate, Calendar.MONTH).getTime());

                OPFEngine.StatisticsService.saveLogTransaction(logTransaction);
                statistics.clear();/*from  w  ww. jav a  2  s.c om*/
            } else {
                logger.warn("Hibernate Statistics is disabled.");
            }
        }
    }
}

From source file:org.beangle.ems.dev.hibernate.web.action.CacheAction.java

License:Open Source License

public String index() {
    Statistics statistics = sessionFactory.getStatistics();
    Date lastUpdate = new Date();
    Date activation = null;/*from   ww w .  ja v a  2 s  .  co m*/
    Date deactivation = null;

    List<Long> generalStatistics = CollectUtils.newArrayList(18);
    final String action = get("do");
    final StringBuilder info = new StringBuilder(512);

    if ("activate".equals(action) && !statistics.isStatisticsEnabled()) {
        statistics.setStatisticsEnabled(true);
        activation = new Date();
        getSession().put("hibernate.stat.activation", activation);
        getSession().remove("hibernate.stat.deactivation");
        info.append("Statistics enabled\n");
    } else if ("deactivate".equals(action) && statistics.isStatisticsEnabled()) {
        statistics.setStatisticsEnabled(false);
        deactivation = new Date();
        getSession().put("hibernate.stat.deactivation", deactivation);
        activation = (Date) getSession().get("hibernate.stat.activation");
        info.append("Statistics disabled\n");
    } else if ("clear".equals(action)) {
        activation = null;
        deactivation = null;
        statistics.clear();
        getSession().remove("hibernate.stat.activation");
        getSession().remove("hibernate.stat.deactivation");
        generalStatistics.clear();
        info.append("Statistics cleared\n");
    } else {
        activation = (Date) getSession().get("hibernate.stat.activation");
        deactivation = (Date) getSession().get("hibernate.stat.deactivation");
    }

    if (info.length() > 0)
        addMessage(info.toString());

    boolean active = statistics.isStatisticsEnabled();
    if (active) {
        generalStatistics.add(statistics.getConnectCount());
        generalStatistics.add(statistics.getFlushCount());

        generalStatistics.add(statistics.getPrepareStatementCount());
        generalStatistics.add(statistics.getCloseStatementCount());

        generalStatistics.add(statistics.getSessionCloseCount());
        generalStatistics.add(statistics.getSessionOpenCount());

        generalStatistics.add(statistics.getTransactionCount());
        generalStatistics.add(statistics.getSuccessfulTransactionCount());
        generalStatistics.add(statistics.getOptimisticFailureCount());
    }
    put("active", active);
    put("lastUpdate", lastUpdate);
    if (null != activation) {
        if (null != deactivation) {
            put("duration", deactivation.getTime() - activation.getTime());
        } else {
            put("duration", lastUpdate.getTime() - activation.getTime());
        }
    }
    put("activation", activation);
    put("deactivation", deactivation);
    put("generalStatistics", generalStatistics);
    return forward();
}

From source file:org.bedework.calcore.hibernate.DbStatistics.java

License:Apache License

/** Get the current statistics
 *
 * @param dbStats//www.  ja  v a2  s. c  om
 * @return Collection
 */
public static Collection<StatsEntry> getStats(Statistics dbStats) {
    /* XXX this ought to be property driven to some extent. The cache stats in
     * particular.
     */
    ArrayList<StatsEntry> al = new ArrayList<StatsEntry>();

    if (dbStats == null) {
        return al;
    }

    al.add(new StatsEntry("Database statistics"));

    al.add(new StatsEntry("Number of connection requests", dbStats.getConnectCount()));
    al.add(new StatsEntry("Session flushes", dbStats.getFlushCount()));
    al.add(new StatsEntry("Transactions", dbStats.getTransactionCount()));
    al.add(new StatsEntry("Successful transactions", dbStats.getSuccessfulTransactionCount()));
    al.add(new StatsEntry("Sessions opened", dbStats.getSessionOpenCount()));
    al.add(new StatsEntry("Sessions closed", dbStats.getSessionCloseCount()));
    al.add(new StatsEntry("Queries executed", dbStats.getQueryExecutionCount()));
    al.add(new StatsEntry("Max query time", dbStats.getQueryExecutionMaxTime()));
    al.add(new StatsEntry("Max time query", dbStats.getQueryExecutionMaxTimeQueryString()));

    al.add(new StatsEntry("Collection statistics"));

    al.add(new StatsEntry("Collections fetched", dbStats.getCollectionFetchCount()));
    al.add(new StatsEntry("Collections loaded", dbStats.getCollectionLoadCount()));
    al.add(new StatsEntry("Collections rebuilt", dbStats.getCollectionRecreateCount()));
    al.add(new StatsEntry("Collections batch deleted", dbStats.getCollectionRemoveCount()));
    al.add(new StatsEntry("Collections batch updated", dbStats.getCollectionUpdateCount()));

    al.add(new StatsEntry("Object statistics"));

    al.add(new StatsEntry("Objects fetched", dbStats.getEntityFetchCount()));
    al.add(new StatsEntry("Objects loaded", dbStats.getEntityLoadCount()));
    al.add(new StatsEntry("Objects inserted", dbStats.getEntityInsertCount()));
    al.add(new StatsEntry("Objects deleted", dbStats.getEntityDeleteCount()));
    al.add(new StatsEntry("Objects updated", dbStats.getEntityUpdateCount()));

    al.add(new StatsEntry("Cache statistics"));

    double chit = dbStats.getQueryCacheHitCount();
    double cmiss = dbStats.getQueryCacheMissCount();

    al.add(new StatsEntry("Cache hit count", chit));
    al.add(new StatsEntry("Cache miss count", cmiss));
    al.add(new StatsEntry("Cache hit ratio", chit / (chit + cmiss)));

    entityStats(al, dbStats, BwCalendar.class);
    entityStats(al, dbStats, BwEventObj.class);
    entityStats(al, dbStats, BwEventAnnotation.class);
    entityStats(al, dbStats, BwCategory.class);
    entityStats(al, dbStats, BwLocation.class);
    entityStats(al, dbStats, BwContact.class);
    entityStats(al, dbStats, BwUser.class);

    collectionStats(al, dbStats, BwCalendar.class, "children");

    collectionStats(al, dbStats, BwEventObj.class, "attendees");
    collectionStats(al, dbStats, BwEventObj.class, "categories");
    collectionStats(al, dbStats, BwEventObj.class, "descriptions");
    collectionStats(al, dbStats, BwEventObj.class, "summaries");

    collectionStats(al, dbStats, BwEventObj.class, "rrules");
    collectionStats(al, dbStats, BwEventObj.class, "rdates");
    collectionStats(al, dbStats, BwEventObj.class, "exdates");

    collectionStats(al, dbStats, BwEventAnnotation.class, "attendees");
    collectionStats(al, dbStats, BwEventAnnotation.class, "categories");
    collectionStats(al, dbStats, BwEventAnnotation.class, "descriptions");
    collectionStats(al, dbStats, BwEventAnnotation.class, "summaries");

    collectionStats(al, dbStats, BwEventAnnotation.class, "rrules");
    collectionStats(al, dbStats, BwEventAnnotation.class, "rdates");
    collectionStats(al, dbStats, BwEventAnnotation.class, "exdates");

    String[] qs = dbStats.getQueries();

    for (String q : qs) {
        queryStats(al, dbStats, q);
    }

    String[] slcrn = dbStats.getSecondLevelCacheRegionNames();

    for (String s : slcrn) {
        secondLevelStats(al, dbStats, s);
    }

    return al;
}