You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by rv...@apache.org on 2015/04/28 23:40:18 UTC
[13/51] [partial] incubator-geode git commit: Init
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/19459053/gemfire-core/src/main/java/com/gemstone/gemfire/cache/client/internal/ConnectionStats.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/cache/client/internal/ConnectionStats.java b/gemfire-core/src/main/java/com/gemstone/gemfire/cache/client/internal/ConnectionStats.java
new file mode 100644
index 0000000..d324db8
--- /dev/null
+++ b/gemfire-core/src/main/java/com/gemstone/gemfire/cache/client/internal/ConnectionStats.java
@@ -0,0 +1,3283 @@
+/*=========================================================================
+ * 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.cache.client.internal;
+
+import com.gemstone.gemfire.StatisticDescriptor;
+import com.gemstone.gemfire.Statistics;
+import com.gemstone.gemfire.StatisticsFactory;
+import com.gemstone.gemfire.StatisticsType;
+import com.gemstone.gemfire.StatisticsTypeFactory;
+import com.gemstone.gemfire.distributed.internal.DistributionStats;
+import com.gemstone.gemfire.internal.StatisticsTypeFactoryImpl;
+import com.gemstone.gemfire.internal.cache.PoolStats;
+import com.gemstone.gemfire.internal.cache.tier.sockets.MessageStats;
+
+/**
+ * Stats for a client to server {@link Connection}
+ * @author darrel
+ * @since 5.7
+ */
+public class ConnectionStats implements MessageStats {
+ // static fields
+ private static final StatisticsType type;
+ private static final StatisticsType sendType;
+
+ ///////////////////////////////////////////////////////////////////////
+ /*
+ private final static int opInProgressId;
+ private final static int opSendInProgressId;
+ private final static int opSendFailedId;
+ private final static int opSendId;
+ private final static int opSendDurationId;
+ private final static int opTimedOutId;
+ private final static int opFailedId;
+ private final static int opId;
+ private final static int opDurationId;
+ */
+ ///////////////////////////////////////////////////////////////////////
+
+ private final static int getInProgressId;
+ private final static int getSendInProgressId;
+ private final static int getSendFailedId;
+ private final static int getSendId;
+ private final static int getSendDurationId;
+ private final static int getTimedOutId;
+ private final static int getFailedId;
+ private final static int getId;
+ private final static int getDurationId;
+
+ private final static int putInProgressId;
+ private final static int putSendInProgressId;
+ private final static int putSendFailedId;
+ private final static int putSendId;
+ private final static int putSendDurationId;
+ private final static int putTimedOutId;
+ private final static int putFailedId;
+ private final static int putId;
+ private final static int putDurationId;
+
+ private final static int destroyInProgressId;
+ private final static int destroySendInProgressId;
+ private final static int destroySendFailedId;
+ private final static int destroySendId;
+ private final static int destroySendDurationId;
+ private final static int destroyTimedOutId;
+ private final static int destroyFailedId;
+ private final static int destroyId;
+ private final static int destroyDurationId;
+
+ private final static int destroyRegionInProgressId;
+ private final static int destroyRegionSendInProgressId;
+ private final static int destroyRegionSendFailedId;
+ private final static int destroyRegionSendId;
+ private final static int destroyRegionSendDurationId;
+ private final static int destroyRegionTimedOutId;
+ private final static int destroyRegionFailedId;
+ private final static int destroyRegionId;
+ private final static int destroyRegionDurationId;
+
+ private final static int clearInProgressId;
+ private final static int clearSendInProgressId;
+ private final static int clearSendFailedId;
+ private final static int clearSendId;
+ private final static int clearSendDurationId;
+ private final static int clearTimedOutId;
+ private final static int clearFailedId;
+ private final static int clearId;
+ private final static int clearDurationId;
+
+ private final static int containsKeyInProgressId;
+ private final static int containsKeySendInProgressId;
+ private final static int containsKeySendFailedId;
+ private final static int containsKeySendId;
+ private final static int containsKeySendDurationId;
+ private final static int containsKeyTimedOutId;
+ private final static int containsKeyFailedId;
+ private final static int containsKeyId;
+ private final static int containsKeyDurationId;
+
+ private final static int keySetInProgressId;
+ private final static int keySetSendInProgressId;
+ private final static int keySetSendFailedId;
+ private final static int keySetSendId;
+ private final static int keySetSendDurationId;
+ private final static int keySetTimedOutId;
+ private final static int keySetFailedId;
+ private final static int keySetId;
+ private final static int keySetDurationId;
+
+ private final static int commitInProgressId;
+ private final static int commitSendInProgressId;
+ private final static int commitSendFailedId;
+ private final static int commitSendId;
+ private final static int commitSendDurationId;
+
+ private final static int commitFailedId;
+ private final static int commitTimedOutId;
+ private final static int commitId;
+ private final static int commitDurationId;
+
+ private final static int rollbackInProgressId;
+ private final static int rollbackSendInProgressId;
+ private final static int rollbackSendFailedId;
+ private final static int rollbackSendId;
+ private final static int rollbackSendDurationId;
+
+ private final static int rollbackFailedId;
+ private final static int rollbackTimedOutId;
+ private final static int rollbackId;
+ private final static int rollbackDurationId;
+
+ private final static int getEntryInProgressId;
+ private final static int getEntrySendInProgressId;
+ private final static int getEntrySendFailedId;
+ private final static int getEntrySendId;
+ private final static int getEntrySendDurationId;
+
+ private final static int getEntryFailedId;
+ private final static int getEntryTimedOutId;
+ private final static int getEntryId;
+ private final static int getEntryDurationId;
+
+ private final static int txSynchronizationInProgressId;
+ private final static int txSynchronizationSendInProgressId;
+ private final static int txSynchronizationSendFailedId;
+ private final static int txSynchronizationSendId;
+ private final static int txSynchronizationSendDurationId;
+
+ private final static int txSynchronizationFailedId;
+ private final static int txSynchronizationTimedOutId;
+ private final static int txSynchronizationId;
+ private final static int txSynchronizationDurationId;
+
+ private final static int txFailoverInProgressId;
+ private final static int txFailoverSendInProgressId;
+ private final static int txFailoverSendFailedId;
+ private final static int txFailoverSendId;
+ private final static int txFailoverSendDurationId;
+
+ private final static int txFailoverFailedId;
+ private final static int txFailoverTimedOutId;
+ private final static int txFailoverId;
+ private final static int txFailoverDurationId;
+
+ private final static int sizeInProgressId;
+ private final static int sizeSendInProgressId;
+ private final static int sizeSendFailedId;
+ private final static int sizeSendId;
+ private final static int sizeSendDurationId;
+
+ private final static int sizeFailedId;
+ private final static int sizeTimedOutId;
+ private final static int sizeId;
+ private final static int sizeDurationId;
+
+ private final static int invalidateInProgressId;
+ private final static int invalidateSendInProgressId;
+ private final static int invalidateSendFailedId;
+ private final static int invalidateSendId;
+ private final static int invalidateSendDurationId;
+
+ private final static int invalidateFailedId;
+ private final static int invalidateTimedOutId;
+ private final static int invalidateId;
+ private final static int invalidateDurationId;
+
+
+ private final static int registerInterestInProgressId;
+ private final static int registerInterestSendInProgressId;
+ private final static int registerInterestSendFailedId;
+ private final static int registerInterestSendId;
+ private final static int registerInterestSendDurationId;
+ private final static int registerInterestTimedOutId;
+ private final static int registerInterestFailedId;
+ private final static int registerInterestId;
+ private final static int registerInterestDurationId;
+
+ private final static int unregisterInterestInProgressId;
+ private final static int unregisterInterestSendInProgressId;
+ private final static int unregisterInterestSendFailedId;
+ private final static int unregisterInterestSendId;
+ private final static int unregisterInterestSendDurationId;
+ private final static int unregisterInterestTimedOutId;
+ private final static int unregisterInterestFailedId;
+ private final static int unregisterInterestId;
+ private final static int unregisterInterestDurationId;
+
+ private final static int queryInProgressId;
+ private final static int querySendInProgressId;
+ private final static int querySendFailedId;
+ private final static int querySendId;
+ private final static int querySendDurationId;
+ private final static int queryTimedOutId;
+ private final static int queryFailedId;
+ private final static int queryId;
+ private final static int queryDurationId;
+
+ private final static int createCQInProgressId;
+ private final static int createCQSendInProgressId;
+ private final static int createCQSendFailedId;
+ private final static int createCQSendId;
+ private final static int createCQSendDurationId;
+ private final static int createCQTimedOutId;
+ private final static int createCQFailedId;
+ private final static int createCQId;
+ private final static int createCQDurationId;
+ private final static int stopCQInProgressId;
+ private final static int stopCQSendInProgressId;
+ private final static int stopCQSendFailedId;
+ private final static int stopCQSendId;
+ private final static int stopCQSendDurationId;
+ private final static int stopCQTimedOutId;
+ private final static int stopCQFailedId;
+ private final static int stopCQId;
+ private final static int stopCQDurationId;
+ private final static int closeCQInProgressId;
+ private final static int closeCQSendInProgressId;
+ private final static int closeCQSendFailedId;
+ private final static int closeCQSendId;
+ private final static int closeCQSendDurationId;
+ private final static int closeCQTimedOutId;
+ private final static int closeCQFailedId;
+ private final static int closeCQId;
+ private final static int closeCQDurationId;
+ private final static int gatewayBatchInProgressId;
+ private final static int gatewayBatchSendInProgressId;
+ private final static int gatewayBatchSendFailedId;
+ private final static int gatewayBatchSendId;
+ private final static int gatewayBatchSendDurationId;
+ private final static int gatewayBatchTimedOutId;
+ private final static int gatewayBatchFailedId;
+ private final static int gatewayBatchId;
+ private final static int gatewayBatchDurationId;
+ private final static int getDurableCQsInProgressId;
+ private final static int getDurableCQsSendsInProgressId;
+ private final static int getDurableCQsSendFailedId;
+ private final static int getDurableCQsSendId;
+ private final static int getDurableCQsSendDurationId;
+ private final static int getDurableCQsTimedOutId;
+ private final static int getDurableCQsFailedId;
+ private final static int getDurableCQsId;
+ private final static int getDurableCQsDurationId;
+
+ private final static int readyForEventsInProgressId;
+ private final static int readyForEventsSendInProgressId;
+ private final static int readyForEventsSendFailedId;
+ private final static int readyForEventsSendId;
+ private final static int readyForEventsSendDurationId;
+ private final static int readyForEventsTimedOutId;
+ private final static int readyForEventsFailedId;
+ private final static int readyForEventsId;
+ private final static int readyForEventsDurationId;
+
+ private final static int makePrimaryInProgressId;
+ private final static int makePrimarySendInProgressId;
+ private final static int makePrimarySendFailedId;
+ private final static int makePrimarySendId;
+ private final static int makePrimarySendDurationId;
+ private final static int makePrimaryTimedOutId;
+ private final static int makePrimaryFailedId;
+ private final static int makePrimaryId;
+ private final static int makePrimaryDurationId;
+
+ private final static int closeConInProgressId;
+ private final static int closeConSendInProgressId;
+ private final static int closeConSendFailedId;
+ private final static int closeConSendId;
+ private final static int closeConSendDurationId;
+ private final static int closeConTimedOutId;
+ private final static int closeConFailedId;
+ private final static int closeConId;
+ private final static int closeConDurationId;
+
+ private final static int primaryAckInProgressId;
+ private final static int primaryAckSendInProgressId;
+ private final static int primaryAckSendFailedId;
+ private final static int primaryAckSendId;
+ private final static int primaryAckSendDurationId;
+ private final static int primaryAckTimedOutId;
+ private final static int primaryAckFailedId;
+ private final static int primaryAckId;
+ private final static int primaryAckDurationId;
+
+ private final static int pingInProgressId;
+ private final static int pingSendInProgressId;
+ private final static int pingSendFailedId;
+ private final static int pingSendId;
+ private final static int pingSendDurationId;
+ private final static int pingTimedOutId;
+ private final static int pingFailedId;
+ private final static int pingId;
+ private final static int pingDurationId;
+
+ private final static int registerInstantiatorsInProgressId;
+ private final static int registerInstantiatorsSendInProgressId;
+ private final static int registerInstantiatorsSendFailedId;
+ private final static int registerInstantiatorsSendId;
+ private final static int registerInstantiatorsSendDurationId;
+ private final static int registerInstantiatorsTimedOutId;
+ private final static int registerInstantiatorsFailedId;
+ private final static int registerInstantiatorsId;
+ private final static int registerInstantiatorsDurationId;
+
+ private final static int registerDataSerializersInProgressId;
+ private final static int registerDataSerializersSendInProgressId;
+ private final static int registerDataSerializersSendFailedId;
+ private final static int registerDataSerializersSendId;
+ private final static int registerDataSerializersSendDurationId;
+ private final static int registerDataSerializersTimedOutId;
+ private final static int registerDataSerializersFailedId;
+ private final static int registerDataSerializersId;
+ private final static int registerDataSerializersDurationId;
+
+ private final static int putAllInProgressId;
+ private final static int putAllSendInProgressId;
+ private final static int putAllSendFailedId;
+ private final static int putAllSendId;
+ private final static int putAllSendDurationId;
+ private final static int putAllTimedOutId;
+ private final static int putAllFailedId;
+ private final static int putAllId;
+ private final static int putAllDurationId;
+
+ private final static int removeAllInProgressId;
+ private final static int removeAllSendInProgressId;
+ private final static int removeAllSendFailedId;
+ private final static int removeAllSendId;
+ private final static int removeAllSendDurationId;
+ private final static int removeAllTimedOutId;
+ private final static int removeAllFailedId;
+ private final static int removeAllId;
+ private final static int removeAllDurationId;
+
+ private final static int getAllInProgressId;
+ private final static int getAllSendInProgressId;
+ private final static int getAllSendFailedId;
+ private final static int getAllSendId;
+ private final static int getAllSendDurationId;
+ private final static int getAllTimedOutId;
+ private final static int getAllFailedId;
+ private final static int getAllId;
+ private final static int getAllDurationId;
+
+ private final static int connectionsId;
+ private final static int connectsId;
+ private final static int disconnectsId;
+ private final static int messagesBeingReceivedId;
+ private final static int messageBytesBeingReceivedId;
+ private final static int receivedBytesId;
+ private final static int sentBytesId;
+
+ private final static int executeFunctionInProgressId;
+ private final static int executeFunctionSendInProgressId;
+ private final static int executeFunctionSendFailedId;
+ private final static int executeFunctionSendId;
+ private final static int executeFunctionSendDurationId;
+ private final static int executeFunctionTimedOutId;
+ private final static int executeFunctionFailedId;
+ private final static int executeFunctionId;
+ private final static int executeFunctionDurationId;
+
+ private final static int getClientPRMetadataInProgressId;
+ private final static int getClientPRMetadataSendInProgressId;
+ private final static int getClientPRMetadataSendFailedId;
+ private final static int getClientPRMetadataSendId;
+ private final static int getClientPRMetadataSendDurationId;
+ private final static int getClientPRMetadataTimedOutId;
+ private final static int getClientPRMetadataFailedId;
+ private final static int getClientPRMetadataId;
+ private final static int getClientPRMetadataDurationId;
+
+ private final static int getClientPartitionAttributesInProgressId;
+ private final static int getClientPartitionAttributesSendInProgressId;
+ private final static int getClientPartitionAttributesSendFailedId;
+ private final static int getClientPartitionAttributesSendId;
+ private final static int getClientPartitionAttributesSendDurationId;
+ private final static int getClientPartitionAttributesTimedOutId;
+ private final static int getClientPartitionAttributesFailedId;
+ private final static int getClientPartitionAttributesId;
+ private final static int getClientPartitionAttributesDurationId;
+
+ private final static int getPDXIdForTypeInProgressId;
+ private final static int getPDXIdForTypeSendInProgressId;
+ private final static int getPDXIdForTypeSendFailedId;
+ private final static int getPDXIdForTypeSendId;
+ private final static int getPDXIdForTypeSendDurationId;
+ private final static int getPDXIdForTypeTimedOutId;
+ private final static int getPDXIdForTypeFailedId;
+ private final static int getPDXIdForTypeId;
+ private final static int getPDXIdForTypeDurationId;
+
+ private final static int getPDXTypeByIdInProgressId;
+ private final static int getPDXTypeByIdSendInProgressId;
+ private final static int getPDXTypeByIdSendFailedId;
+ private final static int getPDXTypeByIdSendId;
+ private final static int getPDXTypeByIdSendDurationId;
+ private final static int getPDXTypeByIdTimedOutId;
+ private final static int getPDXTypeByIdFailedId;
+ private final static int getPDXTypeByIdId;
+ private final static int getPDXTypeByIdDurationId;
+
+ private final static int addPdxTypeInProgressId;
+ private final static int addPdxTypeSendInProgressId;
+ private final static int addPdxTypeSendFailedId;
+ private final static int addPdxTypeSendId;
+ private final static int addPdxTypeSendDurationId;
+ private final static int addPdxTypeTimedOutId;
+ private final static int addPdxTypeFailedId;
+ private final static int addPdxTypeId;
+ private final static int addPdxTypeDurationId;
+
+
+ //An array of all of the ids that represent operation statistics. This
+ //is used by the getOps method to aggregate the individual stats
+ //into a total value for all operations.
+ private static int[] opIds;
+
+ static {
+ try {
+ StatisticsTypeFactory f = StatisticsTypeFactoryImpl.singleton();
+ type = f.createType(
+ "ClientStats",
+ "Statistics about client to server communication",
+ new StatisticDescriptor[] {
+ ///////////////////////////////////////////////////////////////////////
+ /*
+ f.createIntGauge("opsInProgress", "Current number of ops being executed", "ops"),
+ f.createIntCounter("ops", "Total number of ops completed successfully", "ops"),
+ f.createIntCounter("opFailures", "Total number of op attempts that have failed", "ops"),
+ f.createIntCounter("opTimeouts", "Total number of op attempts that have timed out", "ops"),
+ f.createLongCounter("opTime", "Total amount of time, in nanoseconds spent doing ops", "nanoseconds"),
+ */
+ ///////////////////////////////////////////////////////////////////////
+ f.createIntGauge("getsInProgress", "Current number of gets being executed", "gets"),
+ f.createIntCounter("gets", "Total number of gets completed successfully", "gets"),
+ f.createIntCounter("getFailures", "Total number of get attempts that have failed", "gets"),
+ f.createIntCounter("getTimeouts", "Total number of get attempts that have timed out", "gets"),
+ f.createLongCounter("getTime", "Total amount of time, in nanoseconds spent doing gets", "nanoseconds"),
+ f.createIntGauge("putsInProgress", "Current number of puts being executed", "puts"),
+ f.createIntCounter("puts", "Total number of puts completed successfully", "puts"),
+ f.createIntCounter("putFailures", "Total number of put attempts that have failed", "puts"),
+ f.createIntCounter("putTimeouts", "Total number of put attempts that have timed out", "puts"),
+ f.createLongCounter("putTime", "Total amount of time, in nanoseconds spent doing puts", "nanoseconds"),
+ f.createIntGauge("destroysInProgress", "Current number of destroys being executed", "destroys"),
+ f.createIntCounter("destroys", "Total number of destroys completed successfully", "destroys"),
+ f.createIntCounter("destroyFailures", "Total number of destroy attempts that have failed", "destroys"),
+ f.createIntCounter("destroyTimeouts", "Total number of destroy attempts that have timed out", "destroys"),
+ f.createLongCounter("destroyTime", "Total amount of time, in nanoseconds spent doing destroys", "nanoseconds"),
+ f.createIntGauge("destroyRegionsInProgress", "Current number of destroyRegions being executed", "destroyRegions"),
+ f.createIntCounter("destroyRegions", "Total number of destroyRegions completed successfully", "destroyRegions"),
+ f.createIntCounter("destroyRegionFailures", "Total number of destroyRegion attempts that have failed", "destroyRegions"),
+ f.createIntCounter("destroyRegionTimeouts", "Total number of destroyRegion attempts that have timed out", "destroyRegions"),
+ f.createLongCounter("destroyRegionTime", "Total amount of time, in nanoseconds spent doing destroyRegions", "nanoseconds"),
+ f.createIntGauge("clearsInProgress", "Current number of clears being executed", "clears"),
+ f.createIntCounter("clears", "Total number of clears completed successfully", "clears"),
+ f.createIntCounter("clearFailures", "Total number of clear attempts that have failed", "clears"),
+ f.createIntCounter("clearTimeouts", "Total number of clear attempts that have timed out", "clears"),
+ f.createLongCounter("clearTime", "Total amount of time, in nanoseconds spent doing clears", "nanoseconds"),
+ f.createIntGauge("containsKeysInProgress", "Current number of containsKeys being executed", "containsKeys"),
+ f.createIntCounter("containsKeys", "Total number of containsKeys completed successfully", "containsKeys"),
+ f.createIntCounter("containsKeyFailures", "Total number of containsKey attempts that have failed", "containsKeys"),
+ f.createIntCounter("containsKeyTimeouts", "Total number of containsKey attempts that have timed out", "containsKeys"),
+ f.createLongCounter("containsKeyTime", "Total amount of time, in nanoseconds spent doing containsKeys", "nanoseconds"),
+ f.createIntGauge("keySetsInProgress", "Current number of keySets being executed", "keySets"),
+ f.createIntCounter("keySets", "Total number of keySets completed successfully", "keySets"),
+ f.createIntCounter("keySetFailures", "Total number of keySet attempts that have failed", "keySets"),
+ f.createIntCounter("keySetTimeouts", "Total number of keySet attempts that have timed out", "keySets"),
+ f.createLongCounter("keySetTime", "Total amount of time, in nanoseconds spent doing keySets", "nanoseconds"),
+
+ f.createIntGauge("commitsInProgress", "Current number of commits being executed", "commits"),
+ f.createIntCounter("commits", "Total number of commits completed successfully", "commits"),
+ f.createIntCounter("commitFailures", "Total number of commit attempts that have failed", "commits"),
+ f.createIntCounter("commitTimeouts", "Total number of commit attempts that have timed out", "commits"),
+ f.createLongCounter("commitTime", "Total amount of time, in nanoseconds spent doing commits", "nanoseconds"),
+
+ f.createIntGauge("rollbacksInProgress", "Current number of rollbacks being executed", "rollbacks"),
+ f.createIntCounter("rollbacks", "Total number of rollbacks completed successfully", "rollbacks"),
+ f.createIntCounter("rollbackFailures", "Total number of rollback attempts that have failed", "rollbacks"),
+ f.createIntCounter("rollbackTimeouts", "Total number of rollback attempts that have timed out", "rollbacks"),
+ f.createLongCounter("rollbackTime", "Total amount of time, in nanoseconds spent doing rollbacks", "nanoseconds"),
+
+ f.createIntGauge("getEntrysInProgress", "Current number of getEntry messages being executed", "messages"),
+ f.createIntCounter("getEntrys", "Total number of getEntry messages completed successfully", "messages"),
+ f.createIntCounter("getEntryFailures", "Total number of getEntry attempts that have failed", "attempts"),
+ f.createIntCounter("getEntryTimeouts", "Total number of getEntry attempts that have timed out", "attempts"),
+ f.createLongCounter("getEntryTime", "Total amount of time, in nanoseconds spent doing getEntry processings", "nanoseconds"),
+
+ f.createIntGauge("jtaSynchronizationsInProgress", "Current number of jtaSynchronizations being executed", "sizes"),
+ f.createIntCounter("jtaSynchronizations", "Total number of jtaSynchronizations completed successfully", "jtaSynchronizations"),
+ f.createIntCounter("jtaSynchronizationFailures", "Total number of jtaSynchronization attempts that have failed", "jtaSynchronizations"),
+ f.createIntCounter("jtaSynchronizationTimeouts", "Total number of jtaSynchronization attempts that have timed out", "jtaSynchronizations"),
+ f.createLongCounter("jtaSynchronizationTime", "Total amount of time, in nanoseconds spent doing jtaSynchronizations", "nanoseconds"),
+
+ f.createIntGauge("txFailoversInProgress", "Current number of txFailovers being executed", "txFailovers"),
+ f.createIntCounter("txFailovers", "Total number of txFailovers completed successfully", "txFailovers"),
+ f.createIntCounter("txFailoverFailures", "Total number of txFailover attempts that have failed", "txFailovers"),
+ f.createIntCounter("txFailoverTimeouts", "Total number of txFailover attempts that have timed out", "sizes"),
+ f.createLongCounter("txFailoverTime", "Total amount of time, in nanoseconds spent doing txFailovers", "nanoseconds"),
+
+ f.createIntGauge("sizesInProgress", "Current number of sizes being executed", "sizes"),
+ f.createIntCounter("sizes", "Total number of sizes completed successfully", "sizes"),
+ f.createIntCounter("sizeFailures", "Total number of size attempts that have failed", "sizes"),
+ f.createIntCounter("sizeTimeouts", "Total number of size attempts that have timed out", "sizes"),
+ f.createLongCounter("sizeTime", "Total amount of time, in nanoseconds spent doing sizes", "nanoseconds"),
+
+ f.createIntGauge("invalidatesInProgress", "Current number of invalidates being executed", "invalidates"),
+ f.createIntCounter("invalidates", "Total number of invalidates completed successfully", "invalidates"),
+ f.createIntCounter("invalidateFailures", "Total number of invalidate attempts that have failed", "invalidates"),
+ f.createIntCounter("invalidateTimeouts", "Total number of invalidate attempts that have timed out", "invalidates"),
+ f.createLongCounter("invalidateTime", "Total amount of time, in nanoseconds spent doing invalidates", "nanoseconds"),
+
+
+ f.createIntGauge("registerInterestsInProgress", "Current number of registerInterests being executed", "registerInterests"),
+ f.createIntCounter("registerInterests", "Total number of registerInterests completed successfully", "registerInterests"),
+ f.createIntCounter("registerInterestFailures", "Total number of registerInterest attempts that have failed", "registerInterests"),
+ f.createIntCounter("registerInterestTimeouts", "Total number of registerInterest attempts that have timed out", "registerInterests"),
+ f.createLongCounter("registerInterestTime", "Total amount of time, in nanoseconds spent doing registerInterests", "nanoseconds"),
+ f.createIntGauge("unregisterInterestsInProgress", "Current number of unregisterInterests being executed", "unregisterInterests"),
+ f.createIntCounter("unregisterInterests", "Total number of unregisterInterests completed successfully", "unregisterInterests"),
+ f.createIntCounter("unregisterInterestFailures", "Total number of unregisterInterest attempts that have failed", "unregisterInterests"),
+ f.createIntCounter("unregisterInterestTimeouts", "Total number of unregisterInterest attempts that have timed out", "unregisterInterests"),
+ f.createLongCounter("unregisterInterestTime", "Total amount of time, in nanoseconds spent doing unregisterInterests", "nanoseconds"),
+ f.createIntGauge("querysInProgress", "Current number of querys being executed", "querys"),
+ f.createIntCounter("querys", "Total number of querys completed successfully", "querys"),
+ f.createIntCounter("queryFailures", "Total number of query attempts that have failed", "querys"),
+ f.createIntCounter("queryTimeouts", "Total number of query attempts that have timed out", "querys"),
+ f.createLongCounter("queryTime", "Total amount of time, in nanoseconds spent doing querys", "nanoseconds"),
+ f.createIntGauge("createCQsInProgress", "Current number of createCQs being executed", "createCQs"),
+ f.createIntCounter("createCQs", "Total number of createCQs completed successfully", "createCQs"),
+ f.createIntCounter("createCQFailures", "Total number of createCQ attempts that have failed", "createCQs"),
+ f.createIntCounter("createCQTimeouts", "Total number of createCQ attempts that have timed out", "createCQs"),
+ f.createLongCounter("createCQTime", "Total amount of time, in nanoseconds spent doing createCQs", "nanoseconds"),
+ f.createIntGauge("stopCQsInProgress", "Current number of stopCQs being executed", "stopCQs"),
+ f.createIntCounter("stopCQs", "Total number of stopCQs completed successfully", "stopCQs"),
+ f.createIntCounter("stopCQFailures", "Total number of stopCQ attempts that have failed", "stopCQs"),
+ f.createIntCounter("stopCQTimeouts", "Total number of stopCQ attempts that have timed out", "stopCQs"),
+ f.createLongCounter("stopCQTime", "Total amount of time, in nanoseconds spent doing stopCQs", "nanoseconds"),
+ f.createIntGauge("closeCQsInProgress", "Current number of closeCQs being executed", "closeCQs"),
+ f.createIntCounter("closeCQs", "Total number of closeCQs completed successfully", "closeCQs"),
+ f.createIntCounter("closeCQFailures", "Total number of closeCQ attempts that have failed", "closeCQs"),
+ f.createIntCounter("closeCQTimeouts", "Total number of closeCQ attempts that have timed out", "closeCQs"),
+ f.createLongCounter("closeCQTime", "Total amount of time, in nanoseconds spent doing closeCQs", "nanoseconds"),
+ f.createIntGauge("gatewayBatchsInProgress", "Current number of gatewayBatchs being executed", "gatewayBatchs"),
+ f.createIntCounter("gatewayBatchs", "Total number of gatewayBatchs completed successfully", "gatewayBatchs"),
+ f.createIntCounter("gatewayBatchFailures", "Total number of gatewayBatch attempts that have failed", "gatewayBatchs"),
+ f.createIntCounter("gatewayBatchTimeouts", "Total number of gatewayBatch attempts that have timed out", "gatewayBatchs"),
+ f.createLongCounter("gatewayBatchTime", "Total amount of time, in nanoseconds spent doing gatewayBatchs", "nanoseconds"),
+ f.createIntGauge("getDurableCQsInProgress", "Current number of getDurableCQs being executed", "getDurableCQs"),
+ f.createIntCounter("getDurableCQs", "Total number of getDurableCQs completed successfully", "getDurableCQs"),
+ f.createIntCounter("getDurableCQsFailures", "Total number of getDurableCQs attempts that have failed", "getDurableCQs"),
+ f.createIntCounter("getDurableCQsTimeouts", "Total number of getDurableCQs attempts that have timed out", "getDurableCQs"),
+ f.createLongCounter("getDurableCQsTime", "Total amount of time, in nanoseconds spent doing getDurableCQs", "nanoseconds"),
+ f.createIntGauge("readyForEventsInProgress", "Current number of readyForEvents being executed", "readyForEvents"),
+ f.createIntCounter("readyForEvents", "Total number of readyForEvents completed successfully", "readyForEvents"),
+ f.createIntCounter("readyForEventsFailures", "Total number of readyForEvents attempts that have failed", "readyForEvents"),
+ f.createIntCounter("readyForEventsTimeouts", "Total number of readyForEvents attempts that have timed out", "readyForEvents"),
+ f.createLongCounter("readyForEventsTime", "Total amount of time, in nanoseconds spent doing readyForEvents", "nanoseconds"),
+ f.createIntGauge("makePrimarysInProgress", "Current number of makePrimarys being executed", "makePrimarys"),
+ f.createIntCounter("makePrimarys", "Total number of makePrimarys completed successfully", "makePrimarys"),
+ f.createIntCounter("makePrimaryFailures", "Total number of makePrimary attempts that have failed", "makePrimarys"),
+ f.createIntCounter("makePrimaryTimeouts", "Total number of makePrimary attempts that have timed out", "makePrimarys"),
+ f.createLongCounter("makePrimaryTime", "Total amount of time, in nanoseconds spent doing makePrimarys", "nanoseconds"),
+
+ f.createIntGauge("closeConsInProgress", "Current number of closeCons being executed", "closeCons"),
+ f.createIntCounter("closeCons", "Total number of closeCons completed successfully", "closeCons"),
+ f.createIntCounter("closeConFailures", "Total number of closeCon attempts that have failed", "closeCons"),
+ f.createIntCounter("closeConTimeouts", "Total number of closeCon attempts that have timed out", "closeCons"),
+ f.createLongCounter("closeConTime", "Total amount of time, in nanoseconds spent doing closeCons", "nanoseconds"),
+
+ f.createIntGauge("primaryAcksInProgress", "Current number of primaryAcks being executed", "primaryAcks"),
+ f.createIntCounter("primaryAcks", "Total number of primaryAcks completed successfully", "primaryAcks"),
+ f.createIntCounter("primaryAckFailures", "Total number of primaryAck attempts that have failed", "primaryAcks"),
+ f.createIntCounter("primaryAckTimeouts", "Total number of primaryAck attempts that have timed out", "primaryAcks"),
+ f.createLongCounter("primaryAckTime", "Total amount of time, in nanoseconds spent doing primaryAcks", "nanoseconds"),
+
+ f.createIntGauge("pingsInProgress", "Current number of pings being executed", "pings"),
+ f.createIntCounter("pings", "Total number of pings completed successfully", "pings"),
+ f.createIntCounter("pingFailures", "Total number of ping attempts that have failed", "pings"),
+ f.createIntCounter("pingTimeouts", "Total number of ping attempts that have timed out", "pings"),
+ f.createLongCounter("pingTime", "Total amount of time, in nanoseconds spent doing pings", "nanoseconds"),
+
+ f.createIntGauge("registerInstantiatorsInProgress", "Current number of registerInstantiators being executed", "registerInstantiators"),
+ f.createIntCounter("registerInstantiators", "Total number of registerInstantiators completed successfully", "registerInstantiators"),
+ f.createIntCounter("registerInstantiatorsFailures", "Total number of registerInstantiators attempts that have failed", "registerInstantiators"),
+ f.createIntCounter("registerInstantiatorsTimeouts", "Total number of registerInstantiators attempts that have timed out", "registerInstantiators"),
+ f.createLongCounter("registerInstantiatorsTime", "Total amount of time, in nanoseconds spent doing registerInstantiators", "nanoseconds"),
+
+ f.createIntGauge("registerDataSerializersInProgress", "Current number of registerDataSerializers being executed", "registerDataSerializers"),
+ f.createIntCounter("registerDataSerializers", "Total number of registerDataSerializers completed successfully", "registerDataSerializers"),
+ f.createIntCounter("registerDataSerializersFailures", "Total number of registerDataSerializers attempts that have failed", "registerDataSerializers"),
+ f.createIntCounter("registerDataSerializersTimeouts", "Total number of registerDataSerializers attempts that have timed out", "registerDataSerializers"),
+ f.createLongCounter("registerDataSerializersTime", "Total amount of time, in nanoseconds spent doing registerDataSerializers", "nanoseconds"),
+
+ f.createIntGauge("connections", "Current number of connections", "connections"),
+ f.createIntCounter("connects", "Total number of times a connection has been created.", "connects"),
+ f.createIntCounter("disconnects", "Total number of times a connection has been destroyed.", "disconnects"),
+ f.createIntGauge("putAllsInProgress", "Current number of putAlls being executed", "putAlls"),
+ f.createIntCounter("putAlls", "Total number of putAlls completed successfully", "putAlls"),
+ f.createIntCounter("putAllFailures", "Total number of putAll attempts that have failed", "putAlls"),
+ f.createIntCounter("putAllTimeouts", "Total number of putAll attempts that have timed out", "putAlls"),
+ f.createLongCounter("putAllTime", "Total amount of time, in nanoseconds spent doing putAlls", "nanoseconds"),
+ f.createIntGauge("removeAllsInProgress", "Current number of removeAlls being executed", "removeAlls"),
+ f.createIntCounter("removeAlls", "Total number of removeAlls completed successfully", "removeAlls"),
+ f.createIntCounter("removeAllFailures", "Total number of removeAll attempts that have failed", "removeAlls"),
+ f.createIntCounter("removeAllTimeouts", "Total number of removeAll attempts that have timed out", "removeAlls"),
+ f.createLongCounter("removeAllTime", "Total amount of time, in nanoseconds spent doing removeAlls", "nanoseconds"),
+ f.createIntGauge("getAllsInProgress", "Current number of getAlls being executed", "getAlls"),
+ f.createIntCounter("getAlls", "Total number of getAlls completed successfully", "getAlls"),
+ f.createIntCounter("getAllFailures", "Total number of getAll attempts that have failed", "getAlls"),
+ f.createIntCounter("getAllTimeouts", "Total number of getAll attempts that have timed out", "getAlls"),
+ f.createLongCounter("getAllTime", "Total amount of time, in nanoseconds spent doing getAlls", "nanoseconds"),
+ f.createLongCounter("receivedBytes",
+ "Total number of bytes received (as responses) from server over a client-to-server connection.",
+ "bytes"),
+ f.createLongCounter("sentBytes",
+ "Total number of bytes sent to server over a client-to-server connection.",
+ "bytes"),
+ f.createIntGauge("messagesBeingReceived", "Current number of message being received off the network or being processed after reception over a client-to-server connection.", "messages"),
+ f.createLongGauge("messageBytesBeingReceived", "Current number of bytes consumed by messages being received or processed over a client-to-server connection.", "bytes"),
+
+ f.createIntGauge("executeFunctionsInProgress", "Current number of Functions being executed", "executeFunctions"),
+ f.createIntCounter("executeFunctions", "Total number of Functions completed successfully", "executeFunctions"),
+ f.createIntCounter("executeFunctionFailures", "Total number of Function attempts that have failed", "executeFunctions"),
+ f.createIntCounter("executeFunctionTimeouts", "Total number of Function attempts that have timed out", "executeFunctions"),
+ f.createLongCounter("executeFunctionTime", "Total amount of time, in nanoseconds spent doing Functions", "nanoseconds"),
+
+ f.createIntGauge("asyncExecuteFunctionsInProgress", "Current number of Functions being executed asynchronously", "asyncExecuteFunctions"),
+ f.createIntCounter("asyncExecuteFunctions", "Total number of asynchronous Functions completed successfully", "asyncExecuteFunctions"),
+ f.createIntCounter("asyncExecuteFunctionFailures", "Total number of asynchronous Function attempts that have failed", "asyncExecuteFunctions"),
+ f.createIntCounter("asyncExecuteFunctionTimeouts", "Total number of asynchronous Function attempts that have timed out", "asyncExecuteFunctions"),
+ f.createLongCounter("asyncExecuteFunctionTime", "Total amount of time, in nanoseconds spent doing asynchronous Functions", "nanoseconds"),
+
+ f.createIntGauge("getClientPRMetadataInProgress", "Current number of getClientPRMetadata operations being executed", "getClientPRMetadata"),
+ f.createIntCounter("getClientPRMetadataFailures", "Total number of getClientPRMetadata operation attempts that have failed", "getClientPRMetadata"),
+ f.createIntCounter("getClientPRMetadataSuccessful", "Total number of getClientPRMetadata operations completed successfully", "getClientPRMetadata"),
+ f.createIntCounter("getClientPRMetadataTimeouts", "Total number of getClientPRMetadata operation attempts that have timed out", "getClientPRMetadata"),
+ f.createLongCounter("getClientPRMetadataTime", "Total amount of time, in nanoseconds spent doing getClientPRMetadata successfully/unsuccessfully", "nanoseconds"),
+
+ f.createIntGauge("getClientPartitionAttributesInProgress", "Current number of getClientPartitionAttributes operations being executed", "getClientPartitionAttributes"),
+ f.createIntCounter("getClientPartitionAttributesFailures", "Total number of getClientPartitionAttributes operation attempts that have failed", "getClientPartitionAttributes"),
+ f.createIntCounter("getClientPartitionAttributesSuccessful", "Total number of getClientPartitionAttributes operations completed successfully", "getClientPartitionAttributes"),
+ f.createIntCounter("getClientPartitionAttributesTimeouts", "Total number of getClientPartitionAttributes operation attempts that have timed out", "getClientPartitionAttributes"),
+ f.createLongCounter("getClientPartitionAttributesTime", "Total amount of time, in nanoseconds spent doing getClientPartitionAttributes successfully/unsuccessfully.", "nanoseconds"),
+
+ f.createIntGauge("getPDXTypeByIdInProgress", "Current number of getPDXTypeById operations being executed", "getPDXTypeById"),
+ f.createIntCounter("getPDXTypeByIdFailures", "Total number of getPDXTypeById operation attempts that have failed", "getPDXTypeById"),
+ f.createIntCounter("getPDXTypeByIdSuccessful", "Total number of getPDXTypeById operations completed successfully", "getPDXTypeById"),
+ f.createIntCounter("getPDXTypeByIdTimeouts", "Total number of getPDXTypeById operation attempts that have timed out", "getPDXTypeById"),
+ f.createLongCounter("getPDXTypeByIdTime", "Total amount of time, in nanoseconds spent doing getPDXTypeById successfully/unsuccessfully.", "nanoseconds"),
+
+ f.createIntGauge("getPDXIdForTypeInProgress", "Current number of getPDXIdForType operations being executed", "getPDXIdForType"),
+ f.createIntCounter("getPDXIdForTypeFailures", "Total number of getPDXIdForType operation attempts that have failed", "getPDXIdForType"),
+ f.createIntCounter("getPDXIdForTypeSuccessful", "Total number of getPDXIdForType operations completed successfully", "getPDXIdForType"),
+ f.createIntCounter("getPDXIdForTypeTimeouts", "Total number of getPDXIdForType operation attempts that have timed out", "getPDXIdForType"),
+ f.createLongCounter("getPDXIdForTypeTime", "Total amount of time, in nanoseconds spent doing getPDXIdForType successfully/unsuccessfully.", "nanoseconds"),
+
+ f.createIntGauge("addPdxTypeInProgress", "Current number of addPdxType operations being executed", "addPdxType"),
+ f.createIntCounter("addPdxTypeFailures", "Total number of addPdxType operation attempts that have failed", "addPdxType"),
+ f.createIntCounter("addPdxTypeSuccessful", "Total number of addPdxType operations completed successfully", "addPdxType"),
+ f.createIntCounter("addPdxTypeTimeouts", "Total number of addPdxType operation attempts that have timed out", "addPdxType"),
+ f.createLongCounter("addPdxTypeTime", "Total amount of time, in nanoseconds spent doing addPdxType successfully/unsuccessfully.", "nanoseconds"),
+ }
+ );
+
+ sendType = f.createType(
+ "ClientSendStats",
+ "Statistics about client to server communication",
+ new StatisticDescriptor[] {
+ ///////////////////////////////////////////////////////////////////////
+ /*
+ f.createIntGauge("opSendsInProgress", "Current number of op sends being executed", "sends"),
+ f.createIntCounter("opSends", "Total number of op sends that have completed successfully", "sends"),
+ f.createIntCounter("opSendFailures", "Total number of op sends that have failed", "sends"),
+ f.createLongCounter("opSendTime", "Total amount of time, in nanoseconds spent doing op sends", "nanoseconds"),
+ */
+ ///////////////////////////////////////////////////////////////////////
+ f.createIntGauge("getSendsInProgress", "Current number of get sends being executed", "sends"),
+ f.createIntCounter("getSends", "Total number of get sends that have completed successfully", "sends"),
+ f.createIntCounter("getSendFailures", "Total number of get sends that have failed", "sends"),
+ f.createLongCounter("getSendTime", "Total amount of time, in nanoseconds spent doing get sends", "nanoseconds"),
+ f.createIntGauge("putSendsInProgress", "Current number of put sends being executed", "sends"),
+ f.createIntCounter("putSends", "Total number of put sends that have completed successfully", "sends"),
+ f.createIntCounter("putSendFailures", "Total number of put sends that have failed", "sends"),
+ f.createLongCounter("putSendTime", "Total amount of time, in nanoseconds spent doing put sends", "nanoseconds"),
+ f.createIntGauge("destroySendsInProgress", "Current number of destroy sends being executed", "sends"),
+ f.createIntCounter("destroySends", "Total number of destroy sends that have completed successfully", "sends"),
+ f.createIntCounter("destroySendFailures", "Total number of destroy sends that have failed", "sends"),
+ f.createLongCounter("destroySendTime", "Total amount of time, in nanoseconds spent doing destroy sends", "nanoseconds"),
+ f.createIntGauge("destroyRegionSendsInProgress", "Current number of destroyRegion sends being executed", "sends"),
+ f.createIntCounter("destroyRegionSends", "Total number of destroyRegion sends that have completed successfully", "sends"),
+ f.createIntCounter("destroyRegionSendFailures", "Total number of destroyRegion sends that have failed", "sends"),
+ f.createLongCounter("destroyRegionSendTime", "Total amount of time, in nanoseconds spent doing destroyRegion sends", "nanoseconds"),
+ f.createIntGauge("clearSendsInProgress", "Current number of clear sends being executed", "sends"),
+ f.createIntCounter("clearSends", "Total number of clear sends that have completed successfully", "sends"),
+ f.createIntCounter("clearSendFailures", "Total number of clear sends that have failed", "sends"),
+ f.createLongCounter("clearSendTime", "Total amount of time, in nanoseconds spent doing clear sends", "nanoseconds"),
+ f.createIntGauge("containsKeySendsInProgress", "Current number of containsKey sends being executed", "sends"),
+ f.createIntCounter("containsKeySends", "Total number of containsKey sends that have completed successfully", "sends"),
+ f.createIntCounter("containsKeySendFailures", "Total number of containsKey sends that have failed", "sends"),
+ f.createLongCounter("containsKeySendTime", "Total amount of time, in nanoseconds spent doing containsKey sends", "nanoseconds"),
+ f.createIntGauge("keySetSendsInProgress", "Current number of keySet sends being executed", "sends"),
+ f.createIntCounter("keySetSends", "Total number of keySet sends that have completed successfully", "sends"),
+ f.createIntCounter("keySetSendFailures", "Total number of keySet sends that have failed", "sends"),
+ f.createLongCounter("keySetSendTime", "Total amount of time, in nanoseconds spent doing keySet sends", "nanoseconds"),
+
+ f.createIntGauge("commitSendsInProgress", "Current number of commit sends being executed", "sends"),
+ f.createIntCounter("commitSendFailures", "Total number of commit sends that have failed", "sends"),
+ f.createIntCounter("commitSends", "Total number of commit sends that have failed", "sends"),
+ f.createLongCounter("commitSendTime", "Total amount of time, in nanoseconds spent doing commits", "nanoseconds"),
+ f.createIntGauge("rollbackSendsInProgress", "Current number of rollback sends being executed", "sends"),
+ f.createIntCounter("rollbackSendFailures", "Total number of rollback sends that have failed", "sends"),
+ f.createIntCounter("rollbackSends", "Total number of rollback sends that have failed", "sends"),
+ f.createLongCounter("rollbackSendTime", "Total amount of time, in nanoseconds spent doing rollbacks", "nanoseconds"),
+ f.createIntGauge("getEntrySendsInProgress", "Current number of getEntry sends being executed", "sends"),
+ f.createIntCounter("getEntrySendFailures", "Total number of getEntry sends that have failed", "sends"),
+ f.createIntCounter("getEntrySends", "Total number of getEntry sends that have failed", "sends"),
+ f.createLongCounter("getEntrySendTime", "Total amount of time, in nanoseconds spent sending getEntry messages", "nanoseconds"),
+ f.createIntGauge("jtaSynchronizationSendsInProgress", "Current number of jtaSynchronization sends being executed", "sends"),
+ f.createIntCounter("jtaSynchronizationSendFailures", "Total number of jtaSynchronization sends that have failed", "sends"),
+ f.createIntCounter("jtaSynchronizationSends", "Total number of jtaSynchronization sends that have failed", "sends"),
+ f.createLongCounter("jtaSynchronizationSendTime", "Total amount of time, in nanoseconds spent doing jtaSynchronizations", "nanoseconds"),
+ f.createIntGauge("txFailoverSendsInProgress", "Current number of txFailover sends being executed", "sends"),
+ f.createIntCounter("txFailoverSendFailures", "Total number of txFailover sends that have failed", "sends"),
+ f.createIntCounter("txFailoverSends", "Total number of txFailover sends that have failed", "sends"),
+ f.createLongCounter("txFailoverSendTime", "Total amount of time, in nanoseconds spent doing txFailovers", "nanoseconds"),
+ f.createIntGauge("sizeSendsInProgress", "Current number of size sends being executed", "sends"),
+ f.createIntCounter("sizeSendFailures", "Total number of size sends that have failed", "sends"),
+ f.createIntCounter("sizeSends", "Total number of size sends that have failed", "sends"),
+ f.createLongCounter("sizeSendTime", "Total amount of time, in nanoseconds spent doing sizes", "nanoseconds"),
+ f.createIntGauge("invalidateSendsInProgress", "Current number of invalidate sends being executed", "sends"),
+ f.createIntCounter("invalidateSendFailures", "Total number of invalidate sends that have failed", "sends"),
+ f.createIntCounter("invalidateSends", "Total number of invalidate sends that have failed", "sends"),
+ f.createLongCounter("invalidateSendTime", "Total amount of time, in nanoseconds spent doing invalidates", "nanoseconds"),
+ f.createIntGauge("registerInterestSendsInProgress", "Current number of registerInterest sends being executed", "sends"),
+ f.createIntCounter("registerInterestSends", "Total number of registerInterest sends that have completed successfully", "sends"),
+ f.createIntCounter("registerInterestSendFailures", "Total number of registerInterest sends that have failed", "sends"),
+ f.createLongCounter("registerInterestSendTime", "Total amount of time, in nanoseconds spent doing registerInterest sends", "nanoseconds"),
+ f.createIntGauge("unregisterInterestSendsInProgress", "Current number of unregisterInterest sends being executed", "sends"),
+ f.createIntCounter("unregisterInterestSends", "Total number of unregisterInterest sends that have completed successfully", "sends"),
+ f.createIntCounter("unregisterInterestSendFailures", "Total number of unregisterInterest sends that have failed", "sends"),
+ f.createLongCounter("unregisterInterestSendTime", "Total amount of time, in nanoseconds spent doing unregisterInterest sends", "nanoseconds"),
+ f.createIntGauge("querySendsInProgress", "Current number of query sends being executed", "sends"),
+ f.createIntCounter("querySends", "Total number of query sends that have completed successfully", "sends"),
+ f.createIntCounter("querySendFailures", "Total number of query sends that have failed", "sends"),
+ f.createLongCounter("querySendTime", "Total amount of time, in nanoseconds spent doing query sends", "nanoseconds"),
+ f.createIntGauge("createCQSendsInProgress", "Current number of createCQ sends being executed", "sends"),
+ f.createIntCounter("createCQSends", "Total number of createCQ sends that have completed successfully", "sends"),
+ f.createIntCounter("createCQSendFailures", "Total number of createCQ sends that have failed", "sends"),
+ f.createLongCounter("createCQSendTime", "Total amount of time, in nanoseconds spent doing createCQ sends", "nanoseconds"),
+ f.createIntGauge("stopCQSendsInProgress", "Current number of stopCQ sends being executed", "sends"),
+ f.createIntCounter("stopCQSends", "Total number of stopCQ sends that have completed successfully", "sends"),
+ f.createIntCounter("stopCQSendFailures", "Total number of stopCQ sends that have failed", "sends"),
+ f.createLongCounter("stopCQSendTime", "Total amount of time, in nanoseconds spent doing stopCQ sends", "nanoseconds"),
+ f.createIntGauge("closeCQSendsInProgress", "Current number of closeCQ sends being executed", "sends"),
+ f.createIntCounter("closeCQSends", "Total number of closeCQ sends that have completed successfully", "sends"),
+ f.createIntCounter("closeCQSendFailures", "Total number of closeCQ sends that have failed", "sends"),
+ f.createLongCounter("closeCQSendTime", "Total amount of time, in nanoseconds spent doing closeCQ sends", "nanoseconds"),
+ f.createIntGauge("gatewayBatchSendsInProgress", "Current number of gatewayBatch sends being executed", "sends"),
+ f.createIntCounter("gatewayBatchSends", "Total number of gatewayBatch sends that have completed successfully", "sends"),
+ f.createIntCounter("gatewayBatchSendFailures", "Total number of gatewayBatch sends that have failed", "sends"),
+ f.createLongCounter("gatewayBatchSendTime", "Total amount of time, in nanoseconds spent doing gatewayBatch sends", "nanoseconds"),
+ f.createIntGauge("getDurableCQsSendsInProgressId", "Current number of getDurableCQs sends being executed", "sends"),
+ f.createIntCounter("getDurableCQsSends", "Total number of getDurableCQs sends that have completed successfully", "sends"),
+ f.createIntCounter("getDurableCQsSendFailures", "Total number of getDurableCQs sends that have failed", "sends"),
+ f.createLongCounter("getDurableCQsSendTime", "Total amount of time, in nanoseconds spent doing getDurableCQs sends", "nanoseconds"),
+ f.createIntGauge("readyForEventsSendsInProgress", "Current number of readyForEvents sends being executed", "sends"),
+ f.createIntCounter("readyForEventsSends", "Total number of readyForEvents sends that have completed successfully", "sends"),
+ f.createIntCounter("readyForEventsSendFailures", "Total number of readyForEvents sends that have failed", "sends"),
+ f.createLongCounter("readyForEventsSendTime", "Total amount of time, in nanoseconds spent doing readyForEvents sends", "nanoseconds"),
+ f.createIntGauge("makePrimarySendsInProgress", "Current number of makePrimary sends being executed", "sends"),
+ f.createIntCounter("makePrimarySends", "Total number of makePrimary sends that have completed successfully", "sends"),
+ f.createIntCounter("makePrimarySendFailures", "Total number of makePrimary sends that have failed", "sends"),
+ f.createLongCounter("makePrimarySendTime", "Total amount of time, in nanoseconds spent doing makePrimary sends", "nanoseconds"),
+ f.createIntGauge("closeConSendsInProgress", "Current number of closeCon sends being executed", "sends"),
+ f.createIntCounter("closeConSends", "Total number of closeCon sends that have completed successfully", "sends"),
+ f.createIntCounter("closeConSendFailures", "Total number of closeCon sends that have failed", "sends"),
+ f.createLongCounter("closeConSendTime", "Total amount of time, in nanoseconds spent doing closeCon sends", "nanoseconds"),
+ f.createIntGauge("primaryAckSendsInProgress", "Current number of primaryAck sends being executed", "sends"),
+ f.createIntCounter("primaryAckSends", "Total number of primaryAck sends that have completed successfully", "sends"),
+ f.createIntCounter("primaryAckSendFailures", "Total number of primaryAck sends that have failed", "sends"),
+ f.createLongCounter("primaryAckSendTime", "Total amount of time, in nanoseconds spent doing primaryAck sends", "nanoseconds"),
+ f.createIntGauge("pingSendsInProgress", "Current number of ping sends being executed", "sends"),
+ f.createIntCounter("pingSends", "Total number of ping sends that have completed successfully", "sends"),
+ f.createIntCounter("pingSendFailures", "Total number of ping sends that have failed", "sends"),
+ f.createLongCounter("pingSendTime", "Total amount of time, in nanoseconds spent doing ping sends", "nanoseconds"),
+ f.createIntGauge("registerInstantiatorsSendsInProgress", "Current number of registerInstantiators sends being executed", "sends"),
+ f.createIntCounter("registerInstantiatorsSends", "Total number of registerInstantiators sends that have completed successfully", "sends"),
+ f.createIntCounter("registerInstantiatorsSendFailures", "Total number of registerInstantiators sends that have failed", "sends"),
+ f.createLongCounter("registerInstantiatorsSendTime", "Total amount of time, in nanoseconds spent doing registerInstantiators sends", "nanoseconds"),
+ f.createIntGauge("registerDataSerializersSendInProgress", "Current number of registerDataSerializers sends being executed", "sends"),
+ f.createIntCounter("registerDataSerializersSends", "Total number of registerDataSerializers sends that have completed successfully", "sends"),
+ f.createIntCounter("registerDataSerializersSendFailures", "Total number of registerDataSerializers sends that have failed", "sends"),
+ f.createLongCounter("registerDataSerializersSendTime", "Total amount of time, in nanoseconds spent doing registerDataSerializers sends", "nanoseconds"),
+ f.createIntGauge("putAllSendsInProgress", "Current number of putAll sends being executed", "sends"),
+ f.createIntCounter("putAllSends", "Total number of putAll sends that have completed successfully", "sends"),
+ f.createIntCounter("putAllSendFailures", "Total number of putAll sends that have failed", "sends"),
+ f.createLongCounter("putAllSendTime", "Total amount of time, in nanoseconds spent doing putAll sends", "nanoseconds"),
+ f.createIntGauge("removeAllSendsInProgress", "Current number of removeAll sends being executed", "sends"),
+ f.createIntCounter("removeAllSends", "Total number of removeAll sends that have completed successfully", "sends"),
+ f.createIntCounter("removeAllSendFailures", "Total number of removeAll sends that have failed", "sends"),
+ f.createLongCounter("removeAllSendTime", "Total amount of time, in nanoseconds spent doing removeAll sends", "nanoseconds"),
+ f.createIntGauge("getAllSendsInProgress", "Current number of getAll sends being executed", "sends"),
+ f.createIntCounter("getAllSends", "Total number of getAll sends that have completed successfully", "sends"),
+ f.createIntCounter("getAllSendFailures", "Total number of getAll sends that have failed", "sends"),
+ f.createLongCounter("getAllSendTime", "Total amount of time, in nanoseconds spent doing getAll sends", "nanoseconds"),
+ f.createIntGauge("executeFunctionSendsInProgress", "Current number of Function sends being executed", "sends"),
+ f.createIntCounter("executeFunctionSends", "Total number of Function sends that have completed successfully", "sends"),
+ f.createIntCounter("executeFunctionSendFailures", "Total number of Function sends that have failed", "sends"),
+ f.createLongCounter("executeFunctionSendTime", "Total amount of time, in nanoseconds spent doing Function sends", "nanoseconds"),
+ f.createIntGauge("asyncExecuteFunctionSendsInProgress", "Current number of Function sends being executed asynchronously", "sends"),
+ f.createIntCounter("asyncExecuteFunctionSends", "Total number of asynchronous Function sends that have completed successfully", "sends"),
+ f.createIntCounter("asyncExecuteFunctionSendFailures", "Total number of asynchronous Function sends that have failed", "sends"),
+ f.createLongCounter("asyncExecuteFunctionSendTime", "Total amount of time, in nanoseconds spent doing asynchronous Function sends", "nanoseconds"),
+ f.createIntGauge("getClientPRMetadataSendsInProgress", "Current number of getClientPRMetadata operation's request messages being send from the client to server", "sends"),
+ f.createIntCounter("getClientPRMetadataSendFailures", "Total number of getClientPRMetadata operation's request messages not sent successfully from the client to server", "sends"),
+ f.createIntCounter("getClientPRMetadataSendsSuccessful", "Total number of getClientPRMetadata operation's request messages sent successfully from the client to server", "sends"),
+ f.createLongCounter("getClientPRMetadataSendTime" ,"Total amount of time, in nanoseconds spent sending getClientPRMetadata operation's request messages successfully/unsuccessfully from the client to server", "nanoseconds"),
+ f.createIntGauge("getClientPartitionAttributesSendsInProgress", "Current number of getClientPartitionAttributes operation's request messages being send from the client to server", "sends"),
+ f.createIntCounter("getClientPartitionAttributesSendFailures", "Total number of getClientPartitionAttributes operation's request messages not sent successfully from the client to server", "sends"),
+ f.createIntCounter("getClientPartitionAttributesSendsSuccessful", "Total number of getClientPartitionAttributes operation's request messages sent successfully from the client to server", "sends"),
+ f.createLongCounter("getClientPartitionAttributesSendTime","Total amount of time, in nanoseconds spent sending getClientPartitionAttributes operation's request messages successfully/unsuccessfully from the client to server", "nanoseconds"),
+ f.createIntGauge("getPDXTypeByIdSendsInProgress", "Current number of getPDXTypeById operation's request messages being send from the client to server", "sends"),
+ f.createIntCounter("getPDXTypeByIdSendFailures", "Total number of getPDXTypeById operation's request messages not sent successfully from the client to server", "sends"),
+ f.createIntCounter("getPDXTypeByIdSendsSuccessful", "Total number of getPDXTypeById operation's request messages sent successfully from the client to server", "sends"),
+ f.createLongCounter("getPDXTypeByIdSendTime","Total amount of time, in nanoseconds spent sending getPDXTypeById operation's request messages successfully/unsuccessfully from the client to server", "nanoseconds"),
+ f.createIntGauge("getPDXIdForTypeSendsInProgress", "Current number of getPDXIdForType operation's request messages being send from the client to server", "sends"),
+ f.createIntCounter("getPDXIdForTypeSendFailures", "Total number of getPDXIdForType operation's request messages not sent successfully from the client to server", "sends"),
+ f.createIntCounter("getPDXIdForTypeSendsSuccessful", "Total number of getPDXIdForType operation's request messages sent successfully from the client to server", "sends"),
+ f.createLongCounter("getPDXIdForTypeSendTime","Total amount of time, in nanoseconds spent sending getPDXIdForType operation's request messages successfully/unsuccessfully from the client to server", "nanoseconds"),
+ f.createIntGauge("addPdxTypeSendsInProgress", "Current number of addPdxType operation's request messages being send from the client to server", "sends"),
+ f.createIntCounter("addPdxTypeSendFailures", "Total number of addPdxType operation's request messages not sent successfully from the client to server", "sends"),
+ f.createIntCounter("addPdxTypeSendsSuccessful", "Total number of addPdxType operation's request messages sent successfully from the client to server", "sends"),
+ f.createLongCounter("addPdxTypeSendTime","Total amount of time, in nanoseconds spent sending addPdxType operation's request messages successfully/unsuccessfully from the client to server", "nanoseconds"),
+ }
+ );
+ ///////////////////////////////////////////////////////////////////////
+ /*
+ opInProgressId = type.nameToId("opsInProgress");
+ opSendInProgressId = sendType.nameToId("opSendsInProgress");
+ opSendFailedId = sendType.nameToId("opSendFailures");
+ opSendId = sendType.nameToId("opSends");
+ opSendDurationId = sendType.nameToId("opSendTime");
+ opTimedOutId = type.nameToId("opTimeouts");
+ opFailedId = type.nameToId("opFailures");
+ opId = type.nameToId("ops");
+ opDurationId = type.nameToId("opTime");
+ */
+ ///////////////////////////////////////////////////////////////////////
+ getInProgressId = type.nameToId("getsInProgress");
+ getSendInProgressId = sendType.nameToId("getSendsInProgress");
+ getSendFailedId = sendType.nameToId("getSendFailures");
+ getSendId = sendType.nameToId("getSends");
+ getSendDurationId = sendType.nameToId("getSendTime");
+ getTimedOutId = type.nameToId("getTimeouts");
+ getFailedId = type.nameToId("getFailures");
+ getId = type.nameToId("gets");
+ getDurationId = type.nameToId("getTime");
+ putInProgressId = type.nameToId("putsInProgress");
+ putSendInProgressId = sendType.nameToId("putSendsInProgress");
+ putSendFailedId = sendType.nameToId("putSendFailures");
+ putSendId = sendType.nameToId("putSends");
+ putSendDurationId = sendType.nameToId("putSendTime");
+ putTimedOutId = type.nameToId("putTimeouts");
+ putFailedId = type.nameToId("putFailures");
+ putId = type.nameToId("puts");
+ putDurationId = type.nameToId("putTime");
+ destroyInProgressId = type.nameToId("destroysInProgress");
+ destroySendInProgressId = sendType.nameToId("destroySendsInProgress");
+ destroySendFailedId = sendType.nameToId("destroySendFailures");
+ destroySendId = sendType.nameToId("destroySends");
+ destroySendDurationId = sendType.nameToId("destroySendTime");
+ destroyTimedOutId = type.nameToId("destroyTimeouts");
+ destroyFailedId = type.nameToId("destroyFailures");
+ destroyId = type.nameToId("destroys");
+ destroyDurationId = type.nameToId("destroyTime");
+ destroyRegionInProgressId = type.nameToId("destroyRegionsInProgress");
+ destroyRegionSendInProgressId = sendType.nameToId("destroyRegionSendsInProgress");
+ destroyRegionSendFailedId = sendType.nameToId("destroyRegionSendFailures");
+ destroyRegionSendId = sendType.nameToId("destroyRegionSends");
+ destroyRegionSendDurationId = sendType.nameToId("destroyRegionSendTime");
+ destroyRegionTimedOutId = type.nameToId("destroyRegionTimeouts");
+ destroyRegionFailedId = type.nameToId("destroyRegionFailures");
+ destroyRegionId = type.nameToId("destroyRegions");
+ destroyRegionDurationId = type.nameToId("destroyRegionTime");
+ clearInProgressId = type.nameToId("clearsInProgress");
+ clearSendInProgressId = sendType.nameToId("clearSendsInProgress");
+ clearSendFailedId = sendType.nameToId("clearSendFailures");
+ clearSendId = sendType.nameToId("clearSends");
+ clearSendDurationId = sendType.nameToId("clearSendTime");
+ clearTimedOutId = type.nameToId("clearTimeouts");
+ clearFailedId = type.nameToId("clearFailures");
+ clearId = type.nameToId("clears");
+ clearDurationId = type.nameToId("clearTime");
+ containsKeyInProgressId = type.nameToId("containsKeysInProgress");
+ containsKeySendInProgressId = sendType.nameToId("containsKeySendsInProgress");
+ containsKeySendFailedId = sendType.nameToId("containsKeySendFailures");
+ containsKeySendId = sendType.nameToId("containsKeySends");
+ containsKeySendDurationId = sendType.nameToId("containsKeySendTime");
+ containsKeyTimedOutId = type.nameToId("containsKeyTimeouts");
+ containsKeyFailedId = type.nameToId("containsKeyFailures");
+ containsKeyId = type.nameToId("containsKeys");
+ containsKeyDurationId = type.nameToId("containsKeyTime");
+
+ keySetInProgressId = type.nameToId("keySetsInProgress");
+ keySetSendInProgressId = sendType.nameToId("keySetSendsInProgress");
+ keySetSendFailedId = sendType.nameToId("keySetSendFailures");
+ keySetSendId = sendType.nameToId("keySetSends");
+ keySetSendDurationId = sendType.nameToId("keySetSendTime");
+ keySetTimedOutId = type.nameToId("keySetTimeouts");
+ keySetFailedId = type.nameToId("keySetFailures");
+ keySetId = type.nameToId("keySets");
+ keySetDurationId = type.nameToId("keySetTime");
+
+ commitInProgressId = type.nameToId("commitsInProgress");
+ commitSendInProgressId = sendType.nameToId("commitSendsInProgress");
+ commitSendFailedId = sendType.nameToId("commitSendFailures");
+ commitSendId = sendType.nameToId("commitSends");
+ commitSendDurationId = sendType.nameToId("commitSendTime");
+ commitDurationId = type.nameToId("commitTime");
+ commitTimedOutId = type.nameToId("commitTimeouts");
+ commitFailedId = type.nameToId("commitFailures");
+ commitId = type.nameToId("commits");
+
+ rollbackInProgressId = type.nameToId("rollbacksInProgress");
+ rollbackSendInProgressId = sendType.nameToId("rollbackSendsInProgress");
+ rollbackSendFailedId = sendType.nameToId("rollbackSendFailures");
+ rollbackSendId = sendType.nameToId("rollbackSends");
+ rollbackSendDurationId = sendType.nameToId("rollbackSendTime");
+ rollbackDurationId = type.nameToId("rollbackTime");
+ rollbackTimedOutId = type.nameToId("rollbackTimeouts");
+ rollbackFailedId = type.nameToId("rollbackFailures");
+ rollbackId = type.nameToId("rollbacks");
+
+ getEntryInProgressId = type.nameToId("getEntrysInProgress");
+ getEntrySendInProgressId = sendType.nameToId("getEntrySendsInProgress");
+ getEntrySendFailedId = sendType.nameToId("getEntrySendFailures");
+ getEntrySendId = sendType.nameToId("getEntrySends");
+ getEntrySendDurationId = sendType.nameToId("getEntrySendTime");
+ getEntryDurationId = type.nameToId("getEntryTime");
+ getEntryTimedOutId = type.nameToId("getEntryTimeouts");
+ getEntryFailedId = type.nameToId("getEntryFailures");
+ getEntryId = type.nameToId("getEntrys");
+
+ txSynchronizationInProgressId = type.nameToId("jtaSynchronizationsInProgress");
+ txSynchronizationSendInProgressId = sendType.nameToId("jtaSynchronizationSendsInProgress");
+ txSynchronizationSendFailedId = sendType.nameToId("jtaSynchronizationSendFailures");
+ txSynchronizationSendId = sendType.nameToId("jtaSynchronizationSends");
+ txSynchronizationSendDurationId = sendType.nameToId("jtaSynchronizationSendTime");
+ txSynchronizationDurationId = type.nameToId("jtaSynchronizationTime");
+ txSynchronizationTimedOutId = type.nameToId("jtaSynchronizationTimeouts");
+ txSynchronizationFailedId = type.nameToId("jtaSynchronizationFailures");
+ txSynchronizationId = type.nameToId("jtaSynchronizations");
+
+ txFailoverInProgressId = type.nameToId("txFailoversInProgress");
+ txFailoverSendInProgressId = sendType.nameToId("txFailoverSendsInProgress");
+ txFailoverSendFailedId = sendType.nameToId("txFailoverSendFailures");
+ txFailoverSendId = sendType.nameToId("txFailoverSends");
+ txFailoverSendDurationId = sendType.nameToId("txFailoverSendTime");
+ txFailoverDurationId = type.nameToId("txFailoverTime");
+ txFailoverTimedOutId = type.nameToId("txFailoverTimeouts");
+ txFailoverFailedId = type.nameToId("txFailoverFailures");
+ txFailoverId = type.nameToId("txFailovers");
+
+ sizeInProgressId = type.nameToId("sizesInProgress");
+ sizeSendInProgressId = sendType.nameToId("sizeSendsInProgress");
+ sizeSendFailedId = sendType.nameToId("sizeSendFailures");
+ sizeSendId = sendType.nameToId("sizeSends");
+ sizeSendDurationId = sendType.nameToId("sizeSendTime");
+ sizeDurationId = type.nameToId("sizeTime");
+ sizeTimedOutId = type.nameToId("sizeTimeouts");
+ sizeFailedId = type.nameToId("sizeFailures");
+ sizeId = type.nameToId("sizes");
+
+
+ invalidateInProgressId = type.nameToId("invalidatesInProgress");
+ invalidateSendInProgressId = sendType.nameToId("invalidateSendsInProgress");
+ invalidateSendFailedId = sendType.nameToId("invalidateSendFailures");
+ invalidateSendId = sendType.nameToId("invalidateSends");
+ invalidateSendDurationId = sendType.nameToId("invalidateSendTime");
+ invalidateDurationId = type.nameToId("invalidateTime");
+ invalidateTimedOutId = type.nameToId("invalidateTimeouts");
+ invalidateFailedId = type.nameToId("invalidateFailures");
+ invalidateId = type.nameToId("invalidates");
+
+
+ registerInterestInProgressId = type.nameToId("registerInterestsInProgress");
+ registerInterestSendInProgressId = sendType.nameToId("registerInterestSendsInProgress");
+ registerInterestSendFailedId = sendType.nameToId("registerInterestSendFailures");
+ registerInterestSendId = sendType.nameToId("registerInterestSends");
+ registerInterestSendDurationId = sendType.nameToId("registerInterestSendTime");
+ registerInterestTimedOutId = type.nameToId("registerInterestTimeouts");
+ registerInterestFailedId = type.nameToId("registerInterestFailures");
+ registerInterestId = type.nameToId("registerInterests");
+ registerInterestDurationId = type.nameToId("registerInterestTime");
+ unregisterInterestInProgressId = type.nameToId("unregisterInterestsInProgress");
+ unregisterInterestSendInProgressId = sendType.nameToId("unregisterInterestSendsInProgress");
+ unregisterInterestSendFailedId = sendType.nameToId("unregisterInterestSendFailures");
+ unregisterInterestSendId = sendType.nameToId("unregisterInterestSends");
+ unregisterInterestSendDurationId = sendType.nameToId("unregisterInterestSendTime");
+ unregisterInterestTimedOutId = type.nameToId("unregisterInterestTimeouts");
+ unregisterInterestFailedId = type.nameToId("unregisterInterestFailures");
+ unregisterInterestId = type.nameToId("unregisterInterests");
+ unregisterInterestDurationId = type.nameToId("unregisterInterestTime");
+ queryInProgressId = type.nameToId("querysInProgress");
+ querySendInProgressId = sendType.nameToId("querySendsInProgress");
+ querySendFailedId = sendType.nameToId("querySendFailures");
+ querySendId = sendType.nameToId("querySends");
+ querySendDurationId = sendType.nameToId("querySendTime");
+ queryTimedOutId = type.nameToId("queryTimeouts");
+ queryFailedId = type.nameToId("queryFailures");
+ queryId = type.nameToId("querys");
+ queryDurationId = type.nameToId("queryTime");
+ createCQInProgressId = type.nameToId("createCQsInProgress");
+ createCQSendInProgressId = sendType.nameToId("createCQSendsInProgress");
+ createCQSendFailedId = sendType.nameToId("createCQSendFailures");
+ createCQSendId = sendType.nameToId("createCQSends");
+ createCQSendDurationId = sendType.nameToId("createCQSendTime");
+ createCQTimedOutId = type.nameToId("createCQTimeouts");
+ createCQFailedId = type.nameToId("createCQFailures");
+ createCQId = type.nameToId("createCQs");
+ createCQDurationId = type.nameToId("createCQTime");
+ stopCQInProgressId = type.nameToId("stopCQsInProgress");
+ stopCQSendInProgressId = sendType.nameToId("stopCQSendsInProgress");
+ stopCQSendFailedId = sendType.nameToId("stopCQSendFailures");
+ stopCQSendId = sendType.nameToId("stopCQSends");
+ stopCQSendDurationId = sendType.nameToId("stopCQSendTime");
+ stopCQTimedOutId = type.nameToId("stopCQTimeouts");
+ stopCQFailedId = type.nameToId("stopCQFailures");
+ stopCQId = type.nameToId("stopCQs");
+ stopCQDurationId = type.nameToId("stopCQTime");
+ closeCQInProgressId = type.nameToId("closeCQsInProgress");
+ closeCQSendInProgressId = sendType.nameToId("closeCQSendsInProgress");
+ closeCQSendFailedId = sendType.nameToId("closeCQSendFailures");
+ closeCQSendId = sendType.nameToId("closeCQSends");
+ closeCQSendDurationId = sendType.nameToId("closeCQSendTime");
+ closeCQTimedOutId = type.nameToId("closeCQTimeouts");
+ closeCQFailedId = type.nameToId("closeCQFailures");
+ closeCQId = type.nameToId("closeCQs");
+ closeCQDurationId = type.nameToId("closeCQTime");
+ gatewayBatchInProgressId = type.nameToId("gatewayBatchsInProgress");
+ gatewayBatchSendInProgressId = sendType.nameToId("gatewayBatchSendsInProgress");
+ gatewayBatchSendFailedId = sendType.nameToId("gatewayBatchSendFailures");
+ gatewayBatchSendId = sendType.nameToId("gatewayBatchSends");
+ gatewayBatchSendDurationId = sendType.nameToId("gatewayBatchSendTime");
+ gatewayBatchTimedOutId = type.nameToId("gatewayBatchTimeouts");
+ gatewayBatchFailedId = type.nameToId("gatewayBatchFailures");
+ gatewayBatchId = type.nameToId("gatewayBatchs");
+ gatewayBatchDurationId = type.nameToId("gatewayBatchTime");
+ getDurableCQsInProgressId = type.nameToId("getDurableCQsInProgress");
+ getDurableCQsSendsInProgressId = sendType.nameToId("getDurableCQsSendsInProgressId");
+ getDurableCQsSendFailedId = sendType.nameToId("getDurableCQsSendFailures");
+ getDurableCQsSendId = sendType.nameToId("getDurableCQsSends");
+ getDurableCQsSendDurationId = sendType.nameToId("getDurableCQsSendTime");
+ getDurableCQsTimedOutId = type.nameToId("getDurableCQsTimeouts");
+ getDurableCQsFailedId = type.nameToId("getDurableCQsFailures");
+ getDurableCQsId = type.nameToId("getDurableCQs");
+ getDurableCQsDurationId = type.nameToId("getDurableCQsTime");
+ readyForEventsInProgressId = type.nameToId("readyForEventsInProgress");
+ readyForEventsSendInProgressId = sendType.nameToId("readyForEventsSendsInProgress");
+ readyForEventsSendFailedId = sendType.nameToId("readyForEventsSendFailures");
+ readyForEventsSendId = sendType.nameToId("readyForEventsSends");
+ readyForEventsSendDurationId = sendType.nameToId("readyForEventsSendTime");
+ readyForEventsTimedOutId = type.nameToId("readyForEventsTimeouts");
+ readyForEventsFailedId = type.nameToId("readyForEventsFailures");
+ readyForEventsId = type.nameToId("readyForEvents");
+ readyForEventsDurationId = type.nameToId("readyForEventsTime");
+ makePrimaryInProgressId = type.nameToId("makePrimarysInProgress");
+ makePrimarySendInProgressId = sendType.nameToId("makePrimarySendsInProgress");
+ makePrimarySendFailedId = sendType.nameToId("makePrimarySendFailures");
+ makePrimarySendId = sendType.nameToId("makePrimarySends");
+ makePrimarySendDurationId = sendType.nameToId("makePrimarySendTime");
+ makePrimaryTimedOutId = type.nameToId("makePrimaryTimeouts");
+ makePrimaryFailedId = type.nameToId("makePrimaryFailures");
+ makePrimaryId = type.nameToId("makePrimarys");
+ makePrimaryDurationId = type.nameToId("makePrimaryTime");
+
+ closeConInProgressId = type.nameToId("closeConsInProgress");
+ closeConSendInProgressId = sendType.nameToId("closeConSendsInProgress");
+ closeConSendFailedId = sendType.nameToId("closeConSendFailures");
+ closeConSendId = sendType.nameToId("closeConSends");
+ closeConSendDurationId = sendType.nameToId("closeConSendTime");
+ closeConTimedOutId = type.nameToId("closeConTimeouts");
+ closeConFailedId = type.nameToId("closeConFailures");
+ closeConId = type.nameToId("closeCons");
+ closeConDurationId = type.nameToId("closeConTime");
+
+ primaryAckInProgressId = type.nameToId("primaryAcksInProgress");
+ primaryAckSendInProgressId = sendType.nameToId("primaryAckSendsInProgress");
+ primaryAckSendFailedId = sendType.nameToId("primaryAckSendFailures");
+ primaryAckSendId = sendType.nameToId("primaryAckSends");
+ primaryAckSendDurationId = sendType.nameToId("primaryAckSendTime");
+ primaryAckTimedOutId = type.nameToId("primaryAckTimeouts");
+ primaryAckFailedId = type.nameToId("primaryAckFailures");
+ primaryAckId = type.nameToId("primaryAcks");
+ primaryAckDurationId = type.nameToId("primaryAckTime");
+
+ pingInProgressId = type.nameToId("pingsInProgress");
+ pingSendInProgressId = sendType.nameToId("pingSendsInProgress");
+ pingSendFailedId = sendType.nameToId("pingSendFailures");
+ pingSendId = sendType.nameToId("pingSends");
+ pingSendDurationId = sendType.nameToId("pingSendTime");
+ pingTimedOutId = type.nameToId("pingTimeouts");
+ pingFailedId = type.nameToId("pingFailures");
+ pingId = type.nameToId("pings");
+ pingDurationId = type.nameToId("pingTime");
+
+ registerInstantiatorsInProgressId = type.nameToId("registerInstantiatorsInProgress");
+ registerInstantiatorsSendInProgressId = sendType.nameToId("registerInstantiatorsSendsInProgress");
+ registerInstantiatorsSendFailedId = sendType.nameToId("registerInstantiatorsSendFailures");
+ registerInstantiatorsSendId = sendType.nameToId("registerInstantiatorsSends");
+ registerInstantiatorsSendDurationId = sendType.nameToId("registerInstantiatorsSendTime");
+ registerInstantiatorsTimedOutId = type.nameToId("registerInstantiatorsTimeouts");
+ registerInstantiatorsFailedId = type.nameToId("registerInstantiatorsFailures");
+ registerInstantiatorsId = type.nameToId("registerInstantiators");
+ registerInstantiatorsDurationId = type.nameToId("registerInstantiatorsTime");
+
+ registerDataSerializersInProgressId = type.nameToId("registerDataSerializersInProgress");
+ registerDataSerializersSendInProgressId = sendType.nameToId("registerDataSerializersSendInProgress");
+ registerDataSerializersSendFailedId = sendType.nameToId("registerDataSerializersSendFailures");
+ registerDataSerializersSendId = sendType.nameToId("registerDataSerializersSends");
+ registerDataSerializersSendDurationId = sendType.nameToId("registerDataSerializersSendTime");
+ registerDataSerializersTimedOutId = type.nameToId("registerDataSerializersTimeouts");
+ registerDataSerializersFailedId = type.nameToId("registerDataSerializersFailures");
+ registerDataSerializersId = type.nameToId("registerDataSerializers");
+ registerDataSerializersDurationId = type.nameToId("registerDataSerializersTime");
+
+ putAllInProgressId = type.nameToId("putAllsInProgress");
+ putAllSendInProgressId = sendType.nameToId("putAllSendsInProgress");
+ putAllSendFailedId = sendType.nameToId("putAllSendFailures");
+ putAllSendId = sendType.nameToId("putAllSends");
+ putAllSendDurationId = sendType.nameToId("putAllSendTime");
+ putAllTimedOutId = type.nameToId("putAllTimeouts");
+ putAllFailedId = type.nameToId("putAllFailures");
+ putAllId = type.nameToId("putAlls");
+ putAllDurationId = type.nameToId("putAllTime");
+
+ removeAllInProgressId = type.nameToId("removeAllsInProgress");
+ removeAllSendInProgressId = sendType.nameToId("removeAllSendsInProgress");
+ removeAllSendFailedId = sendType.nameToId("removeAllSendFailures");
+ removeAllSendId = sendType.nameToId("removeAllSends");
+ removeAllSendDurationId = sendType.nameToId("removeAllSendTime");
+ removeAllTimedOutId = type.nameToId("removeAllTimeouts");
+ removeAllFailedId = type.nameToId("removeAllFailures");
+ removeAllId = type.nameToId("removeAlls");
+ removeAllDurationId = type.nameToId("removeAllTime");
+
+ getAllInProgressId = type.nameToId("getAllsInProgress");
+ getAllSendInProgressId = sendType.nameToId("getAllSendsInProgress");
+ getAllSendFailedId = sendType.nameToId("getAllSendFailures");
+ getAllSendId = sendType.nameToId("getAllSends");
+ getAllSendDurationId = sendType.nameToId("getAllSendTime");
+ getAllTimedOutId = type.nameToId("getAllTimeouts");
+ getAllFailedId = type.nameToId("getAllFailures");
+ getAllId = type.nameToId("getAlls");
+ getAllDurationId = type.nameToId("getAllTime");
+
+ connectionsId = type.nameToId("connections");
+ connectsId = type.nameToId("connects");
+ disconnectsId = type.nameToId("disconnects");
+
+ receivedBytesId = type.nameToId("receivedBytes");
+ sentBytesId = type.nameToId("sentBytes");
+ messagesBeingReceivedId = type.nameToId("messagesBeingReceived");
+ messageBytesBeingReceivedId = type.nameToId("messageBytesBeingReceived");
+
+ executeFunctionInProgressId = type.nameToId("executeFunctionsInProgress");
+ executeFunctionSendInProgressId = sendType.nameToId("executeFunctionSendsInProgress");
+ executeFunctionSendFailedId = sendType.nameToId("executeFunctionSendFailures");
+ executeFunctionSendId = sendType.nameToId("executeFunctionSends");
+ executeFunctionSendDurationId = sendType.nameToId("executeFunctionSendTime");
+ executeFunctionTimedOutId = type.nameToId("executeFunctionTimeouts");
+ executeFunctionFailedId = type.nameToId("executeFunctionFailures");
+ executeFunctionId = type.nameToId("executeFunctions");
+ executeFunctionDurationId = type.
<TRUNCATED>