| /* |
| * 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. |
| */ |
| |
| #include "PoolStatistics.hpp" |
| |
| #include <geode/internal/geode_globals.hpp> |
| //#include "StatisticsFactory.hpp" |
| |
| #include <mutex> |
| |
| #include <ace/Singleton.h> |
| |
| #include "util/concurrent/spinlock_mutex.hpp" |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| namespace apache { |
| namespace geode { |
| namespace client { |
| |
| using statistics::StatisticsFactory; |
| using statistics::StatisticsManager; |
| using util::concurrent::spinlock_mutex; |
| |
| constexpr const char* PoolStats::STATS_NAME; |
| constexpr const char* PoolStats::STATS_DESC; |
| |
| PoolStats::PoolStats(StatisticsFactory* factory, const std::string& poolName) { |
| auto statsType = factory->findType(STATS_NAME); |
| |
| if (statsType == nullptr) { |
| auto stats = new StatisticDescriptor*[27]; |
| |
| stats[0] = factory->createIntGauge( |
| "locators", "Current number of locators discovered", "locators"); |
| stats[1] = factory->createIntGauge( |
| "servers", "Current number of servers discovered", "servers"); |
| stats[2] = factory->createIntGauge( |
| "subscriptionServers", |
| "Number of servers hosting this clients subscriptions", "servers"); |
| stats[3] = factory->createLongCounter( |
| "locatorRequests", |
| "Number of requests from this connection pool to a locator", |
| "requests"); |
| stats[4] = factory->createLongCounter( |
| "locatorResponses", |
| "Number of responses from the locator to this connection pool", |
| "responses"); |
| stats[5] = factory->createIntGauge( |
| "poolConnections", "Current number of pool connections", "connections"); |
| stats[6] = factory->createIntCounter( |
| "connects", "Total number of times a connection has been created.", |
| "connects"); |
| stats[7] = factory->createIntCounter( |
| "disconnects", "Total number of times a connection has been destroyed.", |
| "disconnects"); |
| stats[8] = factory->createIntCounter( |
| "minPoolSizeConnects", |
| "Total number of connects done to maintain minimum pool size.", |
| "connects"); |
| stats[9] = factory->createIntCounter( |
| "loadConditioningConnects", |
| "Total number of connects done due to load conditioning.", "connects"); |
| stats[10] = factory->createIntCounter( |
| "idleDisconnects", |
| "Total number of disconnects done due to idle expiration.", |
| "disconnects"); |
| stats[11] = factory->createIntCounter( |
| "loadConditioningDisconnects", |
| "Total number of disconnects done due to load conditioning expiration.", |
| "disconnects"); |
| stats[12] = factory->createIntGauge( |
| "connectionWaitsInProgress", |
| "Current number of threads waiting for a connection", "threads"); |
| stats[13] = factory->createIntCounter( |
| "connectionWaits", |
| "Total number of times a thread completed waiting for a connection (by " |
| "timing out or by getting a connection).", |
| "waits"); |
| stats[14] = factory->createLongCounter( |
| "connectionWaitTime", |
| "Total time (nanoseconds) spent waiting for a connection.", |
| "nanoseconds"); |
| stats[15] = factory->createIntGauge( |
| "clientOpsInProgress", "Current number of clientOps being executed", |
| "clientOps"); |
| stats[16] = factory->createIntCounter( |
| "clientOps", "Total number of clientOps completed successfully", |
| "clientOps"); |
| stats[17] = factory->createLongCounter( |
| "clientOpTime", |
| "Total amount of time, in nanoseconds spent doing clientOps", |
| "nanoseconds"); |
| stats[18] = factory->createIntCounter( |
| "clientOpFailures", |
| "Total number of clientOp attempts that have failed", "clientOps"); |
| stats[19] = factory->createIntCounter( |
| "clientOpTimeouts", |
| "Total number of clientOp attempts that have timed out", "clientOps"); |
| stats[20] = factory->createLongCounter( |
| "receivedBytes", "Total number of bytes received from the server.", |
| "bytes"); |
| stats[21] = factory->createLongCounter( |
| "messagesBeingReceived", |
| "Total number of message being received off the network.", "messages"); |
| stats[22] = factory->createLongCounter( |
| "processedDeltaMessages", |
| "Total number of delta message processed successfully", "messages"); |
| stats[23] = factory->createLongCounter( |
| "deltaMessageFailures", "Total number of failures in processing delta", |
| "messages"); |
| stats[24] = factory->createLongCounter( |
| "processedDeltaMessagesTime", "Total time spent while processing Delta", |
| "nanoseconds"); |
| stats[25] = factory->createIntCounter("queryExecutions", |
| "Total number of queryExecutions", |
| "queryExecutions"); |
| stats[26] = factory->createLongCounter( |
| "queryExecutionTime", |
| "Total time spent while processing queryExecution", "nanoseconds"); |
| |
| statsType = factory->createType(STATS_NAME, STATS_DESC, stats, 27); |
| } |
| m_locatorsId = statsType->nameToId("locators"); |
| m_serversId = statsType->nameToId("servers"); |
| m_subsServsId = statsType->nameToId("subscriptionServers"); |
| m_locReqsId = statsType->nameToId("locatorRequests"); |
| m_locRespsId = statsType->nameToId("locatorResponses"); |
| m_poolConnsId = statsType->nameToId("poolConnections"); |
| m_connectsId = statsType->nameToId("connects"); |
| m_disconnectsId = statsType->nameToId("disconnects"); |
| m_minPoolConnectsId = statsType->nameToId("minPoolSizeConnects"); |
| m_loadCondConnectsId = statsType->nameToId("loadConditioningConnects"); |
| m_idleDisconnectsId = statsType->nameToId("idleDisconnects"); |
| m_loadCondDisconnectsId = statsType->nameToId("loadConditioningDisconnects"); |
| m_waitingConnectionsId = statsType->nameToId("connectionWaitsInProgress"); |
| m_totalWaitingConnsId = statsType->nameToId("connectionWaits"); |
| m_totalWaitingConnTimeId = statsType->nameToId("connectionWaitTime"); |
| m_curClientOpsId = statsType->nameToId("clientOpsInProgress"); |
| m_clientOpsSuccessId = statsType->nameToId("clientOps"); |
| m_clientOpsSuccessTimeId = statsType->nameToId("clientOpTime"); |
| m_clientOpsFailedId = statsType->nameToId("clientOpFailures"); |
| m_clientOpsTimeoutId = statsType->nameToId("clientOpTimeouts"); |
| m_receivedBytesId = statsType->nameToId("receivedBytes"); |
| m_messagesBeingReceivedId = statsType->nameToId("messagesBeingReceived"); |
| m_processedDeltaMessagesId = statsType->nameToId("processedDeltaMessages"); |
| m_deltaMessageFailuresId = statsType->nameToId("deltaMessageFailures"); |
| m_processedDeltaMessagesTimeId = |
| statsType->nameToId("processedDeltaMessagesTime"); |
| m_queryExecutionsId = statsType->nameToId("queryExecutions"); |
| m_queryExecutionTimeId = statsType->nameToId("queryExecutionTime"); |
| |
| m_poolStats = factory->createAtomicStatistics(statsType, poolName.c_str()); |
| |
| getStats()->setInt(m_locatorsId, 0); |
| getStats()->setInt(m_serversId, 0); |
| getStats()->setInt(m_subsServsId, 0); |
| getStats()->setLong(m_locReqsId, 0); |
| getStats()->setLong(m_locRespsId, 0); |
| getStats()->setInt(m_poolConnsId, 0); |
| getStats()->setInt(m_connectsId, 0); |
| getStats()->setInt(m_disconnectsId, 0); |
| getStats()->setInt(m_minPoolConnectsId, 0); |
| getStats()->setInt(m_loadCondConnectsId, 0); |
| getStats()->setInt(m_idleDisconnectsId, 0); |
| getStats()->setInt(m_loadCondDisconnectsId, 0); |
| getStats()->setInt(m_waitingConnectionsId, 0); |
| getStats()->setInt(m_totalWaitingConnsId, 0); |
| getStats()->setLong(m_totalWaitingConnTimeId, 0); |
| getStats()->setInt(m_curClientOpsId, 0); |
| getStats()->setInt(m_clientOpsSuccessId, 0); |
| getStats()->setLong(m_clientOpsSuccessTimeId, 0); |
| getStats()->setInt(m_clientOpsFailedId, 0); |
| getStats()->setInt(m_clientOpsTimeoutId, 0); |
| getStats()->setInt(m_receivedBytesId, 0); |
| getStats()->setInt(m_messagesBeingReceivedId, 0); |
| getStats()->setInt(m_processedDeltaMessagesId, 0); |
| getStats()->setInt(m_deltaMessageFailuresId, 0); |
| getStats()->setInt(m_processedDeltaMessagesTimeId, 0); |
| getStats()->setInt(m_queryExecutionsId, 0); |
| getStats()->setLong(m_queryExecutionTimeId, 0); |
| } |
| |
| PoolStats::~PoolStats() { |
| if (m_poolStats != nullptr) { |
| m_poolStats = nullptr; |
| } |
| } |
| } // namespace client |
| } // namespace geode |
| } // namespace apache |
