gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/beans/stats/MemberClusterStatsMonitor.java

/*
 * ========================================================================
 *  Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
 *  This product is protected by U.S. and international copyright
 *  and intellectual property laws. Pivotal products are covered by
 *  more patents listed at http://www.pivotal.io/patents.
 * ========================================================================
 */
package com.gemstone.gemfire.management.internal.beans.stats;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

import com.gemstone.gemfire.management.internal.FederationComponent;

/**
 *
 * @author rishim
 *
 */
public class MemberClusterStatsMonitor {


  private static final String SYSTEM_DISK_STORE_COUNT = "DiskStores";

  private static final String DISK_READS_RATE = "DiskReadsRate";

  private static final String DISK_WRITES_RATE = "DiskWritesRate";

  private static final String DISK_FLUSH_AVG_LATENCY = "DiskFlushAvgLatency";

  private static final String TOTAL_BACKUP_IN_PROGRESS = "TotalBackupInProgress";

  private static final String TOTAL_HIT_COUNT = "TotalHitCount";

  private static final String TOTAL_MISS_COUNT = "TotalMissCount";

  private static final String NUM_INITIAL_IMAGE_IN_PROGRESSS = "numInitialImagesInProgress";

  private static final String TOTAL_DISK_USAGE = "TotalDiskUsage";

  private static final String NUM_RUNNING_FUNCTIONS = "NumRunningFunctions";

  private static final String AVERAGE_READS = "AverageReads";

  private static final String AVERAGE_WRITES = "AverageWrites";

  private static final String GARBAGE_COLL_COUNT = "GarbageCollectionCount";

  private static final String JVM_PAUSES = "JVMPauses";
  
  private static final String OFF_HEAP_MAX_MEMORY = "OffHeapMaxMemory";
  
  private static final String OFF_HEAP_USED_MEMORY = "OffHeapUsedMemory";
  
  private static final String OFF_HEAP_FREE_MEMORY = "OffHeapFreeMemory";
  
  private static final String TXN_COMMITTED_TOTAL_COUNT = "TransactionCommittedTotalCount";
  
  private static final String TXN_ROLLEDBACK_TOTAL_COUNT = "TransactionRolledBackTotalCount";

  private static final String MAX_MEMORY = "MaxMemory";
  
  private static final String USED_MEMORY = "UsedMemory";
  
  private static final String FREE_MEMORY = "FreeMemory";
  
  private AtomicInteger systemDiskStoreCount = new AtomicInteger(0);  
  
  private StatsAggregator aggregator;
  
  private IntegerStatsDeltaAggregator deltas;

  private Map<String, Class<?>> typeMap;

  public void aggregate(FederationComponent newState,
      FederationComponent oldState) {
    aggregator.aggregate(newState, oldState);
    // Special Aggregations
    incSystemDiskStoreCount(newState, oldState);
    deltas.aggregate(newState,oldState);
  }

  public MemberClusterStatsMonitor() {
    this.typeMap = new HashMap<String, Class<?>>();
    intTypeMap();
    this.aggregator = new StatsAggregator(typeMap);
    
    List<String> keysList = new ArrayList<String>();
    keysList.add(TXN_COMMITTED_TOTAL_COUNT);
    keysList.add(TXN_ROLLEDBACK_TOTAL_COUNT);
    deltas = new IntegerStatsDeltaAggregator(keysList);
  }

  private void intTypeMap() {
    typeMap.put(DISK_FLUSH_AVG_LATENCY, Long.TYPE);
    typeMap.put(DISK_READS_RATE, Float.TYPE);
    typeMap.put(DISK_WRITES_RATE, Float.TYPE);
    typeMap.put(TOTAL_BACKUP_IN_PROGRESS, Integer.TYPE);
    typeMap.put(TOTAL_HIT_COUNT, Integer.TYPE);
    typeMap.put(TOTAL_MISS_COUNT, Integer.TYPE);
    typeMap.put(NUM_INITIAL_IMAGE_IN_PROGRESSS, Integer.TYPE);
    typeMap.put(TOTAL_DISK_USAGE, Long.TYPE);
    typeMap.put(NUM_RUNNING_FUNCTIONS, Integer.TYPE);
    typeMap.put(AVERAGE_READS, Float.TYPE);
    typeMap.put(AVERAGE_WRITES, Float.TYPE);
    typeMap.put(GARBAGE_COLL_COUNT, Long.TYPE);
    typeMap.put(JVM_PAUSES, Long.TYPE);
    typeMap.put(MAX_MEMORY, Long.TYPE);
    typeMap.put(USED_MEMORY, Long.TYPE);
    typeMap.put(FREE_MEMORY, Long.TYPE);
    typeMap.put(OFF_HEAP_MAX_MEMORY, Long.TYPE);
    typeMap.put(OFF_HEAP_USED_MEMORY, Long.TYPE);
    typeMap.put(OFF_HEAP_FREE_MEMORY, Long.TYPE);
  }

  public float getDiskReadsRate() {
    return aggregator.getFloatValue(DISK_READS_RATE);
  }

  public float getDiskWritesRate() {
    return aggregator.getFloatValue(DISK_WRITES_RATE);
  }

  public long getDiskFlushAvgLatency() {
    return aggregator.getLongValue(DISK_FLUSH_AVG_LATENCY);
  }

  public int getSystemDiskStoreCount() {
    return systemDiskStoreCount.get();
  }

  public int getTotalBackupInProgress() {
    return aggregator.getIntValue(TOTAL_BACKUP_IN_PROGRESS);
  }

  public long getTotalHeapSize() {
    return getMaxMemory();
  }

  public int getTotalHitCount() {
    return aggregator.getIntValue(TOTAL_HIT_COUNT);
  }

  public int getTotalMissCount() {
    return aggregator.getIntValue(TOTAL_MISS_COUNT);
  }

  public int getNumInitialImagesInProgress() {
    return aggregator.getIntValue(NUM_INITIAL_IMAGE_IN_PROGRESSS);
  }

  public void incSystemDiskStoreCount(FederationComponent newState, FederationComponent oldState) {
    if (oldState != null) {
      if (oldState.getValue(SYSTEM_DISK_STORE_COUNT) != null) {
        String[] diskStores = (String[]) oldState.getValue(SYSTEM_DISK_STORE_COUNT);
        if (diskStores != null) {
          systemDiskStoreCount.addAndGet(-diskStores.length);// Used Atomic
                                                             // Integer to avoid
                                                             // race condition
                                                             // between
                                                             // different
                                                             // members

        }

      }

    }
    if (newState != null) {
      if (newState.getValue(SYSTEM_DISK_STORE_COUNT) != null) {
        String[] diskStores = (String[]) newState.getValue(SYSTEM_DISK_STORE_COUNT);
        if (diskStores != null) {
            systemDiskStoreCount.addAndGet(diskStores.length);// Used Atomic
                                                              // Integer to
                                                              // avoid race
                                                              // condition
                                                              // between
                                                              // different
                                                              // members

        }
      }
    }

  }
  

  public int getNumRunningFunctions() {
    return aggregator.getIntValue(NUM_RUNNING_FUNCTIONS);
  }

  public long getTotalDiskUsage() {
    return aggregator.getLongValue(TOTAL_DISK_USAGE);
  }

  public float getAverageReads() {
    return aggregator.getFloatValue(AVERAGE_READS);
  }

  public float getAverageWrites() {
    return aggregator.getFloatValue(AVERAGE_WRITES);
  }

  public long getUsedHeapSize() {
    return getUsedMemory();
  }

  public long getGarbageCollectionCount() {
    return aggregator.getLongValue(GARBAGE_COLL_COUNT);
  }

  public long getJVMPauses() {
    return aggregator.getLongValue(JVM_PAUSES);
  }
  
  public long getOffHeapFreeMemory() {
    return aggregator.getLongValue(OFF_HEAP_FREE_MEMORY);
  }

  public long getOffHeapUsedMemory() {
    return aggregator.getLongValue(OFF_HEAP_USED_MEMORY);
  }
  
  public int getTransactionCommitted() {
    return deltas.getDelta(TXN_COMMITTED_TOTAL_COUNT);
  }

  public int getTransactionRolledBack() {
    return deltas.getDelta(TXN_ROLLEDBACK_TOTAL_COUNT);
  }

  public long getMaxMemory() {
    return aggregator.getLongValue(MAX_MEMORY);
  }
  
  public long getFreeMemory() {
    return aggregator.getLongValue(FREE_MEMORY);
  }
  
  public long getUsedMemory() {
    return aggregator.getLongValue(USED_MEMORY);
  }
}