| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more contributor license |
| * agreements. See the NOTICE file distributed with this work for additional information regarding |
| * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance with the License. You may obtain a |
| * copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software distributed under the License |
| * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express |
| * or implied. See the License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package org.apache.geode.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 org.apache.geode.management.internal.FederationComponent; |
| |
| 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); |
| } |
| } |