in mcrouter/stats.cpp [373:625]
void prepare_stats(CarbonRouterInstanceBase& router, stat_t* stats) {
init_stats(stats);
uint64_t config_last_success = 0;
uint64_t destinationBatchesSum = 0;
uint64_t destinationRequestsSum = 0;
uint64_t outstandingGetReqsTotal = 0;
uint64_t outstandingGetReqsHelper = 0;
uint64_t outstandingGetWaitTimeSumUs = 0;
uint64_t outstandingUpdateReqsTotal = 0;
uint64_t outstandingUpdateReqsHelper = 0;
uint64_t outstandingUpdateWaitTimeSumUs = 0;
uint64_t retransPerKByteSum = 0;
uint64_t retransNumTotal = 0;
uint64_t destinationRequestsDirtyBufferSum = 0;
uint64_t destinationRequestsTotalSum = 0;
for (size_t i = 0; i < router.opts().num_proxies; ++i) {
auto proxy = router.getProxyBase(i);
config_last_success = std::max(
config_last_success, proxy->stats().getValue(config_last_success_stat));
destinationBatchesSum +=
proxy->stats().getStatValueWithinWindow(destination_batches_sum_stat);
destinationRequestsSum +=
proxy->stats().getStatValueWithinWindow(destination_requests_sum_stat);
outstandingGetReqsTotal += proxy->stats().getStatValueWithinWindow(
outstanding_route_get_reqs_queued_stat);
outstandingGetReqsHelper += proxy->stats().getStatValueWithinWindow(
outstanding_route_get_reqs_queued_helper_stat);
outstandingGetWaitTimeSumUs += proxy->stats().getStatValueWithinWindow(
outstanding_route_get_wait_time_sum_us_stat);
outstandingUpdateReqsTotal += proxy->stats().getStatValueWithinWindow(
outstanding_route_update_reqs_queued_stat);
outstandingUpdateReqsHelper += proxy->stats().getStatValueWithinWindow(
outstanding_route_update_reqs_queued_helper_stat);
outstandingUpdateWaitTimeSumUs += proxy->stats().getStatValueWithinWindow(
outstanding_route_update_wait_time_sum_us_stat);
retransPerKByteSum +=
proxy->stats().getStatValueWithinWindow(retrans_per_kbyte_sum_stat);
retransNumTotal +=
proxy->stats().getStatValueWithinWindow(retrans_num_total_stat);
destinationRequestsDirtyBufferSum +=
proxy->stats().getStatValueWithinWindow(
destination_reqs_dirty_buffer_sum_stat);
destinationRequestsTotalSum += proxy->stats().getStatValueWithinWindow(
destination_reqs_total_sum_stat);
}
stat_set(
stats,
num_suspect_servers_stat,
router.tkoTrackerMap().getSuspectServersCount());
double avgBatchSize = 0.0;
if (destinationBatchesSum != 0) {
avgBatchSize = destinationRequestsSum / (double)destinationBatchesSum;
}
stat_set(stats, destination_batch_size_stat, avgBatchSize);
double avgRetransPerKByte = 0.0;
if (retransNumTotal != 0) {
avgRetransPerKByte = retransPerKByteSum / (double)retransNumTotal;
}
stat_set(stats, retrans_per_kbyte_avg_stat, avgRetransPerKByte);
double reqsDirtyBufferRatio = 0.0;
if (destinationRequestsTotalSum != 0) {
reqsDirtyBufferRatio =
destinationRequestsDirtyBufferSum / (double)destinationRequestsTotalSum;
}
stat_set(
stats, destination_reqs_dirty_buffer_ratio_stat, reqsDirtyBufferRatio);
stat_set(stats, outstanding_route_get_avg_queue_size_stat, 0.0);
stat_set(stats, outstanding_route_get_avg_wait_time_sec_stat, 0.0);
if (outstandingGetReqsTotal > 0) {
stat_set(
stats,
outstanding_route_get_avg_queue_size_stat,
outstandingGetReqsHelper / (double)outstandingGetReqsTotal);
stat_set(
stats,
outstanding_route_get_avg_wait_time_sec_stat,
outstandingGetWaitTimeSumUs / (1000000.0 * outstandingGetReqsTotal));
}
stat_set(stats, outstanding_route_update_avg_queue_size_stat, 0.0);
stat_set(stats, outstanding_route_update_avg_wait_time_sec_stat, 0.0);
if (outstandingUpdateReqsTotal > 0) {
stat_set(
stats,
outstanding_route_update_avg_queue_size_stat,
outstandingUpdateReqsHelper / (double)outstandingUpdateReqsTotal);
stat_set(
stats,
outstanding_route_update_avg_wait_time_sec_stat,
outstandingUpdateWaitTimeSumUs /
(1000000.0 * outstandingUpdateReqsTotal));
}
folly::make_atomic_ref(stats[commandargs_stat].data.string)
.store(gStandaloneArgs, std::memory_order_relaxed);
uint64_t now = time(nullptr);
stat_set(stats, time_stat, now);
stat_set(stats, uptime_stat, now - router.startTime());
stat_set(stats, config_age_stat, now - config_last_success);
stat_set(stats, config_last_success_stat, config_last_success);
stat_set(
stats,
config_last_attempt_stat,
static_cast<uint64_t>(router.lastConfigAttempt()));
stat_set(stats, config_failures_stat, router.configFailures());
stat_set(stats, config_full_attempt_stat, router.configFullAttempt());
stat_set(
stats,
configs_from_disk_stat,
static_cast<uint64_t>(router.configuredFromDisk()));
stat_set(
stats,
config_partial_reconfig_attempt_stat,
router.partialReconfigAttempt());
stat_set(
stats,
config_partial_reconfig_success_stat,
router.partialReconfigSuccess());
folly::make_atomic_ref(stats[pid_stat].data.int64)
.store(getpid(), std::memory_order_relaxed);
folly::make_atomic_ref(stats[parent_pid_stat].data.int64)
.store(getppid(), std::memory_order_relaxed);
struct rusage ru;
getrusage(RUSAGE_SELF, &ru);
stat_set(
stats,
rusage_user_stat,
ru.ru_utime.tv_sec + ru.ru_utime.tv_usec / 1000000.0);
stat_set(
stats,
rusage_system_stat,
ru.ru_stime.tv_sec + ru.ru_stime.tv_usec / 1000000.0);
proc_stat_data_t ps_data;
get_proc_stat(getpid(), &ps_data);
stat_set(stats, ps_num_minor_faults_stat, ps_data.num_minor_faults);
stat_set(stats, ps_num_major_faults_stat, ps_data.num_major_faults);
stat_set(stats, ps_user_time_sec_stat, ps_data.user_time_sec);
stat_set(stats, ps_system_time_sec_stat, ps_data.system_time_sec);
stat_set(stats, ps_rss_stat, ps_data.rss);
stat_set(stats, ps_vsize_stat, ps_data.vsize);
stat_set(stats, fibers_allocated_stat, UINT64_C(0));
stat_set(stats, fibers_pool_size_stat, UINT64_C(0));
stat_set(stats, fibers_stack_high_watermark_stat, UINT64_C(0));
for (size_t i = 0; i < router.opts().num_proxies; ++i) {
auto pr = router.getProxyBase(i);
stat_incr(
stats,
fibers_allocated_stat,
static_cast<int64_t>(pr->fiberManager().fibersAllocated()));
stat_incr(
stats,
fibers_pool_size_stat,
static_cast<int64_t>(pr->fiberManager().fibersPoolSize()));
stat_set(
stats,
fibers_stack_high_watermark_stat,
std::max(
stat_get_uint64(stats, fibers_stack_high_watermark_stat),
pr->fiberManager().stackHighWatermark()));
stat_incr(stats, duration_us_stat, pr->stats().durationUs().value());
stat_incr(stats, duration_get_us_stat, pr->stats().durationGetUs().value());
stat_incr(
stats, duration_update_us_stat, pr->stats().durationUpdateUs().value());
stat_incr(
stats,
inactive_connection_closed_interval_sec_stat,
pr->stats().inactiveConnectionClosedIntervalSec().value());
stat_incr(
stats,
client_queue_notify_period_stat,
static_cast<int64_t>(pr->queueNotifyPeriod()));
stat_incr(
stats,
asynclog_duration_us_stat,
pr->stats().asyncLogDurationUs().value());
stat_incr(
stats,
axonlog_duration_us_stat,
pr->stats().axonLogDurationUs().value());
stat_set(
stats,
proxy_queue_full_stat,
std::max(
stat_get_uint64(stats, proxy_queue_full_stat),
static_cast<uint64_t>(pr->messageQueueFull() ? 1 : 0)));
stat_set(
stats,
proxy_queues_all_full_stat,
std::min(
i ? stat_get_uint64(stats, proxy_queue_full_stat) : 0,
static_cast<uint64_t>(pr->messageQueueFull() ? 1 : 0)));
}
if (router.opts().num_proxies > 0) {
stat_div(stats, duration_us_stat, router.opts().num_proxies);
stat_div(stats, duration_get_us_stat, router.opts().num_proxies);
stat_div(stats, duration_update_us_stat, router.opts().num_proxies);
stat_div(
stats,
inactive_connection_closed_interval_sec_stat,
router.opts().num_proxies);
stat_div(stats, client_queue_notify_period_stat, router.opts().num_proxies);
stat_div(stats, asynclog_duration_us_stat, router.opts().num_proxies);
stat_div(stats, axonlog_duration_us_stat, router.opts().num_proxies);
}
for (int i = 0; i < num_stats; i++) {
if (stats[i].aggregate && !(stats[i].group & rate_stats)) {
for (size_t j = 0; j < router.opts().num_proxies; ++j) {
auto pr = router.getProxyBase(j);
if (stats[i].type == stat_uint64) {
stat_incr(
stats,
static_cast<stat_name_t>(i),
static_cast<int64_t>(
folly::make_atomic_ref(pr->stats().getStat(i).data.uint64)
.load(std::memory_order_relaxed)));
} else if (stats[i].type == stat_int64) {
stat_incr(
stats,
static_cast<stat_name_t>(i),
folly::make_atomic_ref(pr->stats().getStat(i).data.int64)
.load(std::memory_order_relaxed));
} else if (stats[i].type == stat_double) {
stat_incr(
stats,
static_cast<stat_name_t>(i),
folly::make_atomic_ref(pr->stats().getStat(i).data.dbl)
.load(std::memory_order_relaxed));
} else {
LOG(FATAL) << "you can't aggregate non-numerical stats!";
}
}
}
}
}