diff options
Diffstat (limited to '')
31 files changed, 9229 insertions, 0 deletions
diff --git a/src/go/collectors/go.d.plugin/modules/consul/README.md b/src/go/collectors/go.d.plugin/modules/consul/README.md new file mode 120000 index 000000000..5e57e46dc --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/README.md @@ -0,0 +1 @@ +integrations/consul.md
\ No newline at end of file diff --git a/src/go/collectors/go.d.plugin/modules/consul/charts.go b/src/go/collectors/go.d.plugin/modules/consul/charts.go new file mode 100644 index 000000000..3e6c50cfd --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/charts.go @@ -0,0 +1,739 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package consul + +import ( + "fmt" + + "github.com/blang/semver/v4" + + "github.com/netdata/netdata/go/go.d.plugin/agent/module" +) + +const ( + _ = module.Priority + iota + prioKVSApplyTime + prioKVSApplyOperations + prioTXNApplyTime + prioTXNApplyOperations + prioRaftCommitTime + prioRaftCommitsRate + + prioServerLeadershipStatus + prioRaftLeaderLastContactTime + prioRaftFollowerLastContactLeaderTime + prioRaftLeaderElections + prioRaftLeadershipTransitions + + prioAutopilotClusterHealthStatus + prioAutopilotFailureTolerance + prioAutopilotServerHealthStatus + prioAutopilotServerStableTime + prioAutopilotServerSerfStatus + prioAutopilotServerVoterStatus + + prioNetworkLanRTT + + prioRPCRequests + prioRPCRequestsExceeded + prioRPCRequestsFailed + + prioRaftThreadMainSaturation + prioRaftThreadFSMSaturation + + prioRaftFSMLastRestoreDuration + prioRaftLeaderOldestLogAge + prioRaftRPCInstallSnapshotTime + + prioBoltDBFreelistBytes + prioBoltDBLogsPerBatch + prioBoltDBStoreLogsTime + + prioMemoryAllocated + prioMemorySys + prioGCPauseTime + + prioServiceHealthCheckStatus + prioNodeHealthCheckStatus + + prioLicenseExpirationTime +) + +var ( + clientCharts = module.Charts{ + clientRPCRequestsRateChart.Copy(), + clientRPCRequestsExceededRateChart.Copy(), + clientRPCRequestsFailedRateChart.Copy(), + + memoryAllocatedChart.Copy(), + memorySysChart.Copy(), + gcPauseTimeChart.Copy(), + + licenseExpirationTimeChart.Copy(), + } + + serverLeaderCharts = module.Charts{ + raftCommitTimeChart.Copy(), + raftLeaderLastContactTimeChart.Copy(), + raftCommitsRateChart.Copy(), + raftLeaderOldestLogAgeChart.Copy(), + } + serverFollowerCharts = module.Charts{ + raftFollowerLastContactLeaderTimeChart.Copy(), + raftRPCInstallSnapshotTimeChart.Copy(), + } + serverAutopilotHealthCharts = module.Charts{ + autopilotServerHealthStatusChart.Copy(), + autopilotServerStableTimeChart.Copy(), + autopilotServerSerfStatusChart.Copy(), + autopilotServerVoterStatusChart.Copy(), + } + serverCommonCharts = module.Charts{ + kvsApplyTimeChart.Copy(), + kvsApplyOperationsRateChart.Copy(), + txnApplyTimeChart.Copy(), + txnApplyOperationsRateChart.Copy(), + + autopilotClusterHealthStatusChart.Copy(), + autopilotFailureTolerance.Copy(), + + raftLeaderElectionsRateChart.Copy(), + raftLeadershipTransitionsRateChart.Copy(), + serverLeadershipStatusChart.Copy(), + + networkLanRTTChart.Copy(), + + clientRPCRequestsRateChart.Copy(), + clientRPCRequestsExceededRateChart.Copy(), + clientRPCRequestsFailedRateChart.Copy(), + + raftThreadMainSaturationPercChart.Copy(), + raftThreadFSMSaturationPercChart.Copy(), + + raftFSMLastRestoreDurationChart.Copy(), + + raftBoltDBFreelistBytesChart.Copy(), + raftBoltDBLogsPerBatchChart.Copy(), + raftBoltDBStoreLogsTimeChart.Copy(), + + memoryAllocatedChart.Copy(), + memorySysChart.Copy(), + gcPauseTimeChart.Copy(), + + licenseExpirationTimeChart.Copy(), + } + + kvsApplyTimeChart = module.Chart{ + ID: "kvs_apply_time", + Title: "KVS apply time", + Units: "ms", + Fam: "transaction timing", + Ctx: "consul.kvs_apply_time", + Priority: prioKVSApplyTime, + Dims: module.Dims{ + {ID: "kvs_apply_quantile=0.5", Name: "quantile_0.5", Div: precision * precision}, + {ID: "kvs_apply_quantile=0.9", Name: "quantile_0.9", Div: precision * precision}, + {ID: "kvs_apply_quantile=0.99", Name: "quantile_0.99", Div: precision * precision}, + }, + } + kvsApplyOperationsRateChart = module.Chart{ + ID: "kvs_apply_operations_rate", + Title: "KVS apply operations", + Units: "ops/s", + Fam: "transaction timing", + Ctx: "consul.kvs_apply_operations_rate", + Priority: prioKVSApplyOperations, + Dims: module.Dims{ + {ID: "kvs_apply_count", Name: "kvs_apply"}, + }, + } + txnApplyTimeChart = module.Chart{ + ID: "txn_apply_time", + Title: "Transaction apply time", + Units: "ms", + Fam: "transaction timing", + Ctx: "consul.txn_apply_time", + Priority: prioTXNApplyTime, + Dims: module.Dims{ + {ID: "txn_apply_quantile=0.5", Name: "quantile_0.5", Div: precision * precision}, + {ID: "txn_apply_quantile=0.9", Name: "quantile_0.9", Div: precision * precision}, + {ID: "txn_apply_quantile=0.99", Name: "quantile_0.99", Div: precision * precision}, + }, + } + txnApplyOperationsRateChart = module.Chart{ + ID: "txn_apply_operations_rate", + Title: "Transaction apply operations", + Units: "ops/s", + Fam: "transaction timing", + Ctx: "consul.txn_apply_operations_rate", + Priority: prioTXNApplyOperations, + Dims: module.Dims{ + {ID: "txn_apply_count", Name: "kvs_apply"}, + }, + } + + raftCommitTimeChart = module.Chart{ + ID: "raft_commit_time", + Title: "Raft commit time", + Units: "ms", + Fam: "transaction timing", + Ctx: "consul.raft_commit_time", + Priority: prioRaftCommitTime, + Dims: module.Dims{ + {ID: "raft_commitTime_quantile=0.5", Name: "quantile_0.5", Div: precision * precision}, + {ID: "raft_commitTime_quantile=0.9", Name: "quantile_0.9", Div: precision * precision}, + {ID: "raft_commitTime_quantile=0.99", Name: "quantile_0.99", Div: precision * precision}, + }, + } + raftCommitsRateChart = module.Chart{ + ID: "raft_commits_rate", + Title: "Raft commits rate", + Units: "commits/s", + Fam: "transaction timing", + Ctx: "consul.raft_commits_rate", + Priority: prioRaftCommitsRate, + Dims: module.Dims{ + {ID: "raft_apply", Name: "commits", Div: precision, Algo: module.Incremental}, + }, + } + + autopilotClusterHealthStatusChart = module.Chart{ + ID: "autopilot_health_status", + Title: "Autopilot cluster health status", + Units: "status", + Fam: "autopilot", + Ctx: "consul.autopilot_health_status", + Priority: prioAutopilotClusterHealthStatus, + Dims: module.Dims{ + {ID: "autopilot_healthy_yes", Name: "healthy"}, + {ID: "autopilot_healthy_no", Name: "unhealthy"}, + }, + } + autopilotFailureTolerance = module.Chart{ + ID: "autopilot_failure_tolerance", + Title: "Autopilot cluster failure tolerance", + Units: "servers", + Fam: "autopilot", + Ctx: "consul.autopilot_failure_tolerance", + Priority: prioAutopilotFailureTolerance, + Dims: module.Dims{ + {ID: "autopilot_failure_tolerance", Name: "failure_tolerance"}, + }, + } + autopilotServerHealthStatusChart = module.Chart{ + ID: "autopilot_server_health_status", + Title: "Autopilot server health status", + Units: "status", + Fam: "autopilot", + Ctx: "consul.autopilot_server_health_status", + Priority: prioAutopilotServerHealthStatus, + Dims: module.Dims{ + {ID: "autopilot_server_healthy_yes", Name: "healthy"}, + {ID: "autopilot_server_healthy_no", Name: "unhealthy"}, + }, + } + autopilotServerStableTimeChart = module.Chart{ + ID: "autopilot_server_stable_time", + Title: "Autopilot server stable time", + Units: "seconds", + Fam: "autopilot", + Ctx: "consul.autopilot_server_stable_time", + Priority: prioAutopilotServerStableTime, + Dims: module.Dims{ + {ID: "autopilot_server_stable_time", Name: "stable"}, + }, + } + autopilotServerSerfStatusChart = module.Chart{ + ID: "autopilot_server_serf_status", + Title: "Autopilot server Serf status", + Units: "status", + Fam: "autopilot", + Ctx: "consul.autopilot_server_serf_status", + Priority: prioAutopilotServerSerfStatus, + Dims: module.Dims{ + {ID: "autopilot_server_sefStatus_alive", Name: "alive"}, + {ID: "autopilot_server_sefStatus_failed", Name: "failed"}, + {ID: "autopilot_server_sefStatus_left", Name: "left"}, + {ID: "autopilot_server_sefStatus_none", Name: "none"}, + }, + } + autopilotServerVoterStatusChart = module.Chart{ + ID: "autopilot_server_voter_status", + Title: "Autopilot server Raft voting membership", + Units: "status", + Fam: "autopilot", + Ctx: "consul.autopilot_server_voter_status", + Priority: prioAutopilotServerVoterStatus, + Dims: module.Dims{ + {ID: "autopilot_server_voter_yes", Name: "voter"}, + {ID: "autopilot_server_voter_no", Name: "not_voter"}, + }, + } + + raftLeaderLastContactTimeChart = module.Chart{ + ID: "raft_leader_last_contact_time", + Title: "Raft leader last contact time", + Units: "ms", + Fam: "leadership changes", + Ctx: "consul.raft_leader_last_contact_time", + Priority: prioRaftLeaderLastContactTime, + Dims: module.Dims{ + {ID: "raft_leader_lastContact_quantile=0.5", Name: "quantile_0.5", Div: precision * precision}, + {ID: "raft_leader_lastContact_quantile=0.9", Name: "quantile_0.9", Div: precision * precision}, + {ID: "raft_leader_lastContact_quantile=0.99", Name: "quantile_0.99", Div: precision * precision}, + }, + } + raftFollowerLastContactLeaderTimeChart = module.Chart{ + ID: "raft_follower_last_contact_leader_time", + Title: "Raft follower last contact with the leader time", + Units: "ms", + Fam: "leadership changes", + Ctx: "consul.raft_follower_last_contact_leader_time", + Priority: prioRaftFollowerLastContactLeaderTime, + Dims: module.Dims{ + {ID: "autopilot_server_lastContact_leader", Name: "leader_last_contact"}, + }, + } + raftLeaderElectionsRateChart = module.Chart{ + ID: "raft_leader_elections_rate", + Title: "Raft leader elections rate", + Units: "elections/s", + Fam: "leadership changes", + Ctx: "consul.raft_leader_elections_rate", + Priority: prioRaftLeaderElections, + Dims: module.Dims{ + {ID: "raft_state_candidate", Name: "leader", Algo: module.Incremental}, + }, + } + raftLeadershipTransitionsRateChart = module.Chart{ + ID: "raft_leadership_transitions_rate", + Title: "Raft leadership transitions rate", + Units: "transitions/s", + Fam: "leadership changes", + Ctx: "consul.raft_leadership_transitions_rate", + Priority: prioRaftLeadershipTransitions, + Dims: module.Dims{ + {ID: "raft_state_leader", Name: "leadership", Algo: module.Incremental}, + }, + } + serverLeadershipStatusChart = module.Chart{ + ID: "server_leadership_status", + Title: "Server leadership status", + Units: "status", + Fam: "leadership changes", + Ctx: "consul.server_leadership_status", + Priority: prioServerLeadershipStatus, + Dims: module.Dims{ + {ID: "server_isLeader_yes", Name: "leader"}, + {ID: "server_isLeader_no", Name: "not_leader"}, + }, + } + + networkLanRTTChart = module.Chart{ + ID: "network_lan_rtt", + Title: "Network lan RTT", + Units: "ms", + Fam: "network rtt", + Ctx: "consul.network_lan_rtt", + Type: module.Area, + Priority: prioNetworkLanRTT, + Dims: module.Dims{ + {ID: "network_lan_rtt_min", Name: "min", Div: 1e6}, + {ID: "network_lan_rtt_max", Name: "max", Div: 1e6}, + {ID: "network_lan_rtt_avg", Name: "avg", Div: 1e6}, + }, + } + + clientRPCRequestsRateChart = module.Chart{ + ID: "client_rpc_requests_rate", + Title: "Client RPC requests", + Units: "requests/s", + Fam: "rpc network activity", + Ctx: "consul.client_rpc_requests_rate", + Priority: prioRPCRequests, + Dims: module.Dims{ + {ID: "client_rpc", Name: "rpc", Algo: module.Incremental}, + }, + } + clientRPCRequestsExceededRateChart = module.Chart{ + ID: "client_rpc_requests_exceeded_rate", + Title: "Client rate-limited RPC requests", + Units: "requests/s", + Fam: "rpc network activity", + Ctx: "consul.client_rpc_requests_exceeded_rate", + Priority: prioRPCRequestsExceeded, + Dims: module.Dims{ + {ID: "client_rpc_exceeded", Name: "exceeded", Algo: module.Incremental}, + }, + } + clientRPCRequestsFailedRateChart = module.Chart{ + ID: "client_rpc_requests_failed_rate", + Title: "Client failed RPC requests", + Units: "requests/s", + Fam: "rpc network activity", + Ctx: "consul.client_rpc_requests_failed_rate", + Priority: prioRPCRequestsFailed, + Dims: module.Dims{ + {ID: "client_rpc_failed", Name: "failed", Algo: module.Incremental}, + }, + } + + raftThreadMainSaturationPercChart = module.Chart{ + ID: "raft_thread_main_saturation_perc", + Title: "Raft main thread saturation", + Units: "percentage", + Fam: "raft saturation", + Ctx: "consul.raft_thread_main_saturation_perc", + Priority: prioRaftThreadMainSaturation, + Dims: module.Dims{ + {ID: "raft_thread_main_saturation_quantile=0.5", Name: "quantile_0.5", Div: precision * 10}, + {ID: "raft_thread_main_saturation_quantile=0.9", Name: "quantile_0.9", Div: precision * 10}, + {ID: "raft_thread_main_saturation_quantile=0.99", Name: "quantile_0.99", Div: precision * 10}, + }, + } + raftThreadFSMSaturationPercChart = module.Chart{ + ID: "raft_thread_fsm_saturation_perc", + Title: "Raft FSM thread saturation", + Units: "percentage", + Fam: "raft saturation", + Ctx: "consul.raft_thread_fsm_saturation_perc", + Priority: prioRaftThreadFSMSaturation, + Dims: module.Dims{ + {ID: "raft_thread_fsm_saturation_quantile=0.5", Name: "quantile_0.5", Div: precision * 10}, + {ID: "raft_thread_fsm_saturation_quantile=0.9", Name: "quantile_0.9", Div: precision * 10}, + {ID: "raft_thread_fsm_saturation_quantile=0.99", Name: "quantile_0.99", Div: precision * 10}, + }, + } + + raftFSMLastRestoreDurationChart = module.Chart{ + ID: "raft_fsm_last_restore_duration", + Title: "Raft last restore duration", + Units: "ms", + Fam: "raft replication capacity", + Ctx: "consul.raft_fsm_last_restore_duration", + Priority: prioRaftFSMLastRestoreDuration, + Dims: module.Dims{ + {ID: "raft_fsm_lastRestoreDuration", Name: "last_restore_duration"}, + }, + } + raftLeaderOldestLogAgeChart = module.Chart{ + ID: "raft_leader_oldest_log_age", + Title: "Raft leader oldest log age", + Units: "seconds", + Fam: "raft replication capacity", + Ctx: "consul.raft_leader_oldest_log_age", + Priority: prioRaftLeaderOldestLogAge, + Dims: module.Dims{ + {ID: "raft_leader_oldestLogAge", Name: "oldest_log_age", Div: 1000}, + }, + } + raftRPCInstallSnapshotTimeChart = module.Chart{ + ID: "raft_rpc_install_snapshot_time", + Title: "Raft RPC install snapshot time", + Units: "ms", + Fam: "raft replication capacity", + Ctx: "consul.raft_rpc_install_snapshot_time", + Priority: prioRaftRPCInstallSnapshotTime, + Dims: module.Dims{ + {ID: "raft_rpc_installSnapshot_quantile=0.5", Name: "quantile_0.5", Div: precision * precision}, + {ID: "raft_rpc_installSnapshot_quantile=0.9", Name: "quantile_0.9", Div: precision * precision}, + {ID: "raft_rpc_installSnapshot_quantile=0.99", Name: "quantile_0.99", Div: precision * precision}, + }, + } + + raftBoltDBFreelistBytesChart = module.Chart{ + ID: "raft_boltdb_freelist_bytes", + Title: "Raft BoltDB freelist", + Units: "bytes", + Fam: "boltdb performance", + Ctx: "consul.raft_boltdb_freelist_bytes", + Priority: prioBoltDBFreelistBytes, + Dims: module.Dims{ + {ID: "raft_boltdb_freelistBytes", Name: "freelist"}, + }, + } + raftBoltDBLogsPerBatchChart = module.Chart{ + ID: "raft_boltdb_logs_per_batch_rate", + Title: "Raft BoltDB logs written per batch", + Units: "logs/s", + Fam: "boltdb performance", + Ctx: "consul.raft_boltdb_logs_per_batch_rate", + Priority: prioBoltDBLogsPerBatch, + Dims: module.Dims{ + {ID: "raft_boltdb_logsPerBatch_sum", Name: "written", Algo: module.Incremental}, + }, + } + + raftBoltDBStoreLogsTimeChart = module.Chart{ + ID: "raft_boltdb_store_logs_time", + Title: "Raft BoltDB store logs time", + Units: "ms", + Fam: "boltdb performance", + Ctx: "consul.raft_boltdb_store_logs_time", + Priority: prioBoltDBStoreLogsTime, + Dims: module.Dims{ + {ID: "raft_boltdb_storeLogs_quantile=0.5", Name: "quantile_0.5", Div: precision * precision}, + {ID: "raft_boltdb_storeLogs_quantile=0.9", Name: "quantile_0.9", Div: precision * precision}, + {ID: "raft_boltdb_storeLogs_quantile=0.99", Name: "quantile_0.99", Div: precision * precision}, + }, + } + + memoryAllocatedChart = module.Chart{ + ID: "memory_allocated", + Title: "Memory allocated by the Consul process", + Units: "bytes", + Fam: "memory", + Ctx: "consul.memory_allocated", + Priority: prioMemoryAllocated, + Dims: module.Dims{ + {ID: "runtime_alloc_bytes", Name: "allocated"}, + }, + } + memorySysChart = module.Chart{ + ID: "memory_sys", + Title: "Memory obtained from the OS", + Units: "bytes", + Fam: "memory", + Ctx: "consul.memory_sys", + Priority: prioMemorySys, + Dims: module.Dims{ + {ID: "runtime_sys_bytes", Name: "sys"}, + }, + } + + gcPauseTimeChart = module.Chart{ + ID: "gc_pause_time", + Title: "Garbage collection stop-the-world pause time", + Units: "seconds", + Fam: "garbage collection", + Ctx: "consul.gc_pause_time", + Priority: prioGCPauseTime, + Dims: module.Dims{ + {ID: "runtime_total_gc_pause_ns", Name: "gc_pause", Algo: module.Incremental, Div: 1e9}, + }, + } + + licenseExpirationTimeChart = module.Chart{ + ID: "license_expiration_time", + Title: "License expiration time", + Units: "seconds", + Fam: "license", + Ctx: "consul.license_expiration_time", + Priority: prioLicenseExpirationTime, + Dims: module.Dims{ + {ID: "system_licenseExpiration", Name: "license_expiration"}, + }, + } +) + +var ( + serviceHealthCheckStatusChartTmpl = module.Chart{ + ID: "health_check_%s_status", + Title: "Service health check status", + Units: "status", + Fam: "service health checks", + Ctx: "consul.service_health_check_status", + Priority: prioServiceHealthCheckStatus, + Dims: module.Dims{ + {ID: "health_check_%s_passing_status", Name: "passing"}, + {ID: "health_check_%s_critical_status", Name: "critical"}, + {ID: "health_check_%s_maintenance_status", Name: "maintenance"}, + {ID: "health_check_%s_warning_status", Name: "warning"}, + }, + } + nodeHealthCheckStatusChartTmpl = module.Chart{ + ID: "health_check_%s_status", + Title: "Node health check status", + Units: "status", + Fam: "node health checks", + Ctx: "consul.node_health_check_status", + Priority: prioNodeHealthCheckStatus, + Dims: module.Dims{ + {ID: "health_check_%s_passing_status", Name: "passing"}, + {ID: "health_check_%s_critical_status", Name: "critical"}, + {ID: "health_check_%s_maintenance_status", Name: "maintenance"}, + {ID: "health_check_%s_warning_status", Name: "warning"}, + }, + } +) + +func (c *Consul) addGlobalCharts() { + if !c.isTelemetryPrometheusEnabled() { + return + } + + var charts *module.Charts + + if !c.isServer() { + charts = clientCharts.Copy() + } else { + charts = serverCommonCharts.Copy() + + // can't really rely on checking if a response contains a metric due to retention of some metrics + // https://github.com/hashicorp/go-metrics/blob/b6d5c860c07ef6eeec89f4a662c7b452dd4d0c93/prometheus/prometheus.go#L75-L76 + if c.version != nil { + if c.version.LT(semver.Version{Major: 1, Minor: 13, Patch: 0}) { + _ = charts.Remove(raftThreadMainSaturationPercChart.ID) + _ = charts.Remove(raftThreadFSMSaturationPercChart.ID) + } + if c.version.LT(semver.Version{Major: 1, Minor: 11, Patch: 0}) { + _ = charts.Remove(kvsApplyTimeChart.ID) + _ = charts.Remove(kvsApplyOperationsRateChart.ID) + _ = charts.Remove(txnApplyTimeChart.ID) + _ = charts.Remove(txnApplyOperationsRateChart.ID) + _ = charts.Remove(raftBoltDBFreelistBytesChart.ID) + } + } + } + + if !c.hasLicense() { + _ = charts.Remove(licenseExpirationTimeChart.ID) + } + + for _, chart := range *charts { + chart.Labels = []module.Label{ + {Key: "datacenter", Value: c.cfg.Config.Datacenter}, + {Key: "node_name", Value: c.cfg.Config.NodeName}, + } + } + + if err := c.Charts().Add(*charts.Copy()...); err != nil { + c.Warning(err) + } +} + +func (c *Consul) addServerAutopilotHealthCharts() { + charts := serverAutopilotHealthCharts.Copy() + + for _, chart := range *charts { + chart.Labels = []module.Label{ + {Key: "datacenter", Value: c.cfg.Config.Datacenter}, + {Key: "node_name", Value: c.cfg.Config.NodeName}, + } + } + + if err := c.Charts().Add(*charts...); err != nil { + c.Warning(err) + } +} + +func newServiceHealthCheckChart(check *agentCheck) *module.Chart { + chart := serviceHealthCheckStatusChartTmpl.Copy() + chart.ID = fmt.Sprintf(chart.ID, check.CheckID) + chart.Labels = []module.Label{ + {Key: "node_name", Value: check.Node}, + {Key: "check_name", Value: check.Name}, + {Key: "service_name", Value: check.ServiceName}, + } + for _, d := range chart.Dims { + d.ID = fmt.Sprintf(d.ID, check.CheckID) + } + return chart +} + +func newNodeHealthCheckChart(check *agentCheck) *module.Chart { + chart := nodeHealthCheckStatusChartTmpl.Copy() + chart.ID = fmt.Sprintf(chart.ID, check.CheckID) + chart.Labels = []module.Label{ + {Key: "node_name", Value: check.Node}, + {Key: "check_name", Value: check.Name}, + } + for _, d := range chart.Dims { + d.ID = fmt.Sprintf(d.ID, check.CheckID) + } + return chart +} + +func (c *Consul) addHealthCheckCharts(check *agentCheck) { + var chart *module.Chart + + if check.ServiceName != "" { + chart = newServiceHealthCheckChart(check) + } else { + chart = newNodeHealthCheckChart(check) + } + + chart.Labels = append(chart.Labels, module.Label{ + Key: "datacenter", + Value: c.cfg.Config.Datacenter, + }) + + if err := c.Charts().Add(chart); err != nil { + c.Warning(err) + } +} + +func (c *Consul) removeHealthCheckCharts(checkID string) { + id := fmt.Sprintf("health_check_%s_status", checkID) + + chart := c.Charts().Get(id) + if chart == nil { + c.Warningf("failed to remove '%s' chart: the chart does not exist", id) + return + } + + chart.MarkRemove() + chart.MarkNotCreated() +} + +func (c *Consul) addLeaderCharts() { + charts := serverLeaderCharts.Copy() + + for _, chart := range *charts { + chart.Labels = []module.Label{ + {Key: "datacenter", Value: c.cfg.Config.Datacenter}, + {Key: "node_name", Value: c.cfg.Config.NodeName}, + } + } + + if err := c.Charts().Add(*charts...); err != nil { + c.Warning(err) + } +} + +func (c *Consul) removeLeaderCharts() { + s := make(map[string]bool) + for _, v := range serverLeaderCharts { + s[v.ID] = true + } + + for _, v := range *c.Charts() { + if s[v.ID] { + v.MarkRemove() + v.MarkNotCreated() + } + } +} + +func (c *Consul) addFollowerCharts() { + charts := serverFollowerCharts.Copy() + if c.isCloudManaged() { + // 'autopilot_server_lastContact_leader' comes from 'operator/autopilot/health' which is disabled + _ = charts.Remove(raftFollowerLastContactLeaderTimeChart.ID) + } + + for _, chart := range *charts { + chart.Labels = []module.Label{ + {Key: "datacenter", Value: c.cfg.Config.Datacenter}, + {Key: "node_name", Value: c.cfg.Config.NodeName}, + } + } + + if err := c.Charts().Add(*charts...); err != nil { + c.Warning(err) + } +} + +func (c *Consul) removeFollowerCharts() { + s := make(map[string]bool) + for _, v := range serverFollowerCharts { + s[v.ID] = true + } + + for _, v := range *c.Charts() { + if s[v.ID] { + v.MarkRemove() + v.MarkNotCreated() + } + } +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/collect.go b/src/go/collectors/go.d.plugin/modules/consul/collect.go new file mode 100644 index 000000000..3b5ebfd30 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/collect.go @@ -0,0 +1,117 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package consul + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + + "github.com/netdata/netdata/go/go.d.plugin/pkg/web" +) + +const ( + precision = 1000 +) + +func (c *Consul) collect() (map[string]int64, error) { + if c.cfg == nil { + if err := c.collectConfiguration(); err != nil { + return nil, err + } + + c.addGlobalChartsOnce.Do(c.addGlobalCharts) + } + + mx := make(map[string]int64) + + if err := c.collectChecks(mx); err != nil { + return nil, err + } + + if c.isServer() { + if !c.isCloudManaged() { + c.addServerAutopilotChartsOnce.Do(c.addServerAutopilotHealthCharts) + // 'operator/autopilot/health' is disabled in Cloud managed (403: Operation is not allowed in managed Consul clusters) + if err := c.collectAutopilotHealth(mx); err != nil { + return nil, err + } + } + if err := c.collectNetworkRTT(mx); err != nil { + return nil, err + } + } + + if c.isTelemetryPrometheusEnabled() { + if err := c.collectMetricsPrometheus(mx); err != nil { + return nil, err + } + } + + return mx, nil +} + +func (c *Consul) isTelemetryPrometheusEnabled() bool { + return c.cfg.DebugConfig.Telemetry.PrometheusOpts.Expiration != "0s" +} + +func (c *Consul) isCloudManaged() bool { + return c.cfg.DebugConfig.Cloud.ClientSecret != "" || c.cfg.DebugConfig.Cloud.ResourceID != "" +} + +func (c *Consul) hasLicense() bool { + return c.cfg.Stats.License.ID != "" +} + +func (c *Consul) isServer() bool { + return c.cfg.Config.Server +} + +func (c *Consul) doOKDecode(urlPath string, in interface{}, statusCodes ...int) error { + req, err := web.NewHTTPRequest(c.Request.Copy()) + if err != nil { + return fmt.Errorf("error on creating request: %v", err) + } + + req.URL.Path = urlPath + if c.ACLToken != "" { + req.Header.Set("X-Consul-Token", c.ACLToken) + } + + resp, err := c.httpClient.Do(req) + if err != nil { + return fmt.Errorf("error on request to %s : %v", req.URL, err) + } + + defer closeBody(resp) + + codes := map[int]bool{http.StatusOK: true} + for _, v := range statusCodes { + codes[v] = true + } + + if !codes[resp.StatusCode] { + return fmt.Errorf("%s returned HTTP status %d", req.URL, resp.StatusCode) + } + + if err = json.NewDecoder(resp.Body).Decode(&in); err != nil { + return fmt.Errorf("error on decoding response from %s : %v", req.URL, err) + } + + return nil +} + +func closeBody(resp *http.Response) { + if resp != nil && resp.Body != nil { + _, _ = io.Copy(io.Discard, resp.Body) + _ = resp.Body.Close() + } +} + +func boolToInt(v bool) int64 { + if v { + return 1 + } + return 0 +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/collect_autopilot.go b/src/go/collectors/go.d.plugin/modules/consul/collect_autopilot.go new file mode 100644 index 000000000..e73ce9b25 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/collect_autopilot.go @@ -0,0 +1,62 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package consul + +import ( + "net/http" + "time" +) + +const ( + // https://developer.hashicorp.com/consul/api-docs/operator/autopilot#read-health + urlPathOperationAutopilotHealth = "/v1/operator/autopilot/health" +) + +type autopilotHealth struct { + Servers []struct { + ID string + SerfStatus string + Leader bool + LastContact string + Healthy bool + Voter bool + StableSince time.Time + } +} + +func (c *Consul) collectAutopilotHealth(mx map[string]int64) error { + var health autopilotHealth + + // The HTTP status code will indicate the health of the cluster: 200 is healthy, 429 is unhealthy. + // https://github.com/hashicorp/consul/blob/c7ef04c5979dbc311ff3c67b7bf3028a93e8b0f1/agent/operator_endpoint.go#L325 + if err := c.doOKDecode(urlPathOperationAutopilotHealth, &health, http.StatusTooManyRequests); err != nil { + return err + } + + for _, srv := range health.Servers { + if srv.ID == c.cfg.Config.NodeID { + // SerfStatus: alive, left, failed or none: + // https://github.com/hashicorp/consul/blob/c7ef04c5979dbc311ff3c67b7bf3028a93e8b0f1/agent/consul/operator_autopilot_endpoint.go#L124-L133 + mx["autopilot_server_sefStatus_alive"] = boolToInt(srv.SerfStatus == "alive") + mx["autopilot_server_sefStatus_left"] = boolToInt(srv.SerfStatus == "left") + mx["autopilot_server_sefStatus_failed"] = boolToInt(srv.SerfStatus == "failed") + mx["autopilot_server_sefStatus_none"] = boolToInt(srv.SerfStatus == "none") + // https://github.com/hashicorp/raft-autopilot/blob/d936f51c374c3b7902d5e4fdafe9f7d8d199ea53/types.go#L110 + mx["autopilot_server_healthy_yes"] = boolToInt(srv.Healthy) + mx["autopilot_server_healthy_no"] = boolToInt(!srv.Healthy) + mx["autopilot_server_voter_yes"] = boolToInt(srv.Voter) + mx["autopilot_server_voter_no"] = boolToInt(!srv.Voter) + mx["autopilot_server_stable_time"] = int64(time.Since(srv.StableSince).Seconds()) + mx["autopilot_server_stable_time"] = int64(time.Since(srv.StableSince).Seconds()) + if !srv.Leader { + if v, err := time.ParseDuration(srv.LastContact); err == nil { + mx["autopilot_server_lastContact_leader"] = v.Milliseconds() + } + } + + break + } + } + + return nil +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/collect_checks.go b/src/go/collectors/go.d.plugin/modules/consul/collect_checks.go new file mode 100644 index 000000000..88ea4612b --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/collect_checks.go @@ -0,0 +1,47 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package consul + +const ( + // https://www.consul.io/api-docs/agent/check#list-checks + urlPathAgentChecks = "/v1/agent/checks" +) + +type agentCheck struct { + Node string + CheckID string + Name string + Status string + ServiceID string + ServiceName string + ServiceTags []string +} + +func (c *Consul) collectChecks(mx map[string]int64) error { + var checks map[string]*agentCheck + + if err := c.doOKDecode(urlPathAgentChecks, &checks); err != nil { + return err + } + + for id, check := range checks { + if !c.checks[id] { + c.checks[id] = true + c.addHealthCheckCharts(check) + } + + mx["health_check_"+id+"_passing_status"] = boolToInt(check.Status == "passing") + mx["health_check_"+id+"_warning_status"] = boolToInt(check.Status == "warning") + mx["health_check_"+id+"_critical_status"] = boolToInt(check.Status == "critical") + mx["health_check_"+id+"_maintenance_status"] = boolToInt(check.Status == "maintenance") + } + + for id := range c.checks { + if _, ok := checks[id]; !ok { + delete(c.checks, id) + c.removeHealthCheckCharts(id) + } + } + + return nil +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/collect_config.go b/src/go/collectors/go.d.plugin/modules/consul/collect_config.go new file mode 100644 index 000000000..14c77067f --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/collect_config.go @@ -0,0 +1,71 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package consul + +import ( + "github.com/blang/semver/v4" +) + +const ( + // https://developer.hashicorp.com/consul/api-docs/agent#read-configuration + urlPathAgentSelf = "/v1/agent/self" +) + +type consulConfig struct { + Config struct { + Datacenter string + PrimaryDatacenter string + NodeName string + NodeID string + Server bool + Version string + } + DebugConfig struct { + Telemetry struct { + MetricsPrefix string + DisableHostname bool + PrometheusOpts struct { + Expiration string + Name string + } + } + Cloud struct { + AuthURL string + ClientID string + ClientSecret string + Hostname string + ResourceID string + ScadaAddress string + } + } + Stats struct { + License struct { + ID string `json:"id"` + } `json:"license"` + } +} + +func (c *Consul) collectConfiguration() error { + var cfg consulConfig + + if err := c.doOKDecode(urlPathAgentSelf, &cfg); err != nil { + return err + } + + c.cfg = &cfg + c.Debugf("consul config: %+v", cfg) + + if !c.isTelemetryPrometheusEnabled() { + c.Warning("export of Prometheus metrics is disabled") + } + + ver, err := semver.New(c.cfg.Config.Version) + if err != nil { + c.Warningf("error on parsing Consul version '%s': %v", c.cfg.Config.Version, err) + return nil + } + + c.version = ver + + return nil +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/collect_metrics.go b/src/go/collectors/go.d.plugin/modules/consul/collect_metrics.go new file mode 100644 index 000000000..8dcfe1838 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/collect_metrics.go @@ -0,0 +1,205 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package consul + +import ( + "fmt" + "math" + "strconv" + "strings" + + "github.com/netdata/netdata/go/go.d.plugin/pkg/prometheus" +) + +func (c *Consul) collectMetricsPrometheus(mx map[string]int64) error { + mfs, err := c.prom.Scrape() + if err != nil { + return err + } + + // Key Metrics (https://developer.hashicorp.com/consul/docs/agent/telemetry#key-metrics) + + // prometheus metrics are messy: + // - if 'disable_hostname' is false (default): + // - consul_autopilot_failure_tolerance => consul_hostname_autopilot_failure_tolerance + // - both are exposed + // - only the one with the hostname has the correct value + // - 1.14.3 (it probably has something to do with cloud management version): + // - runtime_sys_bytes => runtime_sys_bytes_sys_bytes; consul_autopilot_healthy => consul_autopilot_healthy_healthy + // - both are exposed + // - only the one with the double name has the correct value + + if c.isServer() { + c.collectSummary(mx, mfs, "raft_thread_main_saturation") + c.collectSummary(mx, mfs, "raft_thread_fsm_saturation") + c.collectSummary(mx, mfs, "raft_boltdb_logsPerBatch") + c.collectSummary(mx, mfs, "kvs_apply") + c.collectSummary(mx, mfs, "txn_apply") + c.collectSummary(mx, mfs, "raft_boltdb_storeLogs") + c.collectSummary(mx, mfs, "raft_rpc_installSnapshot") // make sense for followers only + c.collectSummary(mx, mfs, "raft_commitTime") // make sense for leader only + c.collectSummary(mx, mfs, "raft_leader_lastContact") // make sense for leader only + + c.collectCounter(mx, mfs, "raft_apply", precision) // make sense for leader only + c.collectCounter(mx, mfs, "raft_state_candidate", 1) + c.collectCounter(mx, mfs, "raft_state_leader", 1) + + c.collectGaugeBool(mx, mfs, "autopilot_healthy", "autopilot_healthy_healthy") + c.collectGaugeBool(mx, mfs, "server_isLeader", "server_isLeader_isLeader") + c.collectGauge(mx, mfs, "autopilot_failure_tolerance", 1, "autopilot_failure_tolerance_failure_tolerance") + c.collectGauge(mx, mfs, "raft_fsm_lastRestoreDuration", 1) + c.collectGauge(mx, mfs, "raft_leader_oldestLogAge", 1, "raft_leader_oldestLogAge_oldestLogAge") + c.collectGauge(mx, mfs, "raft_boltdb_freelistBytes", 1, "raft_boltdb_freelistBytes_freelistBytes") + + if isLeader, ok := c.isLeader(mfs); ok { + if isLeader && !c.hasLeaderCharts { + c.addLeaderCharts() + c.hasLeaderCharts = true + } + if !isLeader && c.hasLeaderCharts { + c.removeLeaderCharts() + c.hasLeaderCharts = false + } + if !isLeader && !c.hasFollowerCharts { + c.addFollowerCharts() + c.hasFollowerCharts = true + } + if isLeader && c.hasFollowerCharts { + c.removeFollowerCharts() + c.hasFollowerCharts = false + } + } + } + + c.collectGauge(mx, mfs, "system_licenseExpiration", 3600, "system_licenseExpiration_licenseExpiration") + + c.collectCounter(mx, mfs, "client_rpc", 1) + c.collectCounter(mx, mfs, "client_rpc_exceeded", 1) + c.collectCounter(mx, mfs, "client_rpc_failed", 1) + + c.collectGauge(mx, mfs, "runtime_alloc_bytes", 1, "runtime_alloc_bytes_alloc_bytes") + c.collectGauge(mx, mfs, "runtime_sys_bytes", 1, "runtime_sys_bytes_sys_bytes") + c.collectGauge(mx, mfs, "runtime_total_gc_pause_ns", 1, "runtime_total_gc_pause_ns_total_gc_pause_ns") + + return nil +} + +func (c *Consul) isLeader(mfs prometheus.MetricFamilies) (bool, bool) { + var mf *prometheus.MetricFamily + for _, v := range []string{"server_isLeader_isLeader", "server_isLeader"} { + if mf = mfs.GetGauge(c.promMetricNameWithHostname(v)); mf != nil { + break + } + if mf = mfs.GetGauge(c.promMetricName(v)); mf != nil { + break + } + } + + if mf == nil { + return false, false + } + + return mf.Metrics()[0].Gauge().Value() == 1, true +} + +func (c *Consul) collectGauge(mx map[string]int64, mfs prometheus.MetricFamilies, name string, mul float64, aliases ...string) { + var mf *prometheus.MetricFamily + for _, v := range append(aliases, name) { + if mf = mfs.GetGauge(c.promMetricNameWithHostname(v)); mf != nil { + break + } + if mf = mfs.GetGauge(c.promMetricName(v)); mf != nil { + break + } + } + + if mf == nil { + return + } + + v := mf.Metrics()[0].Gauge().Value() + + if !math.IsNaN(v) { + mx[name] = int64(v * mul) + } +} + +func (c *Consul) collectGaugeBool(mx map[string]int64, mfs prometheus.MetricFamilies, name string, aliases ...string) { + var mf *prometheus.MetricFamily + for _, v := range append(aliases, name) { + if mf = mfs.GetGauge(c.promMetricNameWithHostname(v)); mf != nil { + break + } + if mf = mfs.GetGauge(c.promMetricName(v)); mf != nil { + break + } + } + + if mf == nil { + return + } + + v := mf.Metrics()[0].Gauge().Value() + + if !math.IsNaN(v) { + mx[name+"_yes"] = boolToInt(v == 1) + mx[name+"_no"] = boolToInt(v == 0) + } +} + +func (c *Consul) collectCounter(mx map[string]int64, mfs prometheus.MetricFamilies, name string, mul float64) { + mf := mfs.GetCounter(c.promMetricName(name)) + if mf == nil { + return + } + + v := mf.Metrics()[0].Counter().Value() + + if !math.IsNaN(v) { + mx[name] = int64(v * mul) + } +} + +func (c *Consul) collectSummary(mx map[string]int64, mfs prometheus.MetricFamilies, name string) { + mf := mfs.GetSummary(c.promMetricName(name)) + if mf == nil { + return + } + + m := mf.Metrics()[0] + + for _, q := range m.Summary().Quantiles() { + v := q.Value() + // MaxAge is 10 seconds (hardcoded) + // https://github.com/hashicorp/go-metrics/blob/b6d5c860c07ef6eeec89f4a662c7b452dd4d0c93/prometheus/prometheus.go#L227 + if math.IsNaN(v) { + v = 0 + } + + id := fmt.Sprintf("%s_quantile=%s", name, formatFloat(q.Quantile())) + mx[id] = int64(v * precision * precision) + } + + mx[name+"_sum"] = int64(m.Summary().Sum() * precision) + mx[name+"_count"] = int64(m.Summary().Count()) +} + +func (c *Consul) promMetricName(name string) string { + px := c.cfg.DebugConfig.Telemetry.MetricsPrefix + return px + "_" + name +} + +var forbiddenCharsReplacer = strings.NewReplacer(" ", "_", ".", "_", "=", "_", "-", "_", "/", "_") + +// controlled by 'disable_hostname' +// https://developer.hashicorp.com/consul/docs/agent/config/config-files#telemetry-disable_hostname +func (c *Consul) promMetricNameWithHostname(name string) string { + px := c.cfg.DebugConfig.Telemetry.MetricsPrefix + node := forbiddenCharsReplacer.Replace(c.cfg.Config.NodeName) + + return px + "_" + node + "_" + name +} + +func formatFloat(v float64) string { + return strconv.FormatFloat(v, 'f', -1, 64) +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/collect_net_rtt.go b/src/go/collectors/go.d.plugin/modules/consul/collect_net_rtt.go new file mode 100644 index 000000000..1b1853719 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/collect_net_rtt.go @@ -0,0 +1,75 @@ +package consul + +import ( + "math" + "time" + + "github.com/netdata/netdata/go/go.d.plugin/pkg/metrics" +) + +const ( + // https://developer.hashicorp.com/consul/api-docs/coordinate#read-lan-coordinates-for-all-nodes + urlPathCoordinateNodes = "/v1/coordinate/nodes" +) + +type nodeCoordinates struct { + Node string + Coord struct { + Vec []float64 + Error float64 + Adjustment float64 + Height float64 + } +} + +func (c *Consul) collectNetworkRTT(mx map[string]int64) error { + var coords []nodeCoordinates + + if err := c.doOKDecode(urlPathCoordinateNodes, &coords); err != nil { + return err + } + + var thisNode nodeCoordinates + var ok bool + + coords, thisNode, ok = removeNodeCoordinates(coords, c.cfg.Config.NodeName) + if !ok || len(coords) == 0 { + return nil + } + + sum := metrics.NewSummary() + for _, v := range coords { + d := calcDistance(thisNode, v) + sum.Observe(d.Seconds()) + } + sum.WriteTo(mx, "network_lan_rtt", 1e9, 1) + + return nil +} + +func calcDistance(a, b nodeCoordinates) time.Duration { + // https://developer.hashicorp.com/consul/docs/architecture/coordinates#working-with-coordinates + sum := 0.0 + for i := 0; i < len(a.Coord.Vec); i++ { + diff := a.Coord.Vec[i] - b.Coord.Vec[i] + sum += diff * diff + } + + rtt := math.Sqrt(sum) + a.Coord.Height + b.Coord.Height + + adjusted := rtt + a.Coord.Adjustment + b.Coord.Adjustment + if adjusted > 0.0 { + rtt = adjusted + } + + return time.Duration(rtt * 1e9) // nanoseconds +} + +func removeNodeCoordinates(coords []nodeCoordinates, node string) ([]nodeCoordinates, nodeCoordinates, bool) { + for i, v := range coords { + if v.Node == node { + return append(coords[:i], coords[i+1:]...), v, true + } + } + return coords, nodeCoordinates{}, false +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/config_schema.json b/src/go/collectors/go.d.plugin/modules/consul/config_schema.json new file mode 100644 index 000000000..18679ad09 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/config_schema.json @@ -0,0 +1,184 @@ +{ + "jsonSchema": { + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Consul collector configuration.", + "type": "object", + "properties": { + "update_every": { + "title": "Update every", + "description": "Data collection interval, measured in seconds.", + "type": "integer", + "minimum": 1, + "default": 1 + }, + "url": { + "title": "URL", + "description": "The base URL of the Consul [HTTP(S) API](https://developer.hashicorp.com/consul/api-docs).", + "type": "string", + "default": "http://127.0.0.1:8500", + "format": "uri" + }, + "timeout": { + "title": "Timeout", + "description": "The timeout in seconds for the HTTP request.", + "type": "number", + "minimum": 0.5, + "default": 1 + }, + "not_follow_redirects": { + "title": "Not follow redirects", + "description": "If set, the client will not follow HTTP redirects automatically.", + "type": "boolean" + }, + "acl_token": { + "title": "X-Consul-Token", + "description": "The Consul token for [authentication](https://developer.hashicorp.com/consul/api-docs/api-structure#authentication).", + "type": "string", + "sensitive": true + }, + "username": { + "title": "Username", + "description": "The username for basic authentication.", + "type": "string", + "sensitive": true + }, + "password": { + "title": "Password", + "description": "The password for basic authentication.", + "type": "string", + "sensitive": true + }, + "proxy_url": { + "title": "Proxy URL", + "description": "The URL of the proxy server.", + "type": "string" + }, + "proxy_username": { + "title": "Proxy username", + "description": "The username for proxy authentication.", + "type": "string", + "sensitive": true + }, + "proxy_password": { + "title": "Proxy password", + "description": "The password for proxy authentication.", + "type": "string", + "sensitive": true + }, + "headers": { + "title": "Headers", + "description": "Additional HTTP headers to include in the request.", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "type": "string" + } + }, + "tls_skip_verify": { + "title": "Skip TLS verification", + "description": "If set, TLS certificate verification will be skipped.", + "type": "boolean" + }, + "tls_ca": { + "title": "TLS CA", + "description": "The path to the CA certificate file for TLS verification.", + "type": "string", + "pattern": "^$|^/" + }, + "tls_cert": { + "title": "TLS certificate", + "description": "The path to the client certificate file for TLS authentication.", + "type": "string", + "pattern": "^$|^/" + }, + "tls_key": { + "title": "TLS key", + "description": "The path to the client key file for TLS authentication.", + "type": "string", + "pattern": "^$|^/" + }, + "body": { + "title": "Body", + "type": "string" + }, + "method": { + "title": "Method", + "type": "string" + } + }, + "required": [ + "url" + ], + "additionalProperties": false, + "patternProperties": { + "^name$": {} + } + }, + "uiSchema": { + "ui:flavour": "tabs", + "ui:options": { + "tabs": [ + { + "title": "Base", + "fields": [ + "update_every", + "url", + "timeout", + "not_follow_redirects" + ] + }, + { + "title": "Auth", + "fields": [ + "acl_token", + "username", + "password" + ] + }, + { + "title": "TLS", + "fields": [ + "tls_skip_verify", + "tls_ca", + "tls_cert", + "tls_key" + ] + }, + { + "title": "Proxy", + "fields": [ + "proxy_url", + "proxy_username", + "proxy_password" + ] + }, + { + "title": "Headers", + "fields": [ + "headers" + ] + } + ] + }, + "uiOptions": { + "fullPage": true + }, + "body": { + "ui:widget": "hidden" + }, + "method": { + "ui:widget": "hidden" + }, + "timeout": { + "ui:help": "Accepts decimals for precise control (e.g., type 1.5 for 1.5 seconds)." + }, + "password": { + "ui:widget": "password" + }, + "proxy_password": { + "ui:widget": "password" + } + } +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/consul.go b/src/go/collectors/go.d.plugin/modules/consul/consul.go new file mode 100644 index 000000000..2e2793fa7 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/consul.go @@ -0,0 +1,136 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package consul + +import ( + _ "embed" + "errors" + "net/http" + "sync" + "time" + + "github.com/netdata/netdata/go/go.d.plugin/agent/module" + "github.com/netdata/netdata/go/go.d.plugin/pkg/prometheus" + "github.com/netdata/netdata/go/go.d.plugin/pkg/web" + + "github.com/blang/semver/v4" +) + +//go:embed "config_schema.json" +var configSchema string + +func init() { + module.Register("consul", module.Creator{ + JobConfigSchema: configSchema, + Defaults: module.Defaults{ + UpdateEvery: 1, + }, + Create: func() module.Module { return New() }, + Config: func() any { return &Config{} }, + }) +} + +func New() *Consul { + return &Consul{ + Config: Config{ + HTTP: web.HTTP{ + Request: web.Request{ + URL: "http://127.0.0.1:8500", + }, + Client: web.Client{ + Timeout: web.Duration(time.Second), + }, + }, + }, + charts: &module.Charts{}, + addGlobalChartsOnce: &sync.Once{}, + addServerAutopilotChartsOnce: &sync.Once{}, + checks: make(map[string]bool), + } +} + +type Config struct { + UpdateEvery int `yaml:"update_every,omitempty" json:"update_every"` + web.HTTP `yaml:",inline" json:""` + ACLToken string `yaml:"acl_token,omitempty" json:"acl_token"` +} + +type Consul struct { + module.Base + Config `yaml:",inline" json:""` + + charts *module.Charts + addGlobalChartsOnce *sync.Once + addServerAutopilotChartsOnce *sync.Once + + httpClient *http.Client + prom prometheus.Prometheus + + cfg *consulConfig + version *semver.Version + hasLeaderCharts bool + hasFollowerCharts bool + checks map[string]bool +} + +func (c *Consul) Configuration() any { + return c.Config +} + +func (c *Consul) Init() error { + if err := c.validateConfig(); err != nil { + c.Errorf("config validation: %v", err) + return err + } + + httpClient, err := c.initHTTPClient() + if err != nil { + c.Errorf("init HTTP client: %v", err) + return err + } + c.httpClient = httpClient + + prom, err := c.initPrometheusClient(httpClient) + if err != nil { + c.Errorf("init Prometheus client: %v", err) + return err + } + c.prom = prom + + return nil +} + +func (c *Consul) Check() error { + mx, err := c.collect() + if err != nil { + c.Error(err) + return err + } + if len(mx) == 0 { + return errors.New("no metrics collected") + + } + return nil +} + +func (c *Consul) Charts() *module.Charts { + return c.charts +} + +func (c *Consul) Collect() map[string]int64 { + mx, err := c.collect() + if err != nil { + c.Error(err) + } + + if len(mx) == 0 { + return nil + } + return mx +} + +func (c *Consul) Cleanup() { + if c.httpClient != nil { + c.httpClient.CloseIdleConnections() + } +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/consul_test.go b/src/go/collectors/go.d.plugin/modules/consul/consul_test.go new file mode 100644 index 000000000..9d53b6cb9 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/consul_test.go @@ -0,0 +1,721 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package consul + +import ( + "net/http" + "net/http/httptest" + "os" + "testing" + + "github.com/netdata/netdata/go/go.d.plugin/agent/module" + "github.com/netdata/netdata/go/go.d.plugin/pkg/web" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +var ( + dataConfigJSON, _ = os.ReadFile("testdata/config.json") + dataConfigYAML, _ = os.ReadFile("testdata/config.yaml") + + dataVer1132Checks, _ = os.ReadFile("testdata/v1.13.2/v1-agent-checks.json") + dataVer1132ClientSelf, _ = os.ReadFile("testdata/v1.13.2/client_v1-agent-self.json") + dataVer1132ClientPromMetrics, _ = os.ReadFile("testdata/v1.13.2/client_v1-agent-metrics.txt") + dataVer1132ServerSelf, _ = os.ReadFile("testdata/v1.13.2/server_v1-agent-self.json") + dataVer1132ServerSelfDisabledPrometheus, _ = os.ReadFile("testdata/v1.13.2/server_v1-agent-self_disabled_prom.json") + dataVer1132ServerSelfWithHostname, _ = os.ReadFile("testdata/v1.13.2/server_v1-agent-self_with_hostname.json") + dataVer1132ServerPromMetrics, _ = os.ReadFile("testdata/v1.13.2/server_v1-agent-metrics.txt") + dataVer1132ServerPromMetricsWithHostname, _ = os.ReadFile("testdata/v1.13.2/server_v1-agent-metrics_with_hostname.txt") + dataVer1132ServerOperatorAutopilotHealth, _ = os.ReadFile("testdata/v1.13.2/server_v1-operator-autopilot-health.json") + dataVer1132ServerCoordinateNodes, _ = os.ReadFile("testdata/v1.13.2/server_v1-coordinate-nodes.json") + + dataVer1143CloudServerPromMetrics, _ = os.ReadFile("testdata/v1.14.3-cloud/server_v1-agent-metrics.txt") + dataVer1143CloudServerSelf, _ = os.ReadFile("testdata/v1.14.3-cloud/server_v1-agent-self.json") + dataVer1143CloudServerCoordinateNodes, _ = os.ReadFile("testdata/v1.14.3-cloud/server_v1-coordinate-nodes.json") + dataVer1143CloudChecks, _ = os.ReadFile("testdata/v1.14.3-cloud/v1-agent-checks.json") +) + +func Test_testDataIsValid(t *testing.T) { + for name, data := range map[string][]byte{ + "dataConfigJSON": dataConfigJSON, + "dataConfigYAML": dataConfigYAML, + "dataVer1132Checks": dataVer1132Checks, + "dataVer1132ClientSelf": dataVer1132ClientSelf, + "dataVer1132ClientPromMetrics": dataVer1132ClientPromMetrics, + "dataVer1132ServerSelf": dataVer1132ServerSelf, + "dataVer1132ServerSelfWithHostname": dataVer1132ServerSelfWithHostname, + "dataVer1132ServerSelfDisabledPrometheus": dataVer1132ServerSelfDisabledPrometheus, + "dataVer1132ServerPromMetrics": dataVer1132ServerPromMetrics, + "dataVer1132ServerPromMetricsWithHostname": dataVer1132ServerPromMetricsWithHostname, + "dataVer1132ServerOperatorAutopilotHealth": dataVer1132ServerOperatorAutopilotHealth, + "dataVer1132ServerCoordinateNodes": dataVer1132ServerCoordinateNodes, + "dataVer1143CloudServerPromMetrics": dataVer1143CloudServerPromMetrics, + "dataVer1143CloudServerSelf": dataVer1143CloudServerSelf, + "dataVer1143CloudServerCoordinateNodes": dataVer1143CloudServerCoordinateNodes, + "dataVer1143CloudChecks": dataVer1143CloudChecks, + } { + require.NotNil(t, data, name) + } +} + +func TestConsul_ConfigurationSerialize(t *testing.T) { + module.TestConfigurationSerialize(t, &Consul{}, dataConfigJSON, dataConfigYAML) +} + +func TestConsul_Init(t *testing.T) { + tests := map[string]struct { + wantFail bool + config Config + }{ + "success with default": { + wantFail: false, + config: New().Config, + }, + "fail when URL not set": { + wantFail: true, + config: Config{ + HTTP: web.HTTP{ + Request: web.Request{URL: ""}, + }, + }, + }, + } + + for name, test := range tests { + t.Run(name, func(t *testing.T) { + consul := New() + consul.Config = test.config + + if test.wantFail { + assert.Error(t, consul.Init()) + } else { + assert.NoError(t, consul.Init()) + } + }) + } +} + +func TestConsul_Check(t *testing.T) { + tests := map[string]struct { + wantFail bool + prepare func(t *testing.T) (consul *Consul, cleanup func()) + }{ + "success on response from Consul v1.13.2 server": { + wantFail: false, + prepare: caseConsulV1132ServerResponse, + }, + "success on response from Consul v1.14.3 server cloud managed": { + wantFail: false, + prepare: caseConsulV1143CloudServerResponse, + }, + "success on response from Consul v1.13.2 server with enabled hostname": { + wantFail: false, + prepare: caseConsulV1132ServerWithHostnameResponse, + }, + "success on response from Consul v1.13.2 server with disabled prometheus": { + wantFail: false, + prepare: caseConsulV1132ServerWithDisabledPrometheus, + }, + "success on response from Consul v1.13.2 client": { + wantFail: false, + prepare: caseConsulV1132ClientResponse, + }, + "fail on invalid data response": { + wantFail: true, + prepare: caseInvalidDataResponse, + }, + "fail on connection refused": { + wantFail: true, + prepare: caseConnectionRefused, + }, + "fail on 404 response": { + wantFail: true, + prepare: case404, + }, + } + + for name, test := range tests { + t.Run(name, func(t *testing.T) { + consul, cleanup := test.prepare(t) + defer cleanup() + + if test.wantFail { + assert.Error(t, consul.Check()) + } else { + assert.NoError(t, consul.Check()) + } + }) + } +} + +func TestConsul_Collect(t *testing.T) { + tests := map[string]struct { + prepare func(t *testing.T) (consul *Consul, cleanup func()) + wantNumOfCharts int + wantMetrics map[string]int64 + }{ + "success on response from Consul v1.13.2 server": { + prepare: caseConsulV1132ServerResponse, + // 3 node, 1 service check, no license + wantNumOfCharts: len(serverCommonCharts) + len(serverAutopilotHealthCharts) + len(serverLeaderCharts) + 3 + 1 - 1, + wantMetrics: map[string]int64{ + "autopilot_failure_tolerance": 1, + "autopilot_healthy_no": 0, + "autopilot_healthy_yes": 1, + "autopilot_server_healthy_no": 0, + "autopilot_server_healthy_yes": 1, + "autopilot_server_lastContact_leader": 13, + "autopilot_server_sefStatus_alive": 1, + "autopilot_server_sefStatus_failed": 0, + "autopilot_server_sefStatus_left": 0, + "autopilot_server_sefStatus_none": 0, + "autopilot_server_stable_time": 265849, + "autopilot_server_voter_no": 0, + "autopilot_server_voter_yes": 1, + "client_rpc": 6838, + "client_rpc_exceeded": 0, + "client_rpc_failed": 0, + "health_check_chk1_critical_status": 0, + "health_check_chk1_maintenance_status": 0, + "health_check_chk1_passing_status": 1, + "health_check_chk1_warning_status": 0, + "health_check_chk2_critical_status": 1, + "health_check_chk2_maintenance_status": 0, + "health_check_chk2_passing_status": 0, + "health_check_chk2_warning_status": 0, + "health_check_chk3_critical_status": 1, + "health_check_chk3_maintenance_status": 0, + "health_check_chk3_passing_status": 0, + "health_check_chk3_warning_status": 0, + "health_check_mysql_critical_status": 1, + "health_check_mysql_maintenance_status": 0, + "health_check_mysql_passing_status": 0, + "health_check_mysql_warning_status": 0, + "kvs_apply_count": 0, + "kvs_apply_quantile=0.5": 0, + "kvs_apply_quantile=0.9": 0, + "kvs_apply_quantile=0.99": 0, + "kvs_apply_sum": 0, + "network_lan_rtt_avg": 737592, + "network_lan_rtt_count": 2, + "network_lan_rtt_max": 991168, + "network_lan_rtt_min": 484017, + "network_lan_rtt_sum": 1475185, + "raft_apply": 10681000, + "raft_boltdb_freelistBytes": 11264, + "raft_boltdb_logsPerBatch_count": 12360, + "raft_boltdb_logsPerBatch_quantile=0.5": 1000000, + "raft_boltdb_logsPerBatch_quantile=0.9": 1000000, + "raft_boltdb_logsPerBatch_quantile=0.99": 1000000, + "raft_boltdb_logsPerBatch_sum": 12362000, + "raft_boltdb_storeLogs_count": 12360, + "raft_boltdb_storeLogs_quantile=0.5": 13176624, + "raft_boltdb_storeLogs_quantile=0.9": 13176624, + "raft_boltdb_storeLogs_quantile=0.99": 13176624, + "raft_boltdb_storeLogs_sum": 651888027, + "raft_commitTime_count": 12345, + "raft_commitTime_quantile=0.5": 41146488, + "raft_commitTime_quantile=0.9": 41146488, + "raft_commitTime_quantile=0.99": 41146488, + "raft_commitTime_sum": 955781149, + "raft_fsm_lastRestoreDuration": 2, + "raft_leader_lastContact_count": 80917, + "raft_leader_lastContact_quantile=0.5": 33000000, + "raft_leader_lastContact_quantile=0.9": 68000000, + "raft_leader_lastContact_quantile=0.99": 68000000, + "raft_leader_lastContact_sum": 3066900000, + "raft_leader_oldestLogAge": 166046464, + "raft_rpc_installSnapshot_count": 0, + "raft_rpc_installSnapshot_quantile=0.5": 0, + "raft_rpc_installSnapshot_quantile=0.9": 0, + "raft_rpc_installSnapshot_quantile=0.99": 0, + "raft_rpc_installSnapshot_sum": 0, + "raft_state_candidate": 1, + "raft_state_leader": 1, + "raft_thread_fsm_saturation_count": 11923, + "raft_thread_fsm_saturation_quantile=0.5": 0, + "raft_thread_fsm_saturation_quantile=0.9": 0, + "raft_thread_fsm_saturation_quantile=0.99": 0, + "raft_thread_fsm_saturation_sum": 90, + "raft_thread_main_saturation_count": 43067, + "raft_thread_main_saturation_quantile=0.5": 0, + "raft_thread_main_saturation_quantile=0.9": 0, + "raft_thread_main_saturation_quantile=0.99": 0, + "raft_thread_main_saturation_sum": 205409, + "runtime_alloc_bytes": 53065368, + "runtime_sys_bytes": 84955160, + "runtime_total_gc_pause_ns": 1372001280, + "server_isLeader_no": 0, + "server_isLeader_yes": 1, + "txn_apply_count": 0, + "txn_apply_quantile=0.5": 0, + "txn_apply_quantile=0.9": 0, + "txn_apply_quantile=0.99": 0, + "txn_apply_sum": 0, + }, + }, + "success on response from Consul v1.14.3 server cloud managed": { + prepare: caseConsulV1143CloudServerResponse, + // 3 node, 1 service check, license + wantNumOfCharts: len(serverCommonCharts) + len(serverLeaderCharts) + 3 + 1, + wantMetrics: map[string]int64{ + "autopilot_failure_tolerance": 0, + "autopilot_healthy_no": 0, + "autopilot_healthy_yes": 1, + "client_rpc": 438718, + "client_rpc_exceeded": 0, + "client_rpc_failed": 0, + "health_check_chk1_critical_status": 0, + "health_check_chk1_maintenance_status": 0, + "health_check_chk1_passing_status": 1, + "health_check_chk1_warning_status": 0, + "health_check_chk2_critical_status": 1, + "health_check_chk2_maintenance_status": 0, + "health_check_chk2_passing_status": 0, + "health_check_chk2_warning_status": 0, + "health_check_chk3_critical_status": 1, + "health_check_chk3_maintenance_status": 0, + "health_check_chk3_passing_status": 0, + "health_check_chk3_warning_status": 0, + "health_check_mysql_critical_status": 1, + "health_check_mysql_maintenance_status": 0, + "health_check_mysql_passing_status": 0, + "health_check_mysql_warning_status": 0, + "kvs_apply_count": 2, + "kvs_apply_quantile=0.5": 0, + "kvs_apply_quantile=0.9": 0, + "kvs_apply_quantile=0.99": 0, + "kvs_apply_sum": 18550, + "network_lan_rtt_avg": 1321107, + "network_lan_rtt_count": 1, + "network_lan_rtt_max": 1321107, + "network_lan_rtt_min": 1321107, + "network_lan_rtt_sum": 1321107, + "raft_apply": 115252000, + "raft_boltdb_freelistBytes": 26008, + "raft_boltdb_logsPerBatch_count": 122794, + "raft_boltdb_logsPerBatch_quantile=0.5": 1000000, + "raft_boltdb_logsPerBatch_quantile=0.9": 1000000, + "raft_boltdb_logsPerBatch_quantile=0.99": 1000000, + "raft_boltdb_logsPerBatch_sum": 122856000, + "raft_boltdb_storeLogs_count": 122794, + "raft_boltdb_storeLogs_quantile=0.5": 1673303, + "raft_boltdb_storeLogs_quantile=0.9": 2210979, + "raft_boltdb_storeLogs_quantile=0.99": 2210979, + "raft_boltdb_storeLogs_sum": 278437403, + "raft_commitTime_count": 122785, + "raft_commitTime_quantile=0.5": 1718204, + "raft_commitTime_quantile=0.9": 2262192, + "raft_commitTime_quantile=0.99": 2262192, + "raft_commitTime_sum": 284260428, + "raft_fsm_lastRestoreDuration": 0, + "raft_leader_lastContact_count": 19, + "raft_leader_lastContact_quantile=0.5": 0, + "raft_leader_lastContact_quantile=0.9": 0, + "raft_leader_lastContact_quantile=0.99": 0, + "raft_leader_lastContact_sum": 598000, + "raft_leader_oldestLogAge": 68835264, + "raft_rpc_installSnapshot_count": 1, + "raft_rpc_installSnapshot_quantile=0.5": 0, + "raft_rpc_installSnapshot_quantile=0.9": 0, + "raft_rpc_installSnapshot_quantile=0.99": 0, + "raft_rpc_installSnapshot_sum": 473038, + "raft_state_candidate": 1, + "raft_state_leader": 1, + "raft_thread_fsm_saturation_count": 44326, + "raft_thread_fsm_saturation_quantile=0.5": 0, + "raft_thread_fsm_saturation_quantile=0.9": 0, + "raft_thread_fsm_saturation_quantile=0.99": 0, + "raft_thread_fsm_saturation_sum": 729, + "raft_thread_main_saturation_count": 451221, + "raft_thread_main_saturation_quantile=0.5": 0, + "raft_thread_main_saturation_quantile=0.9": 0, + "raft_thread_main_saturation_quantile=0.99": 9999, + "raft_thread_main_saturation_sum": 213059, + "runtime_alloc_bytes": 51729856, + "runtime_sys_bytes": 160156960, + "runtime_total_gc_pause_ns": 832754048, + "server_isLeader_no": 0, + "server_isLeader_yes": 1, + "system_licenseExpiration": 2949945, + "txn_apply_count": 0, + "txn_apply_quantile=0.5": 0, + "txn_apply_quantile=0.9": 0, + "txn_apply_quantile=0.99": 0, + "txn_apply_sum": 0, + }, + }, + "success on response from Consul v1.13.2 server with enabled hostname": { + prepare: caseConsulV1132ServerResponse, + // 3 node, 1 service check, no license + wantNumOfCharts: len(serverCommonCharts) + len(serverAutopilotHealthCharts) + len(serverLeaderCharts) + 3 + 1 - 1, + wantMetrics: map[string]int64{ + "autopilot_failure_tolerance": 1, + "autopilot_healthy_no": 0, + "autopilot_healthy_yes": 1, + "autopilot_server_healthy_no": 0, + "autopilot_server_healthy_yes": 1, + "autopilot_server_lastContact_leader": 13, + "autopilot_server_sefStatus_alive": 1, + "autopilot_server_sefStatus_failed": 0, + "autopilot_server_sefStatus_left": 0, + "autopilot_server_sefStatus_none": 0, + "autopilot_server_stable_time": 265825, + "autopilot_server_voter_no": 0, + "autopilot_server_voter_yes": 1, + "client_rpc": 6838, + "client_rpc_exceeded": 0, + "client_rpc_failed": 0, + "health_check_chk1_critical_status": 0, + "health_check_chk1_maintenance_status": 0, + "health_check_chk1_passing_status": 1, + "health_check_chk1_warning_status": 0, + "health_check_chk2_critical_status": 1, + "health_check_chk2_maintenance_status": 0, + "health_check_chk2_passing_status": 0, + "health_check_chk2_warning_status": 0, + "health_check_chk3_critical_status": 1, + "health_check_chk3_maintenance_status": 0, + "health_check_chk3_passing_status": 0, + "health_check_chk3_warning_status": 0, + "health_check_mysql_critical_status": 1, + "health_check_mysql_maintenance_status": 0, + "health_check_mysql_passing_status": 0, + "health_check_mysql_warning_status": 0, + "kvs_apply_count": 0, + "kvs_apply_quantile=0.5": 0, + "kvs_apply_quantile=0.9": 0, + "kvs_apply_quantile=0.99": 0, + "kvs_apply_sum": 0, + "network_lan_rtt_avg": 737592, + "network_lan_rtt_count": 2, + "network_lan_rtt_max": 991168, + "network_lan_rtt_min": 484017, + "network_lan_rtt_sum": 1475185, + "raft_apply": 10681000, + "raft_boltdb_freelistBytes": 11264, + "raft_boltdb_logsPerBatch_count": 12360, + "raft_boltdb_logsPerBatch_quantile=0.5": 1000000, + "raft_boltdb_logsPerBatch_quantile=0.9": 1000000, + "raft_boltdb_logsPerBatch_quantile=0.99": 1000000, + "raft_boltdb_logsPerBatch_sum": 12362000, + "raft_boltdb_storeLogs_count": 12360, + "raft_boltdb_storeLogs_quantile=0.5": 13176624, + "raft_boltdb_storeLogs_quantile=0.9": 13176624, + "raft_boltdb_storeLogs_quantile=0.99": 13176624, + "raft_boltdb_storeLogs_sum": 651888027, + "raft_commitTime_count": 12345, + "raft_commitTime_quantile=0.5": 41146488, + "raft_commitTime_quantile=0.9": 41146488, + "raft_commitTime_quantile=0.99": 41146488, + "raft_commitTime_sum": 955781149, + "raft_fsm_lastRestoreDuration": 2, + "raft_leader_lastContact_count": 80917, + "raft_leader_lastContact_quantile=0.5": 33000000, + "raft_leader_lastContact_quantile=0.9": 68000000, + "raft_leader_lastContact_quantile=0.99": 68000000, + "raft_leader_lastContact_sum": 3066900000, + "raft_leader_oldestLogAge": 166046464, + "raft_rpc_installSnapshot_count": 0, + "raft_rpc_installSnapshot_quantile=0.5": 0, + "raft_rpc_installSnapshot_quantile=0.9": 0, + "raft_rpc_installSnapshot_quantile=0.99": 0, + "raft_rpc_installSnapshot_sum": 0, + "raft_state_candidate": 1, + "raft_state_leader": 1, + "raft_thread_fsm_saturation_count": 11923, + "raft_thread_fsm_saturation_quantile=0.5": 0, + "raft_thread_fsm_saturation_quantile=0.9": 0, + "raft_thread_fsm_saturation_quantile=0.99": 0, + "raft_thread_fsm_saturation_sum": 90, + "raft_thread_main_saturation_count": 43067, + "raft_thread_main_saturation_quantile=0.5": 0, + "raft_thread_main_saturation_quantile=0.9": 0, + "raft_thread_main_saturation_quantile=0.99": 0, + "raft_thread_main_saturation_sum": 205409, + "runtime_alloc_bytes": 53065368, + "runtime_sys_bytes": 84955160, + "runtime_total_gc_pause_ns": 1372001280, + "server_isLeader_no": 0, + "server_isLeader_yes": 1, + "txn_apply_count": 0, + "txn_apply_quantile=0.5": 0, + "txn_apply_quantile=0.9": 0, + "txn_apply_quantile=0.99": 0, + "txn_apply_sum": 0, + }, + }, + "success on response from Consul v1.13.2 server with disabled prometheus": { + prepare: caseConsulV1132ServerWithDisabledPrometheus, + // 3 node, 1 service check, no license + wantNumOfCharts: len(serverAutopilotHealthCharts) + 3 + 1, + wantMetrics: map[string]int64{ + "autopilot_server_healthy_no": 0, + "autopilot_server_healthy_yes": 1, + "autopilot_server_lastContact_leader": 13, + "autopilot_server_sefStatus_alive": 1, + "autopilot_server_sefStatus_failed": 0, + "autopilot_server_sefStatus_left": 0, + "autopilot_server_sefStatus_none": 0, + "autopilot_server_stable_time": 265805, + "autopilot_server_voter_no": 0, + "autopilot_server_voter_yes": 1, + "health_check_chk1_critical_status": 0, + "health_check_chk1_maintenance_status": 0, + "health_check_chk1_passing_status": 1, + "health_check_chk1_warning_status": 0, + "health_check_chk2_critical_status": 1, + "health_check_chk2_maintenance_status": 0, + "health_check_chk2_passing_status": 0, + "health_check_chk2_warning_status": 0, + "health_check_chk3_critical_status": 1, + "health_check_chk3_maintenance_status": 0, + "health_check_chk3_passing_status": 0, + "health_check_chk3_warning_status": 0, + "health_check_mysql_critical_status": 1, + "health_check_mysql_maintenance_status": 0, + "health_check_mysql_passing_status": 0, + "health_check_mysql_warning_status": 0, + "network_lan_rtt_avg": 737592, + "network_lan_rtt_count": 2, + "network_lan_rtt_max": 991168, + "network_lan_rtt_min": 484017, + "network_lan_rtt_sum": 1475185, + }, + }, + "success on response from Consul v1.13.2 client": { + prepare: caseConsulV1132ClientResponse, + // 3 node, 1 service check, no license + wantNumOfCharts: len(clientCharts) + 3 + 1 - 1, + wantMetrics: map[string]int64{ + "client_rpc": 34, + "client_rpc_exceeded": 0, + "client_rpc_failed": 0, + "health_check_chk1_critical_status": 0, + "health_check_chk1_maintenance_status": 0, + "health_check_chk1_passing_status": 1, + "health_check_chk1_warning_status": 0, + "health_check_chk2_critical_status": 1, + "health_check_chk2_maintenance_status": 0, + "health_check_chk2_passing_status": 0, + "health_check_chk2_warning_status": 0, + "health_check_chk3_critical_status": 1, + "health_check_chk3_maintenance_status": 0, + "health_check_chk3_passing_status": 0, + "health_check_chk3_warning_status": 0, + "health_check_mysql_critical_status": 1, + "health_check_mysql_maintenance_status": 0, + "health_check_mysql_passing_status": 0, + "health_check_mysql_warning_status": 0, + "runtime_alloc_bytes": 26333408, + "runtime_sys_bytes": 51201032, + "runtime_total_gc_pause_ns": 4182423, + }, + }, + "fail on invalid data response": { + prepare: caseInvalidDataResponse, + wantNumOfCharts: 0, + wantMetrics: nil, + }, + "fail on connection refused": { + prepare: caseConnectionRefused, + wantNumOfCharts: 0, + wantMetrics: nil, + }, + "fail on 404 response": { + prepare: case404, + wantNumOfCharts: 0, + wantMetrics: nil, + }, + } + + for name, test := range tests { + t.Run(name, func(t *testing.T) { + consul, cleanup := test.prepare(t) + defer cleanup() + + mx := consul.Collect() + + delete(mx, "autopilot_server_stable_time") + delete(test.wantMetrics, "autopilot_server_stable_time") + + require.Equal(t, test.wantMetrics, mx) + if len(test.wantMetrics) > 0 { + assert.Equal(t, test.wantNumOfCharts, len(*consul.Charts())) + } + }) + } +} + +func caseConsulV1143CloudServerResponse(t *testing.T) (*Consul, func()) { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc( + func(w http.ResponseWriter, r *http.Request) { + switch { + case r.URL.Path == urlPathAgentSelf: + _, _ = w.Write(dataVer1143CloudServerSelf) + case r.URL.Path == urlPathAgentChecks: + _, _ = w.Write(dataVer1143CloudChecks) + case r.URL.Path == urlPathAgentMetrics && r.URL.RawQuery == "format=prometheus": + _, _ = w.Write(dataVer1143CloudServerPromMetrics) + case r.URL.Path == urlPathOperationAutopilotHealth: + w.WriteHeader(http.StatusForbidden) + case r.URL.Path == urlPathCoordinateNodes: + _, _ = w.Write(dataVer1143CloudServerCoordinateNodes) + default: + w.WriteHeader(http.StatusNotFound) + } + })) + + consul := New() + consul.URL = srv.URL + + require.NoError(t, consul.Init()) + + return consul, srv.Close +} + +func caseConsulV1132ServerResponse(t *testing.T) (*Consul, func()) { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc( + func(w http.ResponseWriter, r *http.Request) { + switch { + case r.URL.Path == urlPathAgentSelf: + _, _ = w.Write(dataVer1132ServerSelf) + case r.URL.Path == urlPathAgentChecks: + _, _ = w.Write(dataVer1132Checks) + case r.URL.Path == urlPathAgentMetrics && r.URL.RawQuery == "format=prometheus": + _, _ = w.Write(dataVer1132ServerPromMetrics) + case r.URL.Path == urlPathOperationAutopilotHealth: + _, _ = w.Write(dataVer1132ServerOperatorAutopilotHealth) + case r.URL.Path == urlPathCoordinateNodes: + _, _ = w.Write(dataVer1132ServerCoordinateNodes) + default: + w.WriteHeader(http.StatusNotFound) + } + })) + + consul := New() + consul.URL = srv.URL + + require.NoError(t, consul.Init()) + + return consul, srv.Close +} + +func caseConsulV1132ServerWithHostnameResponse(t *testing.T) (*Consul, func()) { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc( + func(w http.ResponseWriter, r *http.Request) { + switch { + case r.URL.Path == urlPathAgentSelf: + _, _ = w.Write(dataVer1132ServerSelfWithHostname) + case r.URL.Path == urlPathAgentChecks: + _, _ = w.Write(dataVer1132Checks) + case r.URL.Path == urlPathAgentMetrics && r.URL.RawQuery == "format=prometheus": + _, _ = w.Write(dataVer1132ServerPromMetricsWithHostname) + case r.URL.Path == urlPathOperationAutopilotHealth: + _, _ = w.Write(dataVer1132ServerOperatorAutopilotHealth) + case r.URL.Path == urlPathCoordinateNodes: + _, _ = w.Write(dataVer1132ServerCoordinateNodes) + default: + w.WriteHeader(http.StatusNotFound) + } + })) + + consul := New() + consul.URL = srv.URL + + require.NoError(t, consul.Init()) + + return consul, srv.Close +} + +func caseConsulV1132ServerWithDisabledPrometheus(t *testing.T) (*Consul, func()) { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc( + func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case urlPathAgentSelf: + _, _ = w.Write(dataVer1132ServerSelfDisabledPrometheus) + case urlPathAgentChecks: + _, _ = w.Write(dataVer1132Checks) + case urlPathOperationAutopilotHealth: + _, _ = w.Write(dataVer1132ServerOperatorAutopilotHealth) + case urlPathCoordinateNodes: + _, _ = w.Write(dataVer1132ServerCoordinateNodes) + default: + w.WriteHeader(http.StatusNotFound) + } + })) + + consul := New() + consul.URL = srv.URL + + require.NoError(t, consul.Init()) + + return consul, srv.Close +} + +func caseConsulV1132ClientResponse(t *testing.T) (*Consul, func()) { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc( + func(w http.ResponseWriter, r *http.Request) { + switch { + case r.URL.Path == urlPathAgentSelf: + _, _ = w.Write(dataVer1132ClientSelf) + case r.URL.Path == urlPathAgentChecks: + _, _ = w.Write(dataVer1132Checks) + case r.URL.Path == urlPathAgentMetrics && r.URL.RawQuery == "format=prometheus": + _, _ = w.Write(dataVer1132ClientPromMetrics) + default: + w.WriteHeader(http.StatusNotFound) + } + })) + + consul := New() + consul.URL = srv.URL + + require.NoError(t, consul.Init()) + + return consul, srv.Close +} + +func caseInvalidDataResponse(t *testing.T) (*Consul, func()) { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc( + func(w http.ResponseWriter, r *http.Request) { + _, _ = w.Write([]byte("hello and\n goodbye")) + })) + + consul := New() + consul.URL = srv.URL + + require.NoError(t, consul.Init()) + + return consul, srv.Close +} + +func caseConnectionRefused(t *testing.T) (*Consul, func()) { + t.Helper() + consul := New() + consul.URL = "http://127.0.0.1:65535/" + require.NoError(t, consul.Init()) + + return consul, func() {} +} + +func case404(t *testing.T) (*Consul, func()) { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc( + func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotFound) + })) + + consul := New() + consul.URL = srv.URL + require.NoError(t, consul.Init()) + + return consul, srv.Close +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/init.go b/src/go/collectors/go.d.plugin/modules/consul/init.go new file mode 100644 index 000000000..944609a16 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/init.go @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package consul + +import ( + "errors" + "net/http" + "net/url" + + "github.com/netdata/netdata/go/go.d.plugin/pkg/prometheus" + "github.com/netdata/netdata/go/go.d.plugin/pkg/web" +) + +func (c *Consul) validateConfig() error { + if c.URL == "" { + return errors.New("'url' not set") + } + return nil +} + +func (c *Consul) initHTTPClient() (*http.Client, error) { + return web.NewHTTPClient(c.Client) +} + +const urlPathAgentMetrics = "/v1/agent/metrics" + +func (c *Consul) initPrometheusClient(httpClient *http.Client) (prometheus.Prometheus, error) { + r, err := web.NewHTTPRequest(c.Request.Copy()) + if err != nil { + return nil, err + } + r.URL.Path = urlPathAgentMetrics + r.URL.RawQuery = url.Values{ + "format": []string{"prometheus"}, + }.Encode() + + req := c.Request.Copy() + req.URL = r.URL.String() + + if c.ACLToken != "" { + if req.Headers == nil { + req.Headers = make(map[string]string) + } + req.Headers["X-Consul-Token"] = c.ACLToken + } + + return prometheus.New(httpClient, req), nil +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/integrations/consul.md b/src/go/collectors/go.d.plugin/modules/consul/integrations/consul.md new file mode 100644 index 000000000..c8d014d05 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/integrations/consul.md @@ -0,0 +1,324 @@ +<!--startmeta +custom_edit_url: "https://github.com/netdata/netdata/edit/master/src/go/collectors/go.d.plugin/modules/consul/README.md" +meta_yaml: "https://github.com/netdata/netdata/edit/master/src/go/collectors/go.d.plugin/modules/consul/metadata.yaml" +sidebar_label: "Consul" +learn_status: "Published" +learn_rel_path: "Collecting Metrics/Service Discovery / Registry" +most_popular: True +message: "DO NOT EDIT THIS FILE DIRECTLY, IT IS GENERATED BY THE COLLECTOR'S metadata.yaml FILE" +endmeta--> + +# Consul + + +<img src="https://netdata.cloud/img/consul.svg" width="150"/> + + +Plugin: go.d.plugin +Module: consul + +<img src="https://img.shields.io/badge/maintained%20by-Netdata-%2300ab44" /> + +## Overview + +This collector monitors [key metrics](https://developer.hashicorp.com/consul/docs/agent/telemetry#key-metrics) of Consul Agents: transaction timings, leadership changes, memory usage and more. + + +It periodically sends HTTP requests to [Consul REST API](https://developer.hashicorp.com/consul/api-docs). + +Used endpoints: + +- [/operator/autopilot/health](https://developer.hashicorp.com/consul/api-docs/operator/autopilot#read-health) +- [/agent/checks](https://developer.hashicorp.com/consul/api-docs/agent/check#list-checks) +- [/agent/self](https://developer.hashicorp.com/consul/api-docs/agent#read-configuration) +- [/agent/metrics](https://developer.hashicorp.com/consul/api-docs/agent#view-metrics) +- [/coordinate/nodes](https://developer.hashicorp.com/consul/api-docs/coordinate#read-lan-coordinates-for-all-nodes) + + +This collector is supported on all platforms. + +This collector supports collecting metrics from multiple instances of this integration, including remote instances. + + +### Default Behavior + +#### Auto-Detection + +This collector discovers instances running on the local host, that provide metrics on port 8500. + +On startup, it tries to collect metrics from: + +- http://localhost:8500 +- http://127.0.0.1:8500 + + +#### Limits + +The default configuration for this integration does not impose any limits on data collection. + +#### Performance Impact + +The default configuration for this integration is not expected to impose a significant performance impact on the system. + + +## Metrics + +Metrics grouped by *scope*. + +The scope defines the instance that the metric belongs to. An instance is uniquely identified by a set of labels. + +The set of metrics depends on the [Consul Agent mode](https://developer.hashicorp.com/consul/docs/install/glossary#agent). + + +### Per Consul instance + +These metrics refer to the entire monitored application. + +This scope has no labels. + +Metrics: + +| Metric | Dimensions | Unit | Leader | Follower | Client | +|:------|:----------|:----|:---:|:---:|:---:| +| consul.client_rpc_requests_rate | rpc | requests/s | • | • | • | +| consul.client_rpc_requests_exceeded_rate | exceeded | requests/s | • | • | • | +| consul.client_rpc_requests_failed_rate | failed | requests/s | • | • | • | +| consul.memory_allocated | allocated | bytes | • | • | • | +| consul.memory_sys | sys | bytes | • | • | • | +| consul.gc_pause_time | gc_pause | seconds | • | • | • | +| consul.kvs_apply_time | quantile_0.5, quantile_0.9, quantile_0.99 | ms | • | • | | +| consul.kvs_apply_operations_rate | kvs_apply | ops/s | • | • | | +| consul.txn_apply_time | quantile_0.5, quantile_0.9, quantile_0.99 | ms | • | • | | +| consul.txn_apply_operations_rate | txn_apply | ops/s | • | • | | +| consul.autopilot_health_status | healthy, unhealthy | status | • | • | | +| consul.autopilot_failure_tolerance | failure_tolerance | servers | • | • | | +| consul.autopilot_server_health_status | healthy, unhealthy | status | • | • | | +| consul.autopilot_server_stable_time | stable | seconds | • | • | | +| consul.autopilot_server_serf_status | active, failed, left, none | status | • | • | | +| consul.autopilot_server_voter_status | voter, not_voter | status | • | • | | +| consul.network_lan_rtt | min, max, avg | ms | • | • | | +| consul.raft_commit_time | quantile_0.5, quantile_0.9, quantile_0.99 | ms | • | | | +| consul.raft_commits_rate | commits | commits/s | • | | | +| consul.raft_leader_last_contact_time | quantile_0.5, quantile_0.9, quantile_0.99 | ms | • | | | +| consul.raft_leader_oldest_log_age | oldest_log_age | seconds | • | | | +| consul.raft_follower_last_contact_leader_time | leader_last_contact | ms | | • | | +| consul.raft_rpc_install_snapshot_time | quantile_0.5, quantile_0.9, quantile_0.99 | ms | | • | | +| consul.raft_leader_elections_rate | leader | elections/s | • | • | | +| consul.raft_leadership_transitions_rate | leadership | transitions/s | • | • | | +| consul.server_leadership_status | leader, not_leader | status | • | • | | +| consul.raft_thread_main_saturation_perc | quantile_0.5, quantile_0.9, quantile_0.99 | percentage | • | • | | +| consul.raft_thread_fsm_saturation_perc | quantile_0.5, quantile_0.9, quantile_0.99 | percentage | • | • | | +| consul.raft_fsm_last_restore_duration | last_restore_duration | ms | • | • | | +| consul.raft_boltdb_freelist_bytes | freelist | bytes | • | • | | +| consul.raft_boltdb_logs_per_batch_rate | written | logs/s | • | • | | +| consul.raft_boltdb_store_logs_time | quantile_0.5, quantile_0.9, quantile_0.99 | ms | • | • | | +| consul.license_expiration_time | license_expiration | seconds | • | • | • | + +### Per node check + +Metrics about checks on Node level. + +Labels: + +| Label | Description | +|:-----------|:----------------| +| datacenter | Datacenter Identifier | +| node_name | The node's name | +| check_name | The check's name | + +Metrics: + +| Metric | Dimensions | Unit | Leader | Follower | Client | +|:------|:----------|:----|:---:|:---:|:---:| +| consul.node_health_check_status | passing, maintenance, warning, critical | status | • | • | • | + +### Per service check + +Metrics about checks at a Service level. + +Labels: + +| Label | Description | +|:-----------|:----------------| +| datacenter | Datacenter Identifier | +| node_name | The node's name | +| check_name | The check's name | +| service_name | The service's name | + +Metrics: + +| Metric | Dimensions | Unit | Leader | Follower | Client | +|:------|:----------|:----|:---:|:---:|:---:| +| consul.service_health_check_status | passing, maintenance, warning, critical | status | • | • | • | + + + +## Alerts + + +The following alerts are available: + +| Alert name | On metric | Description | +|:------------|:----------|:------------| +| [ consul_node_health_check_status ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.node_health_check_status | node health check ${label:check_name} has failed on server ${label:node_name} datacenter ${label:datacenter} | +| [ consul_service_health_check_status ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.service_health_check_status | service health check ${label:check_name} for service ${label:service_name} has failed on server ${label:node_name} datacenter ${label:datacenter} | +| [ consul_client_rpc_requests_exceeded ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.client_rpc_requests_exceeded_rate | number of rate-limited RPC requests made by server ${label:node_name} datacenter ${label:datacenter} | +| [ consul_client_rpc_requests_failed ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.client_rpc_requests_failed_rate | number of failed RPC requests made by server ${label:node_name} datacenter ${label:datacenter} | +| [ consul_gc_pause_time ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.gc_pause_time | time spent in stop-the-world garbage collection pauses on server ${label:node_name} datacenter ${label:datacenter} | +| [ consul_autopilot_health_status ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.autopilot_health_status | datacenter ${label:datacenter} cluster is unhealthy as reported by server ${label:node_name} | +| [ consul_autopilot_server_health_status ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.autopilot_server_health_status | server ${label:node_name} from datacenter ${label:datacenter} is unhealthy | +| [ consul_raft_leader_last_contact_time ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.raft_leader_last_contact_time | median time elapsed since leader server ${label:node_name} datacenter ${label:datacenter} was last able to contact the follower nodes | +| [ consul_raft_leadership_transitions ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.raft_leadership_transitions_rate | there has been a leadership change and server ${label:node_name} datacenter ${label:datacenter} has become the leader | +| [ consul_raft_thread_main_saturation ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.raft_thread_main_saturation_perc | average saturation of the main Raft goroutine on server ${label:node_name} datacenter ${label:datacenter} | +| [ consul_raft_thread_fsm_saturation ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.raft_thread_fsm_saturation_perc | average saturation of the FSM Raft goroutine on server ${label:node_name} datacenter ${label:datacenter} | +| [ consul_license_expiration_time ](https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf) | consul.license_expiration_time | Consul Enterprise licence expiration time on node ${label:node_name} datacenter ${label:datacenter} | + + +## Setup + +### Prerequisites + +#### Enable Prometheus telemetry + +[Enable](https://developer.hashicorp.com/consul/docs/agent/config/config-files#telemetry-prometheus_retention_time) telemetry on your Consul agent, by increasing the value of `prometheus_retention_time` from `0`. + + +#### Add required ACLs to Token + +Required **only if authentication is enabled**. + +| ACL | Endpoint | +|:---------------:|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `operator:read` | [autopilot health status](https://developer.hashicorp.com/consul/api-docs/operator/autopilot#read-health) | +| `node:read` | [checks](https://developer.hashicorp.com/consul/api-docs/agent/check#list-checks) | +| `agent:read` | [configuration](https://developer.hashicorp.com/consul/api-docs/agent#read-configuration), [metrics](https://developer.hashicorp.com/consul/api-docs/agent#view-metrics), and [lan coordinates](https://developer.hashicorp.com/consul/api-docs/coordinate#read-lan-coordinates-for-all-nodes) | + + + +### Configuration + +#### File + +The configuration file name for this integration is `go.d/consul.conf`. + + +You can edit the configuration file using the `edit-config` script from the +Netdata [config directory](/docs/netdata-agent/configuration/README.md#the-netdata-config-directory). + +```bash +cd /etc/netdata 2>/dev/null || cd /opt/netdata/etc/netdata +sudo ./edit-config go.d/consul.conf +``` +#### Options + +The following options can be defined globally: update_every, autodetection_retry. + + +<details open><summary>All options</summary> + +| Name | Description | Default | Required | +|:----|:-----------|:-------|:--------:| +| update_every | Data collection frequency. | 1 | no | +| autodetection_retry | Recheck interval in seconds. Zero means no recheck will be scheduled. | 0 | no | +| url | Server URL. | http://localhost:8500 | yes | +| acl_token | ACL token used in every request. | | no | +| max_checks | Checks processing/charting limit. | | no | +| max_filter | Checks processing/charting filter. Uses [simple patterns](/src/libnetdata/simple_pattern/README.md). | | no | +| username | Username for basic HTTP authentication. | | no | +| password | Password for basic HTTP authentication. | | no | +| proxy_url | Proxy URL. | | no | +| proxy_username | Username for proxy basic HTTP authentication. | | no | +| proxy_password | Password for proxy basic HTTP authentication. | | no | +| timeout | HTTP request timeout. | 1 | no | +| method | HTTP request method. | GET | no | +| body | HTTP request body. | | no | +| headers | HTTP request headers. | | no | +| not_follow_redirects | Redirect handling policy. Controls whether the client follows redirects. | no | no | +| tls_skip_verify | Server certificate chain and hostname validation policy. Controls whether the client performs this check. | no | no | +| tls_ca | Certification authority that the client uses when verifying the server's certificates. | | no | +| tls_cert | Client tls certificate. | | no | +| tls_key | Client tls key. | | no | + +</details> + +#### Examples + +##### Basic + +An example configuration. + +```yaml +jobs: + - name: local + url: http://127.0.0.1:8500 + acl_token: "ec15675e-2999-d789-832e-8c4794daa8d7" + +``` +##### Basic HTTP auth + +Local server with basic HTTP authentication. + +<details open><summary>Config</summary> + +```yaml +jobs: + - name: local + url: http://127.0.0.1:8500 + acl_token: "ec15675e-2999-d789-832e-8c4794daa8d7" + username: foo + password: bar + +``` +</details> + +##### Multi-instance + +> **Note**: When you define multiple jobs, their names must be unique. + +Collecting metrics from local and remote instances. + + +<details open><summary>Config</summary> + +```yaml +jobs: + - name: local + url: http://127.0.0.1:8500 + acl_token: "ec15675e-2999-d789-832e-8c4794daa8d7" + + - name: remote + url: http://203.0.113.10:8500 + acl_token: "ada7f751-f654-8872-7f93-498e799158b6" + +``` +</details> + + + +## Troubleshooting + +### Debug Mode + +To troubleshoot issues with the `consul` collector, run the `go.d.plugin` with the debug option enabled. The output +should give you clues as to why the collector isn't working. + +- Navigate to the `plugins.d` directory, usually at `/usr/libexec/netdata/plugins.d/`. If that's not the case on + your system, open `netdata.conf` and look for the `plugins` setting under `[directories]`. + + ```bash + cd /usr/libexec/netdata/plugins.d/ + ``` + +- Switch to the `netdata` user. + + ```bash + sudo -u netdata -s + ``` + +- Run the `go.d.plugin` to debug the collector: + + ```bash + ./go.d.plugin -d -m consul + ``` + + diff --git a/src/go/collectors/go.d.plugin/modules/consul/metadata.yaml b/src/go/collectors/go.d.plugin/modules/consul/metadata.yaml new file mode 100644 index 000000000..34445cd7e --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/metadata.yaml @@ -0,0 +1,599 @@ +plugin_name: go.d.plugin +modules: + - meta: + id: collector-go.d.plugin-consul + plugin_name: go.d.plugin + module_name: consul + monitored_instance: + name: Consul + link: https://www.consul.io/ + categories: + - data-collection.service-discovery-registry + icon_filename: consul.svg + alternative_monitored_instances: [] + related_resources: + integrations: + list: [] + info_provided_to_referring_integrations: + description: "" + keywords: + - service networking platform + - hashicorp + most_popular: true + overview: + data_collection: + metrics_description: | + This collector monitors [key metrics](https://developer.hashicorp.com/consul/docs/agent/telemetry#key-metrics) of Consul Agents: transaction timings, leadership changes, memory usage and more. + method_description: | + It periodically sends HTTP requests to [Consul REST API](https://developer.hashicorp.com/consul/api-docs). + + Used endpoints: + + - [/operator/autopilot/health](https://developer.hashicorp.com/consul/api-docs/operator/autopilot#read-health) + - [/agent/checks](https://developer.hashicorp.com/consul/api-docs/agent/check#list-checks) + - [/agent/self](https://developer.hashicorp.com/consul/api-docs/agent#read-configuration) + - [/agent/metrics](https://developer.hashicorp.com/consul/api-docs/agent#view-metrics) + - [/coordinate/nodes](https://developer.hashicorp.com/consul/api-docs/coordinate#read-lan-coordinates-for-all-nodes) + supported_platforms: + include: [] + exclude: [] + multi_instance: true + additional_permissions: + description: "" + default_behavior: + auto_detection: + description: | + This collector discovers instances running on the local host, that provide metrics on port 8500. + + On startup, it tries to collect metrics from: + + - http://localhost:8500 + - http://127.0.0.1:8500 + limits: + description: "" + performance_impact: + description: "" + setup: + prerequisites: + list: + - title: Enable Prometheus telemetry + description: | + [Enable](https://developer.hashicorp.com/consul/docs/agent/config/config-files#telemetry-prometheus_retention_time) telemetry on your Consul agent, by increasing the value of `prometheus_retention_time` from `0`. + - title: Add required ACLs to Token + description: | + Required **only if authentication is enabled**. + + | ACL | Endpoint | + |:---------------:|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| + | `operator:read` | [autopilot health status](https://developer.hashicorp.com/consul/api-docs/operator/autopilot#read-health) | + | `node:read` | [checks](https://developer.hashicorp.com/consul/api-docs/agent/check#list-checks) | + | `agent:read` | [configuration](https://developer.hashicorp.com/consul/api-docs/agent#read-configuration), [metrics](https://developer.hashicorp.com/consul/api-docs/agent#view-metrics), and [lan coordinates](https://developer.hashicorp.com/consul/api-docs/coordinate#read-lan-coordinates-for-all-nodes) | + configuration: + file: + name: go.d/consul.conf + options: + description: | + The following options can be defined globally: update_every, autodetection_retry. + folding: + title: All options + enabled: true + list: + - name: update_every + description: Data collection frequency. + default_value: 1 + required: false + - name: autodetection_retry + description: Recheck interval in seconds. Zero means no recheck will be scheduled. + default_value: 0 + required: false + - name: url + description: Server URL. + default_value: http://localhost:8500 + required: true + - name: acl_token + description: ACL token used in every request. + default_value: "" + required: false + - name: max_checks + description: Checks processing/charting limit. + default_value: "" + required: false + - name: max_filter + description: Checks processing/charting filter. Uses [simple patterns](/src/libnetdata/simple_pattern/README.md). + default_value: "" + required: false + - name: username + description: Username for basic HTTP authentication. + default_value: "" + required: false + - name: password + description: Password for basic HTTP authentication. + default_value: "" + required: false + - name: proxy_url + description: Proxy URL. + default_value: "" + required: false + - name: proxy_username + description: Username for proxy basic HTTP authentication. + default_value: "" + required: false + - name: proxy_password + description: Password for proxy basic HTTP authentication. + default_value: "" + required: false + - name: timeout + description: HTTP request timeout. + default_value: 1 + required: false + - name: method + description: HTTP request method. + default_value: GET + required: false + - name: body + description: HTTP request body. + default_value: "" + required: false + - name: headers + description: HTTP request headers. + default_value: "" + required: false + - name: not_follow_redirects + description: Redirect handling policy. Controls whether the client follows redirects. + default_value: false + required: false + - name: tls_skip_verify + description: Server certificate chain and hostname validation policy. Controls whether the client performs this check. + default_value: false + required: false + - name: tls_ca + description: Certification authority that the client uses when verifying the server's certificates. + default_value: "" + required: false + - name: tls_cert + description: Client tls certificate. + default_value: "" + required: false + - name: tls_key + description: Client tls key. + default_value: "" + required: false + examples: + folding: + title: Config + enabled: true + list: + - name: Basic + description: An example configuration. + folding: + enabled: false + config: | + jobs: + - name: local + url: http://127.0.0.1:8500 + acl_token: "ec15675e-2999-d789-832e-8c4794daa8d7" + - name: Basic HTTP auth + description: Local server with basic HTTP authentication. + config: | + jobs: + - name: local + url: http://127.0.0.1:8500 + acl_token: "ec15675e-2999-d789-832e-8c4794daa8d7" + username: foo + password: bar + - name: Multi-instance + description: | + > **Note**: When you define multiple jobs, their names must be unique. + + Collecting metrics from local and remote instances. + config: | + jobs: + - name: local + url: http://127.0.0.1:8500 + acl_token: "ec15675e-2999-d789-832e-8c4794daa8d7" + + - name: remote + url: http://203.0.113.10:8500 + acl_token: "ada7f751-f654-8872-7f93-498e799158b6" + troubleshooting: + problems: + list: [] + alerts: + - name: consul_node_health_check_status + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.node_health_check_status + info: node health check ${label:check_name} has failed on server ${label:node_name} datacenter ${label:datacenter} + - name: consul_service_health_check_status + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.service_health_check_status + info: service health check ${label:check_name} for service ${label:service_name} has failed on server ${label:node_name} datacenter ${label:datacenter} + - name: consul_client_rpc_requests_exceeded + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.client_rpc_requests_exceeded_rate + info: number of rate-limited RPC requests made by server ${label:node_name} datacenter ${label:datacenter} + - name: consul_client_rpc_requests_failed + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.client_rpc_requests_failed_rate + info: number of failed RPC requests made by server ${label:node_name} datacenter ${label:datacenter} + - name: consul_gc_pause_time + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.gc_pause_time + info: time spent in stop-the-world garbage collection pauses on server ${label:node_name} datacenter ${label:datacenter} + - name: consul_autopilot_health_status + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.autopilot_health_status + info: datacenter ${label:datacenter} cluster is unhealthy as reported by server ${label:node_name} + - name: consul_autopilot_server_health_status + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.autopilot_server_health_status + info: server ${label:node_name} from datacenter ${label:datacenter} is unhealthy + - name: consul_raft_leader_last_contact_time + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.raft_leader_last_contact_time + info: median time elapsed since leader server ${label:node_name} datacenter ${label:datacenter} was last able to contact the follower nodes + - name: consul_raft_leadership_transitions + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.raft_leadership_transitions_rate + info: there has been a leadership change and server ${label:node_name} datacenter ${label:datacenter} has become the leader + - name: consul_raft_thread_main_saturation + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.raft_thread_main_saturation_perc + info: average saturation of the main Raft goroutine on server ${label:node_name} datacenter ${label:datacenter} + - name: consul_raft_thread_fsm_saturation + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.raft_thread_fsm_saturation_perc + info: average saturation of the FSM Raft goroutine on server ${label:node_name} datacenter ${label:datacenter} + - name: consul_license_expiration_time + link: https://github.com/netdata/netdata/blob/master/src/health/health.d/consul.conf + metric: consul.license_expiration_time + info: Consul Enterprise licence expiration time on node ${label:node_name} datacenter ${label:datacenter} + metrics: + folding: + title: Metrics + enabled: false + description: | + The set of metrics depends on the [Consul Agent mode](https://developer.hashicorp.com/consul/docs/install/glossary#agent). + availability: + - Leader + - Follower + - Client + scopes: + - name: global + description: These metrics refer to the entire monitored application. + labels: [] + metrics: + - name: consul.client_rpc_requests_rate + description: Client RPC requests + unit: requests/s + chart_type: line + dimensions: + - name: rpc + - name: consul.client_rpc_requests_exceeded_rate + description: Client rate-limited RPC requests + unit: requests/s + chart_type: line + dimensions: + - name: exceeded + - name: consul.client_rpc_requests_failed_rate + description: Client failed RPC requests + unit: requests/s + chart_type: line + dimensions: + - name: failed + - name: consul.memory_allocated + description: Memory allocated by the Consul process + unit: bytes + chart_type: line + dimensions: + - name: allocated + - name: consul.memory_sys + description: Memory obtained from the OS + unit: bytes + chart_type: line + dimensions: + - name: sys + - name: consul.gc_pause_time + description: Garbage collection stop-the-world pause time + unit: seconds + chart_type: line + dimensions: + - name: gc_pause + - name: consul.kvs_apply_time + description: KVS apply time + unit: ms + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: quantile_0.5 + - name: quantile_0.9 + - name: quantile_0.99 + - name: consul.kvs_apply_operations_rate + description: KVS apply operations + unit: ops/s + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: kvs_apply + - name: consul.txn_apply_time + description: Transaction apply time + unit: ms + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: quantile_0.5 + - name: quantile_0.9 + - name: quantile_0.99 + - name: consul.txn_apply_operations_rate + description: Transaction apply operations + unit: ops/s + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: txn_apply + - name: consul.autopilot_health_status + description: Autopilot cluster health status + unit: status + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: healthy + - name: unhealthy + - name: consul.autopilot_failure_tolerance + description: Autopilot cluster failure tolerance + unit: servers + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: failure_tolerance + - name: consul.autopilot_server_health_status + description: Autopilot server health status + unit: status + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: healthy + - name: unhealthy + - name: consul.autopilot_server_stable_time + description: Autopilot server stable time + unit: seconds + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: stable + - name: consul.autopilot_server_serf_status + description: Autopilot server Serf status + unit: status + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: active + - name: failed + - name: left + - name: none + - name: consul.autopilot_server_voter_status + description: Autopilot server Raft voting membership + unit: status + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: voter + - name: not_voter + - name: consul.network_lan_rtt + description: Network lan RTT + unit: ms + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: min + - name: max + - name: avg + - name: consul.raft_commit_time + description: Raft commit time + unit: ms + chart_type: line + availability: + - Leader + dimensions: + - name: quantile_0.5 + - name: quantile_0.9 + - name: quantile_0.99 + - name: consul.raft_commits_rate + description: Raft commits rate + unit: commits/s + chart_type: line + availability: + - Leader + dimensions: + - name: commits + - name: consul.raft_leader_last_contact_time + description: Raft leader last contact time + unit: ms + chart_type: line + availability: + - Leader + dimensions: + - name: quantile_0.5 + - name: quantile_0.9 + - name: quantile_0.99 + - name: consul.raft_leader_oldest_log_age + description: Raft leader oldest log age + unit: seconds + chart_type: line + availability: + - Leader + dimensions: + - name: oldest_log_age + - name: consul.raft_follower_last_contact_leader_time + description: Raft follower last contact with the leader time + unit: ms + chart_type: line + availability: + - Follower + dimensions: + - name: leader_last_contact + - name: consul.raft_rpc_install_snapshot_time + description: Raft RPC install snapshot time + unit: ms + chart_type: line + availability: + - Follower + dimensions: + - name: quantile_0.5 + - name: quantile_0.9 + - name: quantile_0.99 + - name: consul.raft_leader_elections_rate + description: Raft leader elections rate + unit: elections/s + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: leader + - name: consul.raft_leadership_transitions_rate + description: Raft leadership transitions rate + unit: transitions/s + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: leadership + - name: consul.server_leadership_status + description: Server leadership status + unit: status + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: leader + - name: not_leader + - name: consul.raft_thread_main_saturation_perc + description: Raft main thread saturation + unit: percentage + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: quantile_0.5 + - name: quantile_0.9 + - name: quantile_0.99 + - name: consul.raft_thread_fsm_saturation_perc + description: Raft FSM thread saturation + unit: percentage + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: quantile_0.5 + - name: quantile_0.9 + - name: quantile_0.99 + - name: consul.raft_fsm_last_restore_duration + description: Raft last restore duration + unit: ms + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: last_restore_duration + - name: consul.raft_boltdb_freelist_bytes + description: Raft BoltDB freelist + unit: bytes + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: freelist + - name: consul.raft_boltdb_logs_per_batch_rate + description: Raft BoltDB logs written per batch + unit: logs/s + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: written + - name: consul.raft_boltdb_store_logs_time + description: Raft BoltDB store logs time + unit: ms + chart_type: line + availability: + - Leader + - Follower + dimensions: + - name: quantile_0.5 + - name: quantile_0.9 + - name: quantile_0.99 + - name: consul.license_expiration_time + description: License expiration time + unit: seconds + chart_type: line + dimensions: + - name: license_expiration + - name: node check + description: Metrics about checks on Node level. + labels: + - name: datacenter + description: Datacenter Identifier + - name: node_name + description: The node's name + - name: check_name + description: The check's name + metrics: + - name: consul.node_health_check_status + description: Node health check status + unit: status + chart_type: line + dimensions: + - name: passing + - name: maintenance + - name: warning + - name: critical + - name: service check + description: Metrics about checks at a Service level. + labels: + - name: datacenter + description: Datacenter Identifier + - name: node_name + description: The node's name + - name: check_name + description: The check's name + - name: service_name + description: The service's name + metrics: + - name: consul.service_health_check_status + description: Service health check status + unit: status + chart_type: line + dimensions: + - name: passing + - name: maintenance + - name: warning + - name: critical diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/config.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/config.json new file mode 100644 index 000000000..bcd07a41b --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/config.json @@ -0,0 +1,21 @@ +{ + "update_every": 123, + "url": "ok", + "body": "ok", + "method": "ok", + "headers": { + "ok": "ok" + }, + "username": "ok", + "password": "ok", + "proxy_url": "ok", + "proxy_username": "ok", + "proxy_password": "ok", + "timeout": 123.123, + "not_follow_redirects": true, + "tls_ca": "ok", + "tls_cert": "ok", + "tls_key": "ok", + "tls_skip_verify": true, + "acl_token": "ok" +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/config.yaml b/src/go/collectors/go.d.plugin/modules/consul/testdata/config.yaml new file mode 100644 index 000000000..def554c7e --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/config.yaml @@ -0,0 +1,18 @@ +update_every: 123 +url: "ok" +body: "ok" +method: "ok" +headers: + ok: "ok" +username: "ok" +password: "ok" +proxy_url: "ok" +proxy_username: "ok" +proxy_password: "ok" +timeout: 123.123 +not_follow_redirects: yes +tls_ca: "ok" +tls_cert: "ok" +tls_key: "ok" +tls_skip_verify: yes +acl_token: "ok" diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/client_v1-agent-metrics.txt b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/client_v1-agent-metrics.txt new file mode 100644 index 000000000..e93e677d8 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/client_v1-agent-metrics.txt @@ -0,0 +1,989 @@ +# HELP consul_acl_ResolveToken This measures the time it takes to resolve an ACL token. +# TYPE consul_acl_ResolveToken summary +consul_acl_ResolveToken{quantile="0.5"} NaN +consul_acl_ResolveToken{quantile="0.9"} NaN +consul_acl_ResolveToken{quantile="0.99"} NaN +consul_acl_ResolveToken_sum 0 +consul_acl_ResolveToken_count 0 +# HELP consul_acl_authmethod_delete +# TYPE consul_acl_authmethod_delete summary +consul_acl_authmethod_delete{quantile="0.5"} NaN +consul_acl_authmethod_delete{quantile="0.9"} NaN +consul_acl_authmethod_delete{quantile="0.99"} NaN +consul_acl_authmethod_delete_sum 0 +consul_acl_authmethod_delete_count 0 +# HELP consul_acl_authmethod_upsert +# TYPE consul_acl_authmethod_upsert summary +consul_acl_authmethod_upsert{quantile="0.5"} NaN +consul_acl_authmethod_upsert{quantile="0.9"} NaN +consul_acl_authmethod_upsert{quantile="0.99"} NaN +consul_acl_authmethod_upsert_sum 0 +consul_acl_authmethod_upsert_count 0 +# HELP consul_acl_bindingrule_delete +# TYPE consul_acl_bindingrule_delete summary +consul_acl_bindingrule_delete{quantile="0.5"} NaN +consul_acl_bindingrule_delete{quantile="0.9"} NaN +consul_acl_bindingrule_delete{quantile="0.99"} NaN +consul_acl_bindingrule_delete_sum 0 +consul_acl_bindingrule_delete_count 0 +# HELP consul_acl_bindingrule_upsert +# TYPE consul_acl_bindingrule_upsert summary +consul_acl_bindingrule_upsert{quantile="0.5"} NaN +consul_acl_bindingrule_upsert{quantile="0.9"} NaN +consul_acl_bindingrule_upsert{quantile="0.99"} NaN +consul_acl_bindingrule_upsert_sum 0 +consul_acl_bindingrule_upsert_count 0 +# HELP consul_acl_blocked_check_deregistration Increments whenever a deregistration fails for a check (blocked by an ACL) +# TYPE consul_acl_blocked_check_deregistration counter +consul_acl_blocked_check_deregistration 0 +# HELP consul_acl_blocked_check_registration Increments whenever a registration fails for a check (blocked by an ACL) +# TYPE consul_acl_blocked_check_registration counter +consul_acl_blocked_check_registration 0 +# HELP consul_acl_blocked_node_registration Increments whenever a registration fails for a node (blocked by an ACL) +# TYPE consul_acl_blocked_node_registration counter +consul_acl_blocked_node_registration 0 +# HELP consul_acl_blocked_service_deregistration Increments whenever a deregistration fails for a service (blocked by an ACL) +# TYPE consul_acl_blocked_service_deregistration counter +consul_acl_blocked_service_deregistration 0 +# HELP consul_acl_blocked_service_registration Increments whenever a registration fails for a service (blocked by an ACL) +# TYPE consul_acl_blocked_service_registration counter +consul_acl_blocked_service_registration 0 +# HELP consul_acl_login +# TYPE consul_acl_login summary +consul_acl_login{quantile="0.5"} NaN +consul_acl_login{quantile="0.9"} NaN +consul_acl_login{quantile="0.99"} NaN +consul_acl_login_sum 0 +consul_acl_login_count 0 +# HELP consul_acl_logout +# TYPE consul_acl_logout summary +consul_acl_logout{quantile="0.5"} NaN +consul_acl_logout{quantile="0.9"} NaN +consul_acl_logout{quantile="0.99"} NaN +consul_acl_logout_sum 0 +consul_acl_logout_count 0 +# HELP consul_acl_policy_delete +# TYPE consul_acl_policy_delete summary +consul_acl_policy_delete{quantile="0.5"} NaN +consul_acl_policy_delete{quantile="0.9"} NaN +consul_acl_policy_delete{quantile="0.99"} NaN +consul_acl_policy_delete_sum 0 +consul_acl_policy_delete_count 0 +# HELP consul_acl_policy_upsert +# TYPE consul_acl_policy_upsert summary +consul_acl_policy_upsert{quantile="0.5"} NaN +consul_acl_policy_upsert{quantile="0.9"} NaN +consul_acl_policy_upsert{quantile="0.99"} NaN +consul_acl_policy_upsert_sum 0 +consul_acl_policy_upsert_count 0 +# HELP consul_acl_role_delete +# TYPE consul_acl_role_delete summary +consul_acl_role_delete{quantile="0.5"} NaN +consul_acl_role_delete{quantile="0.9"} NaN +consul_acl_role_delete{quantile="0.99"} NaN +consul_acl_role_delete_sum 0 +consul_acl_role_delete_count 0 +# HELP consul_acl_role_upsert +# TYPE consul_acl_role_upsert summary +consul_acl_role_upsert{quantile="0.5"} NaN +consul_acl_role_upsert{quantile="0.9"} NaN +consul_acl_role_upsert{quantile="0.99"} NaN +consul_acl_role_upsert_sum 0 +consul_acl_role_upsert_count 0 +# HELP consul_acl_token_cache_hit Increments if Consul is able to resolve a token's identity, or a legacy token, from the cache. +# TYPE consul_acl_token_cache_hit counter +consul_acl_token_cache_hit 0 +# HELP consul_acl_token_cache_miss Increments if Consul cannot resolve a token's identity, or a legacy token, from the cache. +# TYPE consul_acl_token_cache_miss counter +consul_acl_token_cache_miss 0 +# HELP consul_acl_token_clone +# TYPE consul_acl_token_clone summary +consul_acl_token_clone{quantile="0.5"} NaN +consul_acl_token_clone{quantile="0.9"} NaN +consul_acl_token_clone{quantile="0.99"} NaN +consul_acl_token_clone_sum 0 +consul_acl_token_clone_count 0 +# HELP consul_acl_token_delete +# TYPE consul_acl_token_delete summary +consul_acl_token_delete{quantile="0.5"} NaN +consul_acl_token_delete{quantile="0.9"} NaN +consul_acl_token_delete{quantile="0.99"} NaN +consul_acl_token_delete_sum 0 +consul_acl_token_delete_count 0 +# HELP consul_acl_token_upsert +# TYPE consul_acl_token_upsert summary +consul_acl_token_upsert{quantile="0.5"} NaN +consul_acl_token_upsert{quantile="0.9"} NaN +consul_acl_token_upsert{quantile="0.99"} NaN +consul_acl_token_upsert_sum 0 +consul_acl_token_upsert_count 0 +# HELP consul_agent_tls_cert_expiry Seconds until the agent tls certificate expires. Updated every hour +# TYPE consul_agent_tls_cert_expiry gauge +consul_agent_tls_cert_expiry 0 +# HELP consul_api_http Samples how long it takes to service the given HTTP request for the given verb and path. +# TYPE consul_api_http summary +consul_api_http{quantile="0.5"} NaN +consul_api_http{quantile="0.9"} NaN +consul_api_http{quantile="0.99"} NaN +consul_api_http_sum 0 +consul_api_http_count 0 +consul_api_http{method="GET",path="v1_agent_checks",quantile="0.5"} 0.12827900052070618 +consul_api_http{method="GET",path="v1_agent_checks",quantile="0.9"} 0.16961899399757385 +consul_api_http{method="GET",path="v1_agent_checks",quantile="0.99"} 0.16961899399757385 +consul_api_http_sum{method="GET",path="v1_agent_checks"} 72.76162604242563 +consul_api_http_count{method="GET",path="v1_agent_checks"} 430 +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.5"} 0.21463799476623535 +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.9"} 0.35256800055503845 +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.99"} 0.35256800055503845 +consul_api_http_sum{method="GET",path="v1_agent_metrics"} 148.1220167428255 +consul_api_http_count{method="GET",path="v1_agent_metrics"} 438 +# HELP consul_catalog_connect_not_found Increments for each connect-based catalog query where the given service could not be found. +# TYPE consul_catalog_connect_not_found counter +consul_catalog_connect_not_found 0 +# HELP consul_catalog_connect_query Increments for each connect-based catalog query for the given service. +# TYPE consul_catalog_connect_query counter +consul_catalog_connect_query 0 +# HELP consul_catalog_connect_query_tag Increments for each connect-based catalog query for the given service with the given tag. +# TYPE consul_catalog_connect_query_tag counter +consul_catalog_connect_query_tag 0 +# HELP consul_catalog_connect_query_tags Increments for each connect-based catalog query for the given service with the given tags. +# TYPE consul_catalog_connect_query_tags counter +consul_catalog_connect_query_tags 0 +# HELP consul_catalog_deregister Measures the time it takes to complete a catalog deregister operation. +# TYPE consul_catalog_deregister summary +consul_catalog_deregister{quantile="0.5"} NaN +consul_catalog_deregister{quantile="0.9"} NaN +consul_catalog_deregister{quantile="0.99"} NaN +consul_catalog_deregister_sum 0 +consul_catalog_deregister_count 0 +# HELP consul_catalog_register Measures the time it takes to complete a catalog register operation. +# TYPE consul_catalog_register summary +consul_catalog_register{quantile="0.5"} NaN +consul_catalog_register{quantile="0.9"} NaN +consul_catalog_register{quantile="0.99"} NaN +consul_catalog_register_sum 0 +consul_catalog_register_count 0 +# HELP consul_catalog_service_not_found Increments for each catalog query where the given service could not be found. +# TYPE consul_catalog_service_not_found counter +consul_catalog_service_not_found 0 +# HELP consul_catalog_service_query Increments for each catalog query for the given service. +# TYPE consul_catalog_service_query counter +consul_catalog_service_query 0 +# HELP consul_catalog_service_query_tag Increments for each catalog query for the given service with the given tag. +# TYPE consul_catalog_service_query_tag counter +consul_catalog_service_query_tag 0 +# HELP consul_catalog_service_query_tags Increments for each catalog query for the given service with the given tags. +# TYPE consul_catalog_service_query_tags counter +consul_catalog_service_query_tags 0 +# HELP consul_client_api_catalog_datacenters Increments whenever a Consul agent receives a request to list datacenters in the catalog. +# TYPE consul_client_api_catalog_datacenters counter +consul_client_api_catalog_datacenters 0 +# HELP consul_client_api_catalog_deregister Increments whenever a Consul agent receives a catalog deregister request. +# TYPE consul_client_api_catalog_deregister counter +consul_client_api_catalog_deregister 0 +# HELP consul_client_api_catalog_gateway_services Increments whenever a Consul agent receives a request to list services associated with a gateway. +# TYPE consul_client_api_catalog_gateway_services counter +consul_client_api_catalog_gateway_services 0 +# HELP consul_client_api_catalog_node_service_list Increments whenever a Consul agent receives a request to list a node's registered services. +# TYPE consul_client_api_catalog_node_service_list counter +consul_client_api_catalog_node_service_list 0 +# HELP consul_client_api_catalog_node_services Increments whenever a Consul agent successfully responds to a request to list nodes offering a service. +# TYPE consul_client_api_catalog_node_services counter +consul_client_api_catalog_node_services 0 +# HELP consul_client_api_catalog_nodes Increments whenever a Consul agent receives a request to list nodes from the catalog. +# TYPE consul_client_api_catalog_nodes counter +consul_client_api_catalog_nodes 0 +# HELP consul_client_api_catalog_register Increments whenever a Consul agent receives a catalog register request. +# TYPE consul_client_api_catalog_register counter +consul_client_api_catalog_register 0 +# HELP consul_client_api_catalog_service_nodes Increments whenever a Consul agent receives a request to list nodes offering a service. +# TYPE consul_client_api_catalog_service_nodes counter +consul_client_api_catalog_service_nodes 0 +# HELP consul_client_api_catalog_services Increments whenever a Consul agent receives a request to list services from the catalog. +# TYPE consul_client_api_catalog_services counter +consul_client_api_catalog_services 0 +# HELP consul_client_api_error_catalog_service_nodes Increments whenever a Consul agent receives an RPC error for request to list nodes offering a service. +# TYPE consul_client_api_error_catalog_service_nodes counter +consul_client_api_error_catalog_service_nodes 0 +# HELP consul_client_api_success_catalog_datacenters Increments whenever a Consul agent successfully responds to a request to list datacenters. +# TYPE consul_client_api_success_catalog_datacenters counter +consul_client_api_success_catalog_datacenters 0 +# HELP consul_client_api_success_catalog_deregister Increments whenever a Consul agent successfully responds to a catalog deregister request. +# TYPE consul_client_api_success_catalog_deregister counter +consul_client_api_success_catalog_deregister 0 +# HELP consul_client_api_success_catalog_gateway_services Increments whenever a Consul agent successfully responds to a request to list services associated with a gateway. +# TYPE consul_client_api_success_catalog_gateway_services counter +consul_client_api_success_catalog_gateway_services 0 +# HELP consul_client_api_success_catalog_node_service_list Increments whenever a Consul agent successfully responds to a request to list a node's registered services. +# TYPE consul_client_api_success_catalog_node_service_list counter +consul_client_api_success_catalog_node_service_list 0 +# HELP consul_client_api_success_catalog_node_services Increments whenever a Consul agent successfully responds to a request to list services in a node. +# TYPE consul_client_api_success_catalog_node_services counter +consul_client_api_success_catalog_node_services 0 +# HELP consul_client_api_success_catalog_nodes Increments whenever a Consul agent successfully responds to a request to list nodes. +# TYPE consul_client_api_success_catalog_nodes counter +consul_client_api_success_catalog_nodes 0 +# HELP consul_client_api_success_catalog_register Increments whenever a Consul agent successfully responds to a catalog register request. +# TYPE consul_client_api_success_catalog_register counter +consul_client_api_success_catalog_register 0 +# HELP consul_client_api_success_catalog_service_nodes Increments whenever a Consul agent successfully responds to a request to list nodes offering a service. +# TYPE consul_client_api_success_catalog_service_nodes counter +consul_client_api_success_catalog_service_nodes 0 +# HELP consul_client_api_success_catalog_services Increments whenever a Consul agent successfully responds to a request to list services. +# TYPE consul_client_api_success_catalog_services counter +consul_client_api_success_catalog_services 0 +# HELP consul_client_rpc Increments whenever a Consul agent in client mode makes an RPC request to a Consul server. +# TYPE consul_client_rpc counter +consul_client_rpc 34 +# HELP consul_client_rpc_error_catalog_datacenters Increments whenever a Consul agent receives an RPC error for a request to list datacenters. +# TYPE consul_client_rpc_error_catalog_datacenters counter +consul_client_rpc_error_catalog_datacenters 0 +# HELP consul_client_rpc_error_catalog_deregister Increments whenever a Consul agent receives an RPC error for a catalog deregister request. +# TYPE consul_client_rpc_error_catalog_deregister counter +consul_client_rpc_error_catalog_deregister 0 +# HELP consul_client_rpc_error_catalog_gateway_services Increments whenever a Consul agent receives an RPC error for a request to list services associated with a gateway. +# TYPE consul_client_rpc_error_catalog_gateway_services counter +consul_client_rpc_error_catalog_gateway_services 0 +# HELP consul_client_rpc_error_catalog_node_service_list Increments whenever a Consul agent receives an RPC error for request to list a node's registered services. +# TYPE consul_client_rpc_error_catalog_node_service_list counter +consul_client_rpc_error_catalog_node_service_list 0 +# HELP consul_client_rpc_error_catalog_node_services Increments whenever a Consul agent receives an RPC error for a request to list services in a node. +# TYPE consul_client_rpc_error_catalog_node_services counter +consul_client_rpc_error_catalog_node_services 0 +# HELP consul_client_rpc_error_catalog_nodes Increments whenever a Consul agent receives an RPC error for a request to list nodes. +# TYPE consul_client_rpc_error_catalog_nodes counter +consul_client_rpc_error_catalog_nodes 0 +# HELP consul_client_rpc_error_catalog_register Increments whenever a Consul agent receives an RPC error for a catalog register request. +# TYPE consul_client_rpc_error_catalog_register counter +consul_client_rpc_error_catalog_register 0 +# HELP consul_client_rpc_error_catalog_service_nodes Increments whenever a Consul agent receives an RPC error for a request to list nodes offering a service. +# TYPE consul_client_rpc_error_catalog_service_nodes counter +consul_client_rpc_error_catalog_service_nodes 0 +# HELP consul_client_rpc_error_catalog_services Increments whenever a Consul agent receives an RPC error for a request to list services. +# TYPE consul_client_rpc_error_catalog_services counter +consul_client_rpc_error_catalog_services 0 +# HELP consul_client_rpc_exceeded Increments whenever a Consul agent in client mode makes an RPC request to a Consul server gets rate limited by that agent's limits configuration. +# TYPE consul_client_rpc_exceeded counter +consul_client_rpc_exceeded 0 +# HELP consul_client_rpc_failed Increments whenever a Consul agent in client mode makes an RPC request to a Consul server and fails. +# TYPE consul_client_rpc_failed counter +consul_client_rpc_failed 0 +# HELP consul_consul_cache_bypass Counts how many times a request bypassed the cache because no cache-key was provided. +# TYPE consul_consul_cache_bypass counter +consul_consul_cache_bypass 0 +# HELP consul_consul_cache_entries_count Represents the number of entries in this cache. +# TYPE consul_consul_cache_entries_count gauge +consul_consul_cache_entries_count 0 +# HELP consul_consul_cache_evict_expired Counts the number of expired entries that are evicted. +# TYPE consul_consul_cache_evict_expired counter +consul_consul_cache_evict_expired 0 +# HELP consul_consul_cache_fetch_error Counts the number of failed fetches by the cache. +# TYPE consul_consul_cache_fetch_error counter +consul_consul_cache_fetch_error 0 +# HELP consul_consul_cache_fetch_success Counts the number of successful fetches by the cache. +# TYPE consul_consul_cache_fetch_success counter +consul_consul_cache_fetch_success 0 +# HELP consul_consul_fsm_ca Deprecated - use fsm_ca instead +# TYPE consul_consul_fsm_ca summary +consul_consul_fsm_ca{quantile="0.5"} NaN +consul_consul_fsm_ca{quantile="0.9"} NaN +consul_consul_fsm_ca{quantile="0.99"} NaN +consul_consul_fsm_ca_sum 0 +consul_consul_fsm_ca_count 0 +# HELP consul_consul_fsm_intention Deprecated - use fsm_intention instead +# TYPE consul_consul_fsm_intention summary +consul_consul_fsm_intention{quantile="0.5"} NaN +consul_consul_fsm_intention{quantile="0.9"} NaN +consul_consul_fsm_intention{quantile="0.99"} NaN +consul_consul_fsm_intention_sum 0 +consul_consul_fsm_intention_count 0 +# HELP consul_consul_intention_apply +# TYPE consul_consul_intention_apply summary +consul_consul_intention_apply{quantile="0.5"} NaN +consul_consul_intention_apply{quantile="0.9"} NaN +consul_consul_intention_apply{quantile="0.99"} NaN +consul_consul_intention_apply_sum 0 +consul_consul_intention_apply_count 0 +# HELP consul_consul_members_clients Measures the current number of client agents registered with Consul. It is only emitted by Consul servers. Added in v1.9.6. +# TYPE consul_consul_members_clients gauge +consul_consul_members_clients 0 +# HELP consul_consul_members_servers Measures the current number of server agents registered with Consul. It is only emitted by Consul servers. Added in v1.9.6. +# TYPE consul_consul_members_servers gauge +consul_consul_members_servers 0 +# HELP consul_consul_state_config_entries Measures the current number of unique configuration entries registered with Consul, labeled by Kind. It is only emitted by Consul servers. Added in v1.10.4. +# TYPE consul_consul_state_config_entries gauge +consul_consul_state_config_entries 0 +# HELP consul_consul_state_connect_instances Measures the current number of unique connect service instances registered with Consul, labeled by Kind. It is only emitted by Consul servers. Added in v1.10.4. +# TYPE consul_consul_state_connect_instances gauge +consul_consul_state_connect_instances 0 +# HELP consul_consul_state_kv_entries Measures the current number of entries in the Consul KV store. It is only emitted by Consul servers. Added in v1.10.3. +# TYPE consul_consul_state_kv_entries gauge +consul_consul_state_kv_entries 0 +# HELP consul_consul_state_nodes Measures the current number of nodes registered with Consul. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_consul_state_nodes gauge +consul_consul_state_nodes 0 +# HELP consul_consul_state_peerings Measures the current number of peerings registered with Consul. It is only emitted by Consul servers. Added in v1.13.0. +# TYPE consul_consul_state_peerings gauge +consul_consul_state_peerings 0 +# HELP consul_consul_state_service_instances Measures the current number of unique services registered with Consul, based on service name. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_consul_state_service_instances gauge +consul_consul_state_service_instances 0 +# HELP consul_consul_state_services Measures the current number of unique services registered with Consul, based on service name. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_consul_state_services gauge +consul_consul_state_services 0 +# HELP consul_federation_state_apply +# TYPE consul_federation_state_apply summary +consul_federation_state_apply{quantile="0.5"} NaN +consul_federation_state_apply{quantile="0.9"} NaN +consul_federation_state_apply{quantile="0.99"} NaN +consul_federation_state_apply_sum 0 +consul_federation_state_apply_count 0 +# HELP consul_federation_state_get +# TYPE consul_federation_state_get summary +consul_federation_state_get{quantile="0.5"} NaN +consul_federation_state_get{quantile="0.9"} NaN +consul_federation_state_get{quantile="0.99"} NaN +consul_federation_state_get_sum 0 +consul_federation_state_get_count 0 +# HELP consul_federation_state_list +# TYPE consul_federation_state_list summary +consul_federation_state_list{quantile="0.5"} NaN +consul_federation_state_list{quantile="0.9"} NaN +consul_federation_state_list{quantile="0.99"} NaN +consul_federation_state_list_sum 0 +consul_federation_state_list_count 0 +# HELP consul_federation_state_list_mesh_gateways +# TYPE consul_federation_state_list_mesh_gateways summary +consul_federation_state_list_mesh_gateways{quantile="0.5"} NaN +consul_federation_state_list_mesh_gateways{quantile="0.9"} NaN +consul_federation_state_list_mesh_gateways{quantile="0.99"} NaN +consul_federation_state_list_mesh_gateways_sum 0 +consul_federation_state_list_mesh_gateways_count 0 +# HELP consul_fsm_acl Measures the time it takes to apply the given ACL operation to the FSM. +# TYPE consul_fsm_acl summary +consul_fsm_acl{quantile="0.5"} NaN +consul_fsm_acl{quantile="0.9"} NaN +consul_fsm_acl{quantile="0.99"} NaN +consul_fsm_acl_sum 0 +consul_fsm_acl_count 0 +# HELP consul_fsm_acl_authmethod Measures the time it takes to apply an ACL authmethod operation to the FSM. +# TYPE consul_fsm_acl_authmethod summary +consul_fsm_acl_authmethod{quantile="0.5"} NaN +consul_fsm_acl_authmethod{quantile="0.9"} NaN +consul_fsm_acl_authmethod{quantile="0.99"} NaN +consul_fsm_acl_authmethod_sum 0 +consul_fsm_acl_authmethod_count 0 +# HELP consul_fsm_acl_bindingrule Measures the time it takes to apply an ACL binding rule operation to the FSM. +# TYPE consul_fsm_acl_bindingrule summary +consul_fsm_acl_bindingrule{quantile="0.5"} NaN +consul_fsm_acl_bindingrule{quantile="0.9"} NaN +consul_fsm_acl_bindingrule{quantile="0.99"} NaN +consul_fsm_acl_bindingrule_sum 0 +consul_fsm_acl_bindingrule_count 0 +# HELP consul_fsm_acl_policy Measures the time it takes to apply an ACL policy operation to the FSM. +# TYPE consul_fsm_acl_policy summary +consul_fsm_acl_policy{quantile="0.5"} NaN +consul_fsm_acl_policy{quantile="0.9"} NaN +consul_fsm_acl_policy{quantile="0.99"} NaN +consul_fsm_acl_policy_sum 0 +consul_fsm_acl_policy_count 0 +# HELP consul_fsm_acl_token Measures the time it takes to apply an ACL token operation to the FSM. +# TYPE consul_fsm_acl_token summary +consul_fsm_acl_token{quantile="0.5"} NaN +consul_fsm_acl_token{quantile="0.9"} NaN +consul_fsm_acl_token{quantile="0.99"} NaN +consul_fsm_acl_token_sum 0 +consul_fsm_acl_token_count 0 +# HELP consul_fsm_autopilot Measures the time it takes to apply the given autopilot update to the FSM. +# TYPE consul_fsm_autopilot summary +consul_fsm_autopilot{quantile="0.5"} NaN +consul_fsm_autopilot{quantile="0.9"} NaN +consul_fsm_autopilot{quantile="0.99"} NaN +consul_fsm_autopilot_sum 0 +consul_fsm_autopilot_count 0 +# HELP consul_fsm_ca Measures the time it takes to apply CA configuration operations to the FSM. +# TYPE consul_fsm_ca summary +consul_fsm_ca{quantile="0.5"} NaN +consul_fsm_ca{quantile="0.9"} NaN +consul_fsm_ca{quantile="0.99"} NaN +consul_fsm_ca_sum 0 +consul_fsm_ca_count 0 +# HELP consul_fsm_ca_leaf Measures the time it takes to apply an operation while signing a leaf certificate. +# TYPE consul_fsm_ca_leaf summary +consul_fsm_ca_leaf{quantile="0.5"} NaN +consul_fsm_ca_leaf{quantile="0.9"} NaN +consul_fsm_ca_leaf{quantile="0.99"} NaN +consul_fsm_ca_leaf_sum 0 +consul_fsm_ca_leaf_count 0 +# HELP consul_fsm_coordinate_batch_update Measures the time it takes to apply the given batch coordinate update to the FSM. +# TYPE consul_fsm_coordinate_batch_update summary +consul_fsm_coordinate_batch_update{quantile="0.5"} NaN +consul_fsm_coordinate_batch_update{quantile="0.9"} NaN +consul_fsm_coordinate_batch_update{quantile="0.99"} NaN +consul_fsm_coordinate_batch_update_sum 0 +consul_fsm_coordinate_batch_update_count 0 +# HELP consul_fsm_deregister Measures the time it takes to apply a catalog deregister operation to the FSM. +# TYPE consul_fsm_deregister summary +consul_fsm_deregister{quantile="0.5"} NaN +consul_fsm_deregister{quantile="0.9"} NaN +consul_fsm_deregister{quantile="0.99"} NaN +consul_fsm_deregister_sum 0 +consul_fsm_deregister_count 0 +# HELP consul_fsm_intention Measures the time it takes to apply an intention operation to the FSM. +# TYPE consul_fsm_intention summary +consul_fsm_intention{quantile="0.5"} NaN +consul_fsm_intention{quantile="0.9"} NaN +consul_fsm_intention{quantile="0.99"} NaN +consul_fsm_intention_sum 0 +consul_fsm_intention_count 0 +# HELP consul_fsm_kvs Measures the time it takes to apply the given KV operation to the FSM. +# TYPE consul_fsm_kvs summary +consul_fsm_kvs{quantile="0.5"} NaN +consul_fsm_kvs{quantile="0.9"} NaN +consul_fsm_kvs{quantile="0.99"} NaN +consul_fsm_kvs_sum 0 +consul_fsm_kvs_count 0 +# HELP consul_fsm_peering Measures the time it takes to apply a peering operation to the FSM. +# TYPE consul_fsm_peering summary +consul_fsm_peering{quantile="0.5"} NaN +consul_fsm_peering{quantile="0.9"} NaN +consul_fsm_peering{quantile="0.99"} NaN +consul_fsm_peering_sum 0 +consul_fsm_peering_count 0 +# HELP consul_fsm_persist Measures the time it takes to persist the FSM to a raft snapshot. +# TYPE consul_fsm_persist summary +consul_fsm_persist{quantile="0.5"} NaN +consul_fsm_persist{quantile="0.9"} NaN +consul_fsm_persist{quantile="0.99"} NaN +consul_fsm_persist_sum 0 +consul_fsm_persist_count 0 +# HELP consul_fsm_prepared_query Measures the time it takes to apply the given prepared query update operation to the FSM. +# TYPE consul_fsm_prepared_query summary +consul_fsm_prepared_query{quantile="0.5"} NaN +consul_fsm_prepared_query{quantile="0.9"} NaN +consul_fsm_prepared_query{quantile="0.99"} NaN +consul_fsm_prepared_query_sum 0 +consul_fsm_prepared_query_count 0 +# HELP consul_fsm_register Measures the time it takes to apply a catalog register operation to the FSM. +# TYPE consul_fsm_register summary +consul_fsm_register{quantile="0.5"} NaN +consul_fsm_register{quantile="0.9"} NaN +consul_fsm_register{quantile="0.99"} NaN +consul_fsm_register_sum 0 +consul_fsm_register_count 0 +# HELP consul_fsm_session Measures the time it takes to apply the given session operation to the FSM. +# TYPE consul_fsm_session summary +consul_fsm_session{quantile="0.5"} NaN +consul_fsm_session{quantile="0.9"} NaN +consul_fsm_session{quantile="0.99"} NaN +consul_fsm_session_sum 0 +consul_fsm_session_count 0 +# HELP consul_fsm_system_metadata Measures the time it takes to apply a system metadata operation to the FSM. +# TYPE consul_fsm_system_metadata summary +consul_fsm_system_metadata{quantile="0.5"} NaN +consul_fsm_system_metadata{quantile="0.9"} NaN +consul_fsm_system_metadata{quantile="0.99"} NaN +consul_fsm_system_metadata_sum 0 +consul_fsm_system_metadata_count 0 +# HELP consul_fsm_tombstone Measures the time it takes to apply the given tombstone operation to the FSM. +# TYPE consul_fsm_tombstone summary +consul_fsm_tombstone{quantile="0.5"} NaN +consul_fsm_tombstone{quantile="0.9"} NaN +consul_fsm_tombstone{quantile="0.99"} NaN +consul_fsm_tombstone_sum 0 +consul_fsm_tombstone_count 0 +# HELP consul_fsm_txn Measures the time it takes to apply the given transaction update to the FSM. +# TYPE consul_fsm_txn summary +consul_fsm_txn{quantile="0.5"} NaN +consul_fsm_txn{quantile="0.9"} NaN +consul_fsm_txn{quantile="0.99"} NaN +consul_fsm_txn_sum 0 +consul_fsm_txn_count 0 +# HELP consul_grpc_client_connection_count Counts the number of new gRPC connections opened by the client agent to a Consul server. +# TYPE consul_grpc_client_connection_count counter +consul_grpc_client_connection_count 2 +# HELP consul_grpc_client_connections Measures the number of active gRPC connections open from the client agent to any Consul servers. +# TYPE consul_grpc_client_connections gauge +consul_grpc_client_connections 1 +# HELP consul_grpc_client_request_count Counts the number of gRPC requests made by the client agent to a Consul server. +# TYPE consul_grpc_client_request_count counter +consul_grpc_client_request_count 0 +# HELP consul_grpc_server_connection_count Counts the number of new gRPC connections received by the server. +# TYPE consul_grpc_server_connection_count counter +consul_grpc_server_connection_count 0 +# HELP consul_grpc_server_connections Measures the number of active gRPC connections open on the server. +# TYPE consul_grpc_server_connections gauge +consul_grpc_server_connections 0 +# HELP consul_grpc_server_request_count Counts the number of gRPC requests received by the server. +# TYPE consul_grpc_server_request_count counter +consul_grpc_server_request_count 0 +# HELP consul_grpc_server_stream_count Counts the number of new gRPC streams received by the server. +# TYPE consul_grpc_server_stream_count counter +consul_grpc_server_stream_count 0 +# HELP consul_grpc_server_streams Measures the number of active gRPC streams handled by the server. +# TYPE consul_grpc_server_streams gauge +consul_grpc_server_streams 0 +# HELP consul_intention_apply +# TYPE consul_intention_apply summary +consul_intention_apply{quantile="0.5"} NaN +consul_intention_apply{quantile="0.9"} NaN +consul_intention_apply{quantile="0.99"} NaN +consul_intention_apply_sum 0 +consul_intention_apply_count 0 +# HELP consul_kvs_apply Measures the time it takes to complete an update to the KV store. +# TYPE consul_kvs_apply summary +consul_kvs_apply{quantile="0.5"} NaN +consul_kvs_apply{quantile="0.9"} NaN +consul_kvs_apply{quantile="0.99"} NaN +consul_kvs_apply_sum 0 +consul_kvs_apply_count 0 +# HELP consul_leader_barrier Measures the time spent waiting for the raft barrier upon gaining leadership. +# TYPE consul_leader_barrier summary +consul_leader_barrier{quantile="0.5"} NaN +consul_leader_barrier{quantile="0.9"} NaN +consul_leader_barrier{quantile="0.99"} NaN +consul_leader_barrier_sum 0 +consul_leader_barrier_count 0 +# HELP consul_leader_reapTombstones Measures the time spent clearing tombstones. +# TYPE consul_leader_reapTombstones summary +consul_leader_reapTombstones{quantile="0.5"} NaN +consul_leader_reapTombstones{quantile="0.9"} NaN +consul_leader_reapTombstones{quantile="0.99"} NaN +consul_leader_reapTombstones_sum 0 +consul_leader_reapTombstones_count 0 +# HELP consul_leader_reconcile Measures the time spent updating the raft store from the serf member information. +# TYPE consul_leader_reconcile summary +consul_leader_reconcile{quantile="0.5"} NaN +consul_leader_reconcile{quantile="0.9"} NaN +consul_leader_reconcile{quantile="0.99"} NaN +consul_leader_reconcile_sum 0 +consul_leader_reconcile_count 0 +# HELP consul_leader_reconcileMember Measures the time spent updating the raft store for a single serf member's information. +# TYPE consul_leader_reconcileMember summary +consul_leader_reconcileMember{quantile="0.5"} NaN +consul_leader_reconcileMember{quantile="0.9"} NaN +consul_leader_reconcileMember{quantile="0.99"} NaN +consul_leader_reconcileMember_sum 0 +consul_leader_reconcileMember_count 0 +# HELP consul_leader_replication_acl_policies_index Tracks the index of ACL policies in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_policies_index gauge +consul_leader_replication_acl_policies_index 0 +# HELP consul_leader_replication_acl_policies_status Tracks the current health of ACL policy replication on the leader +# TYPE consul_leader_replication_acl_policies_status gauge +consul_leader_replication_acl_policies_status 0 +# HELP consul_leader_replication_acl_roles_index Tracks the index of ACL roles in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_roles_index gauge +consul_leader_replication_acl_roles_index 0 +# HELP consul_leader_replication_acl_roles_status Tracks the current health of ACL role replication on the leader +# TYPE consul_leader_replication_acl_roles_status gauge +consul_leader_replication_acl_roles_status 0 +# HELP consul_leader_replication_acl_tokens_index Tracks the index of ACL tokens in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_tokens_index gauge +consul_leader_replication_acl_tokens_index 0 +# HELP consul_leader_replication_acl_tokens_status Tracks the current health of ACL token replication on the leader +# TYPE consul_leader_replication_acl_tokens_status gauge +consul_leader_replication_acl_tokens_status 0 +# HELP consul_leader_replication_config_entries_index Tracks the index of config entries in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_config_entries_index gauge +consul_leader_replication_config_entries_index 0 +# HELP consul_leader_replication_config_entries_status Tracks the current health of config entry replication on the leader +# TYPE consul_leader_replication_config_entries_status gauge +consul_leader_replication_config_entries_status 0 +# HELP consul_leader_replication_federation_state_index Tracks the index of federation states in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_federation_state_index gauge +consul_leader_replication_federation_state_index 0 +# HELP consul_leader_replication_federation_state_status Tracks the current health of federation state replication on the leader +# TYPE consul_leader_replication_federation_state_status gauge +consul_leader_replication_federation_state_status 0 +# HELP consul_leader_replication_namespaces_index Tracks the index of federation states in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_namespaces_index gauge +consul_leader_replication_namespaces_index 0 +# HELP consul_leader_replication_namespaces_status Tracks the current health of federation state replication on the leader +# TYPE consul_leader_replication_namespaces_status gauge +consul_leader_replication_namespaces_status 0 +# HELP consul_memberlist_gossip consul_memberlist_gossip +# TYPE consul_memberlist_gossip summary +consul_memberlist_gossip{network="lan",quantile="0.5"} 0.02992900088429451 +consul_memberlist_gossip{network="lan",quantile="0.9"} 0.05322999879717827 +consul_memberlist_gossip{network="lan",quantile="0.99"} 0.09028899669647217 +consul_memberlist_gossip_sum{network="lan"} 72.09632398188114 +consul_memberlist_gossip_count{network="lan"} 2159 +# HELP consul_memberlist_msg_alive consul_memberlist_msg_alive +# TYPE consul_memberlist_msg_alive counter +consul_memberlist_msg_alive{network="lan"} 3 +# HELP consul_memberlist_probeNode consul_memberlist_probeNode +# TYPE consul_memberlist_probeNode summary +consul_memberlist_probeNode{network="lan",quantile="0.5"} 1.2391510009765625 +consul_memberlist_probeNode{network="lan",quantile="0.9"} 1.470810055732727 +consul_memberlist_probeNode{network="lan",quantile="0.99"} 1.470810055732727 +consul_memberlist_probeNode_sum{network="lan"} 550.6824030280113 +consul_memberlist_probeNode_count{network="lan"} 410 +# HELP consul_memberlist_pushPullNode consul_memberlist_pushPullNode +# TYPE consul_memberlist_pushPullNode summary +consul_memberlist_pushPullNode{network="lan",quantile="0.5"} 1.6478170156478882 +consul_memberlist_pushPullNode{network="lan",quantile="0.9"} 1.6478170156478882 +consul_memberlist_pushPullNode{network="lan",quantile="0.99"} 1.6478170156478882 +consul_memberlist_pushPullNode_sum{network="lan"} 28.438491106033325 +consul_memberlist_pushPullNode_count{network="lan"} 17 +# HELP consul_memberlist_tcp_accept consul_memberlist_tcp_accept +# TYPE consul_memberlist_tcp_accept counter +consul_memberlist_tcp_accept{network="lan"} 15 +# HELP consul_memberlist_tcp_connect consul_memberlist_tcp_connect +# TYPE consul_memberlist_tcp_connect counter +consul_memberlist_tcp_connect{network="lan"} 18 +# HELP consul_memberlist_tcp_sent consul_memberlist_tcp_sent +# TYPE consul_memberlist_tcp_sent counter +consul_memberlist_tcp_sent{network="lan"} 24679 +# HELP consul_memberlist_udp_received consul_memberlist_udp_received +# TYPE consul_memberlist_udp_received counter +consul_memberlist_udp_received{network="lan"} 117437 +# HELP consul_memberlist_udp_sent consul_memberlist_udp_sent +# TYPE consul_memberlist_udp_sent counter +consul_memberlist_udp_sent{network="lan"} 118601 +# HELP consul_prepared_query_apply Measures the time it takes to apply a prepared query update. +# TYPE consul_prepared_query_apply summary +consul_prepared_query_apply{quantile="0.5"} NaN +consul_prepared_query_apply{quantile="0.9"} NaN +consul_prepared_query_apply{quantile="0.99"} NaN +consul_prepared_query_apply_sum 0 +consul_prepared_query_apply_count 0 +# HELP consul_prepared_query_execute Measures the time it takes to process a prepared query execute request. +# TYPE consul_prepared_query_execute summary +consul_prepared_query_execute{quantile="0.5"} NaN +consul_prepared_query_execute{quantile="0.9"} NaN +consul_prepared_query_execute{quantile="0.99"} NaN +consul_prepared_query_execute_sum 0 +consul_prepared_query_execute_count 0 +# HELP consul_prepared_query_execute_remote Measures the time it takes to process a prepared query execute request that was forwarded to another datacenter. +# TYPE consul_prepared_query_execute_remote summary +consul_prepared_query_execute_remote{quantile="0.5"} NaN +consul_prepared_query_execute_remote{quantile="0.9"} NaN +consul_prepared_query_execute_remote{quantile="0.99"} NaN +consul_prepared_query_execute_remote_sum 0 +consul_prepared_query_execute_remote_count 0 +# HELP consul_prepared_query_explain Measures the time it takes to process a prepared query explain request. +# TYPE consul_prepared_query_explain summary +consul_prepared_query_explain{quantile="0.5"} NaN +consul_prepared_query_explain{quantile="0.9"} NaN +consul_prepared_query_explain{quantile="0.99"} NaN +consul_prepared_query_explain_sum 0 +consul_prepared_query_explain_count 0 +# HELP consul_raft_applied_index Represents the raft applied index. +# TYPE consul_raft_applied_index gauge +consul_raft_applied_index 0 +# HELP consul_raft_apply This counts the number of Raft transactions occurring over the interval. +# TYPE consul_raft_apply counter +consul_raft_apply 0 +# HELP consul_raft_commitTime This measures the time it takes to commit a new entry to the Raft log on the leader. +# TYPE consul_raft_commitTime summary +consul_raft_commitTime{quantile="0.5"} NaN +consul_raft_commitTime{quantile="0.9"} NaN +consul_raft_commitTime{quantile="0.99"} NaN +consul_raft_commitTime_sum 0 +consul_raft_commitTime_count 0 +# HELP consul_raft_fsm_lastRestoreDuration This measures how long the last FSM restore (from disk or leader) took. +# TYPE consul_raft_fsm_lastRestoreDuration gauge +consul_raft_fsm_lastRestoreDuration 0 +# HELP consul_raft_last_index Represents the raft last index. +# TYPE consul_raft_last_index gauge +consul_raft_last_index 0 +# HELP consul_raft_leader_lastContact Measures the time since the leader was last able to contact the follower nodes when checking its leader lease. +# TYPE consul_raft_leader_lastContact summary +consul_raft_leader_lastContact{quantile="0.5"} NaN +consul_raft_leader_lastContact{quantile="0.9"} NaN +consul_raft_leader_lastContact{quantile="0.99"} NaN +consul_raft_leader_lastContact_sum 0 +consul_raft_leader_lastContact_count 0 +# HELP consul_raft_leader_oldestLogAge This measures how old the oldest log in the leader's log store is. +# TYPE consul_raft_leader_oldestLogAge gauge +consul_raft_leader_oldestLogAge 0 +# HELP consul_raft_rpc_installSnapshot Measures the time it takes the raft leader to install a snapshot on a follower that is catching up after being down or has just joined the cluster. +# TYPE consul_raft_rpc_installSnapshot summary +consul_raft_rpc_installSnapshot{quantile="0.5"} NaN +consul_raft_rpc_installSnapshot{quantile="0.9"} NaN +consul_raft_rpc_installSnapshot{quantile="0.99"} NaN +consul_raft_rpc_installSnapshot_sum 0 +consul_raft_rpc_installSnapshot_count 0 +# HELP consul_raft_snapshot_persist Measures the time it takes raft to write a new snapshot to disk. +# TYPE consul_raft_snapshot_persist summary +consul_raft_snapshot_persist{quantile="0.5"} NaN +consul_raft_snapshot_persist{quantile="0.9"} NaN +consul_raft_snapshot_persist{quantile="0.99"} NaN +consul_raft_snapshot_persist_sum 0 +consul_raft_snapshot_persist_count 0 +# HELP consul_raft_state_candidate This increments whenever a Consul server starts an election. +# TYPE consul_raft_state_candidate counter +consul_raft_state_candidate 0 +# HELP consul_raft_state_leader This increments whenever a Consul server becomes a leader. +# TYPE consul_raft_state_leader counter +consul_raft_state_leader 0 +# HELP consul_rpc_accept_conn Increments when a server accepts an RPC connection. +# TYPE consul_rpc_accept_conn counter +consul_rpc_accept_conn 0 +# HELP consul_rpc_consistentRead Measures the time spent confirming that a consistent read can be performed. +# TYPE consul_rpc_consistentRead summary +consul_rpc_consistentRead{quantile="0.5"} NaN +consul_rpc_consistentRead{quantile="0.9"} NaN +consul_rpc_consistentRead{quantile="0.99"} NaN +consul_rpc_consistentRead_sum 0 +consul_rpc_consistentRead_count 0 +# HELP consul_rpc_cross_dc Increments when a server sends a (potentially blocking) cross datacenter RPC query. +# TYPE consul_rpc_cross_dc counter +consul_rpc_cross_dc 0 +# HELP consul_rpc_queries_blocking Shows the current number of in-flight blocking queries the server is handling. +# TYPE consul_rpc_queries_blocking gauge +consul_rpc_queries_blocking 0 +# HELP consul_rpc_query Increments when a server receives a read request, indicating the rate of new read queries. +# TYPE consul_rpc_query counter +consul_rpc_query 0 +# HELP consul_rpc_raft_handoff Increments when a server accepts a Raft-related RPC connection. +# TYPE consul_rpc_raft_handoff counter +consul_rpc_raft_handoff 0 +# HELP consul_rpc_request Increments when a server receives a Consul-related RPC request. +# TYPE consul_rpc_request counter +consul_rpc_request 0 +# HELP consul_rpc_request_error Increments when a server returns an error from an RPC request. +# TYPE consul_rpc_request_error counter +consul_rpc_request_error 0 +# HELP consul_runtime_alloc_bytes consul_runtime_alloc_bytes +# TYPE consul_runtime_alloc_bytes gauge +consul_runtime_alloc_bytes 2.6333408e+07 +# HELP consul_runtime_free_count consul_runtime_free_count +# TYPE consul_runtime_free_count gauge +consul_runtime_free_count 674987 +# HELP consul_runtime_gc_pause_ns consul_runtime_gc_pause_ns +# TYPE consul_runtime_gc_pause_ns summary +consul_runtime_gc_pause_ns{quantile="0.5"} NaN +consul_runtime_gc_pause_ns{quantile="0.9"} NaN +consul_runtime_gc_pause_ns{quantile="0.99"} NaN +consul_runtime_gc_pause_ns_sum 4.182423e+06 +consul_runtime_gc_pause_ns_count 17 +# HELP consul_runtime_heap_objects consul_runtime_heap_objects +# TYPE consul_runtime_heap_objects gauge +consul_runtime_heap_objects 63474 +# HELP consul_runtime_malloc_count consul_runtime_malloc_count +# TYPE consul_runtime_malloc_count gauge +consul_runtime_malloc_count 738461 +# HELP consul_runtime_num_goroutines consul_runtime_num_goroutines +# TYPE consul_runtime_num_goroutines gauge +consul_runtime_num_goroutines 53 +# HELP consul_runtime_sys_bytes consul_runtime_sys_bytes +# TYPE consul_runtime_sys_bytes gauge +consul_runtime_sys_bytes 5.1201032e+07 +# HELP consul_runtime_total_gc_pause_ns consul_runtime_total_gc_pause_ns +# TYPE consul_runtime_total_gc_pause_ns gauge +consul_runtime_total_gc_pause_ns 4.182423e+06 +# HELP consul_runtime_total_gc_runs consul_runtime_total_gc_runs +# TYPE consul_runtime_total_gc_runs gauge +consul_runtime_total_gc_runs 17 +# HELP consul_serf_coordinate_adjustment_ms consul_serf_coordinate_adjustment_ms +# TYPE consul_serf_coordinate_adjustment_ms summary +consul_serf_coordinate_adjustment_ms{network="lan",quantile="0.5"} 1.9778540134429932 +consul_serf_coordinate_adjustment_ms{network="lan",quantile="0.9"} 2.0611228942871094 +consul_serf_coordinate_adjustment_ms{network="lan",quantile="0.99"} 2.0611228942871094 +consul_serf_coordinate_adjustment_ms_sum{network="lan"} 375.26442916691303 +consul_serf_coordinate_adjustment_ms_count{network="lan"} 410 +# HELP consul_serf_member_join consul_serf_member_join +# TYPE consul_serf_member_join counter +consul_serf_member_join{network="lan"} 3 +# HELP consul_serf_msgs_received consul_serf_msgs_received +# TYPE consul_serf_msgs_received summary +consul_serf_msgs_received{network="lan",quantile="0.5"} NaN +consul_serf_msgs_received{network="lan",quantile="0.9"} NaN +consul_serf_msgs_received{network="lan",quantile="0.99"} NaN +consul_serf_msgs_received_sum{network="lan"} 100 +consul_serf_msgs_received_count{network="lan"} 4 +# HELP consul_serf_msgs_sent consul_serf_msgs_sent +# TYPE consul_serf_msgs_sent summary +consul_serf_msgs_sent{network="lan",quantile="0.5"} NaN +consul_serf_msgs_sent{network="lan",quantile="0.9"} NaN +consul_serf_msgs_sent{network="lan",quantile="0.99"} NaN +consul_serf_msgs_sent_sum{network="lan"} 200 +consul_serf_msgs_sent_count{network="lan"} 8 +# HELP consul_serf_queue_Event consul_serf_queue_Event +# TYPE consul_serf_queue_Event summary +consul_serf_queue_Event{network="lan",quantile="0.5"} NaN +consul_serf_queue_Event{network="lan",quantile="0.9"} NaN +consul_serf_queue_Event{network="lan",quantile="0.99"} NaN +consul_serf_queue_Event_sum{network="lan"} 0 +consul_serf_queue_Event_count{network="lan"} 14 +# HELP consul_serf_queue_Intent consul_serf_queue_Intent +# TYPE consul_serf_queue_Intent summary +consul_serf_queue_Intent{network="lan",quantile="0.5"} NaN +consul_serf_queue_Intent{network="lan",quantile="0.9"} NaN +consul_serf_queue_Intent{network="lan",quantile="0.99"} NaN +consul_serf_queue_Intent_sum{network="lan"} 0 +consul_serf_queue_Intent_count{network="lan"} 14 +# HELP consul_serf_queue_Query consul_serf_queue_Query +# TYPE consul_serf_queue_Query summary +consul_serf_queue_Query{network="lan",quantile="0.5"} NaN +consul_serf_queue_Query{network="lan",quantile="0.9"} NaN +consul_serf_queue_Query{network="lan",quantile="0.99"} NaN +consul_serf_queue_Query_sum{network="lan"} 0 +consul_serf_queue_Query_count{network="lan"} 14 +# HELP consul_serf_snapshot_appendLine consul_serf_snapshot_appendLine +# TYPE consul_serf_snapshot_appendLine summary +consul_serf_snapshot_appendLine{network="lan",quantile="0.5"} NaN +consul_serf_snapshot_appendLine{network="lan",quantile="0.9"} NaN +consul_serf_snapshot_appendLine{network="lan",quantile="0.99"} NaN +consul_serf_snapshot_appendLine_sum{network="lan"} 0.08486000122502446 +consul_serf_snapshot_appendLine_count{network="lan"} 4 +# HELP consul_server_isLeader Tracks if the server is a leader. +# TYPE consul_server_isLeader gauge +consul_server_isLeader 0 +# HELP consul_session_apply Measures the time spent applying a session update. +# TYPE consul_session_apply summary +consul_session_apply{quantile="0.5"} NaN +consul_session_apply{quantile="0.9"} NaN +consul_session_apply{quantile="0.99"} NaN +consul_session_apply_sum 0 +consul_session_apply_count 0 +# HELP consul_session_renew Measures the time spent renewing a session. +# TYPE consul_session_renew summary +consul_session_renew{quantile="0.5"} NaN +consul_session_renew{quantile="0.9"} NaN +consul_session_renew{quantile="0.99"} NaN +consul_session_renew_sum 0 +consul_session_renew_count 0 +# HELP consul_session_ttl_active Tracks the active number of sessions being tracked. +# TYPE consul_session_ttl_active gauge +consul_session_ttl_active 0 +# HELP consul_session_ttl_invalidate Measures the time spent invalidating an expired session. +# TYPE consul_session_ttl_invalidate summary +consul_session_ttl_invalidate{quantile="0.5"} NaN +consul_session_ttl_invalidate{quantile="0.9"} NaN +consul_session_ttl_invalidate{quantile="0.99"} NaN +consul_session_ttl_invalidate_sum 0 +consul_session_ttl_invalidate_count 0 +# HELP consul_txn_apply Measures the time spent applying a transaction operation. +# TYPE consul_txn_apply summary +consul_txn_apply{quantile="0.5"} NaN +consul_txn_apply{quantile="0.9"} NaN +consul_txn_apply{quantile="0.99"} NaN +consul_txn_apply_sum 0 +consul_txn_apply_count 0 +# HELP consul_txn_read Measures the time spent returning a read transaction. +# TYPE consul_txn_read summary +consul_txn_read{quantile="0.5"} NaN +consul_txn_read{quantile="0.9"} NaN +consul_txn_read{quantile="0.99"} NaN +consul_txn_read_sum 0 +consul_txn_read_count 0 +# HELP consul_version Represents the Consul version. +# TYPE consul_version gauge +consul_version 0 +consul_version{pre_release="",version="1.13.2"} 1 +# HELP consul_xds_server_streams Measures the number of active xDS streams handled by the server split by protocol version. +# TYPE consul_xds_server_streams gauge +consul_xds_server_streams 0 +# HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles. +# TYPE go_gc_duration_seconds summary +go_gc_duration_seconds{quantile="0"} 1.9158e-05 +go_gc_duration_seconds{quantile="0.25"} 0.000109081 +go_gc_duration_seconds{quantile="0.5"} 0.000251188 +go_gc_duration_seconds{quantile="0.75"} 0.000417427 +go_gc_duration_seconds{quantile="1"} 0.000564015 +go_gc_duration_seconds_sum 0.004182423 +go_gc_duration_seconds_count 17 +# HELP go_goroutines Number of goroutines that currently exist. +# TYPE go_goroutines gauge +go_goroutines 58 +# HELP go_info Information about the Go environment. +# TYPE go_info gauge +go_info{version="go1.18.1"} 1 +# HELP go_memstats_alloc_bytes Number of bytes allocated and still in use. +# TYPE go_memstats_alloc_bytes gauge +go_memstats_alloc_bytes 2.6578488e+07 +# HELP go_memstats_alloc_bytes_total Total number of bytes allocated, even if freed. +# TYPE go_memstats_alloc_bytes_total counter +go_memstats_alloc_bytes_total 2.1175476e+08 +# HELP go_memstats_buck_hash_sys_bytes Number of bytes used by the profiling bucket hash table. +# TYPE go_memstats_buck_hash_sys_bytes gauge +go_memstats_buck_hash_sys_bytes 1.493307e+06 +# HELP go_memstats_frees_total Total number of frees. +# TYPE go_memstats_frees_total counter +go_memstats_frees_total 675169 +# HELP go_memstats_gc_cpu_fraction The fraction of this program's available CPU time used by the GC since the program started. +# TYPE go_memstats_gc_cpu_fraction gauge +go_memstats_gc_cpu_fraction 3.182534545511277e-05 +# HELP go_memstats_gc_sys_bytes Number of bytes used for garbage collection system metadata. +# TYPE go_memstats_gc_sys_bytes gauge +go_memstats_gc_sys_bytes 6.043992e+06 +# HELP go_memstats_heap_alloc_bytes Number of heap bytes allocated and still in use. +# TYPE go_memstats_heap_alloc_bytes gauge +go_memstats_heap_alloc_bytes 2.6578488e+07 +# HELP go_memstats_heap_idle_bytes Number of heap bytes waiting to be used. +# TYPE go_memstats_heap_idle_bytes gauge +go_memstats_heap_idle_bytes 1.2009472e+07 +# HELP go_memstats_heap_inuse_bytes Number of heap bytes that are in use. +# TYPE go_memstats_heap_inuse_bytes gauge +go_memstats_heap_inuse_bytes 2.8884992e+07 +# HELP go_memstats_heap_objects Number of allocated objects. +# TYPE go_memstats_heap_objects gauge +go_memstats_heap_objects 64658 +# HELP go_memstats_heap_released_bytes Number of heap bytes released to OS. +# TYPE go_memstats_heap_released_bytes gauge +go_memstats_heap_released_bytes 1.056768e+06 +# HELP go_memstats_heap_sys_bytes Number of heap bytes obtained from system. +# TYPE go_memstats_heap_sys_bytes gauge +go_memstats_heap_sys_bytes 4.0894464e+07 +# HELP go_memstats_last_gc_time_seconds Number of seconds since 1970 of last garbage collection. +# TYPE go_memstats_last_gc_time_seconds gauge +go_memstats_last_gc_time_seconds 1.671442476091947e+09 +# HELP go_memstats_lookups_total Total number of pointer lookups. +# TYPE go_memstats_lookups_total counter +go_memstats_lookups_total 0 +# HELP go_memstats_mallocs_total Total number of mallocs. +# TYPE go_memstats_mallocs_total counter +go_memstats_mallocs_total 739827 +# HELP go_memstats_mcache_inuse_bytes Number of bytes in use by mcache structures. +# TYPE go_memstats_mcache_inuse_bytes gauge +go_memstats_mcache_inuse_bytes 9600 +# HELP go_memstats_mcache_sys_bytes Number of bytes used for mcache structures obtained from system. +# TYPE go_memstats_mcache_sys_bytes gauge +go_memstats_mcache_sys_bytes 15600 +# HELP go_memstats_mspan_inuse_bytes Number of bytes in use by mspan structures. +# TYPE go_memstats_mspan_inuse_bytes gauge +go_memstats_mspan_inuse_bytes 265880 +# HELP go_memstats_mspan_sys_bytes Number of bytes used for mspan structures obtained from system. +# TYPE go_memstats_mspan_sys_bytes gauge +go_memstats_mspan_sys_bytes 310080 +# HELP go_memstats_next_gc_bytes Number of heap bytes when next garbage collection will take place. +# TYPE go_memstats_next_gc_bytes gauge +go_memstats_next_gc_bytes 3.547528e+07 +# HELP go_memstats_other_sys_bytes Number of bytes used for other system allocations. +# TYPE go_memstats_other_sys_bytes gauge +go_memstats_other_sys_bytes 1.395013e+06 +# HELP go_memstats_stack_inuse_bytes Number of bytes in use by the stack allocator. +# TYPE go_memstats_stack_inuse_bytes gauge +go_memstats_stack_inuse_bytes 1.048576e+06 +# HELP go_memstats_stack_sys_bytes Number of bytes obtained from system for stack allocator. +# TYPE go_memstats_stack_sys_bytes gauge +go_memstats_stack_sys_bytes 1.048576e+06 +# HELP go_memstats_sys_bytes Number of bytes obtained from system. +# TYPE go_memstats_sys_bytes gauge +go_memstats_sys_bytes 5.1201032e+07 +# HELP go_threads Number of OS threads created. +# TYPE go_threads gauge +go_threads 13 +# HELP process_cpu_seconds_total Total user and system CPU time spent in seconds. +# TYPE process_cpu_seconds_total counter +process_cpu_seconds_total 3.12 +# HELP process_max_fds Maximum number of open file descriptors. +# TYPE process_max_fds gauge +process_max_fds 1024 +# HELP process_open_fds Number of open file descriptors. +# TYPE process_open_fds gauge +process_open_fds 18 +# HELP process_resident_memory_bytes Resident memory size in bytes. +# TYPE process_resident_memory_bytes gauge +process_resident_memory_bytes 9.9598336e+07 +# HELP process_start_time_seconds Start time of the process since unix epoch in seconds. +# TYPE process_start_time_seconds gauge +process_start_time_seconds 1.67144207026e+09 +# HELP process_virtual_memory_bytes Virtual memory size in bytes. +# TYPE process_virtual_memory_bytes gauge +process_virtual_memory_bytes 8.133632e+08 +# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes. +# TYPE process_virtual_memory_max_bytes gauge +process_virtual_memory_max_bytes -1
\ No newline at end of file diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/client_v1-agent-self.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/client_v1-agent-self.json new file mode 100644 index 000000000..e5f75dc24 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/client_v1-agent-self.json @@ -0,0 +1,50 @@ +{ + "Config": { + "Datacenter": "us-central", + "PrimaryDatacenter": "us-central", + "NodeName": "satya-vm", + "NodeID": "d86b8af4-5dc5-d790-7c32-420d4ac1dd8d", + "Revision": "0e046bbb", + "Server": false, + "Version": "1.13.2", + "BuildDate": "2022-09-20T20:30:07Z" + }, + "DebugConfig": { + "Telemetry": { + "AllowedPrefixes": [], + "BlockedPrefixes": [ + "consul.rpc.server.call" + ], + "CirconusAPIApp": "", + "CirconusAPIToken": "hidden", + "CirconusAPIURL": "", + "CirconusBrokerID": "", + "CirconusBrokerSelectTag": "", + "CirconusCheckDisplayName": "", + "CirconusCheckForceMetricActivation": "", + "CirconusCheckID": "", + "CirconusCheckInstanceID": "", + "CirconusCheckSearchTag": "", + "CirconusCheckTags": "", + "CirconusSubmissionInterval": "", + "CirconusSubmissionURL": "", + "Disable": false, + "DisableHostname": true, + "DogstatsdAddr": "", + "DogstatsdTags": [], + "FilterDefault": true, + "MetricsPrefix": "consul", + "PrometheusOpts": { + "CounterDefinitions": [], + "Expiration": "10m0s", + "GaugeDefinitions": [], + "Name": "consul", + "Registerer": null, + "SummaryDefinitions": [] + }, + "RetryFailedConfiguration": true, + "StatsdAddr": "", + "StatsiteAddr": "" + } + } +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-metrics.txt b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-metrics.txt new file mode 100644 index 000000000..63dbaddfc --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-metrics.txt @@ -0,0 +1,1255 @@ +# HELP consul_acl_ResolveToken This measures the time it takes to resolve an ACL token. +# TYPE consul_acl_ResolveToken summary +consul_acl_ResolveToken{quantile="0.5"} NaN +consul_acl_ResolveToken{quantile="0.9"} NaN +consul_acl_ResolveToken{quantile="0.99"} NaN +consul_acl_ResolveToken_sum 0 +consul_acl_ResolveToken_count 0 +# HELP consul_acl_authmethod_delete +# TYPE consul_acl_authmethod_delete summary +consul_acl_authmethod_delete{quantile="0.5"} NaN +consul_acl_authmethod_delete{quantile="0.9"} NaN +consul_acl_authmethod_delete{quantile="0.99"} NaN +consul_acl_authmethod_delete_sum 0 +consul_acl_authmethod_delete_count 0 +# HELP consul_acl_authmethod_upsert +# TYPE consul_acl_authmethod_upsert summary +consul_acl_authmethod_upsert{quantile="0.5"} NaN +consul_acl_authmethod_upsert{quantile="0.9"} NaN +consul_acl_authmethod_upsert{quantile="0.99"} NaN +consul_acl_authmethod_upsert_sum 0 +consul_acl_authmethod_upsert_count 0 +# HELP consul_acl_bindingrule_delete +# TYPE consul_acl_bindingrule_delete summary +consul_acl_bindingrule_delete{quantile="0.5"} NaN +consul_acl_bindingrule_delete{quantile="0.9"} NaN +consul_acl_bindingrule_delete{quantile="0.99"} NaN +consul_acl_bindingrule_delete_sum 0 +consul_acl_bindingrule_delete_count 0 +# HELP consul_acl_bindingrule_upsert +# TYPE consul_acl_bindingrule_upsert summary +consul_acl_bindingrule_upsert{quantile="0.5"} NaN +consul_acl_bindingrule_upsert{quantile="0.9"} NaN +consul_acl_bindingrule_upsert{quantile="0.99"} NaN +consul_acl_bindingrule_upsert_sum 0 +consul_acl_bindingrule_upsert_count 0 +# HELP consul_acl_blocked_check_deregistration Increments whenever a deregistration fails for a check (blocked by an ACL) +# TYPE consul_acl_blocked_check_deregistration counter +consul_acl_blocked_check_deregistration 0 +# HELP consul_acl_blocked_check_registration Increments whenever a registration fails for a check (blocked by an ACL) +# TYPE consul_acl_blocked_check_registration counter +consul_acl_blocked_check_registration 0 +# HELP consul_acl_blocked_node_registration Increments whenever a registration fails for a node (blocked by an ACL) +# TYPE consul_acl_blocked_node_registration counter +consul_acl_blocked_node_registration 0 +# HELP consul_acl_blocked_service_deregistration Increments whenever a deregistration fails for a service (blocked by an ACL) +# TYPE consul_acl_blocked_service_deregistration counter +consul_acl_blocked_service_deregistration 0 +# HELP consul_acl_blocked_service_registration Increments whenever a registration fails for a service (blocked by an ACL) +# TYPE consul_acl_blocked_service_registration counter +consul_acl_blocked_service_registration 0 +# HELP consul_acl_login +# TYPE consul_acl_login summary +consul_acl_login{quantile="0.5"} NaN +consul_acl_login{quantile="0.9"} NaN +consul_acl_login{quantile="0.99"} NaN +consul_acl_login_sum 0 +consul_acl_login_count 0 +# HELP consul_acl_logout +# TYPE consul_acl_logout summary +consul_acl_logout{quantile="0.5"} NaN +consul_acl_logout{quantile="0.9"} NaN +consul_acl_logout{quantile="0.99"} NaN +consul_acl_logout_sum 0 +consul_acl_logout_count 0 +# HELP consul_acl_policy_delete +# TYPE consul_acl_policy_delete summary +consul_acl_policy_delete{quantile="0.5"} NaN +consul_acl_policy_delete{quantile="0.9"} NaN +consul_acl_policy_delete{quantile="0.99"} NaN +consul_acl_policy_delete_sum 0 +consul_acl_policy_delete_count 0 +# HELP consul_acl_policy_upsert +# TYPE consul_acl_policy_upsert summary +consul_acl_policy_upsert{quantile="0.5"} NaN +consul_acl_policy_upsert{quantile="0.9"} NaN +consul_acl_policy_upsert{quantile="0.99"} NaN +consul_acl_policy_upsert_sum 0 +consul_acl_policy_upsert_count 0 +# HELP consul_acl_role_delete +# TYPE consul_acl_role_delete summary +consul_acl_role_delete{quantile="0.5"} NaN +consul_acl_role_delete{quantile="0.9"} NaN +consul_acl_role_delete{quantile="0.99"} NaN +consul_acl_role_delete_sum 0 +consul_acl_role_delete_count 0 +# HELP consul_acl_role_upsert +# TYPE consul_acl_role_upsert summary +consul_acl_role_upsert{quantile="0.5"} NaN +consul_acl_role_upsert{quantile="0.9"} NaN +consul_acl_role_upsert{quantile="0.99"} NaN +consul_acl_role_upsert_sum 0 +consul_acl_role_upsert_count 0 +# HELP consul_acl_token_cache_hit Increments if Consul is able to resolve a token's identity, or a legacy token, from the cache. +# TYPE consul_acl_token_cache_hit counter +consul_acl_token_cache_hit 0 +# HELP consul_acl_token_cache_miss Increments if Consul cannot resolve a token's identity, or a legacy token, from the cache. +# TYPE consul_acl_token_cache_miss counter +consul_acl_token_cache_miss 0 +# HELP consul_acl_token_clone +# TYPE consul_acl_token_clone summary +consul_acl_token_clone{quantile="0.5"} NaN +consul_acl_token_clone{quantile="0.9"} NaN +consul_acl_token_clone{quantile="0.99"} NaN +consul_acl_token_clone_sum 0 +consul_acl_token_clone_count 0 +# HELP consul_acl_token_delete +# TYPE consul_acl_token_delete summary +consul_acl_token_delete{quantile="0.5"} NaN +consul_acl_token_delete{quantile="0.9"} NaN +consul_acl_token_delete{quantile="0.99"} NaN +consul_acl_token_delete_sum 0 +consul_acl_token_delete_count 0 +# HELP consul_acl_token_upsert +# TYPE consul_acl_token_upsert summary +consul_acl_token_upsert{quantile="0.5"} NaN +consul_acl_token_upsert{quantile="0.9"} NaN +consul_acl_token_upsert{quantile="0.99"} NaN +consul_acl_token_upsert_sum 0 +consul_acl_token_upsert_count 0 +# HELP consul_agent_tls_cert_expiry Seconds until the agent tls certificate expires. Updated every hour +# TYPE consul_agent_tls_cert_expiry gauge +consul_agent_tls_cert_expiry 0 +# HELP consul_api_http Samples how long it takes to service the given HTTP request for the given verb and path. +# TYPE consul_api_http summary +consul_api_http{quantile="0.5"} NaN +consul_api_http{quantile="0.9"} NaN +consul_api_http{quantile="0.99"} NaN +consul_api_http_sum 0 +consul_api_http_count 0 +consul_api_http{method="GET",path="v1_agent_checks",quantile="0.5"} 0.11646900326013565 +consul_api_http{method="GET",path="v1_agent_checks",quantile="0.9"} 0.3685469925403595 +consul_api_http{method="GET",path="v1_agent_checks",quantile="0.99"} 1.142822027206421 +consul_api_http_sum{method="GET",path="v1_agent_checks"} 24054.416150089353 +consul_api_http_count{method="GET",path="v1_agent_checks"} 99423 +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.5"} 0.8454239964485168 +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.9"} 4.116001129150391 +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.99"} 6.345314025878906 +consul_api_http_sum{method="GET",path="v1_agent_metrics"} 169447.17186257243 +consul_api_http_count{method="GET",path="v1_agent_metrics"} 118670 +# HELP consul_autopilot_failure_tolerance Tracks the number of voting servers that the cluster can lose while continuing to function. +# TYPE consul_autopilot_failure_tolerance gauge +consul_autopilot_failure_tolerance 1 +# HELP consul_autopilot_healthy Tracks the overall health of the local server cluster. 1 if all servers are healthy, 0 if one or more are unhealthy. +# TYPE consul_autopilot_healthy gauge +consul_autopilot_healthy 1 +# HELP consul_catalog_connect_not_found Increments for each connect-based catalog query where the given service could not be found. +# TYPE consul_catalog_connect_not_found counter +consul_catalog_connect_not_found 0 +# HELP consul_catalog_connect_query Increments for each connect-based catalog query for the given service. +# TYPE consul_catalog_connect_query counter +consul_catalog_connect_query 0 +# HELP consul_catalog_connect_query_tag Increments for each connect-based catalog query for the given service with the given tag. +# TYPE consul_catalog_connect_query_tag counter +consul_catalog_connect_query_tag 0 +# HELP consul_catalog_connect_query_tags Increments for each connect-based catalog query for the given service with the given tags. +# TYPE consul_catalog_connect_query_tags counter +consul_catalog_connect_query_tags 0 +# HELP consul_catalog_deregister Measures the time it takes to complete a catalog deregister operation. +# TYPE consul_catalog_deregister summary +consul_catalog_deregister{quantile="0.5"} NaN +consul_catalog_deregister{quantile="0.9"} NaN +consul_catalog_deregister{quantile="0.99"} NaN +consul_catalog_deregister_sum 0 +consul_catalog_deregister_count 0 +# HELP consul_catalog_register Measures the time it takes to complete a catalog register operation. +# TYPE consul_catalog_register summary +consul_catalog_register{quantile="0.5"} NaN +consul_catalog_register{quantile="0.9"} NaN +consul_catalog_register{quantile="0.99"} NaN +consul_catalog_register_sum 15302.798070907593 +consul_catalog_register_count 193 +# HELP consul_catalog_service_not_found Increments for each catalog query where the given service could not be found. +# TYPE consul_catalog_service_not_found counter +consul_catalog_service_not_found 0 +# HELP consul_catalog_service_query Increments for each catalog query for the given service. +# TYPE consul_catalog_service_query counter +consul_catalog_service_query 0 +# HELP consul_catalog_service_query_tag Increments for each catalog query for the given service with the given tag. +# TYPE consul_catalog_service_query_tag counter +consul_catalog_service_query_tag 0 +# HELP consul_catalog_service_query_tags Increments for each catalog query for the given service with the given tags. +# TYPE consul_catalog_service_query_tags counter +consul_catalog_service_query_tags 0 +# HELP consul_client_api_catalog_datacenters Increments whenever a Consul agent receives a request to list datacenters in the catalog. +# TYPE consul_client_api_catalog_datacenters counter +consul_client_api_catalog_datacenters 0 +# HELP consul_client_api_catalog_deregister Increments whenever a Consul agent receives a catalog deregister request. +# TYPE consul_client_api_catalog_deregister counter +consul_client_api_catalog_deregister 0 +# HELP consul_client_api_catalog_gateway_services Increments whenever a Consul agent receives a request to list services associated with a gateway. +# TYPE consul_client_api_catalog_gateway_services counter +consul_client_api_catalog_gateway_services 0 +# HELP consul_client_api_catalog_node_service_list Increments whenever a Consul agent receives a request to list a node's registered services. +# TYPE consul_client_api_catalog_node_service_list counter +consul_client_api_catalog_node_service_list 0 +# HELP consul_client_api_catalog_node_services Increments whenever a Consul agent successfully responds to a request to list nodes offering a service. +# TYPE consul_client_api_catalog_node_services counter +consul_client_api_catalog_node_services 0 +# HELP consul_client_api_catalog_nodes Increments whenever a Consul agent receives a request to list nodes from the catalog. +# TYPE consul_client_api_catalog_nodes counter +consul_client_api_catalog_nodes 0 +# HELP consul_client_api_catalog_register Increments whenever a Consul agent receives a catalog register request. +# TYPE consul_client_api_catalog_register counter +consul_client_api_catalog_register 0 +# HELP consul_client_api_catalog_service_nodes Increments whenever a Consul agent receives a request to list nodes offering a service. +# TYPE consul_client_api_catalog_service_nodes counter +consul_client_api_catalog_service_nodes 0 +# HELP consul_client_api_catalog_services Increments whenever a Consul agent receives a request to list services from the catalog. +# TYPE consul_client_api_catalog_services counter +consul_client_api_catalog_services 0 +# HELP consul_client_api_error_catalog_service_nodes Increments whenever a Consul agent receives an RPC error for request to list nodes offering a service. +# TYPE consul_client_api_error_catalog_service_nodes counter +consul_client_api_error_catalog_service_nodes 0 +# HELP consul_client_api_success_catalog_datacenters Increments whenever a Consul agent successfully responds to a request to list datacenters. +# TYPE consul_client_api_success_catalog_datacenters counter +consul_client_api_success_catalog_datacenters 0 +# HELP consul_client_api_success_catalog_deregister Increments whenever a Consul agent successfully responds to a catalog deregister request. +# TYPE consul_client_api_success_catalog_deregister counter +consul_client_api_success_catalog_deregister 0 +# HELP consul_client_api_success_catalog_gateway_services Increments whenever a Consul agent successfully responds to a request to list services associated with a gateway. +# TYPE consul_client_api_success_catalog_gateway_services counter +consul_client_api_success_catalog_gateway_services 0 +# HELP consul_client_api_success_catalog_node_service_list Increments whenever a Consul agent successfully responds to a request to list a node's registered services. +# TYPE consul_client_api_success_catalog_node_service_list counter +consul_client_api_success_catalog_node_service_list 0 +# HELP consul_client_api_success_catalog_node_services Increments whenever a Consul agent successfully responds to a request to list services in a node. +# TYPE consul_client_api_success_catalog_node_services counter +consul_client_api_success_catalog_node_services 0 +# HELP consul_client_api_success_catalog_nodes Increments whenever a Consul agent successfully responds to a request to list nodes. +# TYPE consul_client_api_success_catalog_nodes counter +consul_client_api_success_catalog_nodes 0 +# HELP consul_client_api_success_catalog_register Increments whenever a Consul agent successfully responds to a catalog register request. +# TYPE consul_client_api_success_catalog_register counter +consul_client_api_success_catalog_register 0 +# HELP consul_client_api_success_catalog_service_nodes Increments whenever a Consul agent successfully responds to a request to list nodes offering a service. +# TYPE consul_client_api_success_catalog_service_nodes counter +consul_client_api_success_catalog_service_nodes 0 +# HELP consul_client_api_success_catalog_services Increments whenever a Consul agent successfully responds to a request to list services. +# TYPE consul_client_api_success_catalog_services counter +consul_client_api_success_catalog_services 0 +# HELP consul_client_rpc Increments whenever a Consul agent in client mode makes an RPC request to a Consul server. +# TYPE consul_client_rpc counter +consul_client_rpc 6838 +# HELP consul_client_rpc_error_catalog_datacenters Increments whenever a Consul agent receives an RPC error for a request to list datacenters. +# TYPE consul_client_rpc_error_catalog_datacenters counter +consul_client_rpc_error_catalog_datacenters 0 +# HELP consul_client_rpc_error_catalog_deregister Increments whenever a Consul agent receives an RPC error for a catalog deregister request. +# TYPE consul_client_rpc_error_catalog_deregister counter +consul_client_rpc_error_catalog_deregister 0 +# HELP consul_client_rpc_error_catalog_gateway_services Increments whenever a Consul agent receives an RPC error for a request to list services associated with a gateway. +# TYPE consul_client_rpc_error_catalog_gateway_services counter +consul_client_rpc_error_catalog_gateway_services 0 +# HELP consul_client_rpc_error_catalog_node_service_list Increments whenever a Consul agent receives an RPC error for request to list a node's registered services. +# TYPE consul_client_rpc_error_catalog_node_service_list counter +consul_client_rpc_error_catalog_node_service_list 0 +# HELP consul_client_rpc_error_catalog_node_services Increments whenever a Consul agent receives an RPC error for a request to list services in a node. +# TYPE consul_client_rpc_error_catalog_node_services counter +consul_client_rpc_error_catalog_node_services 0 +# HELP consul_client_rpc_error_catalog_nodes Increments whenever a Consul agent receives an RPC error for a request to list nodes. +# TYPE consul_client_rpc_error_catalog_nodes counter +consul_client_rpc_error_catalog_nodes 0 +# HELP consul_client_rpc_error_catalog_register Increments whenever a Consul agent receives an RPC error for a catalog register request. +# TYPE consul_client_rpc_error_catalog_register counter +consul_client_rpc_error_catalog_register 0 +# HELP consul_client_rpc_error_catalog_service_nodes Increments whenever a Consul agent receives an RPC error for a request to list nodes offering a service. +# TYPE consul_client_rpc_error_catalog_service_nodes counter +consul_client_rpc_error_catalog_service_nodes 0 +# HELP consul_client_rpc_error_catalog_services Increments whenever a Consul agent receives an RPC error for a request to list services. +# TYPE consul_client_rpc_error_catalog_services counter +consul_client_rpc_error_catalog_services 0 +# HELP consul_client_rpc_exceeded Increments whenever a Consul agent in client mode makes an RPC request to a Consul server gets rate limited by that agent's limits configuration. +# TYPE consul_client_rpc_exceeded counter +consul_client_rpc_exceeded 0 +# HELP consul_client_rpc_failed Increments whenever a Consul agent in client mode makes an RPC request to a Consul server and fails. +# TYPE consul_client_rpc_failed counter +consul_client_rpc_failed 0 +# HELP consul_consul_cache_bypass Counts how many times a request bypassed the cache because no cache-key was provided. +# TYPE consul_consul_cache_bypass counter +consul_consul_cache_bypass 0 +# HELP consul_consul_cache_entries_count Represents the number of entries in this cache. +# TYPE consul_consul_cache_entries_count gauge +consul_consul_cache_entries_count 0 +# HELP consul_consul_cache_evict_expired Counts the number of expired entries that are evicted. +# TYPE consul_consul_cache_evict_expired counter +consul_consul_cache_evict_expired 0 +# HELP consul_consul_cache_fetch_error Counts the number of failed fetches by the cache. +# TYPE consul_consul_cache_fetch_error counter +consul_consul_cache_fetch_error 0 +# HELP consul_consul_cache_fetch_success Counts the number of successful fetches by the cache. +# TYPE consul_consul_cache_fetch_success counter +consul_consul_cache_fetch_success 0 +# HELP consul_consul_fsm_ca Deprecated - use fsm_ca instead +# TYPE consul_consul_fsm_ca summary +consul_consul_fsm_ca{quantile="0.5"} NaN +consul_consul_fsm_ca{quantile="0.9"} NaN +consul_consul_fsm_ca{quantile="0.99"} NaN +consul_consul_fsm_ca_sum 0 +consul_consul_fsm_ca_count 0 +# HELP consul_consul_fsm_intention Deprecated - use fsm_intention instead +# TYPE consul_consul_fsm_intention summary +consul_consul_fsm_intention{quantile="0.5"} NaN +consul_consul_fsm_intention{quantile="0.9"} NaN +consul_consul_fsm_intention{quantile="0.99"} NaN +consul_consul_fsm_intention_sum 0 +consul_consul_fsm_intention_count 0 +# HELP consul_consul_intention_apply +# TYPE consul_consul_intention_apply summary +consul_consul_intention_apply{quantile="0.5"} NaN +consul_consul_intention_apply{quantile="0.9"} NaN +consul_consul_intention_apply{quantile="0.99"} NaN +consul_consul_intention_apply_sum 0 +consul_consul_intention_apply_count 0 +# HELP consul_consul_members_clients Measures the current number of client agents registered with Consul. It is only emitted by Consul servers. Added in v1.9.6. +# TYPE consul_consul_members_clients gauge +consul_consul_members_clients 0 +consul_consul_members_clients{datacenter="us-central"} 0 +# HELP consul_consul_members_servers Measures the current number of server agents registered with Consul. It is only emitted by Consul servers. Added in v1.9.6. +# TYPE consul_consul_members_servers gauge +consul_consul_members_servers 0 +consul_consul_members_servers{datacenter="us-central"} 3 +# HELP consul_consul_peering_exported_services A gauge that tracks how many services are exported for the peering. The labels are "peering" and, for enterprise, "partition". We emit this metric every 9 seconds +# TYPE consul_consul_peering_exported_services gauge +consul_consul_peering_exported_services 0 +# HELP consul_consul_state_config_entries Measures the current number of unique configuration entries registered with Consul, labeled by Kind. It is only emitted by Consul servers. Added in v1.10.4. +# TYPE consul_consul_state_config_entries gauge +consul_consul_state_config_entries 0 +consul_consul_state_config_entries{datacenter="us-central",kind="exported-services"} 0 +consul_consul_state_config_entries{datacenter="us-central",kind="ingress-gateway"} 0 +consul_consul_state_config_entries{datacenter="us-central",kind="mesh"} 0 +consul_consul_state_config_entries{datacenter="us-central",kind="proxy-defaults"} 0 +consul_consul_state_config_entries{datacenter="us-central",kind="service-defaults"} 0 +consul_consul_state_config_entries{datacenter="us-central",kind="service-intentions"} 0 +consul_consul_state_config_entries{datacenter="us-central",kind="service-resolver"} 0 +consul_consul_state_config_entries{datacenter="us-central",kind="service-router"} 0 +consul_consul_state_config_entries{datacenter="us-central",kind="service-splitter"} 0 +consul_consul_state_config_entries{datacenter="us-central",kind="terminating-gateway"} 0 +# HELP consul_consul_state_connect_instances Measures the current number of unique connect service instances registered with Consul, labeled by Kind. It is only emitted by Consul servers. Added in v1.10.4. +# TYPE consul_consul_state_connect_instances gauge +consul_consul_state_connect_instances 0 +consul_consul_state_connect_instances{datacenter="us-central",kind="connect-native"} 0 +consul_consul_state_connect_instances{datacenter="us-central",kind="connect-proxy"} 0 +consul_consul_state_connect_instances{datacenter="us-central",kind="ingress-gateway"} 0 +consul_consul_state_connect_instances{datacenter="us-central",kind="mesh-gateway"} 0 +consul_consul_state_connect_instances{datacenter="us-central",kind="terminating-gateway"} 0 +# HELP consul_consul_state_kv_entries Measures the current number of entries in the Consul KV store. It is only emitted by Consul servers. Added in v1.10.3. +# TYPE consul_consul_state_kv_entries gauge +consul_consul_state_kv_entries 0 +consul_consul_state_kv_entries{datacenter="us-central"} 1 +# HELP consul_consul_state_nodes Measures the current number of nodes registered with Consul. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_consul_state_nodes gauge +consul_consul_state_nodes 0 +consul_consul_state_nodes{datacenter="us-central"} 3 +# HELP consul_consul_state_peerings Measures the current number of peerings registered with Consul. It is only emitted by Consul servers. Added in v1.13.0. +# TYPE consul_consul_state_peerings gauge +consul_consul_state_peerings 0 +consul_consul_state_peerings{datacenter="us-central"} 0 +# HELP consul_consul_state_service_instances Measures the current number of unique services registered with Consul, based on service name. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_consul_state_service_instances gauge +consul_consul_state_service_instances 0 +consul_consul_state_service_instances{datacenter="us-central"} 4 +# HELP consul_consul_state_services Measures the current number of unique services registered with Consul, based on service name. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_consul_state_services gauge +consul_consul_state_services 0 +consul_consul_state_services{datacenter="us-central"} 2 +# HELP consul_federation_state_apply +# TYPE consul_federation_state_apply summary +consul_federation_state_apply{quantile="0.5"} NaN +consul_federation_state_apply{quantile="0.9"} NaN +consul_federation_state_apply{quantile="0.99"} NaN +consul_federation_state_apply_sum 0 +consul_federation_state_apply_count 0 +# HELP consul_federation_state_get +# TYPE consul_federation_state_get summary +consul_federation_state_get{quantile="0.5"} NaN +consul_federation_state_get{quantile="0.9"} NaN +consul_federation_state_get{quantile="0.99"} NaN +consul_federation_state_get_sum 0 +consul_federation_state_get_count 0 +# HELP consul_federation_state_list +# TYPE consul_federation_state_list summary +consul_federation_state_list{quantile="0.5"} NaN +consul_federation_state_list{quantile="0.9"} NaN +consul_federation_state_list{quantile="0.99"} NaN +consul_federation_state_list_sum 0 +consul_federation_state_list_count 0 +# HELP consul_federation_state_list_mesh_gateways +# TYPE consul_federation_state_list_mesh_gateways summary +consul_federation_state_list_mesh_gateways{quantile="0.5"} NaN +consul_federation_state_list_mesh_gateways{quantile="0.9"} NaN +consul_federation_state_list_mesh_gateways{quantile="0.99"} NaN +consul_federation_state_list_mesh_gateways_sum 0 +consul_federation_state_list_mesh_gateways_count 0 +# HELP consul_fsm_acl Measures the time it takes to apply the given ACL operation to the FSM. +# TYPE consul_fsm_acl summary +consul_fsm_acl{quantile="0.5"} NaN +consul_fsm_acl{quantile="0.9"} NaN +consul_fsm_acl{quantile="0.99"} NaN +consul_fsm_acl_sum 0 +consul_fsm_acl_count 0 +# HELP consul_fsm_acl_authmethod Measures the time it takes to apply an ACL authmethod operation to the FSM. +# TYPE consul_fsm_acl_authmethod summary +consul_fsm_acl_authmethod{quantile="0.5"} NaN +consul_fsm_acl_authmethod{quantile="0.9"} NaN +consul_fsm_acl_authmethod{quantile="0.99"} NaN +consul_fsm_acl_authmethod_sum 0 +consul_fsm_acl_authmethod_count 0 +# HELP consul_fsm_acl_bindingrule Measures the time it takes to apply an ACL binding rule operation to the FSM. +# TYPE consul_fsm_acl_bindingrule summary +consul_fsm_acl_bindingrule{quantile="0.5"} NaN +consul_fsm_acl_bindingrule{quantile="0.9"} NaN +consul_fsm_acl_bindingrule{quantile="0.99"} NaN +consul_fsm_acl_bindingrule_sum 0 +consul_fsm_acl_bindingrule_count 0 +# HELP consul_fsm_acl_policy Measures the time it takes to apply an ACL policy operation to the FSM. +# TYPE consul_fsm_acl_policy summary +consul_fsm_acl_policy{quantile="0.5"} NaN +consul_fsm_acl_policy{quantile="0.9"} NaN +consul_fsm_acl_policy{quantile="0.99"} NaN +consul_fsm_acl_policy_sum 0 +consul_fsm_acl_policy_count 0 +# HELP consul_fsm_acl_token Measures the time it takes to apply an ACL token operation to the FSM. +# TYPE consul_fsm_acl_token summary +consul_fsm_acl_token{quantile="0.5"} NaN +consul_fsm_acl_token{quantile="0.9"} NaN +consul_fsm_acl_token{quantile="0.99"} NaN +consul_fsm_acl_token_sum 0 +consul_fsm_acl_token_count 0 +# HELP consul_fsm_autopilot Measures the time it takes to apply the given autopilot update to the FSM. +# TYPE consul_fsm_autopilot summary +consul_fsm_autopilot{quantile="0.5"} NaN +consul_fsm_autopilot{quantile="0.9"} NaN +consul_fsm_autopilot{quantile="0.99"} NaN +consul_fsm_autopilot_sum 0 +consul_fsm_autopilot_count 0 +# HELP consul_fsm_ca Measures the time it takes to apply CA configuration operations to the FSM. +# TYPE consul_fsm_ca summary +consul_fsm_ca{quantile="0.5"} NaN +consul_fsm_ca{quantile="0.9"} NaN +consul_fsm_ca{quantile="0.99"} NaN +consul_fsm_ca_sum 0 +consul_fsm_ca_count 0 +# HELP consul_fsm_ca_leaf Measures the time it takes to apply an operation while signing a leaf certificate. +# TYPE consul_fsm_ca_leaf summary +consul_fsm_ca_leaf{quantile="0.5"} NaN +consul_fsm_ca_leaf{quantile="0.9"} NaN +consul_fsm_ca_leaf{quantile="0.99"} NaN +consul_fsm_ca_leaf_sum 0 +consul_fsm_ca_leaf_count 0 +# HELP consul_fsm_coordinate_batch_update Measures the time it takes to apply the given batch coordinate update to the FSM. +# TYPE consul_fsm_coordinate_batch_update summary +consul_fsm_coordinate_batch_update{quantile="0.5"} 0.846472978591919 +consul_fsm_coordinate_batch_update{quantile="0.9"} 0.846472978591919 +consul_fsm_coordinate_batch_update{quantile="0.99"} 0.846472978591919 +consul_fsm_coordinate_batch_update_sum 1319.3496078031603 +consul_fsm_coordinate_batch_update_count 22753 +# HELP consul_fsm_deregister Measures the time it takes to apply a catalog deregister operation to the FSM. +# TYPE consul_fsm_deregister summary +consul_fsm_deregister{quantile="0.5"} NaN +consul_fsm_deregister{quantile="0.9"} NaN +consul_fsm_deregister{quantile="0.99"} NaN +consul_fsm_deregister_sum 7.263695985078812 +consul_fsm_deregister_count 25 +# HELP consul_fsm_intention Measures the time it takes to apply an intention operation to the FSM. +# TYPE consul_fsm_intention summary +consul_fsm_intention{quantile="0.5"} NaN +consul_fsm_intention{quantile="0.9"} NaN +consul_fsm_intention{quantile="0.99"} NaN +consul_fsm_intention_sum 0 +consul_fsm_intention_count 0 +# HELP consul_fsm_kvs Measures the time it takes to apply the given KV operation to the FSM. +# TYPE consul_fsm_kvs summary +consul_fsm_kvs{quantile="0.5"} NaN +consul_fsm_kvs{quantile="0.9"} NaN +consul_fsm_kvs{quantile="0.99"} NaN +consul_fsm_kvs_sum 0 +consul_fsm_kvs_count 0 +# HELP consul_fsm_peering Measures the time it takes to apply a peering operation to the FSM. +# TYPE consul_fsm_peering summary +consul_fsm_peering{quantile="0.5"} NaN +consul_fsm_peering{quantile="0.9"} NaN +consul_fsm_peering{quantile="0.99"} NaN +consul_fsm_peering_sum 0 +consul_fsm_peering_count 0 +# HELP consul_fsm_persist Measures the time it takes to persist the FSM to a raft snapshot. +# TYPE consul_fsm_persist summary +consul_fsm_persist{quantile="0.5"} NaN +consul_fsm_persist{quantile="0.9"} NaN +consul_fsm_persist{quantile="0.99"} NaN +consul_fsm_persist_sum 0.7345139980316162 +consul_fsm_persist_count 1 +# HELP consul_fsm_prepared_query Measures the time it takes to apply the given prepared query update operation to the FSM. +# TYPE consul_fsm_prepared_query summary +consul_fsm_prepared_query{quantile="0.5"} NaN +consul_fsm_prepared_query{quantile="0.9"} NaN +consul_fsm_prepared_query{quantile="0.99"} NaN +consul_fsm_prepared_query_sum 0 +consul_fsm_prepared_query_count 0 +# HELP consul_fsm_register Measures the time it takes to apply a catalog register operation to the FSM. +# TYPE consul_fsm_register summary +consul_fsm_register{quantile="0.5"} NaN +consul_fsm_register{quantile="0.9"} NaN +consul_fsm_register{quantile="0.99"} NaN +consul_fsm_register_sum 77.52807594463229 +consul_fsm_register_count 475 +# HELP consul_fsm_session Measures the time it takes to apply the given session operation to the FSM. +# TYPE consul_fsm_session summary +consul_fsm_session{quantile="0.5"} NaN +consul_fsm_session{quantile="0.9"} NaN +consul_fsm_session{quantile="0.99"} NaN +consul_fsm_session_sum 0 +consul_fsm_session_count 0 +# HELP consul_fsm_system_metadata Measures the time it takes to apply a system metadata operation to the FSM. +# TYPE consul_fsm_system_metadata summary +consul_fsm_system_metadata{quantile="0.5"} NaN +consul_fsm_system_metadata{quantile="0.9"} NaN +consul_fsm_system_metadata{quantile="0.99"} NaN +consul_fsm_system_metadata_sum 0 +consul_fsm_system_metadata_count 0 +# HELP consul_fsm_tombstone Measures the time it takes to apply the given tombstone operation to the FSM. +# TYPE consul_fsm_tombstone summary +consul_fsm_tombstone{quantile="0.5"} NaN +consul_fsm_tombstone{quantile="0.9"} NaN +consul_fsm_tombstone{quantile="0.99"} NaN +consul_fsm_tombstone_sum 0 +consul_fsm_tombstone_count 0 +# HELP consul_fsm_txn Measures the time it takes to apply the given transaction update to the FSM. +# TYPE consul_fsm_txn summary +consul_fsm_txn{quantile="0.5"} NaN +consul_fsm_txn{quantile="0.9"} NaN +consul_fsm_txn{quantile="0.99"} NaN +consul_fsm_txn_sum 0 +consul_fsm_txn_count 0 +# HELP consul_grpc_client_connection_count Counts the number of new gRPC connections opened by the client agent to a Consul server. +# TYPE consul_grpc_client_connection_count counter +consul_grpc_client_connection_count 875 +# HELP consul_grpc_client_connections Measures the number of active gRPC connections open from the client agent to any Consul servers. +# TYPE consul_grpc_client_connections gauge +consul_grpc_client_connections 1 +# HELP consul_grpc_client_request_count Counts the number of gRPC requests made by the client agent to a Consul server. +# TYPE consul_grpc_client_request_count counter +consul_grpc_client_request_count 0 +# HELP consul_grpc_server_connection_count Counts the number of new gRPC connections received by the server. +# TYPE consul_grpc_server_connection_count counter +consul_grpc_server_connection_count 853 +# HELP consul_grpc_server_connections Measures the number of active gRPC connections open on the server. +# TYPE consul_grpc_server_connections gauge +consul_grpc_server_connections 1 +# HELP consul_grpc_server_request_count Counts the number of gRPC requests received by the server. +# TYPE consul_grpc_server_request_count counter +consul_grpc_server_request_count 0 +# HELP consul_grpc_server_stream_count Counts the number of new gRPC streams received by the server. +# TYPE consul_grpc_server_stream_count counter +consul_grpc_server_stream_count 0 +# HELP consul_grpc_server_streams Measures the number of active gRPC streams handled by the server. +# TYPE consul_grpc_server_streams gauge +consul_grpc_server_streams 0 +# HELP consul_intention_apply +# TYPE consul_intention_apply summary +consul_intention_apply{quantile="0.5"} NaN +consul_intention_apply{quantile="0.9"} NaN +consul_intention_apply{quantile="0.99"} NaN +consul_intention_apply_sum 0 +consul_intention_apply_count 0 +# HELP consul_kvs_apply Measures the time it takes to complete an update to the KV store. +# TYPE consul_kvs_apply summary +consul_kvs_apply{quantile="0.5"} NaN +consul_kvs_apply{quantile="0.9"} NaN +consul_kvs_apply{quantile="0.99"} NaN +consul_kvs_apply_sum 0 +consul_kvs_apply_count 0 +# HELP consul_leader_barrier Measures the time spent waiting for the raft barrier upon gaining leadership. +# TYPE consul_leader_barrier summary +consul_leader_barrier{quantile="0.5"} NaN +consul_leader_barrier{quantile="0.9"} NaN +consul_leader_barrier{quantile="0.99"} NaN +consul_leader_barrier_sum 115364.21848773956 +consul_leader_barrier_count 1657 +# HELP consul_leader_reapTombstones Measures the time spent clearing tombstones. +# TYPE consul_leader_reapTombstones summary +consul_leader_reapTombstones{quantile="0.5"} NaN +consul_leader_reapTombstones{quantile="0.9"} NaN +consul_leader_reapTombstones{quantile="0.99"} NaN +consul_leader_reapTombstones_sum 26.21475601196289 +consul_leader_reapTombstones_count 1 +# HELP consul_leader_reconcile Measures the time spent updating the raft store from the serf member information. +# TYPE consul_leader_reconcile summary +consul_leader_reconcile{quantile="0.5"} NaN +consul_leader_reconcile{quantile="0.9"} NaN +consul_leader_reconcile{quantile="0.99"} NaN +consul_leader_reconcile_sum 543.0488127619028 +consul_leader_reconcile_count 1657 +# HELP consul_leader_reconcileMember Measures the time spent updating the raft store for a single serf member's information. +# TYPE consul_leader_reconcileMember summary +consul_leader_reconcileMember{quantile="0.5"} NaN +consul_leader_reconcileMember{quantile="0.9"} NaN +consul_leader_reconcileMember{quantile="0.99"} NaN +consul_leader_reconcileMember_sum 511.33584634773433 +consul_leader_reconcileMember_count 4975 +# HELP consul_leader_replication_acl_policies_index Tracks the index of ACL policies in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_policies_index gauge +consul_leader_replication_acl_policies_index 0 +# HELP consul_leader_replication_acl_policies_status Tracks the current health of ACL policy replication on the leader +# TYPE consul_leader_replication_acl_policies_status gauge +consul_leader_replication_acl_policies_status 0 +# HELP consul_leader_replication_acl_roles_index Tracks the index of ACL roles in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_roles_index gauge +consul_leader_replication_acl_roles_index 0 +# HELP consul_leader_replication_acl_roles_status Tracks the current health of ACL role replication on the leader +# TYPE consul_leader_replication_acl_roles_status gauge +consul_leader_replication_acl_roles_status 0 +# HELP consul_leader_replication_acl_tokens_index Tracks the index of ACL tokens in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_tokens_index gauge +consul_leader_replication_acl_tokens_index 0 +# HELP consul_leader_replication_acl_tokens_status Tracks the current health of ACL token replication on the leader +# TYPE consul_leader_replication_acl_tokens_status gauge +consul_leader_replication_acl_tokens_status 0 +# HELP consul_leader_replication_config_entries_index Tracks the index of config entries in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_config_entries_index gauge +consul_leader_replication_config_entries_index 0 +# HELP consul_leader_replication_config_entries_status Tracks the current health of config entry replication on the leader +# TYPE consul_leader_replication_config_entries_status gauge +consul_leader_replication_config_entries_status 0 +# HELP consul_leader_replication_federation_state_index Tracks the index of federation states in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_federation_state_index gauge +consul_leader_replication_federation_state_index 0 +# HELP consul_leader_replication_federation_state_status Tracks the current health of federation state replication on the leader +# TYPE consul_leader_replication_federation_state_status gauge +consul_leader_replication_federation_state_status 0 +# HELP consul_leader_replication_namespaces_index Tracks the index of federation states in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_namespaces_index gauge +consul_leader_replication_namespaces_index 0 +# HELP consul_leader_replication_namespaces_status Tracks the current health of federation state replication on the leader +# TYPE consul_leader_replication_namespaces_status gauge +consul_leader_replication_namespaces_status 0 +# HELP consul_memberlist_gossip consul_memberlist_gossip +# TYPE consul_memberlist_gossip summary +consul_memberlist_gossip{network="lan",quantile="0.5"} 0.02304000034928322 +consul_memberlist_gossip{network="lan",quantile="0.9"} 0.03136000037193298 +consul_memberlist_gossip{network="lan",quantile="0.99"} 0.0756089985370636 +consul_memberlist_gossip_sum{network="lan"} 10881.414362509036 +consul_memberlist_gossip_count{network="lan"} 497026 +consul_memberlist_gossip{network="wan",quantile="0.5"} 0.018719999119639397 +consul_memberlist_gossip{network="wan",quantile="0.9"} 0.029740000143647194 +consul_memberlist_gossip{network="wan",quantile="0.99"} 0.048298001289367676 +consul_memberlist_gossip_sum{network="wan"} 4231.353692025063 +consul_memberlist_gossip_count{network="wan"} 198810 +# HELP consul_memberlist_probeNode consul_memberlist_probeNode +# TYPE consul_memberlist_probeNode summary +consul_memberlist_probeNode{network="lan",quantile="0.5"} 0.8122829794883728 +consul_memberlist_probeNode{network="lan",quantile="0.9"} 1.0762710571289062 +consul_memberlist_probeNode{network="lan",quantile="0.99"} 1.0762710571289062 +consul_memberlist_probeNode_sum{network="lan"} 79954.1767796278 +consul_memberlist_probeNode_count{network="lan"} 94283 +consul_memberlist_probeNode{network="wan",quantile="0.5"} 0.8124139904975891 +consul_memberlist_probeNode{network="wan",quantile="0.9"} 0.9564329981803894 +consul_memberlist_probeNode{network="wan",quantile="0.99"} 0.9564329981803894 +consul_memberlist_probeNode_sum{network="wan"} 17170.356712043285 +consul_memberlist_probeNode_count{network="wan"} 18817 +# HELP consul_memberlist_pushPullNode consul_memberlist_pushPullNode +# TYPE consul_memberlist_pushPullNode summary +consul_memberlist_pushPullNode{network="lan",quantile="0.5"} NaN +consul_memberlist_pushPullNode{network="lan",quantile="0.9"} NaN +consul_memberlist_pushPullNode{network="lan",quantile="0.99"} NaN +consul_memberlist_pushPullNode_sum{network="lan"} 6319.592049598694 +consul_memberlist_pushPullNode_count{network="lan"} 3316 +consul_memberlist_pushPullNode{network="wan",quantile="0.5"} NaN +consul_memberlist_pushPullNode{network="wan",quantile="0.9"} NaN +consul_memberlist_pushPullNode{network="wan",quantile="0.99"} NaN +consul_memberlist_pushPullNode_sum{network="wan"} 3150.5957354307175 +consul_memberlist_pushPullNode_count{network="wan"} 1657 +# HELP consul_memberlist_tcp_accept consul_memberlist_tcp_accept +# TYPE consul_memberlist_tcp_accept counter +consul_memberlist_tcp_accept{network="lan"} 3327 +consul_memberlist_tcp_accept{network="wan"} 1661 +# HELP consul_memberlist_tcp_connect consul_memberlist_tcp_connect +# TYPE consul_memberlist_tcp_connect counter +consul_memberlist_tcp_connect{network="lan"} 3316 +consul_memberlist_tcp_connect{network="wan"} 1657 +# HELP consul_memberlist_tcp_sent consul_memberlist_tcp_sent +# TYPE consul_memberlist_tcp_sent counter +consul_memberlist_tcp_sent{network="lan"} 5.728236e+06 +consul_memberlist_tcp_sent{network="wan"} 2.671365e+06 +# HELP consul_memberlist_udp_received consul_memberlist_udp_received +# TYPE consul_memberlist_udp_received counter +consul_memberlist_udp_received{network="lan"} 2.7072233e+07 +consul_memberlist_udp_received{network="wan"} 5.805281e+06 +# HELP consul_memberlist_udp_sent consul_memberlist_udp_sent +# TYPE consul_memberlist_udp_sent counter +consul_memberlist_udp_sent{network="lan"} 2.7064743e+07 +consul_memberlist_udp_sent{network="wan"} 5.806099e+06 +# HELP consul_mesh_active_root_ca_expiry Seconds until the service mesh root certificate expires. Updated every hour +# TYPE consul_mesh_active_root_ca_expiry gauge +consul_mesh_active_root_ca_expiry NaN +# HELP consul_mesh_active_signing_ca_expiry Seconds until the service mesh signing certificate expires. Updated every hour +# TYPE consul_mesh_active_signing_ca_expiry gauge +consul_mesh_active_signing_ca_expiry NaN +# HELP consul_prepared_query_apply Measures the time it takes to apply a prepared query update. +# TYPE consul_prepared_query_apply summary +consul_prepared_query_apply{quantile="0.5"} NaN +consul_prepared_query_apply{quantile="0.9"} NaN +consul_prepared_query_apply{quantile="0.99"} NaN +consul_prepared_query_apply_sum 0 +consul_prepared_query_apply_count 0 +# HELP consul_prepared_query_execute Measures the time it takes to process a prepared query execute request. +# TYPE consul_prepared_query_execute summary +consul_prepared_query_execute{quantile="0.5"} NaN +consul_prepared_query_execute{quantile="0.9"} NaN +consul_prepared_query_execute{quantile="0.99"} NaN +consul_prepared_query_execute_sum 0 +consul_prepared_query_execute_count 0 +# HELP consul_prepared_query_execute_remote Measures the time it takes to process a prepared query execute request that was forwarded to another datacenter. +# TYPE consul_prepared_query_execute_remote summary +consul_prepared_query_execute_remote{quantile="0.5"} NaN +consul_prepared_query_execute_remote{quantile="0.9"} NaN +consul_prepared_query_execute_remote{quantile="0.99"} NaN +consul_prepared_query_execute_remote_sum 0 +consul_prepared_query_execute_remote_count 0 +# HELP consul_prepared_query_explain Measures the time it takes to process a prepared query explain request. +# TYPE consul_prepared_query_explain summary +consul_prepared_query_explain{quantile="0.5"} NaN +consul_prepared_query_explain{quantile="0.9"} NaN +consul_prepared_query_explain{quantile="0.99"} NaN +consul_prepared_query_explain_sum 0 +consul_prepared_query_explain_count 0 +# HELP consul_raft_applied_index Represents the raft applied index. +# TYPE consul_raft_applied_index gauge +consul_raft_applied_index 452955 +# HELP consul_raft_apply This counts the number of Raft transactions occurring over the interval. +# TYPE consul_raft_apply counter +consul_raft_apply 10681 +# HELP consul_raft_barrier consul_raft_barrier +# TYPE consul_raft_barrier counter +consul_raft_barrier 1657 +# HELP consul_raft_boltdb_freePageBytes consul_raft_boltdb_freePageBytes +# TYPE consul_raft_boltdb_freePageBytes gauge +consul_raft_boltdb_freePageBytes 5.758976e+06 +# HELP consul_raft_boltdb_freelistBytes consul_raft_boltdb_freelistBytes +# TYPE consul_raft_boltdb_freelistBytes gauge +consul_raft_boltdb_freelistBytes 11264 +# HELP consul_raft_boltdb_getLog consul_raft_boltdb_getLog +# TYPE consul_raft_boltdb_getLog summary +consul_raft_boltdb_getLog{quantile="0.5"} 0.030570000410079956 +consul_raft_boltdb_getLog{quantile="0.9"} 0.030570000410079956 +consul_raft_boltdb_getLog{quantile="0.99"} 0.030570000410079956 +consul_raft_boltdb_getLog_sum 630.6968591569457 +consul_raft_boltdb_getLog_count 39046 +# HELP consul_raft_boltdb_logBatchSize consul_raft_boltdb_logBatchSize +# TYPE consul_raft_boltdb_logBatchSize summary +consul_raft_boltdb_logBatchSize{quantile="0.5"} 243 +consul_raft_boltdb_logBatchSize{quantile="0.9"} 243 +consul_raft_boltdb_logBatchSize{quantile="0.99"} 243 +consul_raft_boltdb_logBatchSize_sum 3.567357e+06 +consul_raft_boltdb_logBatchSize_count 12360 +# HELP consul_raft_boltdb_logSize consul_raft_boltdb_logSize +# TYPE consul_raft_boltdb_logSize summary +consul_raft_boltdb_logSize{quantile="0.5"} 243 +consul_raft_boltdb_logSize{quantile="0.9"} 243 +consul_raft_boltdb_logSize{quantile="0.99"} 243 +consul_raft_boltdb_logSize_sum 3.567357e+06 +consul_raft_boltdb_logSize_count 12362 +# HELP consul_raft_boltdb_logsPerBatch consul_raft_boltdb_logsPerBatch +# TYPE consul_raft_boltdb_logsPerBatch summary +consul_raft_boltdb_logsPerBatch{quantile="0.5"} 1 +consul_raft_boltdb_logsPerBatch{quantile="0.9"} 1 +consul_raft_boltdb_logsPerBatch{quantile="0.99"} 1 +consul_raft_boltdb_logsPerBatch_sum 12362 +consul_raft_boltdb_logsPerBatch_count 12360 +# HELP consul_raft_boltdb_numFreePages consul_raft_boltdb_numFreePages +# TYPE consul_raft_boltdb_numFreePages gauge +consul_raft_boltdb_numFreePages 1399 +# HELP consul_raft_boltdb_numPendingPages consul_raft_boltdb_numPendingPages +# TYPE consul_raft_boltdb_numPendingPages gauge +consul_raft_boltdb_numPendingPages 7 +# HELP consul_raft_boltdb_openReadTxn consul_raft_boltdb_openReadTxn +# TYPE consul_raft_boltdb_openReadTxn gauge +consul_raft_boltdb_openReadTxn 0 +# HELP consul_raft_boltdb_storeLogs consul_raft_boltdb_storeLogs +# TYPE consul_raft_boltdb_storeLogs summary +consul_raft_boltdb_storeLogs{quantile="0.5"} 13.176624298095703 +consul_raft_boltdb_storeLogs{quantile="0.9"} 13.176624298095703 +consul_raft_boltdb_storeLogs{quantile="0.99"} 13.176624298095703 +consul_raft_boltdb_storeLogs_sum 651888.0279793739 +consul_raft_boltdb_storeLogs_count 12360 +# HELP consul_raft_boltdb_totalReadTxn consul_raft_boltdb_totalReadTxn +# TYPE consul_raft_boltdb_totalReadTxn counter +consul_raft_boltdb_totalReadTxn 51200 +# HELP consul_raft_boltdb_txstats_cursorCount consul_raft_boltdb_txstats_cursorCount +# TYPE consul_raft_boltdb_txstats_cursorCount counter +consul_raft_boltdb_txstats_cursorCount 139498 +# HELP consul_raft_boltdb_txstats_nodeCount consul_raft_boltdb_txstats_nodeCount +# TYPE consul_raft_boltdb_txstats_nodeCount counter +consul_raft_boltdb_txstats_nodeCount 52400 +# HELP consul_raft_boltdb_txstats_nodeDeref consul_raft_boltdb_txstats_nodeDeref +# TYPE consul_raft_boltdb_txstats_nodeDeref counter +consul_raft_boltdb_txstats_nodeDeref 0 +# HELP consul_raft_boltdb_txstats_pageAlloc consul_raft_boltdb_txstats_pageAlloc +# TYPE consul_raft_boltdb_txstats_pageAlloc gauge +consul_raft_boltdb_txstats_pageAlloc 4.38874112e+08 +# HELP consul_raft_boltdb_txstats_pageCount consul_raft_boltdb_txstats_pageCount +# TYPE consul_raft_boltdb_txstats_pageCount gauge +consul_raft_boltdb_txstats_pageCount 107147 +# HELP consul_raft_boltdb_txstats_rebalance consul_raft_boltdb_txstats_rebalance +# TYPE consul_raft_boltdb_txstats_rebalance counter +consul_raft_boltdb_txstats_rebalance 5869 +# HELP consul_raft_boltdb_txstats_rebalanceTime consul_raft_boltdb_txstats_rebalanceTime +# TYPE consul_raft_boltdb_txstats_rebalanceTime summary +consul_raft_boltdb_txstats_rebalanceTime{quantile="0.5"} 0 +consul_raft_boltdb_txstats_rebalanceTime{quantile="0.9"} 0 +consul_raft_boltdb_txstats_rebalanceTime{quantile="0.99"} 0 +consul_raft_boltdb_txstats_rebalanceTime_sum 3.391055107116699 +consul_raft_boltdb_txstats_rebalanceTime_count 19882 +# HELP consul_raft_boltdb_txstats_spill consul_raft_boltdb_txstats_spill +# TYPE consul_raft_boltdb_txstats_spill counter +consul_raft_boltdb_txstats_spill 51598 +# HELP consul_raft_boltdb_txstats_spillTime consul_raft_boltdb_txstats_spillTime +# TYPE consul_raft_boltdb_txstats_spillTime summary +consul_raft_boltdb_txstats_spillTime{quantile="0.5"} 0 +consul_raft_boltdb_txstats_spillTime{quantile="0.9"} 0.019670000299811363 +consul_raft_boltdb_txstats_spillTime{quantile="0.99"} 0.019670000299811363 +consul_raft_boltdb_txstats_spillTime_sum 372.6177089449484 +consul_raft_boltdb_txstats_spillTime_count 19882 +# HELP consul_raft_boltdb_txstats_split consul_raft_boltdb_txstats_split +# TYPE consul_raft_boltdb_txstats_split counter +consul_raft_boltdb_txstats_split 2154 +# HELP consul_raft_boltdb_txstats_write consul_raft_boltdb_txstats_write +# TYPE consul_raft_boltdb_txstats_write counter +consul_raft_boltdb_txstats_write 76328 +# HELP consul_raft_boltdb_txstats_writeTime consul_raft_boltdb_txstats_writeTime +# TYPE consul_raft_boltdb_txstats_writeTime summary +consul_raft_boltdb_txstats_writeTime{quantile="0.5"} 0 +consul_raft_boltdb_txstats_writeTime{quantile="0.9"} 13.529101371765137 +consul_raft_boltdb_txstats_writeTime{quantile="0.99"} 13.529101371765137 +consul_raft_boltdb_txstats_writeTime_sum 649086.0377488136 +consul_raft_boltdb_txstats_writeTime_count 19882 +# HELP consul_raft_boltdb_writeCapacity consul_raft_boltdb_writeCapacity +# TYPE consul_raft_boltdb_writeCapacity summary +consul_raft_boltdb_writeCapacity{quantile="0.5"} 76.11837005615234 +consul_raft_boltdb_writeCapacity{quantile="0.9"} 76.11837005615234 +consul_raft_boltdb_writeCapacity{quantile="0.99"} 76.11837005615234 +consul_raft_boltdb_writeCapacity_sum 1.1691283255012557e+06 +consul_raft_boltdb_writeCapacity_count 12360 +# HELP consul_raft_commitNumLogs consul_raft_commitNumLogs +# TYPE consul_raft_commitNumLogs gauge +consul_raft_commitNumLogs 1 +# HELP consul_raft_commitTime This measures the time it takes to commit a new entry to the Raft log on the leader. +# TYPE consul_raft_commitTime summary +consul_raft_commitTime{quantile="0.5"} 41.146488189697266 +consul_raft_commitTime{quantile="0.9"} 41.146488189697266 +consul_raft_commitTime{quantile="0.99"} 41.146488189697266 +consul_raft_commitTime_sum 955781.14939785 +consul_raft_commitTime_count 12345 +# HELP consul_raft_fsm_apply consul_raft_fsm_apply +# TYPE consul_raft_fsm_apply summary +consul_raft_fsm_apply{quantile="0.5"} 0.9867730140686035 +consul_raft_fsm_apply{quantile="0.9"} 0.9867730140686035 +consul_raft_fsm_apply{quantile="0.99"} 0.9867730140686035 +consul_raft_fsm_apply_sum 2157.036477720365 +consul_raft_fsm_apply_count 23257 +# HELP consul_raft_fsm_enqueue consul_raft_fsm_enqueue +# TYPE consul_raft_fsm_enqueue summary +consul_raft_fsm_enqueue{quantile="0.5"} 0.01827000081539154 +consul_raft_fsm_enqueue{quantile="0.9"} 0.01827000081539154 +consul_raft_fsm_enqueue{quantile="0.99"} 0.01827000081539154 +consul_raft_fsm_enqueue_sum 312.4720518933609 +consul_raft_fsm_enqueue_count 12345 +# HELP consul_raft_fsm_lastRestoreDuration This measures how long the last FSM restore (from disk or leader) took. +# TYPE consul_raft_fsm_lastRestoreDuration gauge +consul_raft_fsm_lastRestoreDuration 2 +# HELP consul_raft_last_index Represents the raft last index. +# TYPE consul_raft_last_index gauge +consul_raft_last_index 452955 +# HELP consul_raft_leader_dispatchLog consul_raft_leader_dispatchLog +# TYPE consul_raft_leader_dispatchLog summary +consul_raft_leader_dispatchLog{quantile="0.5"} 13.253751754760742 +consul_raft_leader_dispatchLog{quantile="0.9"} 13.253751754760742 +consul_raft_leader_dispatchLog{quantile="0.99"} 13.253751754760742 +consul_raft_leader_dispatchLog_sum 652275.1332504749 +consul_raft_leader_dispatchLog_count 12345 +# HELP consul_raft_leader_dispatchNumLogs consul_raft_leader_dispatchNumLogs +# TYPE consul_raft_leader_dispatchNumLogs gauge +consul_raft_leader_dispatchNumLogs 1 +# HELP consul_raft_leader_lastContact Measures the time since the leader was last able to contact the follower nodes when checking its leader lease. +# TYPE consul_raft_leader_lastContact summary +consul_raft_leader_lastContact{quantile="0.5"} 33 +consul_raft_leader_lastContact{quantile="0.9"} 68 +consul_raft_leader_lastContact{quantile="0.99"} 68 +consul_raft_leader_lastContact_sum 3.0669e+06 +consul_raft_leader_lastContact_count 80917 +# HELP consul_raft_leader_oldestLogAge This measures how old the oldest log in the leader's log store is. +# TYPE consul_raft_leader_oldestLogAge gauge +consul_raft_leader_oldestLogAge 1.66046464e+08 +# HELP consul_raft_replication_appendEntries_logs consul_raft_replication_appendEntries_logs +# TYPE consul_raft_replication_appendEntries_logs counter +consul_raft_replication_appendEntries_logs{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae"} 12346 +consul_raft_replication_appendEntries_logs{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7"} 12346 +# HELP consul_raft_replication_appendEntries_logs_3e75e0af_859b_83e8_779f_f3a6d12f02ae consul_raft_replication_appendEntries_logs_3e75e0af_859b_83e8_779f_f3a6d12f02ae +# TYPE consul_raft_replication_appendEntries_logs_3e75e0af_859b_83e8_779f_f3a6d12f02ae counter +consul_raft_replication_appendEntries_logs_3e75e0af_859b_83e8_779f_f3a6d12f02ae 12346 +# HELP consul_raft_replication_appendEntries_logs_72849161_41cb_14df_fc9b_563ddff3bae7 consul_raft_replication_appendEntries_logs_72849161_41cb_14df_fc9b_563ddff3bae7 +# TYPE consul_raft_replication_appendEntries_logs_72849161_41cb_14df_fc9b_563ddff3bae7 counter +consul_raft_replication_appendEntries_logs_72849161_41cb_14df_fc9b_563ddff3bae7 12346 +# HELP consul_raft_replication_appendEntries_rpc consul_raft_replication_appendEntries_rpc +# TYPE consul_raft_replication_appendEntries_rpc summary +consul_raft_replication_appendEntries_rpc{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.5"} 0.7382550239562988 +consul_raft_replication_appendEntries_rpc{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.9"} 1.030032992362976 +consul_raft_replication_appendEntries_rpc{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.99"} 3.7775509357452393 +consul_raft_replication_appendEntries_rpc_sum{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae"} 3.243855408252254e+06 +consul_raft_replication_appendEntries_rpc_count{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae"} 1.317473e+06 +consul_raft_replication_appendEntries_rpc{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.5"} 0.6895250082015991 +consul_raft_replication_appendEntries_rpc{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.9"} 0.9500619769096375 +consul_raft_replication_appendEntries_rpc{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.99"} 1.682297945022583 +consul_raft_replication_appendEntries_rpc_sum{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7"} 3.2418369520926476e+06 +consul_raft_replication_appendEntries_rpc_count{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7"} 1.317366e+06 +# HELP consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae +# TYPE consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae summary +consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.5"} 0.7751650214195251 +consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.9"} 1.1017019748687744 +consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.99"} 3.81791090965271 +consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae_sum 3.299558741098821e+06 +consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae_count 1.317473e+06 +# HELP consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7 consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7 +# TYPE consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7 summary +consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.5"} 0.7417550086975098 +consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.9"} 1.0077530145645142 +consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.99"} 1.726017951965332 +consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7_sum 3.2977981372908056e+06 +consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7_count 1.317366e+06 +# HELP consul_raft_replication_heartbeat consul_raft_replication_heartbeat +# TYPE consul_raft_replication_heartbeat summary +consul_raft_replication_heartbeat{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.5"} 0.5587760210037231 +consul_raft_replication_heartbeat{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.9"} 1.304479956626892 +consul_raft_replication_heartbeat{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.99"} 1.4234989881515503 +consul_raft_replication_heartbeat_sum{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae"} 103812.21699500084 +consul_raft_replication_heartbeat_count{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae"} 132454 +consul_raft_replication_heartbeat{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.5"} 0.5443660020828247 +consul_raft_replication_heartbeat{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.9"} 0.9280639886856079 +consul_raft_replication_heartbeat{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.99"} 1.0106929540634155 +consul_raft_replication_heartbeat_sum{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7"} 96512.05100156367 +consul_raft_replication_heartbeat_count{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7"} 132488 +# HELP consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae +# TYPE consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae summary +consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.5"} 0.5922750234603882 +consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.9"} 1.3319799900054932 +consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.99"} 1.454179048538208 +consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae_sum 108115.97687250376 +consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae_count 132454 +# HELP consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7 consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7 +# TYPE consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7 summary +consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.5"} 0.5915359854698181 +consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.9"} 0.9649440050125122 +consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.99"} 1.0576729774475098 +consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7_sum 100780.49696727097 +consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7_count 132488 +# HELP consul_raft_rpc_installSnapshot Measures the time it takes the raft leader to install a snapshot on a follower that is catching up after being down or has just joined the cluster. +# TYPE consul_raft_rpc_installSnapshot summary +consul_raft_rpc_installSnapshot{quantile="0.5"} NaN +consul_raft_rpc_installSnapshot{quantile="0.9"} NaN +consul_raft_rpc_installSnapshot{quantile="0.99"} NaN +consul_raft_rpc_installSnapshot_sum 0 +consul_raft_rpc_installSnapshot_count 0 +# HELP consul_raft_snapshot_persist Measures the time it takes raft to write a new snapshot to disk. +# TYPE consul_raft_snapshot_persist summary +consul_raft_snapshot_persist{quantile="0.5"} NaN +consul_raft_snapshot_persist{quantile="0.9"} NaN +consul_raft_snapshot_persist{quantile="0.99"} NaN +consul_raft_snapshot_persist_sum 0.7742639780044556 +consul_raft_snapshot_persist_count 1 +# HELP consul_raft_state_candidate This increments whenever a Consul server starts an election. +# TYPE consul_raft_state_candidate counter +consul_raft_state_candidate 1 +# HELP consul_raft_state_leader This increments whenever a Consul server becomes a leader. +# TYPE consul_raft_state_leader counter +consul_raft_state_leader 1 +# HELP consul_raft_thread_fsm_saturation consul_raft_thread_fsm_saturation +# TYPE consul_raft_thread_fsm_saturation summary +consul_raft_thread_fsm_saturation{quantile="0.5"} 0 +consul_raft_thread_fsm_saturation{quantile="0.9"} 0 +consul_raft_thread_fsm_saturation{quantile="0.99"} 0 +consul_raft_thread_fsm_saturation_sum 0.09000000357627869 +consul_raft_thread_fsm_saturation_count 11923 +# HELP consul_raft_thread_main_saturation consul_raft_thread_main_saturation +# TYPE consul_raft_thread_main_saturation summary +consul_raft_thread_main_saturation{quantile="0.5"} 0 +consul_raft_thread_main_saturation{quantile="0.9"} 0 +consul_raft_thread_main_saturation{quantile="0.99"} 0 +consul_raft_thread_main_saturation_sum 205.40999860689044 +consul_raft_thread_main_saturation_count 43067 +# HELP consul_raft_verify_leader consul_raft_verify_leader +# TYPE consul_raft_verify_leader counter +consul_raft_verify_leader 364 +# HELP consul_rpc_accept_conn Increments when a server accepts an RPC connection. +# TYPE consul_rpc_accept_conn counter +consul_rpc_accept_conn 864 +# HELP consul_rpc_consistentRead Measures the time spent confirming that a consistent read can be performed. +# TYPE consul_rpc_consistentRead summary +consul_rpc_consistentRead{quantile="0.5"} NaN +consul_rpc_consistentRead{quantile="0.9"} NaN +consul_rpc_consistentRead{quantile="0.99"} NaN +consul_rpc_consistentRead_sum 293.6328800059855 +consul_rpc_consistentRead_count 364 +# HELP consul_rpc_cross_dc Increments when a server sends a (potentially blocking) cross datacenter RPC query. +# TYPE consul_rpc_cross_dc counter +consul_rpc_cross_dc 0 +# HELP consul_rpc_queries_blocking Shows the current number of in-flight blocking queries the server is handling. +# TYPE consul_rpc_queries_blocking gauge +consul_rpc_queries_blocking 1 +# HELP consul_rpc_query Increments when a server receives a read request, indicating the rate of new read queries. +# TYPE consul_rpc_query counter +consul_rpc_query 2559 +# HELP consul_rpc_raft_handoff Increments when a server accepts a Raft-related RPC connection. +# TYPE consul_rpc_raft_handoff counter +consul_rpc_raft_handoff 2 +# HELP consul_rpc_request Increments when a server receives a Consul-related RPC request. +# TYPE consul_rpc_request counter +consul_rpc_request 159034 +# HELP consul_rpc_request_error Increments when a server returns an error from an RPC request. +# TYPE consul_rpc_request_error counter +consul_rpc_request_error 0 +# HELP consul_runtime_alloc_bytes consul_runtime_alloc_bytes +# TYPE consul_runtime_alloc_bytes gauge +consul_runtime_alloc_bytes 5.3065368e+07 +# HELP consul_runtime_free_count consul_runtime_free_count +# TYPE consul_runtime_free_count gauge +consul_runtime_free_count 7.33623104e+08 +# HELP consul_runtime_gc_pause_ns consul_runtime_gc_pause_ns +# TYPE consul_runtime_gc_pause_ns summary +consul_runtime_gc_pause_ns{quantile="0.5"} NaN +consul_runtime_gc_pause_ns{quantile="0.9"} NaN +consul_runtime_gc_pause_ns{quantile="0.99"} NaN +consul_runtime_gc_pause_ns_sum 1.372001275e+09 +consul_runtime_gc_pause_ns_count 3761 +# HELP consul_runtime_heap_objects consul_runtime_heap_objects +# TYPE consul_runtime_heap_objects gauge +consul_runtime_heap_objects 227577 +# HELP consul_runtime_malloc_count consul_runtime_malloc_count +# TYPE consul_runtime_malloc_count gauge +consul_runtime_malloc_count 7.33850688e+08 +# HELP consul_runtime_num_goroutines consul_runtime_num_goroutines +# TYPE consul_runtime_num_goroutines gauge +consul_runtime_num_goroutines 132 +# HELP consul_runtime_sys_bytes consul_runtime_sys_bytes +# TYPE consul_runtime_sys_bytes gauge +consul_runtime_sys_bytes 8.495516e+07 +# HELP consul_runtime_total_gc_pause_ns consul_runtime_total_gc_pause_ns +# TYPE consul_runtime_total_gc_pause_ns gauge +consul_runtime_total_gc_pause_ns 1.37200128e+09 +# HELP consul_runtime_total_gc_runs consul_runtime_total_gc_runs +# TYPE consul_runtime_total_gc_runs gauge +consul_runtime_total_gc_runs 3761 +# HELP consul_serf_coordinate_adjustment_ms consul_serf_coordinate_adjustment_ms +# TYPE consul_serf_coordinate_adjustment_ms summary +consul_serf_coordinate_adjustment_ms{network="lan",quantile="0.5"} 0.1953909993171692 +consul_serf_coordinate_adjustment_ms{network="lan",quantile="0.9"} 0.2344750016927719 +consul_serf_coordinate_adjustment_ms{network="lan",quantile="0.99"} 0.2344750016927719 +consul_serf_coordinate_adjustment_ms_sum{network="lan"} 20281.621190846952 +consul_serf_coordinate_adjustment_ms_count{network="lan"} 94283 +consul_serf_coordinate_adjustment_ms{network="wan",quantile="0.5"} 0.19766099750995636 +consul_serf_coordinate_adjustment_ms{network="wan",quantile="0.9"} 0.20183999836444855 +consul_serf_coordinate_adjustment_ms{network="wan",quantile="0.99"} 0.20183999836444855 +consul_serf_coordinate_adjustment_ms_sum{network="wan"} 4030.8057950612783 +consul_serf_coordinate_adjustment_ms_count{network="wan"} 18817 +# HELP consul_serf_queue_Event consul_serf_queue_Event +# TYPE consul_serf_queue_Event summary +consul_serf_queue_Event{network="lan",quantile="0.5"} NaN +consul_serf_queue_Event{network="lan",quantile="0.9"} NaN +consul_serf_queue_Event{network="lan",quantile="0.99"} NaN +consul_serf_queue_Event_sum{network="lan"} 0 +consul_serf_queue_Event_count{network="lan"} 3313 +consul_serf_queue_Event{network="wan",quantile="0.5"} NaN +consul_serf_queue_Event{network="wan",quantile="0.9"} NaN +consul_serf_queue_Event{network="wan",quantile="0.99"} NaN +consul_serf_queue_Event_sum{network="wan"} 0 +consul_serf_queue_Event_count{network="wan"} 3313 +# HELP consul_serf_queue_Intent consul_serf_queue_Intent +# TYPE consul_serf_queue_Intent summary +consul_serf_queue_Intent{network="lan",quantile="0.5"} NaN +consul_serf_queue_Intent{network="lan",quantile="0.9"} NaN +consul_serf_queue_Intent{network="lan",quantile="0.99"} NaN +consul_serf_queue_Intent_sum{network="lan"} 0 +consul_serf_queue_Intent_count{network="lan"} 3313 +consul_serf_queue_Intent{network="wan",quantile="0.5"} NaN +consul_serf_queue_Intent{network="wan",quantile="0.9"} NaN +consul_serf_queue_Intent{network="wan",quantile="0.99"} NaN +consul_serf_queue_Intent_sum{network="wan"} 0 +consul_serf_queue_Intent_count{network="wan"} 3313 +# HELP consul_serf_queue_Query consul_serf_queue_Query +# TYPE consul_serf_queue_Query summary +consul_serf_queue_Query{network="lan",quantile="0.5"} NaN +consul_serf_queue_Query{network="lan",quantile="0.9"} NaN +consul_serf_queue_Query{network="lan",quantile="0.99"} NaN +consul_serf_queue_Query_sum{network="lan"} 0 +consul_serf_queue_Query_count{network="lan"} 3313 +consul_serf_queue_Query{network="wan",quantile="0.5"} NaN +consul_serf_queue_Query{network="wan",quantile="0.9"} NaN +consul_serf_queue_Query{network="wan",quantile="0.99"} NaN +consul_serf_queue_Query_sum{network="wan"} 0 +consul_serf_queue_Query_count{network="wan"} 3313 +# HELP consul_server_isLeader Tracks if the server is a leader. +# TYPE consul_server_isLeader gauge +consul_server_isLeader 1 +# HELP consul_session_apply Measures the time spent applying a session update. +# TYPE consul_session_apply summary +consul_session_apply{quantile="0.5"} NaN +consul_session_apply{quantile="0.9"} NaN +consul_session_apply{quantile="0.99"} NaN +consul_session_apply_sum 0 +consul_session_apply_count 0 +# HELP consul_session_renew Measures the time spent renewing a session. +# TYPE consul_session_renew summary +consul_session_renew{quantile="0.5"} NaN +consul_session_renew{quantile="0.9"} NaN +consul_session_renew{quantile="0.99"} NaN +consul_session_renew_sum 0 +consul_session_renew_count 0 +# HELP consul_session_ttl_active Tracks the active number of sessions being tracked. +# TYPE consul_session_ttl_active gauge +consul_session_ttl_active 0 +# HELP consul_session_ttl_invalidate Measures the time spent invalidating an expired session. +# TYPE consul_session_ttl_invalidate summary +consul_session_ttl_invalidate{quantile="0.5"} NaN +consul_session_ttl_invalidate{quantile="0.9"} NaN +consul_session_ttl_invalidate{quantile="0.99"} NaN +consul_session_ttl_invalidate_sum 0 +consul_session_ttl_invalidate_count 0 +# HELP consul_txn_apply Measures the time spent applying a transaction operation. +# TYPE consul_txn_apply summary +consul_txn_apply{quantile="0.5"} NaN +consul_txn_apply{quantile="0.9"} NaN +consul_txn_apply{quantile="0.99"} NaN +consul_txn_apply_sum 0 +consul_txn_apply_count 0 +# HELP consul_txn_read Measures the time spent returning a read transaction. +# TYPE consul_txn_read summary +consul_txn_read{quantile="0.5"} NaN +consul_txn_read{quantile="0.9"} NaN +consul_txn_read{quantile="0.99"} NaN +consul_txn_read_sum 0 +consul_txn_read_count 0 +# HELP consul_version Represents the Consul version. +# TYPE consul_version gauge +consul_version 0 +# HELP consul_xds_server_streams Measures the number of active xDS streams handled by the server split by protocol version. +# TYPE consul_xds_server_streams gauge +consul_xds_server_streams 0 +# HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles. +# TYPE go_gc_duration_seconds summary +go_gc_duration_seconds{quantile="0"} 4.9921e-05 +go_gc_duration_seconds{quantile="0.25"} 0.00010804 +go_gc_duration_seconds{quantile="0.5"} 0.00016214 +go_gc_duration_seconds{quantile="0.75"} 0.000549655 +go_gc_duration_seconds{quantile="1"} 0.003364656 +go_gc_duration_seconds_sum 1.3724735909999999 +go_gc_duration_seconds_count 3762 +# HELP go_goroutines Number of goroutines that currently exist. +# TYPE go_goroutines gauge +go_goroutines 137 +# HELP go_info Information about the Go environment. +# TYPE go_info gauge +go_info{version="go1.18.1"} 1 +# HELP go_memstats_alloc_bytes Number of bytes allocated and still in use. +# TYPE go_memstats_alloc_bytes gauge +go_memstats_alloc_bytes 2.6647944e+07 +# HELP go_memstats_alloc_bytes_total Total number of bytes allocated, even if freed. +# TYPE go_memstats_alloc_bytes_total counter +go_memstats_alloc_bytes_total 9.1199946672e+10 +# HELP go_memstats_buck_hash_sys_bytes Number of bytes used by the profiling bucket hash table. +# TYPE go_memstats_buck_hash_sys_bytes gauge +go_memstats_buck_hash_sys_bytes 2.497531e+06 +# HELP go_memstats_frees_total Total number of frees. +# TYPE go_memstats_frees_total counter +go_memstats_frees_total 7.33814669e+08 +# HELP go_memstats_gc_cpu_fraction The fraction of this program's available CPU time used by the GC since the program started. +# TYPE go_memstats_gc_cpu_fraction gauge +go_memstats_gc_cpu_fraction 4.2228338057402265e-05 +# HELP go_memstats_gc_sys_bytes Number of bytes used for garbage collection system metadata. +# TYPE go_memstats_gc_sys_bytes gauge +go_memstats_gc_sys_bytes 8.927624e+06 +# HELP go_memstats_heap_alloc_bytes Number of heap bytes allocated and still in use. +# TYPE go_memstats_heap_alloc_bytes gauge +go_memstats_heap_alloc_bytes 2.6647944e+07 +# HELP go_memstats_heap_idle_bytes Number of heap bytes waiting to be used. +# TYPE go_memstats_heap_idle_bytes gauge +go_memstats_heap_idle_bytes 3.3161216e+07 +# HELP go_memstats_heap_inuse_bytes Number of heap bytes that are in use. +# TYPE go_memstats_heap_inuse_bytes gauge +go_memstats_heap_inuse_bytes 3.620864e+07 +# HELP go_memstats_heap_objects Number of allocated objects. +# TYPE go_memstats_heap_objects gauge +go_memstats_heap_objects 49363 +# HELP go_memstats_heap_released_bytes Number of heap bytes released to OS. +# TYPE go_memstats_heap_released_bytes gauge +go_memstats_heap_released_bytes 9.936896e+06 +# HELP go_memstats_heap_sys_bytes Number of heap bytes obtained from system. +# TYPE go_memstats_heap_sys_bytes gauge +go_memstats_heap_sys_bytes 6.9369856e+07 +# HELP go_memstats_last_gc_time_seconds Number of seconds since 1970 of last garbage collection. +# TYPE go_memstats_last_gc_time_seconds gauge +go_memstats_last_gc_time_seconds 1.6713685789559276e+09 +# HELP go_memstats_lookups_total Total number of pointer lookups. +# TYPE go_memstats_lookups_total counter +go_memstats_lookups_total 0 +# HELP go_memstats_mallocs_total Total number of mallocs. +# TYPE go_memstats_mallocs_total counter +go_memstats_mallocs_total 7.33864032e+08 +# HELP go_memstats_mcache_inuse_bytes Number of bytes in use by mcache structures. +# TYPE go_memstats_mcache_inuse_bytes gauge +go_memstats_mcache_inuse_bytes 9600 +# HELP go_memstats_mcache_sys_bytes Number of bytes used for mcache structures obtained from system. +# TYPE go_memstats_mcache_sys_bytes gauge +go_memstats_mcache_sys_bytes 15600 +# HELP go_memstats_mspan_inuse_bytes Number of bytes in use by mspan structures. +# TYPE go_memstats_mspan_inuse_bytes gauge +go_memstats_mspan_inuse_bytes 413168 +# HELP go_memstats_mspan_sys_bytes Number of bytes used for mspan structures obtained from system. +# TYPE go_memstats_mspan_sys_bytes gauge +go_memstats_mspan_sys_bytes 620160 +# HELP go_memstats_next_gc_bytes Number of heap bytes when next garbage collection will take place. +# TYPE go_memstats_next_gc_bytes gauge +go_memstats_next_gc_bytes 5.3447888e+07 +# HELP go_memstats_other_sys_bytes Number of bytes used for other system allocations. +# TYPE go_memstats_other_sys_bytes gauge +go_memstats_other_sys_bytes 1.591077e+06 +# HELP go_memstats_stack_inuse_bytes Number of bytes in use by the stack allocator. +# TYPE go_memstats_stack_inuse_bytes gauge +go_memstats_stack_inuse_bytes 1.933312e+06 +# HELP go_memstats_stack_sys_bytes Number of bytes obtained from system for stack allocator. +# TYPE go_memstats_stack_sys_bytes gauge +go_memstats_stack_sys_bytes 1.933312e+06 +# HELP go_memstats_sys_bytes Number of bytes obtained from system. +# TYPE go_memstats_sys_bytes gauge +go_memstats_sys_bytes 8.495516e+07 +# HELP go_threads Number of OS threads created. +# TYPE go_threads gauge +go_threads 15 +# HELP process_cpu_seconds_total Total user and system CPU time spent in seconds. +# TYPE process_cpu_seconds_total counter +process_cpu_seconds_total 3612.93 +# HELP process_max_fds Maximum number of open file descriptors. +# TYPE process_max_fds gauge +process_max_fds 1024 +# HELP process_open_fds Number of open file descriptors. +# TYPE process_open_fds gauge +process_open_fds 35 +# HELP process_resident_memory_bytes Resident memory size in bytes. +# TYPE process_resident_memory_bytes gauge +process_resident_memory_bytes 1.53645056e+08 +# HELP process_start_time_seconds Start time of the process since unix epoch in seconds. +# TYPE process_start_time_seconds gauge +process_start_time_seconds 1.67126917263e+09 +# HELP process_virtual_memory_bytes Virtual memory size in bytes. +# TYPE process_virtual_memory_bytes gauge +process_virtual_memory_bytes 9.18421504e+08 +# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes. +# TYPE process_virtual_memory_max_bytes gauge +process_virtual_memory_max_bytes -1
\ No newline at end of file diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-metrics_with_hostname.txt b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-metrics_with_hostname.txt new file mode 100644 index 000000000..a5df1d586 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-metrics_with_hostname.txt @@ -0,0 +1,1509 @@ +# HELP consul_acl_ResolveToken This measures the time it takes to resolve an ACL token. +# TYPE consul_acl_ResolveToken summary +consul_acl_ResolveToken{quantile="0.5"} NaN +consul_acl_ResolveToken{quantile="0.9"} NaN +consul_acl_ResolveToken{quantile="0.99"} NaN +consul_acl_ResolveToken_sum 0 +consul_acl_ResolveToken_count 0 +# HELP consul_acl_authmethod_delete +# TYPE consul_acl_authmethod_delete summary +consul_acl_authmethod_delete{quantile="0.5"} NaN +consul_acl_authmethod_delete{quantile="0.9"} NaN +consul_acl_authmethod_delete{quantile="0.99"} NaN +consul_acl_authmethod_delete_sum 0 +consul_acl_authmethod_delete_count 0 +# HELP consul_acl_authmethod_upsert +# TYPE consul_acl_authmethod_upsert summary +consul_acl_authmethod_upsert{quantile="0.5"} NaN +consul_acl_authmethod_upsert{quantile="0.9"} NaN +consul_acl_authmethod_upsert{quantile="0.99"} NaN +consul_acl_authmethod_upsert_sum 0 +consul_acl_authmethod_upsert_count 0 +# HELP consul_acl_bindingrule_delete +# TYPE consul_acl_bindingrule_delete summary +consul_acl_bindingrule_delete{quantile="0.5"} NaN +consul_acl_bindingrule_delete{quantile="0.9"} NaN +consul_acl_bindingrule_delete{quantile="0.99"} NaN +consul_acl_bindingrule_delete_sum 0 +consul_acl_bindingrule_delete_count 0 +# HELP consul_acl_bindingrule_upsert +# TYPE consul_acl_bindingrule_upsert summary +consul_acl_bindingrule_upsert{quantile="0.5"} NaN +consul_acl_bindingrule_upsert{quantile="0.9"} NaN +consul_acl_bindingrule_upsert{quantile="0.99"} NaN +consul_acl_bindingrule_upsert_sum 0 +consul_acl_bindingrule_upsert_count 0 +# HELP consul_acl_blocked_check_deregistration Increments whenever a deregistration fails for a check (blocked by an ACL) +# TYPE consul_acl_blocked_check_deregistration counter +consul_acl_blocked_check_deregistration 0 +# HELP consul_acl_blocked_check_registration Increments whenever a registration fails for a check (blocked by an ACL) +# TYPE consul_acl_blocked_check_registration counter +consul_acl_blocked_check_registration 0 +# HELP consul_acl_blocked_node_registration Increments whenever a registration fails for a node (blocked by an ACL) +# TYPE consul_acl_blocked_node_registration counter +consul_acl_blocked_node_registration 0 +# HELP consul_acl_blocked_service_deregistration Increments whenever a deregistration fails for a service (blocked by an ACL) +# TYPE consul_acl_blocked_service_deregistration counter +consul_acl_blocked_service_deregistration 0 +# HELP consul_acl_blocked_service_registration Increments whenever a registration fails for a service (blocked by an ACL) +# TYPE consul_acl_blocked_service_registration counter +consul_acl_blocked_service_registration 0 +# HELP consul_acl_login +# TYPE consul_acl_login summary +consul_acl_login{quantile="0.5"} NaN +consul_acl_login{quantile="0.9"} NaN +consul_acl_login{quantile="0.99"} NaN +consul_acl_login_sum 0 +consul_acl_login_count 0 +# HELP consul_acl_logout +# TYPE consul_acl_logout summary +consul_acl_logout{quantile="0.5"} NaN +consul_acl_logout{quantile="0.9"} NaN +consul_acl_logout{quantile="0.99"} NaN +consul_acl_logout_sum 0 +consul_acl_logout_count 0 +# HELP consul_acl_policy_delete +# TYPE consul_acl_policy_delete summary +consul_acl_policy_delete{quantile="0.5"} NaN +consul_acl_policy_delete{quantile="0.9"} NaN +consul_acl_policy_delete{quantile="0.99"} NaN +consul_acl_policy_delete_sum 0 +consul_acl_policy_delete_count 0 +# HELP consul_acl_policy_upsert +# TYPE consul_acl_policy_upsert summary +consul_acl_policy_upsert{quantile="0.5"} NaN +consul_acl_policy_upsert{quantile="0.9"} NaN +consul_acl_policy_upsert{quantile="0.99"} NaN +consul_acl_policy_upsert_sum 0 +consul_acl_policy_upsert_count 0 +# HELP consul_acl_role_delete +# TYPE consul_acl_role_delete summary +consul_acl_role_delete{quantile="0.5"} NaN +consul_acl_role_delete{quantile="0.9"} NaN +consul_acl_role_delete{quantile="0.99"} NaN +consul_acl_role_delete_sum 0 +consul_acl_role_delete_count 0 +# HELP consul_acl_role_upsert +# TYPE consul_acl_role_upsert summary +consul_acl_role_upsert{quantile="0.5"} NaN +consul_acl_role_upsert{quantile="0.9"} NaN +consul_acl_role_upsert{quantile="0.99"} NaN +consul_acl_role_upsert_sum 0 +consul_acl_role_upsert_count 0 +# HELP consul_acl_token_cache_hit Increments if Consul is able to resolve a token's identity, or a legacy token, from the cache. +# TYPE consul_acl_token_cache_hit counter +consul_acl_token_cache_hit 0 +# HELP consul_acl_token_cache_miss Increments if Consul cannot resolve a token's identity, or a legacy token, from the cache. +# TYPE consul_acl_token_cache_miss counter +consul_acl_token_cache_miss 0 +# HELP consul_acl_token_clone +# TYPE consul_acl_token_clone summary +consul_acl_token_clone{quantile="0.5"} NaN +consul_acl_token_clone{quantile="0.9"} NaN +consul_acl_token_clone{quantile="0.99"} NaN +consul_acl_token_clone_sum 0 +consul_acl_token_clone_count 0 +# HELP consul_acl_token_delete +# TYPE consul_acl_token_delete summary +consul_acl_token_delete{quantile="0.5"} NaN +consul_acl_token_delete{quantile="0.9"} NaN +consul_acl_token_delete{quantile="0.99"} NaN +consul_acl_token_delete_sum 0 +consul_acl_token_delete_count 0 +# HELP consul_acl_token_upsert +# TYPE consul_acl_token_upsert summary +consul_acl_token_upsert{quantile="0.5"} NaN +consul_acl_token_upsert{quantile="0.9"} NaN +consul_acl_token_upsert{quantile="0.99"} NaN +consul_acl_token_upsert_sum 0 +consul_acl_token_upsert_count 0 +# HELP consul_agent_tls_cert_expiry Seconds until the agent tls certificate expires. Updated every hour +# TYPE consul_agent_tls_cert_expiry gauge +consul_agent_tls_cert_expiry 0 +# HELP consul_api_http Samples how long it takes to service the given HTTP request for the given verb and path. +# TYPE consul_api_http summary +consul_api_http{quantile="0.5"} NaN +consul_api_http{quantile="0.9"} NaN +consul_api_http{quantile="0.99"} NaN +consul_api_http_sum 0 +consul_api_http_count 0 +consul_api_http{method="GET",path="v1_agent_checks",quantile="0.5"} 0.10910899937152863 +consul_api_http{method="GET",path="v1_agent_checks",quantile="0.9"} 0.2985079884529114 +consul_api_http{method="GET",path="v1_agent_checks",quantile="0.99"} 0.2985079884529114 +consul_api_http_sum{method="GET",path="v1_agent_checks"} 85.87442895025015 +consul_api_http_count{method="GET",path="v1_agent_checks"} 588 +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.5"} 0.5271260142326355 +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.9"} 1.2289390563964844 +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.99"} 1.2289390563964844 +consul_api_http_sum{method="GET",path="v1_agent_metrics"} 409.6580027639866 +consul_api_http_count{method="GET",path="v1_agent_metrics"} 592 +# HELP consul_autopilot_failure_tolerance Tracks the number of voting servers that the cluster can lose while continuing to function. +# TYPE consul_autopilot_failure_tolerance gauge +consul_autopilot_failure_tolerance 0 +# HELP consul_autopilot_healthy Tracks the overall health of the local server cluster. 1 if all servers are healthy, 0 if one or more are unhealthy. +# TYPE consul_autopilot_healthy gauge +consul_autopilot_healthy 0 +# HELP consul_catalog_connect_not_found Increments for each connect-based catalog query where the given service could not be found. +# TYPE consul_catalog_connect_not_found counter +consul_catalog_connect_not_found 0 +# HELP consul_catalog_connect_query Increments for each connect-based catalog query for the given service. +# TYPE consul_catalog_connect_query counter +consul_catalog_connect_query 0 +# HELP consul_catalog_connect_query_tag Increments for each connect-based catalog query for the given service with the given tag. +# TYPE consul_catalog_connect_query_tag counter +consul_catalog_connect_query_tag 0 +# HELP consul_catalog_connect_query_tags Increments for each connect-based catalog query for the given service with the given tags. +# TYPE consul_catalog_connect_query_tags counter +consul_catalog_connect_query_tags 0 +# HELP consul_catalog_deregister Measures the time it takes to complete a catalog deregister operation. +# TYPE consul_catalog_deregister summary +consul_catalog_deregister{quantile="0.5"} NaN +consul_catalog_deregister{quantile="0.9"} NaN +consul_catalog_deregister{quantile="0.99"} NaN +consul_catalog_deregister_sum 0 +consul_catalog_deregister_count 0 +# HELP consul_catalog_register Measures the time it takes to complete a catalog register operation. +# TYPE consul_catalog_register summary +consul_catalog_register{quantile="0.5"} NaN +consul_catalog_register{quantile="0.9"} NaN +consul_catalog_register{quantile="0.99"} NaN +consul_catalog_register_sum 45.98546886444092 +consul_catalog_register_count 2 +# HELP consul_catalog_service_not_found Increments for each catalog query where the given service could not be found. +# TYPE consul_catalog_service_not_found counter +consul_catalog_service_not_found 0 +# HELP consul_catalog_service_query Increments for each catalog query for the given service. +# TYPE consul_catalog_service_query counter +consul_catalog_service_query 0 +# HELP consul_catalog_service_query_tag Increments for each catalog query for the given service with the given tag. +# TYPE consul_catalog_service_query_tag counter +consul_catalog_service_query_tag 0 +# HELP consul_catalog_service_query_tags Increments for each catalog query for the given service with the given tags. +# TYPE consul_catalog_service_query_tags counter +consul_catalog_service_query_tags 0 +# HELP consul_client_api_catalog_datacenters Increments whenever a Consul agent receives a request to list datacenters in the catalog. +# TYPE consul_client_api_catalog_datacenters counter +consul_client_api_catalog_datacenters 0 +# HELP consul_client_api_catalog_deregister Increments whenever a Consul agent receives a catalog deregister request. +# TYPE consul_client_api_catalog_deregister counter +consul_client_api_catalog_deregister 0 +# HELP consul_client_api_catalog_gateway_services Increments whenever a Consul agent receives a request to list services associated with a gateway. +# TYPE consul_client_api_catalog_gateway_services counter +consul_client_api_catalog_gateway_services 0 +# HELP consul_client_api_catalog_node_service_list Increments whenever a Consul agent receives a request to list a node's registered services. +# TYPE consul_client_api_catalog_node_service_list counter +consul_client_api_catalog_node_service_list 0 +# HELP consul_client_api_catalog_node_services Increments whenever a Consul agent successfully responds to a request to list nodes offering a service. +# TYPE consul_client_api_catalog_node_services counter +consul_client_api_catalog_node_services 0 +# HELP consul_client_api_catalog_nodes Increments whenever a Consul agent receives a request to list nodes from the catalog. +# TYPE consul_client_api_catalog_nodes counter +consul_client_api_catalog_nodes 0 +# HELP consul_client_api_catalog_register Increments whenever a Consul agent receives a catalog register request. +# TYPE consul_client_api_catalog_register counter +consul_client_api_catalog_register 0 +# HELP consul_client_api_catalog_service_nodes Increments whenever a Consul agent receives a request to list nodes offering a service. +# TYPE consul_client_api_catalog_service_nodes counter +consul_client_api_catalog_service_nodes 0 +# HELP consul_client_api_catalog_services Increments whenever a Consul agent receives a request to list services from the catalog. +# TYPE consul_client_api_catalog_services counter +consul_client_api_catalog_services 0 +# HELP consul_client_api_error_catalog_service_nodes Increments whenever a Consul agent receives an RPC error for request to list nodes offering a service. +# TYPE consul_client_api_error_catalog_service_nodes counter +consul_client_api_error_catalog_service_nodes 0 +# HELP consul_client_api_success_catalog_datacenters Increments whenever a Consul agent successfully responds to a request to list datacenters. +# TYPE consul_client_api_success_catalog_datacenters counter +consul_client_api_success_catalog_datacenters 0 +# HELP consul_client_api_success_catalog_deregister Increments whenever a Consul agent successfully responds to a catalog deregister request. +# TYPE consul_client_api_success_catalog_deregister counter +consul_client_api_success_catalog_deregister 0 +# HELP consul_client_api_success_catalog_gateway_services Increments whenever a Consul agent successfully responds to a request to list services associated with a gateway. +# TYPE consul_client_api_success_catalog_gateway_services counter +consul_client_api_success_catalog_gateway_services 0 +# HELP consul_client_api_success_catalog_node_service_list Increments whenever a Consul agent successfully responds to a request to list a node's registered services. +# TYPE consul_client_api_success_catalog_node_service_list counter +consul_client_api_success_catalog_node_service_list 0 +# HELP consul_client_api_success_catalog_node_services Increments whenever a Consul agent successfully responds to a request to list services in a node. +# TYPE consul_client_api_success_catalog_node_services counter +consul_client_api_success_catalog_node_services 0 +# HELP consul_client_api_success_catalog_nodes Increments whenever a Consul agent successfully responds to a request to list nodes. +# TYPE consul_client_api_success_catalog_nodes counter +consul_client_api_success_catalog_nodes 0 +# HELP consul_client_api_success_catalog_register Increments whenever a Consul agent successfully responds to a catalog register request. +# TYPE consul_client_api_success_catalog_register counter +consul_client_api_success_catalog_register 0 +# HELP consul_client_api_success_catalog_service_nodes Increments whenever a Consul agent successfully responds to a request to list nodes offering a service. +# TYPE consul_client_api_success_catalog_service_nodes counter +consul_client_api_success_catalog_service_nodes 0 +# HELP consul_client_api_success_catalog_services Increments whenever a Consul agent successfully responds to a request to list services. +# TYPE consul_client_api_success_catalog_services counter +consul_client_api_success_catalog_services 0 +# HELP consul_client_rpc Increments whenever a Consul agent in client mode makes an RPC request to a Consul server. +# TYPE consul_client_rpc counter +consul_client_rpc 46 +# HELP consul_client_rpc_error_catalog_datacenters Increments whenever a Consul agent receives an RPC error for a request to list datacenters. +# TYPE consul_client_rpc_error_catalog_datacenters counter +consul_client_rpc_error_catalog_datacenters 0 +# HELP consul_client_rpc_error_catalog_deregister Increments whenever a Consul agent receives an RPC error for a catalog deregister request. +# TYPE consul_client_rpc_error_catalog_deregister counter +consul_client_rpc_error_catalog_deregister 0 +# HELP consul_client_rpc_error_catalog_gateway_services Increments whenever a Consul agent receives an RPC error for a request to list services associated with a gateway. +# TYPE consul_client_rpc_error_catalog_gateway_services counter +consul_client_rpc_error_catalog_gateway_services 0 +# HELP consul_client_rpc_error_catalog_node_service_list Increments whenever a Consul agent receives an RPC error for request to list a node's registered services. +# TYPE consul_client_rpc_error_catalog_node_service_list counter +consul_client_rpc_error_catalog_node_service_list 0 +# HELP consul_client_rpc_error_catalog_node_services Increments whenever a Consul agent receives an RPC error for a request to list services in a node. +# TYPE consul_client_rpc_error_catalog_node_services counter +consul_client_rpc_error_catalog_node_services 0 +# HELP consul_client_rpc_error_catalog_nodes Increments whenever a Consul agent receives an RPC error for a request to list nodes. +# TYPE consul_client_rpc_error_catalog_nodes counter +consul_client_rpc_error_catalog_nodes 0 +# HELP consul_client_rpc_error_catalog_register Increments whenever a Consul agent receives an RPC error for a catalog register request. +# TYPE consul_client_rpc_error_catalog_register counter +consul_client_rpc_error_catalog_register 0 +# HELP consul_client_rpc_error_catalog_service_nodes Increments whenever a Consul agent receives an RPC error for a request to list nodes offering a service. +# TYPE consul_client_rpc_error_catalog_service_nodes counter +consul_client_rpc_error_catalog_service_nodes 0 +# HELP consul_client_rpc_error_catalog_services Increments whenever a Consul agent receives an RPC error for a request to list services. +# TYPE consul_client_rpc_error_catalog_services counter +consul_client_rpc_error_catalog_services 0 +# HELP consul_client_rpc_exceeded Increments whenever a Consul agent in client mode makes an RPC request to a Consul server gets rate limited by that agent's limits configuration. +# TYPE consul_client_rpc_exceeded counter +consul_client_rpc_exceeded 0 +# HELP consul_client_rpc_failed Increments whenever a Consul agent in client mode makes an RPC request to a Consul server and fails. +# TYPE consul_client_rpc_failed counter +consul_client_rpc_failed 0 +# HELP consul_consul_cache_bypass Counts how many times a request bypassed the cache because no cache-key was provided. +# TYPE consul_consul_cache_bypass counter +consul_consul_cache_bypass 0 +# HELP consul_consul_cache_entries_count Represents the number of entries in this cache. +# TYPE consul_consul_cache_entries_count gauge +consul_consul_cache_entries_count 0 +# HELP consul_consul_cache_evict_expired Counts the number of expired entries that are evicted. +# TYPE consul_consul_cache_evict_expired counter +consul_consul_cache_evict_expired 0 +# HELP consul_consul_cache_fetch_error Counts the number of failed fetches by the cache. +# TYPE consul_consul_cache_fetch_error counter +consul_consul_cache_fetch_error 0 +# HELP consul_consul_cache_fetch_success Counts the number of successful fetches by the cache. +# TYPE consul_consul_cache_fetch_success counter +consul_consul_cache_fetch_success 0 +# HELP consul_consul_fsm_ca Deprecated - use fsm_ca instead +# TYPE consul_consul_fsm_ca summary +consul_consul_fsm_ca{quantile="0.5"} NaN +consul_consul_fsm_ca{quantile="0.9"} NaN +consul_consul_fsm_ca{quantile="0.99"} NaN +consul_consul_fsm_ca_sum 0 +consul_consul_fsm_ca_count 0 +# HELP consul_consul_fsm_intention Deprecated - use fsm_intention instead +# TYPE consul_consul_fsm_intention summary +consul_consul_fsm_intention{quantile="0.5"} NaN +consul_consul_fsm_intention{quantile="0.9"} NaN +consul_consul_fsm_intention{quantile="0.99"} NaN +consul_consul_fsm_intention_sum 0 +consul_consul_fsm_intention_count 0 +# HELP consul_consul_intention_apply +# TYPE consul_consul_intention_apply summary +consul_consul_intention_apply{quantile="0.5"} NaN +consul_consul_intention_apply{quantile="0.9"} NaN +consul_consul_intention_apply{quantile="0.99"} NaN +consul_consul_intention_apply_sum 0 +consul_consul_intention_apply_count 0 +# HELP consul_consul_members_clients Measures the current number of client agents registered with Consul. It is only emitted by Consul servers. Added in v1.9.6. +# TYPE consul_consul_members_clients gauge +consul_consul_members_clients 0 +# HELP consul_consul_members_servers Measures the current number of server agents registered with Consul. It is only emitted by Consul servers. Added in v1.9.6. +# TYPE consul_consul_members_servers gauge +consul_consul_members_servers 0 +# HELP consul_consul_peering_exported_services A gauge that tracks how many services are exported for the peering. The labels are "peering" and, for enterprise, "partition". We emit this metric every 9 seconds +# TYPE consul_consul_peering_exported_services gauge +consul_consul_peering_exported_services 0 +# HELP consul_consul_state_config_entries Measures the current number of unique configuration entries registered with Consul, labeled by Kind. It is only emitted by Consul servers. Added in v1.10.4. +# TYPE consul_consul_state_config_entries gauge +consul_consul_state_config_entries 0 +# HELP consul_consul_state_connect_instances Measures the current number of unique connect service instances registered with Consul, labeled by Kind. It is only emitted by Consul servers. Added in v1.10.4. +# TYPE consul_consul_state_connect_instances gauge +consul_consul_state_connect_instances 0 +# HELP consul_consul_state_kv_entries Measures the current number of entries in the Consul KV store. It is only emitted by Consul servers. Added in v1.10.3. +# TYPE consul_consul_state_kv_entries gauge +consul_consul_state_kv_entries 0 +# HELP consul_consul_state_nodes Measures the current number of nodes registered with Consul. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_consul_state_nodes gauge +consul_consul_state_nodes 0 +# HELP consul_consul_state_peerings Measures the current number of peerings registered with Consul. It is only emitted by Consul servers. Added in v1.13.0. +# TYPE consul_consul_state_peerings gauge +consul_consul_state_peerings 0 +# HELP consul_consul_state_service_instances Measures the current number of unique services registered with Consul, based on service name. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_consul_state_service_instances gauge +consul_consul_state_service_instances 0 +# HELP consul_consul_state_services Measures the current number of unique services registered with Consul, based on service name. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_consul_state_services gauge +consul_consul_state_services 0 +# HELP consul_federation_state_apply +# TYPE consul_federation_state_apply summary +consul_federation_state_apply{quantile="0.5"} NaN +consul_federation_state_apply{quantile="0.9"} NaN +consul_federation_state_apply{quantile="0.99"} NaN +consul_federation_state_apply_sum 0 +consul_federation_state_apply_count 0 +# HELP consul_federation_state_get +# TYPE consul_federation_state_get summary +consul_federation_state_get{quantile="0.5"} NaN +consul_federation_state_get{quantile="0.9"} NaN +consul_federation_state_get{quantile="0.99"} NaN +consul_federation_state_get_sum 0 +consul_federation_state_get_count 0 +# HELP consul_federation_state_list +# TYPE consul_federation_state_list summary +consul_federation_state_list{quantile="0.5"} NaN +consul_federation_state_list{quantile="0.9"} NaN +consul_federation_state_list{quantile="0.99"} NaN +consul_federation_state_list_sum 0 +consul_federation_state_list_count 0 +# HELP consul_federation_state_list_mesh_gateways +# TYPE consul_federation_state_list_mesh_gateways summary +consul_federation_state_list_mesh_gateways{quantile="0.5"} NaN +consul_federation_state_list_mesh_gateways{quantile="0.9"} NaN +consul_federation_state_list_mesh_gateways{quantile="0.99"} NaN +consul_federation_state_list_mesh_gateways_sum 0 +consul_federation_state_list_mesh_gateways_count 0 +# HELP consul_fsm_acl Measures the time it takes to apply the given ACL operation to the FSM. +# TYPE consul_fsm_acl summary +consul_fsm_acl{quantile="0.5"} NaN +consul_fsm_acl{quantile="0.9"} NaN +consul_fsm_acl{quantile="0.99"} NaN +consul_fsm_acl_sum 0 +consul_fsm_acl_count 0 +# HELP consul_fsm_acl_authmethod Measures the time it takes to apply an ACL authmethod operation to the FSM. +# TYPE consul_fsm_acl_authmethod summary +consul_fsm_acl_authmethod{quantile="0.5"} NaN +consul_fsm_acl_authmethod{quantile="0.9"} NaN +consul_fsm_acl_authmethod{quantile="0.99"} NaN +consul_fsm_acl_authmethod_sum 0 +consul_fsm_acl_authmethod_count 0 +# HELP consul_fsm_acl_bindingrule Measures the time it takes to apply an ACL binding rule operation to the FSM. +# TYPE consul_fsm_acl_bindingrule summary +consul_fsm_acl_bindingrule{quantile="0.5"} NaN +consul_fsm_acl_bindingrule{quantile="0.9"} NaN +consul_fsm_acl_bindingrule{quantile="0.99"} NaN +consul_fsm_acl_bindingrule_sum 0 +consul_fsm_acl_bindingrule_count 0 +# HELP consul_fsm_acl_policy Measures the time it takes to apply an ACL policy operation to the FSM. +# TYPE consul_fsm_acl_policy summary +consul_fsm_acl_policy{quantile="0.5"} NaN +consul_fsm_acl_policy{quantile="0.9"} NaN +consul_fsm_acl_policy{quantile="0.99"} NaN +consul_fsm_acl_policy_sum 0 +consul_fsm_acl_policy_count 0 +# HELP consul_fsm_acl_token Measures the time it takes to apply an ACL token operation to the FSM. +# TYPE consul_fsm_acl_token summary +consul_fsm_acl_token{quantile="0.5"} NaN +consul_fsm_acl_token{quantile="0.9"} NaN +consul_fsm_acl_token{quantile="0.99"} NaN +consul_fsm_acl_token_sum 0 +consul_fsm_acl_token_count 0 +# HELP consul_fsm_autopilot Measures the time it takes to apply the given autopilot update to the FSM. +# TYPE consul_fsm_autopilot summary +consul_fsm_autopilot{quantile="0.5"} NaN +consul_fsm_autopilot{quantile="0.9"} NaN +consul_fsm_autopilot{quantile="0.99"} NaN +consul_fsm_autopilot_sum 0 +consul_fsm_autopilot_count 0 +# HELP consul_fsm_ca Measures the time it takes to apply CA configuration operations to the FSM. +# TYPE consul_fsm_ca summary +consul_fsm_ca{quantile="0.5"} NaN +consul_fsm_ca{quantile="0.9"} NaN +consul_fsm_ca{quantile="0.99"} NaN +consul_fsm_ca_sum 0 +consul_fsm_ca_count 0 +# HELP consul_fsm_ca_leaf Measures the time it takes to apply an operation while signing a leaf certificate. +# TYPE consul_fsm_ca_leaf summary +consul_fsm_ca_leaf{quantile="0.5"} NaN +consul_fsm_ca_leaf{quantile="0.9"} NaN +consul_fsm_ca_leaf{quantile="0.99"} NaN +consul_fsm_ca_leaf_sum 0 +consul_fsm_ca_leaf_count 0 +# HELP consul_fsm_coordinate_batch_update Measures the time it takes to apply the given batch coordinate update to the FSM. +# TYPE consul_fsm_coordinate_batch_update summary +consul_fsm_coordinate_batch_update{quantile="0.5"} 0.10997900366783142 +consul_fsm_coordinate_batch_update{quantile="0.9"} 0.10997900366783142 +consul_fsm_coordinate_batch_update{quantile="0.99"} 0.10997900366783142 +consul_fsm_coordinate_batch_update_sum 240.22869294136763 +consul_fsm_coordinate_batch_update_count 11035 +# HELP consul_fsm_deregister Measures the time it takes to apply a catalog deregister operation to the FSM. +# TYPE consul_fsm_deregister summary +consul_fsm_deregister{quantile="0.5"} NaN +consul_fsm_deregister{quantile="0.9"} NaN +consul_fsm_deregister{quantile="0.99"} NaN +consul_fsm_deregister_sum 1.4027419984340668 +consul_fsm_deregister_count 3 +# HELP consul_fsm_intention Measures the time it takes to apply an intention operation to the FSM. +# TYPE consul_fsm_intention summary +consul_fsm_intention{quantile="0.5"} NaN +consul_fsm_intention{quantile="0.9"} NaN +consul_fsm_intention{quantile="0.99"} NaN +consul_fsm_intention_sum 0 +consul_fsm_intention_count 0 +# HELP consul_fsm_kvs Measures the time it takes to apply the given KV operation to the FSM. +# TYPE consul_fsm_kvs summary +consul_fsm_kvs{quantile="0.5"} NaN +consul_fsm_kvs{quantile="0.9"} NaN +consul_fsm_kvs{quantile="0.99"} NaN +consul_fsm_kvs_sum 0 +consul_fsm_kvs_count 0 +# HELP consul_fsm_peering Measures the time it takes to apply a peering operation to the FSM. +# TYPE consul_fsm_peering summary +consul_fsm_peering{quantile="0.5"} NaN +consul_fsm_peering{quantile="0.9"} NaN +consul_fsm_peering{quantile="0.99"} NaN +consul_fsm_peering_sum 0 +consul_fsm_peering_count 0 +# HELP consul_fsm_persist Measures the time it takes to persist the FSM to a raft snapshot. +# TYPE consul_fsm_persist summary +consul_fsm_persist{quantile="0.5"} NaN +consul_fsm_persist{quantile="0.9"} NaN +consul_fsm_persist{quantile="0.99"} NaN +consul_fsm_persist_sum 0 +consul_fsm_persist_count 0 +# HELP consul_fsm_prepared_query Measures the time it takes to apply the given prepared query update operation to the FSM. +# TYPE consul_fsm_prepared_query summary +consul_fsm_prepared_query{quantile="0.5"} NaN +consul_fsm_prepared_query{quantile="0.9"} NaN +consul_fsm_prepared_query{quantile="0.99"} NaN +consul_fsm_prepared_query_sum 0 +consul_fsm_prepared_query_count 0 +# HELP consul_fsm_register Measures the time it takes to apply a catalog register operation to the FSM. +# TYPE consul_fsm_register summary +consul_fsm_register{quantile="0.5"} NaN +consul_fsm_register{quantile="0.9"} NaN +consul_fsm_register{quantile="0.99"} NaN +consul_fsm_register_sum 20.184059869498014 +consul_fsm_register_count 210 +# HELP consul_fsm_session Measures the time it takes to apply the given session operation to the FSM. +# TYPE consul_fsm_session summary +consul_fsm_session{quantile="0.5"} NaN +consul_fsm_session{quantile="0.9"} NaN +consul_fsm_session{quantile="0.99"} NaN +consul_fsm_session_sum 0 +consul_fsm_session_count 0 +# HELP consul_fsm_system_metadata Measures the time it takes to apply a system metadata operation to the FSM. +# TYPE consul_fsm_system_metadata summary +consul_fsm_system_metadata{quantile="0.5"} NaN +consul_fsm_system_metadata{quantile="0.9"} NaN +consul_fsm_system_metadata{quantile="0.99"} NaN +consul_fsm_system_metadata_sum 0 +consul_fsm_system_metadata_count 0 +# HELP consul_fsm_tombstone Measures the time it takes to apply the given tombstone operation to the FSM. +# TYPE consul_fsm_tombstone summary +consul_fsm_tombstone{quantile="0.5"} NaN +consul_fsm_tombstone{quantile="0.9"} NaN +consul_fsm_tombstone{quantile="0.99"} NaN +consul_fsm_tombstone_sum 0 +consul_fsm_tombstone_count 0 +# HELP consul_fsm_txn Measures the time it takes to apply the given transaction update to the FSM. +# TYPE consul_fsm_txn summary +consul_fsm_txn{quantile="0.5"} NaN +consul_fsm_txn{quantile="0.9"} NaN +consul_fsm_txn{quantile="0.99"} NaN +consul_fsm_txn_sum 0 +consul_fsm_txn_count 0 +# HELP consul_grpc_client_connection_count Counts the number of new gRPC connections opened by the client agent to a Consul server. +# TYPE consul_grpc_client_connection_count counter +consul_grpc_client_connection_count 9 +# HELP consul_grpc_client_connections Measures the number of active gRPC connections open from the client agent to any Consul servers. +# TYPE consul_grpc_client_connections gauge +consul_grpc_client_connections 0 +# HELP consul_grpc_client_request_count Counts the number of gRPC requests made by the client agent to a Consul server. +# TYPE consul_grpc_client_request_count counter +consul_grpc_client_request_count 0 +# HELP consul_grpc_server_connection_count Counts the number of new gRPC connections received by the server. +# TYPE consul_grpc_server_connection_count counter +consul_grpc_server_connection_count 6 +# HELP consul_grpc_server_connections Measures the number of active gRPC connections open on the server. +# TYPE consul_grpc_server_connections gauge +consul_grpc_server_connections 0 +# HELP consul_grpc_server_request_count Counts the number of gRPC requests received by the server. +# TYPE consul_grpc_server_request_count counter +consul_grpc_server_request_count 0 +# HELP consul_grpc_server_stream_count Counts the number of new gRPC streams received by the server. +# TYPE consul_grpc_server_stream_count counter +consul_grpc_server_stream_count 0 +# HELP consul_grpc_server_streams Measures the number of active gRPC streams handled by the server. +# TYPE consul_grpc_server_streams gauge +consul_grpc_server_streams 0 +# HELP consul_intention_apply +# TYPE consul_intention_apply summary +consul_intention_apply{quantile="0.5"} NaN +consul_intention_apply{quantile="0.9"} NaN +consul_intention_apply{quantile="0.99"} NaN +consul_intention_apply_sum 0 +consul_intention_apply_count 0 +# HELP consul_kvs_apply Measures the time it takes to complete an update to the KV store. +# TYPE consul_kvs_apply summary +consul_kvs_apply{quantile="0.5"} NaN +consul_kvs_apply{quantile="0.9"} NaN +consul_kvs_apply{quantile="0.99"} NaN +consul_kvs_apply_sum 0 +consul_kvs_apply_count 0 +# HELP consul_leader_barrier Measures the time spent waiting for the raft barrier upon gaining leadership. +# TYPE consul_leader_barrier summary +consul_leader_barrier{quantile="0.5"} NaN +consul_leader_barrier{quantile="0.9"} NaN +consul_leader_barrier{quantile="0.99"} NaN +consul_leader_barrier_sum 168.71699333190918 +consul_leader_barrier_count 8 +# HELP consul_leader_reapTombstones Measures the time spent clearing tombstones. +# TYPE consul_leader_reapTombstones summary +consul_leader_reapTombstones{quantile="0.5"} NaN +consul_leader_reapTombstones{quantile="0.9"} NaN +consul_leader_reapTombstones{quantile="0.99"} NaN +consul_leader_reapTombstones_sum 0 +consul_leader_reapTombstones_count 0 +# HELP consul_leader_reconcile Measures the time spent updating the raft store from the serf member information. +# TYPE consul_leader_reconcile summary +consul_leader_reconcile{quantile="0.5"} NaN +consul_leader_reconcile{quantile="0.9"} NaN +consul_leader_reconcile{quantile="0.99"} NaN +consul_leader_reconcile_sum 2.5833420008420944 +consul_leader_reconcile_count 8 +# HELP consul_leader_reconcileMember Measures the time spent updating the raft store for a single serf member's information. +# TYPE consul_leader_reconcileMember summary +consul_leader_reconcileMember{quantile="0.5"} NaN +consul_leader_reconcileMember{quantile="0.9"} NaN +consul_leader_reconcileMember{quantile="0.99"} NaN +consul_leader_reconcileMember_sum 60.76006331667304 +consul_leader_reconcileMember_count 26 +# HELP consul_leader_replication_acl_policies_index Tracks the index of ACL policies in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_policies_index gauge +consul_leader_replication_acl_policies_index 0 +# HELP consul_leader_replication_acl_policies_status Tracks the current health of ACL policy replication on the leader +# TYPE consul_leader_replication_acl_policies_status gauge +consul_leader_replication_acl_policies_status 0 +# HELP consul_leader_replication_acl_roles_index Tracks the index of ACL roles in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_roles_index gauge +consul_leader_replication_acl_roles_index 0 +# HELP consul_leader_replication_acl_roles_status Tracks the current health of ACL role replication on the leader +# TYPE consul_leader_replication_acl_roles_status gauge +consul_leader_replication_acl_roles_status 0 +# HELP consul_leader_replication_acl_tokens_index Tracks the index of ACL tokens in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_tokens_index gauge +consul_leader_replication_acl_tokens_index 0 +# HELP consul_leader_replication_acl_tokens_status Tracks the current health of ACL token replication on the leader +# TYPE consul_leader_replication_acl_tokens_status gauge +consul_leader_replication_acl_tokens_status 0 +# HELP consul_leader_replication_config_entries_index Tracks the index of config entries in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_config_entries_index gauge +consul_leader_replication_config_entries_index 0 +# HELP consul_leader_replication_config_entries_status Tracks the current health of config entry replication on the leader +# TYPE consul_leader_replication_config_entries_status gauge +consul_leader_replication_config_entries_status 0 +# HELP consul_leader_replication_federation_state_index Tracks the index of federation states in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_federation_state_index gauge +consul_leader_replication_federation_state_index 0 +# HELP consul_leader_replication_federation_state_status Tracks the current health of federation state replication on the leader +# TYPE consul_leader_replication_federation_state_status gauge +consul_leader_replication_federation_state_status 0 +# HELP consul_leader_replication_namespaces_index Tracks the index of federation states in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_namespaces_index gauge +consul_leader_replication_namespaces_index 0 +# HELP consul_leader_replication_namespaces_status Tracks the current health of federation state replication on the leader +# TYPE consul_leader_replication_namespaces_status gauge +consul_leader_replication_namespaces_status 0 +# HELP consul_memberlist_degraded_probe consul_memberlist_degraded_probe +# TYPE consul_memberlist_degraded_probe counter +consul_memberlist_degraded_probe{network="lan"} 1 +consul_memberlist_degraded_probe{network="wan"} 1 +# HELP consul_memberlist_gossip consul_memberlist_gossip +# TYPE consul_memberlist_gossip summary +consul_memberlist_gossip{network="lan",quantile="0.5"} 0.019190000370144844 +consul_memberlist_gossip{network="lan",quantile="0.9"} 0.04447900131344795 +consul_memberlist_gossip{network="lan",quantile="0.99"} 0.06036800146102905 +consul_memberlist_gossip_sum{network="lan"} 72.94090104475617 +consul_memberlist_gossip_count{network="lan"} 2984 +consul_memberlist_gossip{network="wan",quantile="0.5"} 0.020829999819397926 +consul_memberlist_gossip{network="wan",quantile="0.9"} 0.04980999976396561 +consul_memberlist_gossip{network="wan",quantile="0.99"} 0.06190900132060051 +consul_memberlist_gossip_sum{network="wan"} 31.62462099501863 +consul_memberlist_gossip_count{network="wan"} 1193 +# HELP consul_memberlist_msg_alive consul_memberlist_msg_alive +# TYPE consul_memberlist_msg_alive counter +consul_memberlist_msg_alive{network="lan"} 5 +consul_memberlist_msg_alive{network="wan"} 5 +# HELP consul_memberlist_msg_dead consul_memberlist_msg_dead +# TYPE consul_memberlist_msg_dead counter +consul_memberlist_msg_dead{network="lan"} 2 +consul_memberlist_msg_dead{network="wan"} 2 +# HELP consul_memberlist_probeNode consul_memberlist_probeNode +# TYPE consul_memberlist_probeNode summary +consul_memberlist_probeNode{network="lan",quantile="0.5"} 0.9080119729042053 +consul_memberlist_probeNode{network="lan",quantile="0.9"} 1.071262001991272 +consul_memberlist_probeNode{network="lan",quantile="0.99"} 1.071262001991272 +consul_memberlist_probeNode_sum{network="lan"} 560.697409927845 +consul_memberlist_probeNode_count{network="lan"} 559 +consul_memberlist_probeNode{network="wan",quantile="0.5"} 0.7037429809570312 +consul_memberlist_probeNode{network="wan",quantile="0.9"} 1.0175219774246216 +consul_memberlist_probeNode{network="wan",quantile="0.99"} 1.0175219774246216 +consul_memberlist_probeNode_sum{network="wan"} 133.5382086634636 +consul_memberlist_probeNode_count{network="wan"} 112 +# HELP consul_memberlist_pushPullNode consul_memberlist_pushPullNode +# TYPE consul_memberlist_pushPullNode summary +consul_memberlist_pushPullNode{network="lan",quantile="0.5"} NaN +consul_memberlist_pushPullNode{network="lan",quantile="0.9"} NaN +consul_memberlist_pushPullNode{network="lan",quantile="0.99"} NaN +consul_memberlist_pushPullNode_sum{network="lan"} 32.9423828125 +consul_memberlist_pushPullNode_count{network="lan"} 23 +consul_memberlist_pushPullNode{network="wan",quantile="0.5"} NaN +consul_memberlist_pushPullNode{network="wan",quantile="0.9"} NaN +consul_memberlist_pushPullNode{network="wan",quantile="0.99"} NaN +consul_memberlist_pushPullNode_sum{network="wan"} 14.840403079986572 +consul_memberlist_pushPullNode_count{network="wan"} 10 +# HELP consul_memberlist_tcp_accept consul_memberlist_tcp_accept +# TYPE consul_memberlist_tcp_accept counter +consul_memberlist_tcp_accept{network="lan"} 23 +consul_memberlist_tcp_accept{network="wan"} 10 +# HELP consul_memberlist_tcp_connect consul_memberlist_tcp_connect +# TYPE consul_memberlist_tcp_connect counter +consul_memberlist_tcp_connect{network="lan"} 23 +consul_memberlist_tcp_connect{network="wan"} 10 +# HELP consul_memberlist_tcp_sent consul_memberlist_tcp_sent +# TYPE consul_memberlist_tcp_sent counter +consul_memberlist_tcp_sent{network="lan"} 39810 +consul_memberlist_tcp_sent{network="wan"} 15776 +# HELP consul_memberlist_udp_received consul_memberlist_udp_received +# TYPE consul_memberlist_udp_received counter +consul_memberlist_udp_received{network="lan"} 168805 +consul_memberlist_udp_received{network="wan"} 42596 +# HELP consul_memberlist_udp_sent consul_memberlist_udp_sent +# TYPE consul_memberlist_udp_sent counter +consul_memberlist_udp_sent{network="lan"} 168852 +consul_memberlist_udp_sent{network="wan"} 41510 +# HELP consul_mesh_active_root_ca_expiry Seconds until the service mesh root certificate expires. Updated every hour +# TYPE consul_mesh_active_root_ca_expiry gauge +consul_mesh_active_root_ca_expiry 0 +# HELP consul_mesh_active_signing_ca_expiry Seconds until the service mesh signing certificate expires. Updated every hour +# TYPE consul_mesh_active_signing_ca_expiry gauge +consul_mesh_active_signing_ca_expiry 0 +# HELP consul_prepared_query_apply Measures the time it takes to apply a prepared query update. +# TYPE consul_prepared_query_apply summary +consul_prepared_query_apply{quantile="0.5"} NaN +consul_prepared_query_apply{quantile="0.9"} NaN +consul_prepared_query_apply{quantile="0.99"} NaN +consul_prepared_query_apply_sum 0 +consul_prepared_query_apply_count 0 +# HELP consul_prepared_query_execute Measures the time it takes to process a prepared query execute request. +# TYPE consul_prepared_query_execute summary +consul_prepared_query_execute{quantile="0.5"} NaN +consul_prepared_query_execute{quantile="0.9"} NaN +consul_prepared_query_execute{quantile="0.99"} NaN +consul_prepared_query_execute_sum 0 +consul_prepared_query_execute_count 0 +# HELP consul_prepared_query_execute_remote Measures the time it takes to process a prepared query execute request that was forwarded to another datacenter. +# TYPE consul_prepared_query_execute_remote summary +consul_prepared_query_execute_remote{quantile="0.5"} NaN +consul_prepared_query_execute_remote{quantile="0.9"} NaN +consul_prepared_query_execute_remote{quantile="0.99"} NaN +consul_prepared_query_execute_remote_sum 0 +consul_prepared_query_execute_remote_count 0 +# HELP consul_prepared_query_explain Measures the time it takes to process a prepared query explain request. +# TYPE consul_prepared_query_explain summary +consul_prepared_query_explain{quantile="0.5"} NaN +consul_prepared_query_explain{quantile="0.9"} NaN +consul_prepared_query_explain{quantile="0.99"} NaN +consul_prepared_query_explain_sum 0 +consul_prepared_query_explain_count 0 +# HELP consul_raft_applied_index Represents the raft applied index. +# TYPE consul_raft_applied_index gauge +consul_raft_applied_index 0 +# HELP consul_raft_apply This counts the number of Raft transactions occurring over the interval. +# TYPE consul_raft_apply counter +consul_raft_apply 52 +# HELP consul_raft_barrier consul_raft_barrier +# TYPE consul_raft_barrier counter +consul_raft_barrier 8 +# HELP consul_raft_boltdb_getLog consul_raft_boltdb_getLog +# TYPE consul_raft_boltdb_getLog summary +consul_raft_boltdb_getLog{quantile="0.5"} 0.04751899838447571 +consul_raft_boltdb_getLog{quantile="0.9"} 0.04751899838447571 +consul_raft_boltdb_getLog{quantile="0.99"} 0.04751899838447571 +consul_raft_boltdb_getLog_sum 177.71392010012642 +consul_raft_boltdb_getLog_count 25884 +# HELP consul_raft_boltdb_logBatchSize consul_raft_boltdb_logBatchSize +# TYPE consul_raft_boltdb_logBatchSize summary +consul_raft_boltdb_logBatchSize{quantile="0.5"} 414 +consul_raft_boltdb_logBatchSize{quantile="0.9"} 414 +consul_raft_boltdb_logBatchSize{quantile="0.99"} 414 +consul_raft_boltdb_logBatchSize_sum 32278 +consul_raft_boltdb_logBatchSize_count 93 +# HELP consul_raft_boltdb_logSize consul_raft_boltdb_logSize +# TYPE consul_raft_boltdb_logSize summary +consul_raft_boltdb_logSize{quantile="0.5"} 414 +consul_raft_boltdb_logSize{quantile="0.9"} 414 +consul_raft_boltdb_logSize{quantile="0.99"} 414 +consul_raft_boltdb_logSize_sum 32278 +consul_raft_boltdb_logSize_count 95 +# HELP consul_raft_boltdb_logsPerBatch consul_raft_boltdb_logsPerBatch +# TYPE consul_raft_boltdb_logsPerBatch summary +consul_raft_boltdb_logsPerBatch{quantile="0.5"} 1 +consul_raft_boltdb_logsPerBatch{quantile="0.9"} 1 +consul_raft_boltdb_logsPerBatch{quantile="0.99"} 1 +consul_raft_boltdb_logsPerBatch_sum 95 +consul_raft_boltdb_logsPerBatch_count 93 +# HELP consul_raft_boltdb_storeLogs consul_raft_boltdb_storeLogs +# TYPE consul_raft_boltdb_storeLogs summary +consul_raft_boltdb_storeLogs{quantile="0.5"} 17.80512237548828 +consul_raft_boltdb_storeLogs{quantile="0.9"} 17.80512237548828 +consul_raft_boltdb_storeLogs{quantile="0.99"} 17.80512237548828 +consul_raft_boltdb_storeLogs_sum 1006.1075472831726 +consul_raft_boltdb_storeLogs_count 93 +# HELP consul_raft_boltdb_totalReadTxn consul_raft_boltdb_totalReadTxn +# TYPE consul_raft_boltdb_totalReadTxn counter +consul_raft_boltdb_totalReadTxn 25946 +# HELP consul_raft_boltdb_txstats_cursorCount consul_raft_boltdb_txstats_cursorCount +# TYPE consul_raft_boltdb_txstats_cursorCount counter +consul_raft_boltdb_txstats_cursorCount 52198 +# HELP consul_raft_boltdb_txstats_nodeCount consul_raft_boltdb_txstats_nodeCount +# TYPE consul_raft_boltdb_txstats_nodeCount counter +consul_raft_boltdb_txstats_nodeCount 386 +# HELP consul_raft_boltdb_txstats_nodeDeref consul_raft_boltdb_txstats_nodeDeref +# TYPE consul_raft_boltdb_txstats_nodeDeref counter +consul_raft_boltdb_txstats_nodeDeref 0 +# HELP consul_raft_boltdb_txstats_rebalance consul_raft_boltdb_txstats_rebalance +# TYPE consul_raft_boltdb_txstats_rebalance counter +consul_raft_boltdb_txstats_rebalance 0 +# HELP consul_raft_boltdb_txstats_rebalanceTime consul_raft_boltdb_txstats_rebalanceTime +# TYPE consul_raft_boltdb_txstats_rebalanceTime summary +consul_raft_boltdb_txstats_rebalanceTime{quantile="0.5"} 0 +consul_raft_boltdb_txstats_rebalanceTime{quantile="0.9"} 0 +consul_raft_boltdb_txstats_rebalanceTime{quantile="0.99"} 0 +consul_raft_boltdb_txstats_rebalanceTime_sum 0 +consul_raft_boltdb_txstats_rebalanceTime_count 120 +# HELP consul_raft_boltdb_txstats_spill consul_raft_boltdb_txstats_spill +# TYPE consul_raft_boltdb_txstats_spill counter +consul_raft_boltdb_txstats_spill 398 +# HELP consul_raft_boltdb_txstats_spillTime consul_raft_boltdb_txstats_spillTime +# TYPE consul_raft_boltdb_txstats_spillTime summary +consul_raft_boltdb_txstats_spillTime{quantile="0.5"} 0.018939999863505363 +consul_raft_boltdb_txstats_spillTime{quantile="0.9"} 0.04575999826192856 +consul_raft_boltdb_txstats_spillTime{quantile="0.99"} 0.04575999826192856 +consul_raft_boltdb_txstats_spillTime_sum 2.559216999274213 +consul_raft_boltdb_txstats_spillTime_count 120 +# HELP consul_raft_boltdb_txstats_split consul_raft_boltdb_txstats_split +# TYPE consul_raft_boltdb_txstats_split counter +consul_raft_boltdb_txstats_split 19 +# HELP consul_raft_boltdb_txstats_write consul_raft_boltdb_txstats_write +# TYPE consul_raft_boltdb_txstats_write counter +consul_raft_boltdb_txstats_write 600 +# HELP consul_raft_boltdb_txstats_writeTime consul_raft_boltdb_txstats_writeTime +# TYPE consul_raft_boltdb_txstats_writeTime summary +consul_raft_boltdb_txstats_writeTime{quantile="0.5"} 17.56859588623047 +consul_raft_boltdb_txstats_writeTime{quantile="0.9"} 17.67194366455078 +consul_raft_boltdb_txstats_writeTime{quantile="0.99"} 17.67194366455078 +consul_raft_boltdb_txstats_writeTime_sum 1048.4321446418762 +consul_raft_boltdb_txstats_writeTime_count 120 +# HELP consul_raft_boltdb_writeCapacity consul_raft_boltdb_writeCapacity +# TYPE consul_raft_boltdb_writeCapacity summary +consul_raft_boltdb_writeCapacity{quantile="0.5"} 56.34065628051758 +consul_raft_boltdb_writeCapacity{quantile="0.9"} 56.34065628051758 +consul_raft_boltdb_writeCapacity{quantile="0.99"} 56.34065628051758 +consul_raft_boltdb_writeCapacity_sum 11092.64028930664 +consul_raft_boltdb_writeCapacity_count 93 +# HELP consul_raft_candidate_electSelf consul_raft_candidate_electSelf +# TYPE consul_raft_candidate_electSelf summary +consul_raft_candidate_electSelf{quantile="0.5"} NaN +consul_raft_candidate_electSelf{quantile="0.9"} NaN +consul_raft_candidate_electSelf{quantile="0.99"} NaN +consul_raft_candidate_electSelf_sum 64.78176307678223 +consul_raft_candidate_electSelf_count 2 +# HELP consul_raft_commitTime This measures the time it takes to commit a new entry to the Raft log on the leader. +# TYPE consul_raft_commitTime summary +consul_raft_commitTime{quantile="0.5"} 58.47069549560547 +consul_raft_commitTime{quantile="0.9"} 58.47069549560547 +consul_raft_commitTime{quantile="0.99"} 58.47069549560547 +consul_raft_commitTime_sum 1418.8827295303345 +consul_raft_commitTime_count 64 +# HELP consul_raft_fsm_apply consul_raft_fsm_apply +# TYPE consul_raft_fsm_apply summary +consul_raft_fsm_apply{quantile="0.5"} 0.1474989950656891 +consul_raft_fsm_apply{quantile="0.9"} 0.1474989950656891 +consul_raft_fsm_apply{quantile="0.99"} 0.1474989950656891 +consul_raft_fsm_apply_sum 368.55326924845576 +consul_raft_fsm_apply_count 11248 +# HELP consul_raft_fsm_enqueue consul_raft_fsm_enqueue +# TYPE consul_raft_fsm_enqueue summary +consul_raft_fsm_enqueue{quantile="0.5"} 0.01882000081241131 +consul_raft_fsm_enqueue{quantile="0.9"} 0.01882000081241131 +consul_raft_fsm_enqueue{quantile="0.99"} 0.01882000081241131 +consul_raft_fsm_enqueue_sum 1.6373119996860623 +consul_raft_fsm_enqueue_count 64 +# HELP consul_raft_fsm_lastRestoreDuration This measures how long the last FSM restore (from disk or leader) took. +# TYPE consul_raft_fsm_lastRestoreDuration gauge +consul_raft_fsm_lastRestoreDuration 0 +# HELP consul_raft_fsm_restore consul_raft_fsm_restore +# TYPE consul_raft_fsm_restore summary +consul_raft_fsm_restore{quantile="0.5"} NaN +consul_raft_fsm_restore{quantile="0.9"} NaN +consul_raft_fsm_restore{quantile="0.99"} NaN +consul_raft_fsm_restore_sum 2.6886210441589355 +consul_raft_fsm_restore_count 1 +# HELP consul_raft_last_index Represents the raft last index. +# TYPE consul_raft_last_index gauge +consul_raft_last_index 0 +# HELP consul_raft_leader_dispatchLog consul_raft_leader_dispatchLog +# TYPE consul_raft_leader_dispatchLog summary +consul_raft_leader_dispatchLog{quantile="0.5"} 17.841020584106445 +consul_raft_leader_dispatchLog{quantile="0.9"} 17.841020584106445 +consul_raft_leader_dispatchLog{quantile="0.99"} 17.841020584106445 +consul_raft_leader_dispatchLog_sum 614.3611516952515 +consul_raft_leader_dispatchLog_count 64 +# HELP consul_raft_leader_lastContact Measures the time since the leader was last able to contact the follower nodes when checking its leader lease. +# TYPE consul_raft_leader_lastContact summary +consul_raft_leader_lastContact{quantile="0.5"} 30 +consul_raft_leader_lastContact{quantile="0.9"} 67 +consul_raft_leader_lastContact{quantile="0.99"} 67 +consul_raft_leader_lastContact_sum 13872 +consul_raft_leader_lastContact_count 364 +# HELP consul_raft_leader_oldestLogAge This measures how old the oldest log in the leader's log store is. +# TYPE consul_raft_leader_oldestLogAge gauge +consul_raft_leader_oldestLogAge 0 +# HELP consul_raft_net_getRPCType consul_raft_net_getRPCType +# TYPE consul_raft_net_getRPCType summary +consul_raft_net_getRPCType{quantile="0.5"} NaN +consul_raft_net_getRPCType{quantile="0.9"} NaN +consul_raft_net_getRPCType{quantile="0.99"} NaN +consul_raft_net_getRPCType_sum 269090.0442453362 +consul_raft_net_getRPCType_count 2002 +# HELP consul_raft_net_rpcDecode consul_raft_net_rpcDecode +# TYPE consul_raft_net_rpcDecode summary +consul_raft_net_rpcDecode{rpcType="AppendEntries",quantile="0.5"} NaN +consul_raft_net_rpcDecode{rpcType="AppendEntries",quantile="0.9"} NaN +consul_raft_net_rpcDecode{rpcType="AppendEntries",quantile="0.99"} NaN +consul_raft_net_rpcDecode_sum{rpcType="AppendEntries"} 50.56464605871588 +consul_raft_net_rpcDecode_count{rpcType="AppendEntries"} 1811 +consul_raft_net_rpcDecode{rpcType="Heartbeat",quantile="0.5"} NaN +consul_raft_net_rpcDecode{rpcType="Heartbeat",quantile="0.9"} NaN +consul_raft_net_rpcDecode{rpcType="Heartbeat",quantile="0.99"} NaN +consul_raft_net_rpcDecode_sum{rpcType="Heartbeat"} 4.609708994626999 +consul_raft_net_rpcDecode_count{rpcType="Heartbeat"} 189 +consul_raft_net_rpcDecode{rpcType="RequestVote",quantile="0.5"} NaN +consul_raft_net_rpcDecode{rpcType="RequestVote",quantile="0.9"} NaN +consul_raft_net_rpcDecode{rpcType="RequestVote",quantile="0.99"} NaN +consul_raft_net_rpcDecode_sum{rpcType="RequestVote"} 0.052609000355005264 +consul_raft_net_rpcDecode_count{rpcType="RequestVote"} 1 +consul_raft_net_rpcDecode{rpcType="TimeoutNow",quantile="0.5"} NaN +consul_raft_net_rpcDecode{rpcType="TimeoutNow",quantile="0.9"} NaN +consul_raft_net_rpcDecode{rpcType="TimeoutNow",quantile="0.99"} NaN +consul_raft_net_rpcDecode_sum{rpcType="TimeoutNow"} 0.07034999877214432 +consul_raft_net_rpcDecode_count{rpcType="TimeoutNow"} 1 +# HELP consul_raft_net_rpcEnqueue consul_raft_net_rpcEnqueue +# TYPE consul_raft_net_rpcEnqueue summary +consul_raft_net_rpcEnqueue{rpcType="AppendEntries",quantile="0.5"} NaN +consul_raft_net_rpcEnqueue{rpcType="AppendEntries",quantile="0.9"} NaN +consul_raft_net_rpcEnqueue{rpcType="AppendEntries",quantile="0.99"} NaN +consul_raft_net_rpcEnqueue_sum{rpcType="AppendEntries"} 61.944881823379546 +consul_raft_net_rpcEnqueue_count{rpcType="AppendEntries"} 1811 +consul_raft_net_rpcEnqueue{rpcType="Heartbeat",quantile="0.5"} NaN +consul_raft_net_rpcEnqueue{rpcType="Heartbeat",quantile="0.9"} NaN +consul_raft_net_rpcEnqueue{rpcType="Heartbeat",quantile="0.99"} NaN +consul_raft_net_rpcEnqueue_sum{rpcType="Heartbeat"} 4.966151000931859 +consul_raft_net_rpcEnqueue_count{rpcType="Heartbeat"} 189 +consul_raft_net_rpcEnqueue{rpcType="RequestVote",quantile="0.5"} NaN +consul_raft_net_rpcEnqueue{rpcType="RequestVote",quantile="0.9"} NaN +consul_raft_net_rpcEnqueue{rpcType="RequestVote",quantile="0.99"} NaN +consul_raft_net_rpcEnqueue_sum{rpcType="RequestVote"} 0.012551000341773033 +consul_raft_net_rpcEnqueue_count{rpcType="RequestVote"} 1 +consul_raft_net_rpcEnqueue{rpcType="TimeoutNow",quantile="0.5"} NaN +consul_raft_net_rpcEnqueue{rpcType="TimeoutNow",quantile="0.9"} NaN +consul_raft_net_rpcEnqueue{rpcType="TimeoutNow",quantile="0.99"} NaN +consul_raft_net_rpcEnqueue_sum{rpcType="TimeoutNow"} 0.021700000390410423 +consul_raft_net_rpcEnqueue_count{rpcType="TimeoutNow"} 1 +# HELP consul_raft_net_rpcRespond consul_raft_net_rpcRespond +# TYPE consul_raft_net_rpcRespond summary +consul_raft_net_rpcRespond{rpcType="AppendEntries",quantile="0.5"} NaN +consul_raft_net_rpcRespond{rpcType="AppendEntries",quantile="0.9"} NaN +consul_raft_net_rpcRespond{rpcType="AppendEntries",quantile="0.99"} NaN +consul_raft_net_rpcRespond_sum{rpcType="AppendEntries"} 632.5211075674742 +consul_raft_net_rpcRespond_count{rpcType="AppendEntries"} 1811 +consul_raft_net_rpcRespond{rpcType="Heartbeat",quantile="0.5"} NaN +consul_raft_net_rpcRespond{rpcType="Heartbeat",quantile="0.9"} NaN +consul_raft_net_rpcRespond{rpcType="Heartbeat",quantile="0.99"} NaN +consul_raft_net_rpcRespond_sum{rpcType="Heartbeat"} 2.6388960042968392 +consul_raft_net_rpcRespond_count{rpcType="Heartbeat"} 189 +consul_raft_net_rpcRespond{rpcType="RequestVote",quantile="0.5"} NaN +consul_raft_net_rpcRespond{rpcType="RequestVote",quantile="0.9"} NaN +consul_raft_net_rpcRespond{rpcType="RequestVote",quantile="0.99"} NaN +consul_raft_net_rpcRespond_sum{rpcType="RequestVote"} 27.120553970336914 +consul_raft_net_rpcRespond_count{rpcType="RequestVote"} 1 +consul_raft_net_rpcRespond{rpcType="TimeoutNow",quantile="0.5"} NaN +consul_raft_net_rpcRespond{rpcType="TimeoutNow",quantile="0.9"} NaN +consul_raft_net_rpcRespond{rpcType="TimeoutNow",quantile="0.99"} NaN +consul_raft_net_rpcRespond_sum{rpcType="TimeoutNow"} 0.18450799584388733 +consul_raft_net_rpcRespond_count{rpcType="TimeoutNow"} 1 +# HELP consul_raft_replication_appendEntries_logs consul_raft_replication_appendEntries_logs +# TYPE consul_raft_replication_appendEntries_logs counter +consul_raft_replication_appendEntries_logs{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae"} 64 +consul_raft_replication_appendEntries_logs{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7"} 64 +# HELP consul_raft_replication_appendEntries_logs_3e75e0af_859b_83e8_779f_f3a6d12f02ae consul_raft_replication_appendEntries_logs_3e75e0af_859b_83e8_779f_f3a6d12f02ae +# TYPE consul_raft_replication_appendEntries_logs_3e75e0af_859b_83e8_779f_f3a6d12f02ae counter +consul_raft_replication_appendEntries_logs_3e75e0af_859b_83e8_779f_f3a6d12f02ae 64 +# HELP consul_raft_replication_appendEntries_logs_72849161_41cb_14df_fc9b_563ddff3bae7 consul_raft_replication_appendEntries_logs_72849161_41cb_14df_fc9b_563ddff3bae7 +# TYPE consul_raft_replication_appendEntries_logs_72849161_41cb_14df_fc9b_563ddff3bae7 counter +consul_raft_replication_appendEntries_logs_72849161_41cb_14df_fc9b_563ddff3bae7 64 +# HELP consul_raft_replication_appendEntries_rpc consul_raft_replication_appendEntries_rpc +# TYPE consul_raft_replication_appendEntries_rpc summary +consul_raft_replication_appendEntries_rpc{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.5"} 0.7193149924278259 +consul_raft_replication_appendEntries_rpc{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.9"} 1.123671054840088 +consul_raft_replication_appendEntries_rpc{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.99"} 2.9677159786224365 +consul_raft_replication_appendEntries_rpc_sum{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae"} 5982.053934007883 +consul_raft_replication_appendEntries_rpc_count{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae"} 6008 +consul_raft_replication_appendEntries_rpc{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.5"} 0.6742749810218811 +consul_raft_replication_appendEntries_rpc{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.9"} 1.1206400394439697 +consul_raft_replication_appendEntries_rpc{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.99"} 4.632521152496338 +consul_raft_replication_appendEntries_rpc_sum{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7"} 5640.875204831362 +consul_raft_replication_appendEntries_rpc_count{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7"} 6125 +# HELP consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae +# TYPE consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae summary +consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.5"} 0.7773330211639404 +consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.9"} 1.177711009979248 +consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.99"} 3.0745749473571777 +consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae_sum 6255.161469876766 +consul_raft_replication_appendEntries_rpc_3e75e0af_859b_83e8_779f_f3a6d12f02ae_count 6008 +# HELP consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7 consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7 +# TYPE consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7 summary +consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.5"} 0.7206940054893494 +consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.9"} 1.1687090396881104 +consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.99"} 4.6782097816467285 +consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7_sum 5913.810284465551 +consul_raft_replication_appendEntries_rpc_72849161_41cb_14df_fc9b_563ddff3bae7_count 6125 +# HELP consul_raft_replication_heartbeat consul_raft_replication_heartbeat +# TYPE consul_raft_replication_heartbeat summary +consul_raft_replication_heartbeat{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.5"} 0.6244940161705017 +consul_raft_replication_heartbeat{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.9"} 1.0416409969329834 +consul_raft_replication_heartbeat{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae",quantile="0.99"} 1.4274380207061768 +consul_raft_replication_heartbeat_sum{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae"} 488.172178208828 +consul_raft_replication_heartbeat_count{peer_id="3e75e0af-859b-83e8-779f-f3a6d12f02ae"} 601 +consul_raft_replication_heartbeat{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.5"} 0.6106240153312683 +consul_raft_replication_heartbeat{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.9"} 0.9524030089378357 +consul_raft_replication_heartbeat{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7",quantile="0.99"} 0.9726319909095764 +consul_raft_replication_heartbeat_sum{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7"} 459.77358454465866 +consul_raft_replication_heartbeat_count{peer_id="72849161-41cb-14df-fc9b-563ddff3bae7"} 625 +# HELP consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae +# TYPE consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae summary +consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.5"} 0.65802401304245 +consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.9"} 1.0810810327529907 +consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae{quantile="0.99"} 1.4524680376052856 +consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae_sum 509.27614790201187 +consul_raft_replication_heartbeat_3e75e0af_859b_83e8_779f_f3a6d12f02ae_count 601 +# HELP consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7 consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7 +# TYPE consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7 summary +consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.5"} 0.6355040073394775 +consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.9"} 1.000391960144043 +consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7{quantile="0.99"} 1.0161620378494263 +consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7_sum 480.9242581129074 +consul_raft_replication_heartbeat_72849161_41cb_14df_fc9b_563ddff3bae7_count 625 +# HELP consul_raft_rpc_appendEntries consul_raft_rpc_appendEntries +# TYPE consul_raft_rpc_appendEntries summary +consul_raft_rpc_appendEntries{quantile="0.5"} NaN +consul_raft_rpc_appendEntries{quantile="0.9"} NaN +consul_raft_rpc_appendEntries{quantile="0.99"} NaN +consul_raft_rpc_appendEntries_sum 573.4200130868703 +consul_raft_rpc_appendEntries_count 2000 +# HELP consul_raft_rpc_appendEntries_processLogs consul_raft_rpc_appendEntries_processLogs +# TYPE consul_raft_rpc_appendEntries_processLogs summary +consul_raft_rpc_appendEntries_processLogs{quantile="0.5"} NaN +consul_raft_rpc_appendEntries_processLogs{quantile="0.9"} NaN +consul_raft_rpc_appendEntries_processLogs{quantile="0.99"} NaN +consul_raft_rpc_appendEntries_processLogs_sum 148.3990723239258 +consul_raft_rpc_appendEntries_processLogs_count 28 +# HELP consul_raft_rpc_appendEntries_storeLogs consul_raft_rpc_appendEntries_storeLogs +# TYPE consul_raft_rpc_appendEntries_storeLogs summary +consul_raft_rpc_appendEntries_storeLogs{quantile="0.5"} NaN +consul_raft_rpc_appendEntries_storeLogs{quantile="0.9"} NaN +consul_raft_rpc_appendEntries_storeLogs{quantile="0.99"} NaN +consul_raft_rpc_appendEntries_storeLogs_sum 395.2212791442871 +consul_raft_rpc_appendEntries_storeLogs_count 29 +# HELP consul_raft_rpc_installSnapshot Measures the time it takes the raft leader to install a snapshot on a follower that is catching up after being down or has just joined the cluster. +# TYPE consul_raft_rpc_installSnapshot summary +consul_raft_rpc_installSnapshot{quantile="0.5"} NaN +consul_raft_rpc_installSnapshot{quantile="0.9"} NaN +consul_raft_rpc_installSnapshot{quantile="0.99"} NaN +consul_raft_rpc_installSnapshot_sum 0 +consul_raft_rpc_installSnapshot_count 0 +# HELP consul_raft_rpc_processHeartbeat consul_raft_rpc_processHeartbeat +# TYPE consul_raft_rpc_processHeartbeat summary +consul_raft_rpc_processHeartbeat{quantile="0.5"} NaN +consul_raft_rpc_processHeartbeat{quantile="0.9"} NaN +consul_raft_rpc_processHeartbeat{quantile="0.99"} NaN +consul_raft_rpc_processHeartbeat_sum 3.374873999040574 +consul_raft_rpc_processHeartbeat_count 189 +# HELP consul_raft_rpc_requestVote consul_raft_rpc_requestVote +# TYPE consul_raft_rpc_requestVote summary +consul_raft_rpc_requestVote{quantile="0.5"} NaN +consul_raft_rpc_requestVote{quantile="0.9"} NaN +consul_raft_rpc_requestVote{quantile="0.99"} NaN +consul_raft_rpc_requestVote_sum 27.062883377075195 +consul_raft_rpc_requestVote_count 1 +# HELP consul_raft_snapshot_persist Measures the time it takes raft to write a new snapshot to disk. +# TYPE consul_raft_snapshot_persist summary +consul_raft_snapshot_persist{quantile="0.5"} NaN +consul_raft_snapshot_persist{quantile="0.9"} NaN +consul_raft_snapshot_persist{quantile="0.99"} NaN +consul_raft_snapshot_persist_sum 0 +consul_raft_snapshot_persist_count 0 +# HELP consul_raft_state_candidate This increments whenever a Consul server starts an election. +# TYPE consul_raft_state_candidate counter +consul_raft_state_candidate 1 +# HELP consul_raft_state_follower consul_raft_state_follower +# TYPE consul_raft_state_follower counter +consul_raft_state_follower 1 +# HELP consul_raft_state_leader This increments whenever a Consul server becomes a leader. +# TYPE consul_raft_state_leader counter +consul_raft_state_leader 1 +# HELP consul_raft_thread_fsm_saturation consul_raft_thread_fsm_saturation +# TYPE consul_raft_thread_fsm_saturation summary +consul_raft_thread_fsm_saturation{quantile="0.5"} 0 +consul_raft_thread_fsm_saturation{quantile="0.9"} 0 +consul_raft_thread_fsm_saturation{quantile="0.99"} 0 +consul_raft_thread_fsm_saturation_sum 0.14000000059604645 +consul_raft_thread_fsm_saturation_count 75 +# HELP consul_raft_thread_main_saturation consul_raft_thread_main_saturation +# TYPE consul_raft_thread_main_saturation summary +consul_raft_thread_main_saturation{quantile="0.5"} 0 +consul_raft_thread_main_saturation{quantile="0.9"} 0.009999999776482582 +consul_raft_thread_main_saturation{quantile="0.99"} 0.009999999776482582 +consul_raft_thread_main_saturation_sum 0.9699999857693911 +consul_raft_thread_main_saturation_count 328 +# HELP consul_raft_verify_leader consul_raft_verify_leader +# TYPE consul_raft_verify_leader counter +consul_raft_verify_leader 6 +# HELP consul_rpc_accept_conn Increments when a server accepts an RPC connection. +# TYPE consul_rpc_accept_conn counter +consul_rpc_accept_conn 15 +# HELP consul_rpc_consistentRead Measures the time spent confirming that a consistent read can be performed. +# TYPE consul_rpc_consistentRead summary +consul_rpc_consistentRead{quantile="0.5"} NaN +consul_rpc_consistentRead{quantile="0.9"} NaN +consul_rpc_consistentRead{quantile="0.99"} NaN +consul_rpc_consistentRead_sum 3.1557260155677795 +consul_rpc_consistentRead_count 6 +# HELP consul_rpc_cross_dc Increments when a server sends a (potentially blocking) cross datacenter RPC query. +# TYPE consul_rpc_cross_dc counter +consul_rpc_cross_dc 0 +# HELP consul_rpc_queries_blocking Shows the current number of in-flight blocking queries the server is handling. +# TYPE consul_rpc_queries_blocking gauge +consul_rpc_queries_blocking 0 +# HELP consul_rpc_query Increments when a server receives a read request, indicating the rate of new read queries. +# TYPE consul_rpc_query counter +consul_rpc_query 19 +# HELP consul_rpc_raft_handoff Increments when a server accepts a Raft-related RPC connection. +# TYPE consul_rpc_raft_handoff counter +consul_rpc_raft_handoff 4 +# HELP consul_rpc_request Increments when a server receives a Consul-related RPC request. +# TYPE consul_rpc_request counter +consul_rpc_request 936 +# HELP consul_rpc_request_error Increments when a server returns an error from an RPC request. +# TYPE consul_rpc_request_error counter +consul_rpc_request_error 0 +# HELP consul_runtime_gc_pause_ns consul_runtime_gc_pause_ns +# TYPE consul_runtime_gc_pause_ns summary +consul_runtime_gc_pause_ns{quantile="0.5"} NaN +consul_runtime_gc_pause_ns{quantile="0.9"} NaN +consul_runtime_gc_pause_ns{quantile="0.99"} NaN +consul_runtime_gc_pause_ns_sum 1.565053e+07 +consul_runtime_gc_pause_ns_count 42 +# HELP consul_satya_vm_autopilot_failure_tolerance consul_satya_vm_autopilot_failure_tolerance +# TYPE consul_satya_vm_autopilot_failure_tolerance gauge +consul_satya_vm_autopilot_failure_tolerance 1 +# HELP consul_satya_vm_autopilot_healthy consul_satya_vm_autopilot_healthy +# TYPE consul_satya_vm_autopilot_healthy gauge +consul_satya_vm_autopilot_healthy 1 +# HELP consul_satya_vm_consul_members_clients consul_satya_vm_consul_members_clients +# TYPE consul_satya_vm_consul_members_clients gauge +consul_satya_vm_consul_members_clients{datacenter="us-central"} 0 +# HELP consul_satya_vm_consul_members_servers consul_satya_vm_consul_members_servers +# TYPE consul_satya_vm_consul_members_servers gauge +consul_satya_vm_consul_members_servers{datacenter="us-central"} 3 +# HELP consul_satya_vm_consul_state_config_entries consul_satya_vm_consul_state_config_entries +# TYPE consul_satya_vm_consul_state_config_entries gauge +consul_satya_vm_consul_state_config_entries{datacenter="us-central",kind="exported-services"} 0 +consul_satya_vm_consul_state_config_entries{datacenter="us-central",kind="ingress-gateway"} 0 +consul_satya_vm_consul_state_config_entries{datacenter="us-central",kind="mesh"} 0 +consul_satya_vm_consul_state_config_entries{datacenter="us-central",kind="proxy-defaults"} 0 +consul_satya_vm_consul_state_config_entries{datacenter="us-central",kind="service-defaults"} 0 +consul_satya_vm_consul_state_config_entries{datacenter="us-central",kind="service-intentions"} 0 +consul_satya_vm_consul_state_config_entries{datacenter="us-central",kind="service-resolver"} 0 +consul_satya_vm_consul_state_config_entries{datacenter="us-central",kind="service-router"} 0 +consul_satya_vm_consul_state_config_entries{datacenter="us-central",kind="service-splitter"} 0 +consul_satya_vm_consul_state_config_entries{datacenter="us-central",kind="terminating-gateway"} 0 +# HELP consul_satya_vm_consul_state_connect_instances consul_satya_vm_consul_state_connect_instances +# TYPE consul_satya_vm_consul_state_connect_instances gauge +consul_satya_vm_consul_state_connect_instances{datacenter="us-central",kind="connect-native"} 0 +consul_satya_vm_consul_state_connect_instances{datacenter="us-central",kind="connect-proxy"} 0 +consul_satya_vm_consul_state_connect_instances{datacenter="us-central",kind="ingress-gateway"} 0 +consul_satya_vm_consul_state_connect_instances{datacenter="us-central",kind="mesh-gateway"} 0 +consul_satya_vm_consul_state_connect_instances{datacenter="us-central",kind="terminating-gateway"} 0 +# HELP consul_satya_vm_consul_state_kv_entries consul_satya_vm_consul_state_kv_entries +# TYPE consul_satya_vm_consul_state_kv_entries gauge +consul_satya_vm_consul_state_kv_entries{datacenter="us-central"} 1 +# HELP consul_satya_vm_consul_state_nodes consul_satya_vm_consul_state_nodes +# TYPE consul_satya_vm_consul_state_nodes gauge +consul_satya_vm_consul_state_nodes{datacenter="us-central"} 3 +# HELP consul_satya_vm_consul_state_peerings consul_satya_vm_consul_state_peerings +# TYPE consul_satya_vm_consul_state_peerings gauge +consul_satya_vm_consul_state_peerings{datacenter="us-central"} 0 +# HELP consul_satya_vm_consul_state_service_instances consul_satya_vm_consul_state_service_instances +# TYPE consul_satya_vm_consul_state_service_instances gauge +consul_satya_vm_consul_state_service_instances{datacenter="us-central"} 4 +# HELP consul_satya_vm_consul_state_services consul_satya_vm_consul_state_services +# TYPE consul_satya_vm_consul_state_services gauge +consul_satya_vm_consul_state_services{datacenter="us-central"} 2 +# HELP consul_satya_vm_grpc_client_connections consul_satya_vm_grpc_client_connections +# TYPE consul_satya_vm_grpc_client_connections gauge +consul_satya_vm_grpc_client_connections 1 +# HELP consul_satya_vm_grpc_server_connections consul_satya_vm_grpc_server_connections +# TYPE consul_satya_vm_grpc_server_connections gauge +consul_satya_vm_grpc_server_connections 0 +# HELP consul_satya_vm_memberlist_health_score consul_satya_vm_memberlist_health_score +# TYPE consul_satya_vm_memberlist_health_score gauge +consul_satya_vm_memberlist_health_score{network="lan"} 0 +consul_satya_vm_memberlist_health_score{network="wan"} 0 +# HELP consul_satya_vm_mesh_active_root_ca_expiry consul_satya_vm_mesh_active_root_ca_expiry +# TYPE consul_satya_vm_mesh_active_root_ca_expiry gauge +consul_satya_vm_mesh_active_root_ca_expiry NaN +# HELP consul_satya_vm_mesh_active_signing_ca_expiry consul_satya_vm_mesh_active_signing_ca_expiry +# TYPE consul_satya_vm_mesh_active_signing_ca_expiry gauge +consul_satya_vm_mesh_active_signing_ca_expiry NaN +# HELP consul_satya_vm_raft_applied_index consul_satya_vm_raft_applied_index +# TYPE consul_satya_vm_raft_applied_index gauge +consul_satya_vm_raft_applied_index 455437 +# HELP consul_satya_vm_raft_boltdb_freePageBytes consul_satya_vm_raft_boltdb_freePageBytes +# TYPE consul_satya_vm_raft_boltdb_freePageBytes gauge +consul_satya_vm_raft_boltdb_freePageBytes 3.960832e+06 +# HELP consul_satya_vm_raft_boltdb_freelistBytes consul_satya_vm_raft_boltdb_freelistBytes +# TYPE consul_satya_vm_raft_boltdb_freelistBytes gauge +consul_satya_vm_raft_boltdb_freelistBytes 7752 +# HELP consul_satya_vm_raft_boltdb_numFreePages consul_satya_vm_raft_boltdb_numFreePages +# TYPE consul_satya_vm_raft_boltdb_numFreePages gauge +consul_satya_vm_raft_boltdb_numFreePages 961 +# HELP consul_satya_vm_raft_boltdb_numPendingPages consul_satya_vm_raft_boltdb_numPendingPages +# TYPE consul_satya_vm_raft_boltdb_numPendingPages gauge +consul_satya_vm_raft_boltdb_numPendingPages 6 +# HELP consul_satya_vm_raft_boltdb_openReadTxn consul_satya_vm_raft_boltdb_openReadTxn +# TYPE consul_satya_vm_raft_boltdb_openReadTxn gauge +consul_satya_vm_raft_boltdb_openReadTxn 0 +# HELP consul_satya_vm_raft_boltdb_txstats_pageAlloc consul_satya_vm_raft_boltdb_txstats_pageAlloc +# TYPE consul_satya_vm_raft_boltdb_txstats_pageAlloc gauge +consul_satya_vm_raft_boltdb_txstats_pageAlloc 2.465792e+06 +# HELP consul_satya_vm_raft_boltdb_txstats_pageCount consul_satya_vm_raft_boltdb_txstats_pageCount +# TYPE consul_satya_vm_raft_boltdb_txstats_pageCount gauge +consul_satya_vm_raft_boltdb_txstats_pageCount 602 +# HELP consul_satya_vm_raft_commitNumLogs consul_satya_vm_raft_commitNumLogs +# TYPE consul_satya_vm_raft_commitNumLogs gauge +consul_satya_vm_raft_commitNumLogs 1 +# HELP consul_satya_vm_raft_fsm_lastRestoreDuration consul_satya_vm_raft_fsm_lastRestoreDuration +# TYPE consul_satya_vm_raft_fsm_lastRestoreDuration gauge +consul_satya_vm_raft_fsm_lastRestoreDuration 2 +# HELP consul_satya_vm_raft_last_index consul_satya_vm_raft_last_index +# TYPE consul_satya_vm_raft_last_index gauge +consul_satya_vm_raft_last_index 455437 +# HELP consul_satya_vm_raft_leader_dispatchNumLogs consul_satya_vm_raft_leader_dispatchNumLogs +# TYPE consul_satya_vm_raft_leader_dispatchNumLogs gauge +consul_satya_vm_raft_leader_dispatchNumLogs 1 +# HELP consul_satya_vm_raft_leader_oldestLogAge consul_satya_vm_raft_leader_oldestLogAge +# TYPE consul_satya_vm_raft_leader_oldestLogAge gauge +consul_satya_vm_raft_leader_oldestLogAge 1.86193632e+08 +# HELP consul_satya_vm_raft_peers consul_satya_vm_raft_peers +# TYPE consul_satya_vm_raft_peers gauge +consul_satya_vm_raft_peers 3 +# HELP consul_satya_vm_rpc_queries_blocking consul_satya_vm_rpc_queries_blocking +# TYPE consul_satya_vm_rpc_queries_blocking gauge +consul_satya_vm_rpc_queries_blocking 1 +# HELP consul_satya_vm_runtime_alloc_bytes consul_satya_vm_runtime_alloc_bytes +# TYPE consul_satya_vm_runtime_alloc_bytes gauge +consul_satya_vm_runtime_alloc_bytes 3.2406104e+07 +# HELP consul_satya_vm_runtime_free_count consul_satya_vm_runtime_free_count +# TYPE consul_satya_vm_runtime_free_count gauge +consul_satya_vm_runtime_free_count 8.260123e+06 +# HELP consul_satya_vm_runtime_heap_objects consul_satya_vm_runtime_heap_objects +# TYPE consul_satya_vm_runtime_heap_objects gauge +consul_satya_vm_runtime_heap_objects 118531 +# HELP consul_satya_vm_runtime_malloc_count consul_satya_vm_runtime_malloc_count +# TYPE consul_satya_vm_runtime_malloc_count gauge +consul_satya_vm_runtime_malloc_count 8.378654e+06 +# HELP consul_satya_vm_runtime_num_goroutines consul_satya_vm_runtime_num_goroutines +# TYPE consul_satya_vm_runtime_num_goroutines gauge +consul_satya_vm_runtime_num_goroutines 123 +# HELP consul_satya_vm_runtime_sys_bytes consul_satya_vm_runtime_sys_bytes +# TYPE consul_satya_vm_runtime_sys_bytes gauge +consul_satya_vm_runtime_sys_bytes 7.3614344e+07 +# HELP consul_satya_vm_runtime_total_gc_pause_ns consul_satya_vm_runtime_total_gc_pause_ns +# TYPE consul_satya_vm_runtime_total_gc_pause_ns gauge +consul_satya_vm_runtime_total_gc_pause_ns 1.565053e+07 +# HELP consul_satya_vm_runtime_total_gc_runs consul_satya_vm_runtime_total_gc_runs +# TYPE consul_satya_vm_runtime_total_gc_runs gauge +consul_satya_vm_runtime_total_gc_runs 42 +# HELP consul_satya_vm_server_isLeader consul_satya_vm_server_isLeader +# TYPE consul_satya_vm_server_isLeader gauge +consul_satya_vm_server_isLeader 1 +# HELP consul_satya_vm_session_ttl_active consul_satya_vm_session_ttl_active +# TYPE consul_satya_vm_session_ttl_active gauge +consul_satya_vm_session_ttl_active 0 +# HELP consul_satya_vm_version consul_satya_vm_version +# TYPE consul_satya_vm_version gauge +consul_satya_vm_version{pre_release="",version="1.13.2"} 1 +# HELP consul_serf_coordinate_adjustment_ms consul_serf_coordinate_adjustment_ms +# TYPE consul_serf_coordinate_adjustment_ms summary +consul_serf_coordinate_adjustment_ms{network="lan",quantile="0.5"} 0.18447500467300415 +consul_serf_coordinate_adjustment_ms{network="lan",quantile="0.9"} 0.23558799922466278 +consul_serf_coordinate_adjustment_ms{network="lan",quantile="0.99"} 0.3543170094490051 +consul_serf_coordinate_adjustment_ms_sum{network="lan"} 127.64726796071045 +consul_serf_coordinate_adjustment_ms_count{network="lan"} 559 +consul_serf_coordinate_adjustment_ms{network="wan",quantile="0.5"} 0.11145199835300446 +consul_serf_coordinate_adjustment_ms{network="wan",quantile="0.9"} 0.12108899652957916 +consul_serf_coordinate_adjustment_ms{network="wan",quantile="0.99"} 0.12108899652957916 +consul_serf_coordinate_adjustment_ms_sum{network="wan"} 29.19709792546928 +consul_serf_coordinate_adjustment_ms_count{network="wan"} 112 +# HELP consul_serf_events consul_serf_events +# TYPE consul_serf_events counter +consul_serf_events{network="lan"} 2 +# HELP consul_serf_events_consul:new_leader consul_serf_events_consul:new_leader +# TYPE consul_serf_events_consul:new_leader counter +consul_serf_events_consul:new_leader{network="lan"} 2 +# HELP consul_serf_member_join consul_serf_member_join +# TYPE consul_serf_member_join counter +consul_serf_member_join{network="lan"} 5 +consul_serf_member_join{network="wan"} 5 +# HELP consul_serf_member_left consul_serf_member_left +# TYPE consul_serf_member_left counter +consul_serf_member_left{network="lan"} 2 +consul_serf_member_left{network="wan"} 2 +# HELP consul_serf_msgs_received consul_serf_msgs_received +# TYPE consul_serf_msgs_received summary +consul_serf_msgs_received{network="lan",quantile="0.5"} NaN +consul_serf_msgs_received{network="lan",quantile="0.9"} NaN +consul_serf_msgs_received{network="lan",quantile="0.99"} NaN +consul_serf_msgs_received_sum{network="lan"} 1066 +consul_serf_msgs_received_count{network="lan"} 33 +consul_serf_msgs_received{network="wan",quantile="0.5"} NaN +consul_serf_msgs_received{network="wan",quantile="0.9"} NaN +consul_serf_msgs_received{network="wan",quantile="0.99"} NaN +consul_serf_msgs_received_sum{network="wan"} 909 +consul_serf_msgs_received_count{network="wan"} 23 +# HELP consul_serf_msgs_sent consul_serf_msgs_sent +# TYPE consul_serf_msgs_sent summary +consul_serf_msgs_sent{network="lan",quantile="0.5"} NaN +consul_serf_msgs_sent{network="lan",quantile="0.9"} NaN +consul_serf_msgs_sent{network="lan",quantile="0.99"} NaN +consul_serf_msgs_sent_sum{network="lan"} 1204 +consul_serf_msgs_sent_count{network="lan"} 36 +consul_serf_msgs_sent{network="wan",quantile="0.5"} NaN +consul_serf_msgs_sent{network="wan",quantile="0.9"} NaN +consul_serf_msgs_sent{network="wan",quantile="0.99"} NaN +consul_serf_msgs_sent_sum{network="wan"} 792 +consul_serf_msgs_sent_count{network="wan"} 20 +# HELP consul_serf_queue_Event consul_serf_queue_Event +# TYPE consul_serf_queue_Event summary +consul_serf_queue_Event{network="lan",quantile="0.5"} NaN +consul_serf_queue_Event{network="lan",quantile="0.9"} NaN +consul_serf_queue_Event{network="lan",quantile="0.99"} NaN +consul_serf_queue_Event_sum{network="lan"} 0 +consul_serf_queue_Event_count{network="lan"} 19 +consul_serf_queue_Event{network="wan",quantile="0.5"} NaN +consul_serf_queue_Event{network="wan",quantile="0.9"} NaN +consul_serf_queue_Event{network="wan",quantile="0.99"} NaN +consul_serf_queue_Event_sum{network="wan"} 0 +consul_serf_queue_Event_count{network="wan"} 19 +# HELP consul_serf_queue_Intent consul_serf_queue_Intent +# TYPE consul_serf_queue_Intent summary +consul_serf_queue_Intent{network="lan",quantile="0.5"} NaN +consul_serf_queue_Intent{network="lan",quantile="0.9"} NaN +consul_serf_queue_Intent{network="lan",quantile="0.99"} NaN +consul_serf_queue_Intent_sum{network="lan"} 0 +consul_serf_queue_Intent_count{network="lan"} 19 +consul_serf_queue_Intent{network="wan",quantile="0.5"} NaN +consul_serf_queue_Intent{network="wan",quantile="0.9"} NaN +consul_serf_queue_Intent{network="wan",quantile="0.99"} NaN +consul_serf_queue_Intent_sum{network="wan"} 1 +consul_serf_queue_Intent_count{network="wan"} 19 +# HELP consul_serf_queue_Query consul_serf_queue_Query +# TYPE consul_serf_queue_Query summary +consul_serf_queue_Query{network="lan",quantile="0.5"} NaN +consul_serf_queue_Query{network="lan",quantile="0.9"} NaN +consul_serf_queue_Query{network="lan",quantile="0.99"} NaN +consul_serf_queue_Query_sum{network="lan"} 0 +consul_serf_queue_Query_count{network="lan"} 19 +consul_serf_queue_Query{network="wan",quantile="0.5"} NaN +consul_serf_queue_Query{network="wan",quantile="0.9"} NaN +consul_serf_queue_Query{network="wan",quantile="0.99"} NaN +consul_serf_queue_Query_sum{network="wan"} 0 +consul_serf_queue_Query_count{network="wan"} 19 +# HELP consul_serf_snapshot_appendLine consul_serf_snapshot_appendLine +# TYPE consul_serf_snapshot_appendLine summary +consul_serf_snapshot_appendLine{network="lan",quantile="0.5"} NaN +consul_serf_snapshot_appendLine{network="lan",quantile="0.9"} NaN +consul_serf_snapshot_appendLine{network="lan",quantile="0.99"} NaN +consul_serf_snapshot_appendLine_sum{network="lan"} 0.3810300036566332 +consul_serf_snapshot_appendLine_count{network="lan"} 15 +consul_serf_snapshot_appendLine{network="wan",quantile="0.5"} NaN +consul_serf_snapshot_appendLine{network="wan",quantile="0.9"} NaN +consul_serf_snapshot_appendLine{network="wan",quantile="0.99"} NaN +consul_serf_snapshot_appendLine_sum{network="wan"} 0.3907299981219694 +consul_serf_snapshot_appendLine_count{network="wan"} 13 +# HELP consul_server_isLeader Tracks if the server is a leader. +# TYPE consul_server_isLeader gauge +consul_server_isLeader 0 +# HELP consul_session_apply Measures the time spent applying a session update. +# TYPE consul_session_apply summary +consul_session_apply{quantile="0.5"} NaN +consul_session_apply{quantile="0.9"} NaN +consul_session_apply{quantile="0.99"} NaN +consul_session_apply_sum 0 +consul_session_apply_count 0 +# HELP consul_session_renew Measures the time spent renewing a session. +# TYPE consul_session_renew summary +consul_session_renew{quantile="0.5"} NaN +consul_session_renew{quantile="0.9"} NaN +consul_session_renew{quantile="0.99"} NaN +consul_session_renew_sum 0 +consul_session_renew_count 0 +# HELP consul_session_ttl_active Tracks the active number of sessions being tracked. +# TYPE consul_session_ttl_active gauge +consul_session_ttl_active 0 +# HELP consul_session_ttl_invalidate Measures the time spent invalidating an expired session. +# TYPE consul_session_ttl_invalidate summary +consul_session_ttl_invalidate{quantile="0.5"} NaN +consul_session_ttl_invalidate{quantile="0.9"} NaN +consul_session_ttl_invalidate{quantile="0.99"} NaN +consul_session_ttl_invalidate_sum 0 +consul_session_ttl_invalidate_count 0 +# HELP consul_txn_apply Measures the time spent applying a transaction operation. +# TYPE consul_txn_apply summary +consul_txn_apply{quantile="0.5"} NaN +consul_txn_apply{quantile="0.9"} NaN +consul_txn_apply{quantile="0.99"} NaN +consul_txn_apply_sum 0 +consul_txn_apply_count 0 +# HELP consul_txn_read Measures the time spent returning a read transaction. +# TYPE consul_txn_read summary +consul_txn_read{quantile="0.5"} NaN +consul_txn_read{quantile="0.9"} NaN +consul_txn_read{quantile="0.99"} NaN +consul_txn_read_sum 0 +consul_txn_read_count 0 +# HELP consul_version Represents the Consul version. +# TYPE consul_version gauge +consul_version 0 +# HELP consul_xds_server_streams Measures the number of active xDS streams handled by the server split by protocol version. +# TYPE consul_xds_server_streams gauge +consul_xds_server_streams 0 +# HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles. +# TYPE go_gc_duration_seconds summary +go_gc_duration_seconds{quantile="0"} 5.3269e-05 +go_gc_duration_seconds{quantile="0.25"} 0.000130599 +go_gc_duration_seconds{quantile="0.5"} 0.000271028 +go_gc_duration_seconds{quantile="0.75"} 0.000362027 +go_gc_duration_seconds{quantile="1"} 0.002227924 +go_gc_duration_seconds_sum 0.01565053 +go_gc_duration_seconds_count 42 +# HELP go_goroutines Number of goroutines that currently exist. +# TYPE go_goroutines gauge +go_goroutines 130 +# HELP go_info Information about the Go environment. +# TYPE go_info gauge +go_info{version="go1.18.1"} 1 +# HELP go_memstats_alloc_bytes Number of bytes allocated and still in use. +# TYPE go_memstats_alloc_bytes gauge +go_memstats_alloc_bytes 3.2922384e+07 +# HELP go_memstats_alloc_bytes_total Total number of bytes allocated, even if freed. +# TYPE go_memstats_alloc_bytes_total counter +go_memstats_alloc_bytes_total 7.39548784e+08 +# HELP go_memstats_buck_hash_sys_bytes Number of bytes used by the profiling bucket hash table. +# TYPE go_memstats_buck_hash_sys_bytes gauge +go_memstats_buck_hash_sys_bytes 1.625099e+06 +# HELP go_memstats_frees_total Total number of frees. +# TYPE go_memstats_frees_total counter +go_memstats_frees_total 8.260339e+06 +# HELP go_memstats_gc_cpu_fraction The fraction of this program's available CPU time used by the GC since the program started. +# TYPE go_memstats_gc_cpu_fraction gauge +go_memstats_gc_cpu_fraction 7.265691723511656e-05 +# HELP go_memstats_gc_sys_bytes Number of bytes used for garbage collection system metadata. +# TYPE go_memstats_gc_sys_bytes gauge +go_memstats_gc_sys_bytes 6.583e+06 +# HELP go_memstats_heap_alloc_bytes Number of heap bytes allocated and still in use. +# TYPE go_memstats_heap_alloc_bytes gauge +go_memstats_heap_alloc_bytes 3.2922384e+07 +# HELP go_memstats_heap_idle_bytes Number of heap bytes waiting to be used. +# TYPE go_memstats_heap_idle_bytes gauge +go_memstats_heap_idle_bytes 2.3904256e+07 +# HELP go_memstats_heap_inuse_bytes Number of heap bytes that are in use. +# TYPE go_memstats_heap_inuse_bytes gauge +go_memstats_heap_inuse_bytes 3.72736e+07 +# HELP go_memstats_heap_objects Number of allocated objects. +# TYPE go_memstats_heap_objects gauge +go_memstats_heap_objects 122074 +# HELP go_memstats_heap_released_bytes Number of heap bytes released to OS. +# TYPE go_memstats_heap_released_bytes gauge +go_memstats_heap_released_bytes 1.6113664e+07 +# HELP go_memstats_heap_sys_bytes Number of heap bytes obtained from system. +# TYPE go_memstats_heap_sys_bytes gauge +go_memstats_heap_sys_bytes 6.1177856e+07 +# HELP go_memstats_last_gc_time_seconds Number of seconds since 1970 of last garbage collection. +# TYPE go_memstats_last_gc_time_seconds gauge +go_memstats_last_gc_time_seconds 1.6713887082058973e+09 +# HELP go_memstats_lookups_total Total number of pointer lookups. +# TYPE go_memstats_lookups_total counter +go_memstats_lookups_total 0 +# HELP go_memstats_mallocs_total Total number of mallocs. +# TYPE go_memstats_mallocs_total counter +go_memstats_mallocs_total 8.382413e+06 +# HELP go_memstats_mcache_inuse_bytes Number of bytes in use by mcache structures. +# TYPE go_memstats_mcache_inuse_bytes gauge +go_memstats_mcache_inuse_bytes 9600 +# HELP go_memstats_mcache_sys_bytes Number of bytes used for mcache structures obtained from system. +# TYPE go_memstats_mcache_sys_bytes gauge +go_memstats_mcache_sys_bytes 15600 +# HELP go_memstats_mspan_inuse_bytes Number of bytes in use by mspan structures. +# TYPE go_memstats_mspan_inuse_bytes gauge +go_memstats_mspan_inuse_bytes 375768 +# HELP go_memstats_mspan_sys_bytes Number of bytes used for mspan structures obtained from system. +# TYPE go_memstats_mspan_sys_bytes gauge +go_memstats_mspan_sys_bytes 603840 +# HELP go_memstats_next_gc_bytes Number of heap bytes when next garbage collection will take place. +# TYPE go_memstats_next_gc_bytes gauge +go_memstats_next_gc_bytes 4.5858448e+07 +# HELP go_memstats_other_sys_bytes Number of bytes used for other system allocations. +# TYPE go_memstats_other_sys_bytes gauge +go_memstats_other_sys_bytes 1.872245e+06 +# HELP go_memstats_stack_inuse_bytes Number of bytes in use by the stack allocator. +# TYPE go_memstats_stack_inuse_bytes gauge +go_memstats_stack_inuse_bytes 1.736704e+06 +# HELP go_memstats_stack_sys_bytes Number of bytes obtained from system for stack allocator. +# TYPE go_memstats_stack_sys_bytes gauge +go_memstats_stack_sys_bytes 1.736704e+06 +# HELP go_memstats_sys_bytes Number of bytes obtained from system. +# TYPE go_memstats_sys_bytes gauge +go_memstats_sys_bytes 7.3614344e+07 +# HELP go_threads Number of OS threads created. +# TYPE go_threads gauge +go_threads 14 +# HELP process_cpu_seconds_total Total user and system CPU time spent in seconds. +# TYPE process_cpu_seconds_total counter +process_cpu_seconds_total 20.7 +# HELP process_max_fds Maximum number of open file descriptors. +# TYPE process_max_fds gauge +process_max_fds 1024 +# HELP process_open_fds Number of open file descriptors. +# TYPE process_open_fds gauge +process_open_fds 33 +# HELP process_resident_memory_bytes Resident memory size in bytes. +# TYPE process_resident_memory_bytes gauge +process_resident_memory_bytes 1.22032128e+08 +# HELP process_start_time_seconds Start time of the process since unix epoch in seconds. +# TYPE process_start_time_seconds gauge +process_start_time_seconds 1.67138812259e+09 +# HELP process_virtual_memory_bytes Virtual memory size in bytes. +# TYPE process_virtual_memory_bytes gauge +process_virtual_memory_bytes 8.48359424e+08 +# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes. +# TYPE process_virtual_memory_max_bytes gauge +process_virtual_memory_max_bytes -1
\ No newline at end of file diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self.json new file mode 100644 index 000000000..0b11cda53 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self.json @@ -0,0 +1,50 @@ +{ + "Config": { + "Datacenter": "us-central", + "PrimaryDatacenter": "us-central", + "NodeName": "satya-vm", + "NodeID": "d86b8af4-5dc5-d790-7c32-420d4ac1dd8d", + "Revision": "0e046bbb", + "Server": true, + "Version": "1.13.2", + "BuildDate": "2022-09-20T20:30:07Z" + }, + "DebugConfig": { + "Telemetry": { + "AllowedPrefixes": [], + "BlockedPrefixes": [ + "consul.rpc.server.call" + ], + "CirconusAPIApp": "", + "CirconusAPIToken": "hidden", + "CirconusAPIURL": "", + "CirconusBrokerID": "", + "CirconusBrokerSelectTag": "", + "CirconusCheckDisplayName": "", + "CirconusCheckForceMetricActivation": "", + "CirconusCheckID": "", + "CirconusCheckInstanceID": "", + "CirconusCheckSearchTag": "", + "CirconusCheckTags": "", + "CirconusSubmissionInterval": "", + "CirconusSubmissionURL": "", + "Disable": false, + "DisableHostname": false, + "DogstatsdAddr": "", + "DogstatsdTags": [], + "FilterDefault": true, + "MetricsPrefix": "consul", + "PrometheusOpts": { + "CounterDefinitions": [], + "Expiration": "2m0s", + "GaugeDefinitions": [], + "Name": "consul", + "Registerer": null, + "SummaryDefinitions": [] + }, + "RetryFailedConfiguration": true, + "StatsdAddr": "", + "StatsiteAddr": "" + } + } +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self_cloud-managed.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self_cloud-managed.json new file mode 100644 index 000000000..0b11cda53 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self_cloud-managed.json @@ -0,0 +1,50 @@ +{ + "Config": { + "Datacenter": "us-central", + "PrimaryDatacenter": "us-central", + "NodeName": "satya-vm", + "NodeID": "d86b8af4-5dc5-d790-7c32-420d4ac1dd8d", + "Revision": "0e046bbb", + "Server": true, + "Version": "1.13.2", + "BuildDate": "2022-09-20T20:30:07Z" + }, + "DebugConfig": { + "Telemetry": { + "AllowedPrefixes": [], + "BlockedPrefixes": [ + "consul.rpc.server.call" + ], + "CirconusAPIApp": "", + "CirconusAPIToken": "hidden", + "CirconusAPIURL": "", + "CirconusBrokerID": "", + "CirconusBrokerSelectTag": "", + "CirconusCheckDisplayName": "", + "CirconusCheckForceMetricActivation": "", + "CirconusCheckID": "", + "CirconusCheckInstanceID": "", + "CirconusCheckSearchTag": "", + "CirconusCheckTags": "", + "CirconusSubmissionInterval": "", + "CirconusSubmissionURL": "", + "Disable": false, + "DisableHostname": false, + "DogstatsdAddr": "", + "DogstatsdTags": [], + "FilterDefault": true, + "MetricsPrefix": "consul", + "PrometheusOpts": { + "CounterDefinitions": [], + "Expiration": "2m0s", + "GaugeDefinitions": [], + "Name": "consul", + "Registerer": null, + "SummaryDefinitions": [] + }, + "RetryFailedConfiguration": true, + "StatsdAddr": "", + "StatsiteAddr": "" + } + } +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self_disabled_prom.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self_disabled_prom.json new file mode 100644 index 000000000..c964d10fe --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self_disabled_prom.json @@ -0,0 +1,50 @@ +{ + "Config": { + "Datacenter": "us-central", + "PrimaryDatacenter": "us-central", + "NodeName": "satya-vm", + "NodeID": "d86b8af4-5dc5-d790-7c32-420d4ac1dd8d", + "Revision": "0e046bbb", + "Server": true, + "Version": "1.13.2", + "BuildDate": "2022-09-20T20:30:07Z" + }, + "DebugConfig": { + "Telemetry": { + "AllowedPrefixes": [], + "BlockedPrefixes": [ + "consul.rpc.server.call" + ], + "CirconusAPIApp": "", + "CirconusAPIToken": "hidden", + "CirconusAPIURL": "", + "CirconusBrokerID": "", + "CirconusBrokerSelectTag": "", + "CirconusCheckDisplayName": "", + "CirconusCheckForceMetricActivation": "", + "CirconusCheckID": "", + "CirconusCheckInstanceID": "", + "CirconusCheckSearchTag": "", + "CirconusCheckTags": "", + "CirconusSubmissionInterval": "", + "CirconusSubmissionURL": "", + "Disable": false, + "DisableHostname": false, + "DogstatsdAddr": "", + "DogstatsdTags": [], + "FilterDefault": true, + "MetricsPrefix": "consul", + "PrometheusOpts": { + "CounterDefinitions": [], + "Expiration": "0s", + "GaugeDefinitions": [], + "Name": "consul", + "Registerer": null, + "SummaryDefinitions": [] + }, + "RetryFailedConfiguration": true, + "StatsdAddr": "", + "StatsiteAddr": "" + } + } +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self_with_hostname.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self_with_hostname.json new file mode 100644 index 000000000..dfe37bcc0 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-agent-self_with_hostname.json @@ -0,0 +1,50 @@ +{ + "Config": { + "Datacenter": "us-central", + "PrimaryDatacenter": "us-central", + "NodeName": "satya-vm", + "NodeID": "d86b8af4-5dc5-d790-7c32-420d4ac1dd8d", + "Revision": "0e046bbb", + "Server": false, + "Version": "1.13.2", + "BuildDate": "2022-09-20T20:30:07Z" + }, + "DebugConfig": { + "Telemetry": { + "AllowedPrefixes": [], + "BlockedPrefixes": [ + "consul.rpc.server.call" + ], + "CirconusAPIApp": "", + "CirconusAPIToken": "hidden", + "CirconusAPIURL": "", + "CirconusBrokerID": "", + "CirconusBrokerSelectTag": "", + "CirconusCheckDisplayName": "", + "CirconusCheckForceMetricActivation": "", + "CirconusCheckID": "", + "CirconusCheckInstanceID": "", + "CirconusCheckSearchTag": "", + "CirconusCheckTags": "", + "CirconusSubmissionInterval": "", + "CirconusSubmissionURL": "", + "Disable": false, + "DisableHostname": false, + "DogstatsdAddr": "", + "DogstatsdTags": [], + "FilterDefault": true, + "MetricsPrefix": "consul", + "PrometheusOpts": { + "CounterDefinitions": [], + "Expiration": "10m0s", + "GaugeDefinitions": [], + "Name": "consul", + "Registerer": null, + "SummaryDefinitions": [] + }, + "RetryFailedConfiguration": true, + "StatsdAddr": "", + "StatsiteAddr": "" + } + } +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-coordinate-nodes.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-coordinate-nodes.json new file mode 100644 index 000000000..8f3f63839 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-coordinate-nodes.json @@ -0,0 +1,59 @@ +[ + { + "Node": "satya-vm", + "Segment": "", + "Coord": { + "Vec": [ + 0.014829503547751722, + 0.0072173849395880596, + 0.004329474334739038, + -0.0032798752739064438, + -0.010134170963372591, + -0.008257638503292454, + 0.00752142875530981, + 0.0017901665053347217 + ], + "Error": 0.493977389081921, + "Adjustment": 0.00017401717315766792, + "Height": 2.8272088782225915e-05 + } + }, + { + "Node": "satya-vm2", + "Segment": "", + "Coord": { + "Vec": [ + 0.01485399579339927, + 0.007233318963330601, + 0.004314864811042585, + -0.0032764668107421653, + -0.010133938771787391, + -0.008238915750721635, + 0.0075168683512753035, + 0.001776534386752108 + ], + "Error": 0.3003366063730667, + "Adjustment": 0.00019935098724887628, + "Height": 4.192904954404545e-05 + } + }, + { + "Node": "satya-vm3", + "Segment": "", + "Coord": { + "Vec": [ + 0.014782092899311995, + 0.007186516660508205, + 0.004357885422476095, + -0.003286526239099157, + -0.010134722455521066, + -0.008294075475167818, + 0.007530358624901773, + 0.0018166544975743123 + ], + "Error": 0.12048664650994341, + "Adjustment": 0.00014477073973997567, + "Height": 0.0005656138448826895 + } + } +] diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-operator-autopilot-health.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-operator-autopilot-health.json new file mode 100644 index 000000000..4acee01ec --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/server_v1-operator-autopilot-health.json @@ -0,0 +1,48 @@ +{ + "Healthy": true, + "FailureTolerance": 1, + "Servers": [ + { + "ID": "72849161-41cb-14df-fc9b-563ddff3bae7", + "Name": "satya-vm3", + "Address": "10.10.30.119:8300", + "SerfStatus": "alive", + "Version": "1.13.2", + "Leader": false, + "LastContact": "54.653679ms", + "LastTerm": 29, + "LastIndex": 486777, + "Healthy": true, + "Voter": true, + "StableSince": "2022-12-21T13:53:42Z" + }, + { + "ID": "3e75e0af-859b-83e8-779f-f3a6d12f02ae", + "Name": "satya-vm2", + "Address": "10.10.30.176:8300", + "SerfStatus": "alive", + "Version": "1.13.2", + "Leader": true, + "LastContact": "0ms", + "LastTerm": 29, + "LastIndex": 486777, + "Healthy": true, + "Voter": true, + "StableSince": "2022-12-21T13:53:46Z" + }, + { + "ID": "d86b8af4-5dc5-d790-7c32-420d4ac1dd8d", + "Name": "satya-vm", + "Address": "10.10.30.177:8300", + "SerfStatus": "alive", + "Version": "1.13.2", + "Leader": false, + "LastContact": "13.211617ms", + "LastTerm": 29, + "LastIndex": 486777, + "Healthy": true, + "Voter": true, + "StableSince": "2022-12-20T09:55:28Z" + } + ] +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/v1-agent-checks.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/v1-agent-checks.json new file mode 100644 index 000000000..b8967cb74 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.13.2/v1-agent-checks.json @@ -0,0 +1,68 @@ +{ + "chk1": { + "Node": "mysql1", + "CheckID": "chk1", + "Name": "ssh", + "Status": "passing", + "Notes": "", + "Output": "TCP connect 127.0.0.1:22: Success", + "ServiceID": "", + "ServiceName": "", + "ServiceTags": [ + ], + "Definition": { + }, + "CreateIndex": 0, + "ModifyIndex": 0 + }, + "chk2": { + "Node": "mysql1", + "CheckID": "chk2", + "Name": "telnet", + "Status": "critical", + "Notes": "", + "Output": "dial tcp 127.0.0.1:23: connect: connection refused", + "ServiceID": "", + "ServiceName": "", + "ServiceTags": [ + ], + "Definition": { + }, + "CreateIndex": 0, + "ModifyIndex": 0 + }, + "chk3": { + "Node": "mysql1", + "CheckID": "chk3", + "Name": "telnet", + "Status": "critical", + "Notes": "", + "Output": "dial tcp 127.0.0.1:23: connect: connection refused", + "ServiceID": "", + "ServiceName": "", + "ServiceTags": [ + ], + "Definition": { + }, + "CreateIndex": 0, + "ModifyIndex": 0 + }, + "mysql": { + "Node": "mysql1", + "CheckID": "mysql", + "Name": "MYSQL TCP on port 3336", + "Status": "critical", + "Notes": "", + "Output": "dial tcp 127.0.0.1:3336: connect: connection refused", + "ServiceID": "mysql0", + "ServiceName": "mysql", + "ServiceTags": [ + "primary", + "secondary" + ], + "Definition": { + }, + "CreateIndex": 0, + "ModifyIndex": 0 + } +}
\ No newline at end of file diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/server_v1-agent-metrics.txt b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/server_v1-agent-metrics.txt new file mode 100644 index 000000000..094f03508 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/server_v1-agent-metrics.txt @@ -0,0 +1,1502 @@ +# HELP consul_acl_ResolveToken This measures the time it takes to resolve an ACL token. +# TYPE consul_acl_ResolveToken summary +consul_acl_ResolveToken{quantile="0.5"} 0.05904199928045273 +consul_acl_ResolveToken{quantile="0.9"} 0.1010729968547821 +consul_acl_ResolveToken{quantile="0.99"} 0.18903599679470062 +consul_acl_ResolveToken_sum 59019.61223328998 +consul_acl_ResolveToken_count 863476 +# HELP consul_acl_authmethod_delete +# TYPE consul_acl_authmethod_delete summary +consul_acl_authmethod_delete{quantile="0.5"} NaN +consul_acl_authmethod_delete{quantile="0.9"} NaN +consul_acl_authmethod_delete{quantile="0.99"} NaN +consul_acl_authmethod_delete_sum 0 +consul_acl_authmethod_delete_count 0 +# HELP consul_acl_authmethod_upsert +# TYPE consul_acl_authmethod_upsert summary +consul_acl_authmethod_upsert{quantile="0.5"} NaN +consul_acl_authmethod_upsert{quantile="0.9"} NaN +consul_acl_authmethod_upsert{quantile="0.99"} NaN +consul_acl_authmethod_upsert_sum 0 +consul_acl_authmethod_upsert_count 0 +# HELP consul_acl_bindingrule_delete +# TYPE consul_acl_bindingrule_delete summary +consul_acl_bindingrule_delete{quantile="0.5"} NaN +consul_acl_bindingrule_delete{quantile="0.9"} NaN +consul_acl_bindingrule_delete{quantile="0.99"} NaN +consul_acl_bindingrule_delete_sum 0 +consul_acl_bindingrule_delete_count 0 +# HELP consul_acl_bindingrule_upsert +# TYPE consul_acl_bindingrule_upsert summary +consul_acl_bindingrule_upsert{quantile="0.5"} NaN +consul_acl_bindingrule_upsert{quantile="0.9"} NaN +consul_acl_bindingrule_upsert{quantile="0.99"} NaN +consul_acl_bindingrule_upsert_sum 0 +consul_acl_bindingrule_upsert_count 0 +# HELP consul_acl_blocked_check_deregistration Increments whenever a deregistration fails for a check (blocked by an ACL) +# TYPE consul_acl_blocked_check_deregistration counter +consul_acl_blocked_check_deregistration 0 +# HELP consul_acl_blocked_check_registration Increments whenever a registration fails for a check (blocked by an ACL) +# TYPE consul_acl_blocked_check_registration counter +consul_acl_blocked_check_registration 0 +# HELP consul_acl_blocked_node_registration Increments whenever a registration fails for a node (blocked by an ACL) +# TYPE consul_acl_blocked_node_registration counter +consul_acl_blocked_node_registration 0 +# HELP consul_acl_blocked_service_deregistration Increments whenever a deregistration fails for a service (blocked by an ACL) +# TYPE consul_acl_blocked_service_deregistration counter +consul_acl_blocked_service_deregistration 0 +# HELP consul_acl_blocked_service_registration Increments whenever a registration fails for a service (blocked by an ACL) +# TYPE consul_acl_blocked_service_registration counter +consul_acl_blocked_service_registration 0 +# HELP consul_acl_login +# TYPE consul_acl_login summary +consul_acl_login{quantile="0.5"} NaN +consul_acl_login{quantile="0.9"} NaN +consul_acl_login{quantile="0.99"} NaN +consul_acl_login_sum 0 +consul_acl_login_count 0 +# HELP consul_acl_logout +# TYPE consul_acl_logout summary +consul_acl_logout{quantile="0.5"} NaN +consul_acl_logout{quantile="0.9"} NaN +consul_acl_logout{quantile="0.99"} NaN +consul_acl_logout_sum 0 +consul_acl_logout_count 0 +# HELP consul_acl_policy_delete +# TYPE consul_acl_policy_delete summary +consul_acl_policy_delete{quantile="0.5"} NaN +consul_acl_policy_delete{quantile="0.9"} NaN +consul_acl_policy_delete{quantile="0.99"} NaN +consul_acl_policy_delete_sum 2.2944839000701904 +consul_acl_policy_delete_count 1 +# HELP consul_acl_policy_upsert +# TYPE consul_acl_policy_upsert summary +consul_acl_policy_upsert{quantile="0.5"} NaN +consul_acl_policy_upsert{quantile="0.9"} NaN +consul_acl_policy_upsert{quantile="0.99"} NaN +consul_acl_policy_upsert_sum 173.05634947121143 +consul_acl_policy_upsert_count 11 +# HELP consul_acl_role_delete +# TYPE consul_acl_role_delete summary +consul_acl_role_delete{quantile="0.5"} NaN +consul_acl_role_delete{quantile="0.9"} NaN +consul_acl_role_delete{quantile="0.99"} NaN +consul_acl_role_delete_sum 0 +consul_acl_role_delete_count 0 +# HELP consul_acl_role_upsert +# TYPE consul_acl_role_upsert summary +consul_acl_role_upsert{quantile="0.5"} NaN +consul_acl_role_upsert{quantile="0.9"} NaN +consul_acl_role_upsert{quantile="0.99"} NaN +consul_acl_role_upsert_sum 0 +consul_acl_role_upsert_count 0 +# HELP consul_acl_token_cache_hit Increments if Consul is able to resolve a token's identity, or a legacy token, from the cache. +# TYPE consul_acl_token_cache_hit counter +consul_acl_token_cache_hit 0 +# HELP consul_acl_token_cache_miss Increments if Consul cannot resolve a token's identity, or a legacy token, from the cache. +# TYPE consul_acl_token_cache_miss counter +consul_acl_token_cache_miss 0 +# HELP consul_acl_token_clone +# TYPE consul_acl_token_clone summary +consul_acl_token_clone{quantile="0.5"} NaN +consul_acl_token_clone{quantile="0.9"} NaN +consul_acl_token_clone{quantile="0.99"} NaN +consul_acl_token_clone_sum 0 +consul_acl_token_clone_count 0 +# HELP consul_acl_token_delete +# TYPE consul_acl_token_delete summary +consul_acl_token_delete{quantile="0.5"} NaN +consul_acl_token_delete{quantile="0.9"} NaN +consul_acl_token_delete{quantile="0.99"} NaN +consul_acl_token_delete_sum 35.43468403816223 +consul_acl_token_delete_count 12 +# HELP consul_acl_token_upsert +# TYPE consul_acl_token_upsert summary +consul_acl_token_upsert{quantile="0.5"} NaN +consul_acl_token_upsert{quantile="0.9"} NaN +consul_acl_token_upsert{quantile="0.99"} NaN +consul_acl_token_upsert_sum 33.15468955039978 +consul_acl_token_upsert_count 9 +# HELP consul_agent_event consul_agent_event +# TYPE consul_agent_event counter +consul_agent_event 793609 +# HELP consul_agent_tls_cert_expiry Seconds until the agent tls certificate expires. Updated every hour +# TYPE consul_agent_tls_cert_expiry gauge +consul_agent_tls_cert_expiry 0 +# HELP consul_agent_write_event consul_agent_write_event +# TYPE consul_agent_write_event summary +consul_agent_write_event{quantile="0.5"} 0.012071000412106514 +consul_agent_write_event{quantile="0.9"} 0.03231099992990494 +consul_agent_write_event{quantile="0.99"} 0.038460999727249146 +consul_agent_write_event_sum 17825.32184328325 +consul_agent_write_event_count 793609 +# HELP consul_api_http Samples how long it takes to service the given HTTP request for the given verb and path. +# TYPE consul_api_http summary +consul_api_http{quantile="0.5"} NaN +consul_api_http{quantile="0.9"} NaN +consul_api_http{quantile="0.99"} NaN +consul_api_http_sum 0 +consul_api_http_count 0 +consul_api_http{method="GET",path="v1_acl_policy_",quantile="0.5"} NaN +consul_api_http{method="GET",path="v1_acl_policy_",quantile="0.9"} NaN +consul_api_http{method="GET",path="v1_acl_policy_",quantile="0.99"} NaN +consul_api_http_sum{method="GET",path="v1_acl_policy_"} 0.3439910039305687 +consul_api_http_count{method="GET",path="v1_acl_policy_"} 2 +consul_api_http{method="GET",path="v1_acl_policy_name_",quantile="0.5"} NaN +consul_api_http{method="GET",path="v1_acl_policy_name_",quantile="0.9"} NaN +consul_api_http{method="GET",path="v1_acl_policy_name_",quantile="0.99"} NaN +consul_api_http_sum{method="GET",path="v1_acl_policy_name_"} 0.2537579983472824 +consul_api_http_count{method="GET",path="v1_acl_policy_name_"} 2 +consul_api_http{method="GET",path="v1_acl_token_",quantile="0.5"} NaN +consul_api_http{method="GET",path="v1_acl_token_",quantile="0.9"} NaN +consul_api_http{method="GET",path="v1_acl_token_",quantile="0.99"} NaN +consul_api_http_sum{method="GET",path="v1_acl_token_"} 292.9099607616663 +consul_api_http_count{method="GET",path="v1_acl_token_"} 1447 +consul_api_http{method="GET",path="v1_agent_members",quantile="0.5"} NaN +consul_api_http{method="GET",path="v1_agent_members",quantile="0.9"} NaN +consul_api_http{method="GET",path="v1_agent_members",quantile="0.99"} NaN +consul_api_http_sum{method="GET",path="v1_agent_members"} 1504.3780329823494 +consul_api_http_count{method="GET",path="v1_agent_members"} 15059 +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.5"} NaN +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.9"} NaN +consul_api_http{method="GET",path="v1_agent_metrics",quantile="0.99"} NaN +consul_api_http_sum{method="GET",path="v1_agent_metrics"} 47773.76364764571 +consul_api_http_count{method="GET",path="v1_agent_metrics"} 10129 +consul_api_http{method="GET",path="v1_agent_self",quantile="0.5"} NaN +consul_api_http{method="GET",path="v1_agent_self",quantile="0.9"} NaN +consul_api_http{method="GET",path="v1_agent_self",quantile="0.99"} NaN +consul_api_http_sum{method="GET",path="v1_agent_self"} 9246.783903598785 +consul_api_http_count{method="GET",path="v1_agent_self"} 7567 +consul_api_http{method="GET",path="v1_catalog_node-services_",quantile="0.5"} 0.8214660286903381 +consul_api_http{method="GET",path="v1_catalog_node-services_",quantile="0.9"} 1.1057649850845337 +consul_api_http{method="GET",path="v1_catalog_node-services_",quantile="0.99"} 1.1057649850845337 +consul_api_http_sum{method="GET",path="v1_catalog_node-services_"} 824.5040957331657 +consul_api_http_count{method="GET",path="v1_catalog_node-services_"} 1069 +consul_api_http{method="GET",path="v1_catalog_nodes",quantile="0.5"} NaN +consul_api_http{method="GET",path="v1_catalog_nodes",quantile="0.9"} NaN +consul_api_http{method="GET",path="v1_catalog_nodes",quantile="0.99"} NaN +consul_api_http_sum{method="GET",path="v1_catalog_nodes"} 0.37226200103759766 +consul_api_http_count{method="GET",path="v1_catalog_nodes"} 1 +consul_api_http{method="GET",path="v1_catalog_service_",quantile="0.5"} 0.538116991519928 +consul_api_http{method="GET",path="v1_catalog_service_",quantile="0.9"} 0.6367400288581848 +consul_api_http{method="GET",path="v1_catalog_service_",quantile="0.99"} 0.6367400288581848 +consul_api_http_sum{method="GET",path="v1_catalog_service_"} 43381.559261500835 +consul_api_http_count{method="GET",path="v1_catalog_service_"} 75066 +consul_api_http{method="GET",path="v1_internal_ui_catalog-overview",quantile="0.5"} 0.2639490067958832 +consul_api_http{method="GET",path="v1_internal_ui_catalog-overview",quantile="0.9"} 0.2639490067958832 +consul_api_http{method="GET",path="v1_internal_ui_catalog-overview",quantile="0.99"} 0.2639490067958832 +consul_api_http_sum{method="GET",path="v1_internal_ui_catalog-overview"} 3496.612477712333 +consul_api_http_count{method="GET",path="v1_internal_ui_catalog-overview"} 14553 +consul_api_http{method="GET",path="v1_namespace_",quantile="0.5"} 0.14019399881362915 +consul_api_http{method="GET",path="v1_namespace_",quantile="0.9"} 0.29843899607658386 +consul_api_http{method="GET",path="v1_namespace_",quantile="0.99"} 0.29843899607658386 +consul_api_http_sum{method="GET",path="v1_namespace_"} 6329.847745008767 +consul_api_http_count{method="GET",path="v1_namespace_"} 30022 +consul_api_http{method="GET",path="v1_operator_autopilot_health",quantile="0.5"} NaN +consul_api_http{method="GET",path="v1_operator_autopilot_health",quantile="0.9"} NaN +consul_api_http{method="GET",path="v1_operator_autopilot_health",quantile="0.99"} NaN +consul_api_http_sum{method="GET",path="v1_operator_autopilot_health"} 1326.0989246219397 +consul_api_http_count{method="GET",path="v1_operator_autopilot_health"} 7747 +consul_api_http{method="GET",path="v1_partitions",quantile="0.5"} NaN +consul_api_http{method="GET",path="v1_partitions",quantile="0.9"} NaN +consul_api_http{method="GET",path="v1_partitions",quantile="0.99"} NaN +consul_api_http_sum{method="GET",path="v1_partitions"} 3190.110695719719 +consul_api_http_count{method="GET",path="v1_partitions"} 4136 +consul_api_http{method="GET",path="v1_status_leader",quantile="0.5"} 0.07637300342321396 +consul_api_http{method="GET",path="v1_status_leader",quantile="0.9"} 0.07637300342321396 +consul_api_http{method="GET",path="v1_status_leader",quantile="0.99"} 0.07637300342321396 +consul_api_http_sum{method="GET",path="v1_status_leader"} 4829.641642797738 +consul_api_http_count{method="GET",path="v1_status_leader"} 45620 +consul_api_http{method="PUT",path="v1_catalog_register",quantile="0.5"} 2.291783094406128 +consul_api_http{method="PUT",path="v1_catalog_register",quantile="0.9"} 2.9903249740600586 +consul_api_http{method="PUT",path="v1_catalog_register",quantile="0.99"} 2.9903249740600586 +consul_api_http_sum{method="PUT",path="v1_catalog_register"} 284584.19143879414 +consul_api_http_count{method="PUT",path="v1_catalog_register"} 90170 +# HELP consul_autopilot_failure_tolerance Tracks the number of voting servers that the cluster can lose while continuing to function. +# TYPE consul_autopilot_failure_tolerance gauge +consul_autopilot_failure_tolerance 0 +# HELP consul_autopilot_failure_tolerance_failure_tolerance consul_autopilot_failure_tolerance_failure_tolerance +# TYPE consul_autopilot_failure_tolerance_failure_tolerance gauge +consul_autopilot_failure_tolerance_failure_tolerance 0 +# HELP consul_autopilot_healthy Tracks the overall health of the local server cluster. 1 if all servers are healthy, 0 if one or more are unhealthy. +# TYPE consul_autopilot_healthy gauge +consul_autopilot_healthy 0 +# HELP consul_autopilot_healthy_healthy consul_autopilot_healthy_healthy +# TYPE consul_autopilot_healthy_healthy gauge +consul_autopilot_healthy_healthy 1 +# HELP consul_cache_bypass Counts how many times a request bypassed the cache because no cache-key was provided. +# TYPE consul_cache_bypass counter +consul_cache_bypass 0 +# HELP consul_cache_connect_ca_leaf_fetch_success consul_cache_connect_ca_leaf_fetch_success +# TYPE consul_cache_connect_ca_leaf_fetch_success counter +consul_cache_connect_ca_leaf_fetch_success{result_not_modified="false"} 2 +# HELP consul_cache_connect_ca_root_fetch_success consul_cache_connect_ca_root_fetch_success +# TYPE consul_cache_connect_ca_root_fetch_success counter +consul_cache_connect_ca_root_fetch_success{result_not_modified="false"} 271 +# HELP consul_cache_connect_ca_root_hit consul_cache_connect_ca_root_hit +# TYPE consul_cache_connect_ca_root_hit counter +consul_cache_connect_ca_root_hit 2 +# HELP consul_cache_entries_count Represents the number of entries in this cache. +# TYPE consul_cache_entries_count gauge +consul_cache_entries_count 0 +# HELP consul_cache_entries_count_entries_count consul_cache_entries_count_entries_count +# TYPE consul_cache_entries_count_entries_count gauge +consul_cache_entries_count_entries_count 30 +# HELP consul_cache_evict_expired Counts the number of expired entries that are evicted. +# TYPE consul_cache_evict_expired counter +consul_cache_evict_expired 1 +# HELP consul_cache_fetch_error Counts the number of failed fetches by the cache. +# TYPE consul_cache_fetch_error counter +consul_cache_fetch_error 0 +# HELP consul_cache_fetch_success Counts the number of successful fetches by the cache. +# TYPE consul_cache_fetch_success counter +consul_cache_fetch_success 0 +consul_cache_fetch_success{result_not_modified="false"} 1381 +# HELP consul_catalog_connect_not_found Increments for each connect-based catalog query where the given service could not be found. +# TYPE consul_catalog_connect_not_found counter +consul_catalog_connect_not_found 0 +# HELP consul_catalog_connect_query Increments for each connect-based catalog query for the given service. +# TYPE consul_catalog_connect_query counter +consul_catalog_connect_query 0 +# HELP consul_catalog_connect_query_tag Increments for each connect-based catalog query for the given service with the given tag. +# TYPE consul_catalog_connect_query_tag counter +consul_catalog_connect_query_tag 0 +# HELP consul_catalog_connect_query_tags Increments for each connect-based catalog query for the given service with the given tags. +# TYPE consul_catalog_connect_query_tags counter +consul_catalog_connect_query_tags 0 +# HELP consul_catalog_deregister Measures the time it takes to complete a catalog deregister operation. +# TYPE consul_catalog_deregister summary +consul_catalog_deregister{quantile="0.5"} NaN +consul_catalog_deregister{quantile="0.9"} NaN +consul_catalog_deregister{quantile="0.99"} NaN +consul_catalog_deregister_sum 221.93704390525818 +consul_catalog_deregister_count 55 +# HELP consul_catalog_register Measures the time it takes to complete a catalog register operation. +# TYPE consul_catalog_register summary +consul_catalog_register{quantile="0.5"} 2.13044810295105 +consul_catalog_register{quantile="0.9"} 2.721796989440918 +consul_catalog_register{quantile="0.99"} 2.721796989440918 +consul_catalog_register_sum 265432.1276627779 +consul_catalog_register_count 90231 +# HELP consul_catalog_service_not_found Increments for each catalog query where the given service could not be found. +# TYPE consul_catalog_service_not_found counter +consul_catalog_service_not_found 0 +# HELP consul_catalog_service_query Increments for each catalog query for the given service. +# TYPE consul_catalog_service_query counter +consul_catalog_service_query 0 +consul_catalog_service_query{service="consul-connect-injector-consul"} 15004 +consul_catalog_service_query{service="consul-ingress-gateway-consul"} 15009 +consul_catalog_service_query{service="kubelet-default"} 15009 +consul_catalog_service_query{service="kubernetes-default"} 15016 +consul_catalog_service_query{service="netdata-default"} 15009 +# HELP consul_catalog_service_query_tag Increments for each catalog query for the given service with the given tag. +# TYPE consul_catalog_service_query_tag counter +consul_catalog_service_query_tag 0 +# HELP consul_catalog_service_query_tags Increments for each catalog query for the given service with the given tags. +# TYPE consul_catalog_service_query_tags counter +consul_catalog_service_query_tags 0 +consul_catalog_service_query_tags{service="consul-connect-injector-consul",tag="k8s"} 15003 +consul_catalog_service_query_tags{service="consul-ingress-gateway-consul",tag="k8s"} 15009 +consul_catalog_service_query_tags{service="kubelet-default",tag="k8s"} 15009 +consul_catalog_service_query_tags{service="kubernetes-default",tag="k8s"} 15014 +consul_catalog_service_query_tags{service="netdata-default",tag="k8s"} 15004 +# HELP consul_client_api_catalog_datacenters Increments whenever a Consul agent receives a request to list datacenters in the catalog. +# TYPE consul_client_api_catalog_datacenters counter +consul_client_api_catalog_datacenters 0 +# HELP consul_client_api_catalog_deregister Increments whenever a Consul agent receives a catalog deregister request. +# TYPE consul_client_api_catalog_deregister counter +consul_client_api_catalog_deregister 0 +# HELP consul_client_api_catalog_gateway_services Increments whenever a Consul agent receives a request to list services associated with a gateway. +# TYPE consul_client_api_catalog_gateway_services counter +consul_client_api_catalog_gateway_services 0 +# HELP consul_client_api_catalog_node_service_list Increments whenever a Consul agent receives a request to list a node's registered services. +# TYPE consul_client_api_catalog_node_service_list counter +consul_client_api_catalog_node_service_list 0 +consul_client_api_catalog_node_service_list{node="ip-172-25-37-57",partition="default"} 1069 +# HELP consul_client_api_catalog_node_services Increments whenever a Consul agent successfully responds to a request to list nodes offering a service. +# TYPE consul_client_api_catalog_node_services counter +consul_client_api_catalog_node_services 0 +# HELP consul_client_api_catalog_nodes Increments whenever a Consul agent receives a request to list nodes from the catalog. +# TYPE consul_client_api_catalog_nodes counter +consul_client_api_catalog_nodes 0 +consul_client_api_catalog_nodes{node="ip-172-25-37-57",partition="default"} 1 +# HELP consul_client_api_catalog_register Increments whenever a Consul agent receives a catalog register request. +# TYPE consul_client_api_catalog_register counter +consul_client_api_catalog_register 0 +consul_client_api_catalog_register{node="ip-172-25-37-57",partition="default"} 90170 +# HELP consul_client_api_catalog_service_nodes Increments whenever a Consul agent receives a request to list nodes offering a service. +# TYPE consul_client_api_catalog_service_nodes counter +consul_client_api_catalog_service_nodes 0 +consul_client_api_catalog_service_nodes{node="ip-172-25-37-57",partition="default"} 75066 +# HELP consul_client_api_catalog_services Increments whenever a Consul agent receives a request to list services from the catalog. +# TYPE consul_client_api_catalog_services counter +consul_client_api_catalog_services 0 +# HELP consul_client_api_error_catalog_service_nodes Increments whenever a Consul agent receives an RPC error for request to list nodes offering a service. +# TYPE consul_client_api_error_catalog_service_nodes counter +consul_client_api_error_catalog_service_nodes 0 +# HELP consul_client_api_success_catalog_datacenters Increments whenever a Consul agent successfully responds to a request to list datacenters. +# TYPE consul_client_api_success_catalog_datacenters counter +consul_client_api_success_catalog_datacenters 0 +# HELP consul_client_api_success_catalog_deregister Increments whenever a Consul agent successfully responds to a catalog deregister request. +# TYPE consul_client_api_success_catalog_deregister counter +consul_client_api_success_catalog_deregister 0 +# HELP consul_client_api_success_catalog_gateway_services Increments whenever a Consul agent successfully responds to a request to list services associated with a gateway. +# TYPE consul_client_api_success_catalog_gateway_services counter +consul_client_api_success_catalog_gateway_services 0 +# HELP consul_client_api_success_catalog_node_service_list Increments whenever a Consul agent successfully responds to a request to list a node's registered services. +# TYPE consul_client_api_success_catalog_node_service_list counter +consul_client_api_success_catalog_node_service_list 0 +consul_client_api_success_catalog_node_service_list{node="ip-172-25-37-57",partition="default"} 1069 +# HELP consul_client_api_success_catalog_node_services Increments whenever a Consul agent successfully responds to a request to list services in a node. +# TYPE consul_client_api_success_catalog_node_services counter +consul_client_api_success_catalog_node_services 0 +# HELP consul_client_api_success_catalog_nodes Increments whenever a Consul agent successfully responds to a request to list nodes. +# TYPE consul_client_api_success_catalog_nodes counter +consul_client_api_success_catalog_nodes 0 +consul_client_api_success_catalog_nodes{node="ip-172-25-37-57",partition="default"} 1 +# HELP consul_client_api_success_catalog_register Increments whenever a Consul agent successfully responds to a catalog register request. +# TYPE consul_client_api_success_catalog_register counter +consul_client_api_success_catalog_register 0 +consul_client_api_success_catalog_register{node="ip-172-25-37-57",partition="default"} 90170 +# HELP consul_client_api_success_catalog_service_nodes Increments whenever a Consul agent successfully responds to a request to list nodes offering a service. +# TYPE consul_client_api_success_catalog_service_nodes counter +consul_client_api_success_catalog_service_nodes 0 +consul_client_api_success_catalog_service_nodes{node="ip-172-25-37-57",partition="default"} 75072 +# HELP consul_client_api_success_catalog_services Increments whenever a Consul agent successfully responds to a request to list services. +# TYPE consul_client_api_success_catalog_services counter +consul_client_api_success_catalog_services 0 +# HELP consul_client_rpc Increments whenever a Consul agent in client mode makes an RPC request to a Consul server. +# TYPE consul_client_rpc counter +consul_client_rpc 438718 +# HELP consul_client_rpc_error_catalog_datacenters Increments whenever a Consul agent receives an RPC error for a request to list datacenters. +# TYPE consul_client_rpc_error_catalog_datacenters counter +consul_client_rpc_error_catalog_datacenters 0 +# HELP consul_client_rpc_error_catalog_deregister Increments whenever a Consul agent receives an RPC error for a catalog deregister request. +# TYPE consul_client_rpc_error_catalog_deregister counter +consul_client_rpc_error_catalog_deregister 0 +# HELP consul_client_rpc_error_catalog_gateway_services Increments whenever a Consul agent receives an RPC error for a request to list services associated with a gateway. +# TYPE consul_client_rpc_error_catalog_gateway_services counter +consul_client_rpc_error_catalog_gateway_services 0 +# HELP consul_client_rpc_error_catalog_node_service_list Increments whenever a Consul agent receives an RPC error for request to list a node's registered services. +# TYPE consul_client_rpc_error_catalog_node_service_list counter +consul_client_rpc_error_catalog_node_service_list 0 +# HELP consul_client_rpc_error_catalog_node_services Increments whenever a Consul agent receives an RPC error for a request to list services in a node. +# TYPE consul_client_rpc_error_catalog_node_services counter +consul_client_rpc_error_catalog_node_services 0 +# HELP consul_client_rpc_error_catalog_nodes Increments whenever a Consul agent receives an RPC error for a request to list nodes. +# TYPE consul_client_rpc_error_catalog_nodes counter +consul_client_rpc_error_catalog_nodes 0 +# HELP consul_client_rpc_error_catalog_register Increments whenever a Consul agent receives an RPC error for a catalog register request. +# TYPE consul_client_rpc_error_catalog_register counter +consul_client_rpc_error_catalog_register 0 +# HELP consul_client_rpc_error_catalog_service_nodes Increments whenever a Consul agent receives an RPC error for a request to list nodes offering a service. +# TYPE consul_client_rpc_error_catalog_service_nodes counter +consul_client_rpc_error_catalog_service_nodes 0 +# HELP consul_client_rpc_error_catalog_services Increments whenever a Consul agent receives an RPC error for a request to list services. +# TYPE consul_client_rpc_error_catalog_services counter +consul_client_rpc_error_catalog_services 0 +# HELP consul_client_rpc_exceeded Increments whenever a Consul agent in client mode makes an RPC request to a Consul server gets rate limited by that agent's limits configuration. +# TYPE consul_client_rpc_exceeded counter +consul_client_rpc_exceeded 0 +# HELP consul_client_rpc_failed Increments whenever a Consul agent in client mode makes an RPC request to a Consul server and fails. +# TYPE consul_client_rpc_failed counter +consul_client_rpc_failed 0 +# HELP consul_consul_cache_bypass Deprecated - please use cache_bypass instead. +# TYPE consul_consul_cache_bypass counter +consul_consul_cache_bypass 0 +# HELP consul_consul_cache_connect_ca_leaf_fetch_success consul_consul_cache_connect_ca_leaf_fetch_success +# TYPE consul_consul_cache_connect_ca_leaf_fetch_success counter +consul_consul_cache_connect_ca_leaf_fetch_success{result_not_modified="false"} 2 +# HELP consul_consul_cache_connect_ca_root_fetch_success consul_consul_cache_connect_ca_root_fetch_success +# TYPE consul_consul_cache_connect_ca_root_fetch_success counter +consul_consul_cache_connect_ca_root_fetch_success{result_not_modified="false"} 271 +# HELP consul_consul_cache_connect_ca_root_hit consul_consul_cache_connect_ca_root_hit +# TYPE consul_consul_cache_connect_ca_root_hit counter +consul_consul_cache_connect_ca_root_hit 2 +# HELP consul_consul_cache_entries_count Deprecated - please use cache_entries_count instead. +# TYPE consul_consul_cache_entries_count gauge +consul_consul_cache_entries_count 0 +# HELP consul_consul_cache_entries_count_entries_count consul_consul_cache_entries_count_entries_count +# TYPE consul_consul_cache_entries_count_entries_count gauge +consul_consul_cache_entries_count_entries_count 30 +# HELP consul_consul_cache_evict_expired Deprecated - please use cache_evict_expired instead. +# TYPE consul_consul_cache_evict_expired counter +consul_consul_cache_evict_expired 1 +# HELP consul_consul_cache_fetch_error Deprecated - please use cache_fetch_error instead. +# TYPE consul_consul_cache_fetch_error counter +consul_consul_cache_fetch_error 0 +# HELP consul_consul_cache_fetch_success Deprecated - please use cache_fetch_success instead. +# TYPE consul_consul_cache_fetch_success counter +consul_consul_cache_fetch_success 0 +consul_consul_cache_fetch_success{result_not_modified="false"} 1381 +# HELP consul_consul_fsm_ca Deprecated - use fsm_ca instead +# TYPE consul_consul_fsm_ca summary +consul_consul_fsm_ca{quantile="0.5"} NaN +consul_consul_fsm_ca{quantile="0.9"} NaN +consul_consul_fsm_ca{quantile="0.99"} NaN +consul_consul_fsm_ca_sum 0 +consul_consul_fsm_ca_count 0 +# HELP consul_consul_fsm_intention Deprecated - use fsm_intention instead +# TYPE consul_consul_fsm_intention summary +consul_consul_fsm_intention{quantile="0.5"} NaN +consul_consul_fsm_intention{quantile="0.9"} NaN +consul_consul_fsm_intention{quantile="0.99"} NaN +consul_consul_fsm_intention_sum 0 +consul_consul_fsm_intention_count 0 +# HELP consul_consul_intention_apply Deprecated - please use intention_apply +# TYPE consul_consul_intention_apply summary +consul_consul_intention_apply{quantile="0.5"} NaN +consul_consul_intention_apply{quantile="0.9"} NaN +consul_consul_intention_apply{quantile="0.99"} NaN +consul_consul_intention_apply_sum 0 +consul_consul_intention_apply_count 0 +# HELP consul_consul_leader_reconcile consul_consul_leader_reconcile +# TYPE consul_consul_leader_reconcile summary +consul_consul_leader_reconcile{quantile="0.5"} NaN +consul_consul_leader_reconcile{quantile="0.9"} NaN +consul_consul_leader_reconcile{quantile="0.99"} NaN +consul_consul_leader_reconcile_sum 1747.430968016386 +consul_consul_leader_reconcile_count 7530 +# HELP consul_consul_members_clients Deprecated - please use members_clients instead. +# TYPE consul_consul_members_clients gauge +consul_consul_members_clients 0 +# HELP consul_consul_members_clients_clients consul_consul_members_clients_clients +# TYPE consul_consul_members_clients_clients gauge +consul_consul_members_clients_clients{datacenter="consul-sandbox-cluster-0159c9d3"} 1 +consul_consul_members_clients_clients{datacenter="consul-sandbox-cluster-0159c9d3",partition="default",segment=""} 1 +# HELP consul_consul_members_servers Deprecated - please use members_servers instead. +# TYPE consul_consul_members_servers gauge +consul_consul_members_servers 0 +# HELP consul_consul_members_servers_servers consul_consul_members_servers_servers +# TYPE consul_consul_members_servers_servers gauge +consul_consul_members_servers_servers{datacenter="consul-sandbox-cluster-0159c9d3"} 1 +# HELP consul_consul_peering_exported_services Deprecated - please use peering_exported_services +# TYPE consul_consul_peering_exported_services gauge +consul_consul_peering_exported_services 0 +# HELP consul_consul_peering_healthy Deprecated - please use peering_exported_services +# TYPE consul_consul_peering_healthy gauge +consul_consul_peering_healthy 0 +# HELP consul_consul_state_config_entries Deprecated - please use state_config_entries instead. +# TYPE consul_consul_state_config_entries gauge +consul_consul_state_config_entries 0 +# HELP consul_consul_state_config_entries_config_entries consul_consul_state_config_entries_config_entries +# TYPE consul_consul_state_config_entries_config_entries gauge +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="exported-services",namespace="consul",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="exported-services",namespace="default",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="exported-services",namespace="infra",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="ingress-gateway",namespace="consul",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="ingress-gateway",namespace="default",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="ingress-gateway",namespace="infra",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="mesh",namespace="consul",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="mesh",namespace="default",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="mesh",namespace="infra",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="proxy-defaults",namespace="consul",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="proxy-defaults",namespace="default",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="proxy-defaults",namespace="infra",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-defaults",namespace="consul",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-defaults",namespace="default",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-defaults",namespace="infra",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-intentions",namespace="consul",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-intentions",namespace="default",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-intentions",namespace="infra",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-resolver",namespace="consul",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-resolver",namespace="default",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-resolver",namespace="infra",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-router",namespace="consul",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-router",namespace="default",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-router",namespace="infra",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-splitter",namespace="consul",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-splitter",namespace="default",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="service-splitter",namespace="infra",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="terminating-gateway",namespace="consul",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="terminating-gateway",namespace="default",partition="default"} 0 +consul_consul_state_config_entries_config_entries{datacenter="consul-sandbox-cluster-0159c9d3",kind="terminating-gateway",namespace="infra",partition="default"} 0 +# HELP consul_consul_state_connect_instances Deprecated - please use state_connect_instances instead. +# TYPE consul_consul_state_connect_instances gauge +consul_consul_state_connect_instances 0 +# HELP consul_consul_state_connect_instances_connect_instances consul_consul_state_connect_instances_connect_instances +# TYPE consul_consul_state_connect_instances_connect_instances gauge +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="connect-native",namespace="consul",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="connect-native",namespace="default",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="connect-native",namespace="infra",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="connect-proxy",namespace="consul",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="connect-proxy",namespace="default",partition="default"} 1 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="connect-proxy",namespace="infra",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="ingress-gateway",namespace="consul",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="ingress-gateway",namespace="default",partition="default"} 2 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="ingress-gateway",namespace="infra",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="mesh-gateway",namespace="consul",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="mesh-gateway",namespace="default",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="mesh-gateway",namespace="infra",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="terminating-gateway",namespace="consul",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="terminating-gateway",namespace="default",partition="default"} 0 +consul_consul_state_connect_instances_connect_instances{datacenter="consul-sandbox-cluster-0159c9d3",kind="terminating-gateway",namespace="infra",partition="default"} 0 +# HELP consul_consul_state_kv_entries Deprecated - please use kv_entries instead. +# TYPE consul_consul_state_kv_entries gauge +consul_consul_state_kv_entries 0 +# HELP consul_consul_state_kv_entries_kv_entries consul_consul_state_kv_entries_kv_entries +# TYPE consul_consul_state_kv_entries_kv_entries gauge +consul_consul_state_kv_entries_kv_entries{datacenter="consul-sandbox-cluster-0159c9d3",namespace="consul"} 0 +consul_consul_state_kv_entries_kv_entries{datacenter="consul-sandbox-cluster-0159c9d3",namespace="default"} 0 +consul_consul_state_kv_entries_kv_entries{datacenter="consul-sandbox-cluster-0159c9d3",namespace="infra"} 0 +# HELP consul_consul_state_nodes Deprecated - please use state_nodes instead. +# TYPE consul_consul_state_nodes gauge +consul_consul_state_nodes 0 +# HELP consul_consul_state_nodes_nodes consul_consul_state_nodes_nodes +# TYPE consul_consul_state_nodes_nodes gauge +consul_consul_state_nodes_nodes{datacenter="consul-sandbox-cluster-0159c9d3",partition="default"} 8 +# HELP consul_consul_state_peerings Deprecated - please use state_peerings instead. +# TYPE consul_consul_state_peerings gauge +consul_consul_state_peerings 0 +# HELP consul_consul_state_peerings_peerings consul_consul_state_peerings_peerings +# TYPE consul_consul_state_peerings_peerings gauge +consul_consul_state_peerings_peerings{datacenter="consul-sandbox-cluster-0159c9d3",partition="default"} 0 +# HELP consul_consul_state_service_instances Deprecated - please use state_service_instances instead. +# TYPE consul_consul_state_service_instances gauge +consul_consul_state_service_instances 0 +# HELP consul_consul_state_service_instances_service_instances consul_consul_state_service_instances_service_instances +# TYPE consul_consul_state_service_instances_service_instances gauge +consul_consul_state_service_instances_service_instances{datacenter="consul-sandbox-cluster-0159c9d3",namespace="consul",partition="default"} 2 +consul_consul_state_service_instances_service_instances{datacenter="consul-sandbox-cluster-0159c9d3",namespace="default",partition="default"} 9 +consul_consul_state_service_instances_service_instances{datacenter="consul-sandbox-cluster-0159c9d3",namespace="infra",partition="default"} 0 +# HELP consul_consul_state_services Deprecated - please use state_services instead. +# TYPE consul_consul_state_services gauge +consul_consul_state_services 0 +# HELP consul_consul_state_services_services consul_consul_state_services_services +# TYPE consul_consul_state_services_services gauge +consul_consul_state_services_services{datacenter="consul-sandbox-cluster-0159c9d3",namespace="consul",partition="default"} 2 +consul_consul_state_services_services{datacenter="consul-sandbox-cluster-0159c9d3",namespace="default",partition="default"} 7 +consul_consul_state_services_services{datacenter="consul-sandbox-cluster-0159c9d3",namespace="infra",partition="default"} 0 +# HELP consul_federation_state_apply +# TYPE consul_federation_state_apply summary +consul_federation_state_apply{quantile="0.5"} NaN +consul_federation_state_apply{quantile="0.9"} NaN +consul_federation_state_apply{quantile="0.99"} NaN +consul_federation_state_apply_sum 0 +consul_federation_state_apply_count 0 +# HELP consul_federation_state_get +# TYPE consul_federation_state_get summary +consul_federation_state_get{quantile="0.5"} NaN +consul_federation_state_get{quantile="0.9"} NaN +consul_federation_state_get{quantile="0.99"} NaN +consul_federation_state_get_sum 0 +consul_federation_state_get_count 0 +# HELP consul_federation_state_list +# TYPE consul_federation_state_list summary +consul_federation_state_list{quantile="0.5"} NaN +consul_federation_state_list{quantile="0.9"} NaN +consul_federation_state_list{quantile="0.99"} NaN +consul_federation_state_list_sum 0 +consul_federation_state_list_count 0 +# HELP consul_federation_state_list_mesh_gateways +# TYPE consul_federation_state_list_mesh_gateways summary +consul_federation_state_list_mesh_gateways{quantile="0.5"} NaN +consul_federation_state_list_mesh_gateways{quantile="0.9"} NaN +consul_federation_state_list_mesh_gateways{quantile="0.99"} NaN +consul_federation_state_list_mesh_gateways_sum 0 +consul_federation_state_list_mesh_gateways_count 0 +# HELP consul_fsm_acl Measures the time it takes to apply the given ACL operation to the FSM. +# TYPE consul_fsm_acl summary +consul_fsm_acl{quantile="0.5"} NaN +consul_fsm_acl{quantile="0.9"} NaN +consul_fsm_acl{quantile="0.99"} NaN +consul_fsm_acl_sum 0 +consul_fsm_acl_count 0 +# HELP consul_fsm_acl_authmethod Measures the time it takes to apply an ACL authmethod operation to the FSM. +# TYPE consul_fsm_acl_authmethod summary +consul_fsm_acl_authmethod{quantile="0.5"} NaN +consul_fsm_acl_authmethod{quantile="0.9"} NaN +consul_fsm_acl_authmethod{quantile="0.99"} NaN +consul_fsm_acl_authmethod_sum 0 +consul_fsm_acl_authmethod_count 0 +# HELP consul_fsm_acl_bindingrule Measures the time it takes to apply an ACL binding rule operation to the FSM. +# TYPE consul_fsm_acl_bindingrule summary +consul_fsm_acl_bindingrule{quantile="0.5"} NaN +consul_fsm_acl_bindingrule{quantile="0.9"} NaN +consul_fsm_acl_bindingrule{quantile="0.99"} NaN +consul_fsm_acl_bindingrule_sum 0 +consul_fsm_acl_bindingrule_count 0 +# HELP consul_fsm_acl_policy Measures the time it takes to apply an ACL policy operation to the FSM. +# TYPE consul_fsm_acl_policy summary +consul_fsm_acl_policy{quantile="0.5"} NaN +consul_fsm_acl_policy{quantile="0.9"} NaN +consul_fsm_acl_policy{quantile="0.99"} NaN +consul_fsm_acl_policy_sum 0 +consul_fsm_acl_policy_count 0 +# HELP consul_fsm_acl_token Measures the time it takes to apply an ACL token operation to the FSM. +# TYPE consul_fsm_acl_token summary +consul_fsm_acl_token{quantile="0.5"} NaN +consul_fsm_acl_token{quantile="0.9"} NaN +consul_fsm_acl_token{quantile="0.99"} NaN +consul_fsm_acl_token_sum 0 +consul_fsm_acl_token_count 0 +consul_fsm_acl_token{op="upsert",quantile="0.5"} NaN +consul_fsm_acl_token{op="upsert",quantile="0.9"} NaN +consul_fsm_acl_token{op="upsert",quantile="0.99"} NaN +consul_fsm_acl_token_sum{op="upsert"} 0.18545499444007874 +consul_fsm_acl_token_count{op="upsert"} 1 +# HELP consul_fsm_autopilot Measures the time it takes to apply the given autopilot update to the FSM. +# TYPE consul_fsm_autopilot summary +consul_fsm_autopilot{quantile="0.5"} NaN +consul_fsm_autopilot{quantile="0.9"} NaN +consul_fsm_autopilot{quantile="0.99"} NaN +consul_fsm_autopilot_sum 37.74536604247987 +consul_fsm_autopilot_count 753 +# HELP consul_fsm_ca Measures the time it takes to apply CA configuration operations to the FSM. +# TYPE consul_fsm_ca summary +consul_fsm_ca{quantile="0.5"} NaN +consul_fsm_ca{quantile="0.9"} NaN +consul_fsm_ca{quantile="0.99"} NaN +consul_fsm_ca_sum 0 +consul_fsm_ca_count 0 +# HELP consul_fsm_ca_leaf Measures the time it takes to apply an operation while signing a leaf certificate. +# TYPE consul_fsm_ca_leaf summary +consul_fsm_ca_leaf{quantile="0.5"} NaN +consul_fsm_ca_leaf{quantile="0.9"} NaN +consul_fsm_ca_leaf{quantile="0.99"} NaN +consul_fsm_ca_leaf_sum 0 +consul_fsm_ca_leaf_count 0 +# HELP consul_fsm_coordinate_batch_update Measures the time it takes to apply the given batch coordinate update to the FSM. +# TYPE consul_fsm_coordinate_batch_update summary +consul_fsm_coordinate_batch_update{quantile="0.5"} 0.1002039983868599 +consul_fsm_coordinate_batch_update{quantile="0.9"} 0.1002039983868599 +consul_fsm_coordinate_batch_update{quantile="0.99"} 0.1002039983868599 +consul_fsm_coordinate_batch_update_sum 2816.718877375126 +consul_fsm_coordinate_batch_update_count 21979 +# HELP consul_fsm_deregister Measures the time it takes to apply a catalog deregister operation to the FSM. +# TYPE consul_fsm_deregister summary +consul_fsm_deregister{quantile="0.5"} NaN +consul_fsm_deregister{quantile="0.9"} NaN +consul_fsm_deregister{quantile="0.99"} NaN +consul_fsm_deregister_sum 81.9582624938339 +consul_fsm_deregister_count 56 +# HELP consul_fsm_intention Measures the time it takes to apply an intention operation to the FSM. +# TYPE consul_fsm_intention summary +consul_fsm_intention{quantile="0.5"} NaN +consul_fsm_intention{quantile="0.9"} NaN +consul_fsm_intention{quantile="0.99"} NaN +consul_fsm_intention_sum 0 +consul_fsm_intention_count 0 +# HELP consul_fsm_kvs Measures the time it takes to apply the given KV operation to the FSM. +# TYPE consul_fsm_kvs summary +consul_fsm_kvs{quantile="0.5"} NaN +consul_fsm_kvs{quantile="0.9"} NaN +consul_fsm_kvs{quantile="0.99"} NaN +consul_fsm_kvs_sum 0 +consul_fsm_kvs_count 0 +# HELP consul_fsm_peering Measures the time it takes to apply a peering operation to the FSM. +# TYPE consul_fsm_peering summary +consul_fsm_peering{quantile="0.5"} NaN +consul_fsm_peering{quantile="0.9"} NaN +consul_fsm_peering{quantile="0.99"} NaN +consul_fsm_peering_sum 0 +consul_fsm_peering_count 0 +# HELP consul_fsm_persist Measures the time it takes to persist the FSM to a raft snapshot. +# TYPE consul_fsm_persist summary +consul_fsm_persist{quantile="0.5"} NaN +consul_fsm_persist{quantile="0.9"} NaN +consul_fsm_persist{quantile="0.99"} NaN +consul_fsm_persist_sum 361.0432777404785 +consul_fsm_persist_count 10 +# HELP consul_fsm_prepared_query Measures the time it takes to apply the given prepared query update operation to the FSM. +# TYPE consul_fsm_prepared_query summary +consul_fsm_prepared_query{quantile="0.5"} NaN +consul_fsm_prepared_query{quantile="0.9"} NaN +consul_fsm_prepared_query{quantile="0.99"} NaN +consul_fsm_prepared_query_sum 0 +consul_fsm_prepared_query_count 0 +# HELP consul_fsm_register Measures the time it takes to apply a catalog register operation to the FSM. +# TYPE consul_fsm_register summary +consul_fsm_register{quantile="0.5"} 0.15392500162124634 +consul_fsm_register{quantile="0.9"} 0.22902700304985046 +consul_fsm_register{quantile="0.99"} 0.22902700304985046 +consul_fsm_register_sum 17763.026295486838 +consul_fsm_register_count 90283 +# HELP consul_fsm_session Measures the time it takes to apply the given session operation to the FSM. +# TYPE consul_fsm_session summary +consul_fsm_session{quantile="0.5"} NaN +consul_fsm_session{quantile="0.9"} NaN +consul_fsm_session{quantile="0.99"} NaN +consul_fsm_session_sum 0 +consul_fsm_session_count 0 +# HELP consul_fsm_system_metadata Measures the time it takes to apply a system metadata operation to the FSM. +# TYPE consul_fsm_system_metadata summary +consul_fsm_system_metadata{quantile="0.5"} NaN +consul_fsm_system_metadata{quantile="0.9"} NaN +consul_fsm_system_metadata{quantile="0.99"} NaN +consul_fsm_system_metadata_sum 0 +consul_fsm_system_metadata_count 0 +# HELP consul_fsm_tombstone Measures the time it takes to apply the given tombstone operation to the FSM. +# TYPE consul_fsm_tombstone summary +consul_fsm_tombstone{quantile="0.5"} NaN +consul_fsm_tombstone{quantile="0.9"} NaN +consul_fsm_tombstone{quantile="0.99"} NaN +consul_fsm_tombstone_sum 0 +consul_fsm_tombstone_count 0 +# HELP consul_fsm_txn Measures the time it takes to apply the given transaction update to the FSM. +# TYPE consul_fsm_txn summary +consul_fsm_txn{quantile="0.5"} NaN +consul_fsm_txn{quantile="0.9"} NaN +consul_fsm_txn{quantile="0.99"} NaN +consul_fsm_txn_sum 0 +consul_fsm_txn_count 0 +# HELP consul_grpc_client_connection_count Counts the number of new gRPC connections opened by the client agent to a Consul server. +# TYPE consul_grpc_client_connection_count counter +consul_grpc_client_connection_count 0 +# HELP consul_grpc_client_connections Measures the number of active gRPC connections open from the client agent to any Consul servers. +# TYPE consul_grpc_client_connections gauge +consul_grpc_client_connections 0 +# HELP consul_grpc_client_request_count Counts the number of gRPC requests made by the client agent to a Consul server. +# TYPE consul_grpc_client_request_count counter +consul_grpc_client_request_count 0 +consul_grpc_client_request_count{server_type="internal"} 4136 +# HELP consul_grpc_server_connection_count Counts the number of new gRPC connections received by the server. +# TYPE consul_grpc_server_connection_count counter +consul_grpc_server_connection_count 0 +consul_grpc_server_connection_count{server_type="external"} 1 +# HELP consul_grpc_server_connections Measures the number of active gRPC connections open on the server. +# TYPE consul_grpc_server_connections gauge +consul_grpc_server_connections 0 +# HELP consul_grpc_server_connections_connections consul_grpc_server_connections_connections +# TYPE consul_grpc_server_connections_connections gauge +consul_grpc_server_connections_connections{server_type="external"} 5 +# HELP consul_grpc_server_request_count Counts the number of gRPC requests received by the server. +# TYPE consul_grpc_server_request_count counter +consul_grpc_server_request_count 0 +consul_grpc_server_request_count{server_type="external"} 49 +consul_grpc_server_request_count{server_type="internal"} 4139 +# HELP consul_grpc_server_stream_count Counts the number of new gRPC streams received by the server. +# TYPE consul_grpc_server_stream_count counter +consul_grpc_server_stream_count 0 +# HELP consul_grpc_server_streams Measures the number of active gRPC streams handled by the server. +# TYPE consul_grpc_server_streams gauge +consul_grpc_server_streams 0 +# HELP consul_intention_apply +# TYPE consul_intention_apply summary +consul_intention_apply{quantile="0.5"} NaN +consul_intention_apply{quantile="0.9"} NaN +consul_intention_apply{quantile="0.99"} NaN +consul_intention_apply_sum 0 +consul_intention_apply_count 0 +# HELP consul_kvs_apply Measures the time it takes to complete an update to the KV store. +# TYPE consul_kvs_apply summary +consul_kvs_apply{quantile="0.5"} NaN +consul_kvs_apply{quantile="0.9"} NaN +consul_kvs_apply{quantile="0.99"} NaN +consul_kvs_apply_sum 18.550758838653564 +consul_kvs_apply_count 2 +# HELP consul_leader_barrier Measures the time spent waiting for the raft barrier upon gaining leadership. +# TYPE consul_leader_barrier summary +consul_leader_barrier{quantile="0.5"} NaN +consul_leader_barrier{quantile="0.9"} NaN +consul_leader_barrier{quantile="0.99"} NaN +consul_leader_barrier_sum 16746.72570502758 +consul_leader_barrier_count 7530 +# HELP consul_leader_reapTombstones Measures the time spent clearing tombstones. +# TYPE consul_leader_reapTombstones summary +consul_leader_reapTombstones{quantile="0.5"} NaN +consul_leader_reapTombstones{quantile="0.9"} NaN +consul_leader_reapTombstones{quantile="0.99"} NaN +consul_leader_reapTombstones_sum 8.299793243408203 +consul_leader_reapTombstones_count 2 +# HELP consul_leader_reconcile consul_leader_reconcile +# TYPE consul_leader_reconcile summary +consul_leader_reconcile{quantile="0.5"} NaN +consul_leader_reconcile{quantile="0.9"} NaN +consul_leader_reconcile{quantile="0.99"} NaN +consul_leader_reconcile_sum 1640.2054885923862 +consul_leader_reconcile_count 7530 +# HELP consul_leader_reconcileMember Measures the time spent updating the raft store for a single serf member's information. +# TYPE consul_leader_reconcileMember summary +consul_leader_reconcileMember{quantile="0.5"} NaN +consul_leader_reconcileMember{quantile="0.9"} NaN +consul_leader_reconcileMember{quantile="0.99"} NaN +consul_leader_reconcileMember_sum 923.1838235380128 +consul_leader_reconcileMember_count 9879 +# HELP consul_leader_replication_acl_policies_index Tracks the index of ACL policies in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_policies_index gauge +consul_leader_replication_acl_policies_index 0 +# HELP consul_leader_replication_acl_policies_status Tracks the current health of ACL policy replication on the leader +# TYPE consul_leader_replication_acl_policies_status gauge +consul_leader_replication_acl_policies_status 0 +# HELP consul_leader_replication_acl_roles_index Tracks the index of ACL roles in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_roles_index gauge +consul_leader_replication_acl_roles_index 0 +# HELP consul_leader_replication_acl_roles_status Tracks the current health of ACL role replication on the leader +# TYPE consul_leader_replication_acl_roles_status gauge +consul_leader_replication_acl_roles_status 0 +# HELP consul_leader_replication_acl_tokens_index Tracks the index of ACL tokens in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_acl_tokens_index gauge +consul_leader_replication_acl_tokens_index 0 +# HELP consul_leader_replication_acl_tokens_status Tracks the current health of ACL token replication on the leader +# TYPE consul_leader_replication_acl_tokens_status gauge +consul_leader_replication_acl_tokens_status 0 +# HELP consul_leader_replication_config_entries_index Tracks the index of config entries in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_config_entries_index gauge +consul_leader_replication_config_entries_index 0 +# HELP consul_leader_replication_config_entries_status Tracks the current health of config entry replication on the leader +# TYPE consul_leader_replication_config_entries_status gauge +consul_leader_replication_config_entries_status 0 +# HELP consul_leader_replication_federation_state_index Tracks the index of federation states in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_federation_state_index gauge +consul_leader_replication_federation_state_index 0 +# HELP consul_leader_replication_federation_state_status Tracks the current health of federation state replication on the leader +# TYPE consul_leader_replication_federation_state_status gauge +consul_leader_replication_federation_state_status 0 +# HELP consul_leader_replication_namespaces_index Tracks the index of federation states in the primary that the secondary has successfully replicated +# TYPE consul_leader_replication_namespaces_index gauge +consul_leader_replication_namespaces_index 0 +# HELP consul_leader_replication_namespaces_status Tracks the current health of federation state replication on the leader +# TYPE consul_leader_replication_namespaces_status gauge +consul_leader_replication_namespaces_status 0 +# HELP consul_memberlist_gossip consul_memberlist_gossip +# TYPE consul_memberlist_gossip summary +consul_memberlist_gossip{network="wan",quantile="0.5"} 0.013411000370979309 +consul_memberlist_gossip{network="wan",quantile="0.9"} 0.01651100069284439 +consul_memberlist_gossip{network="wan",quantile="0.99"} 0.017091000452637672 +consul_memberlist_gossip_sum{network="wan"} 12186.142546130694 +consul_memberlist_gossip_count{network="wan"} 903629 +consul_memberlist_gossip{network="lan",partition="default",segment="",quantile="0.5"} 0.01858999952673912 +consul_memberlist_gossip{network="lan",partition="default",segment="",quantile="0.9"} 0.02322000078856945 +consul_memberlist_gossip{network="lan",partition="default",segment="",quantile="0.99"} 0.03482099995017052 +consul_memberlist_gossip_sum{network="lan",partition="default",segment=""} 38046.85491481074 +consul_memberlist_gossip_count{network="lan",partition="default",segment=""} 2.259067e+06 +# HELP consul_memberlist_node_instances_instances consul_memberlist_node_instances_instances +# TYPE consul_memberlist_node_instances_instances gauge +consul_memberlist_node_instances_instances{network="lan",node_state="alive",partition="default",segment=""} 2 +consul_memberlist_node_instances_instances{network="lan",node_state="dead",partition="default",segment=""} 0 +consul_memberlist_node_instances_instances{network="lan",node_state="left",partition="default",segment=""} 0 +consul_memberlist_node_instances_instances{network="lan",node_state="suspect",partition="default",segment=""} 0 +# HELP consul_memberlist_probeNode consul_memberlist_probeNode +# TYPE consul_memberlist_probeNode summary +consul_memberlist_probeNode{network="lan",partition="default",segment="",quantile="0.5"} 1.3738830089569092 +consul_memberlist_probeNode{network="lan",partition="default",segment="",quantile="0.9"} 1.4592169523239136 +consul_memberlist_probeNode{network="lan",partition="default",segment="",quantile="0.99"} 1.4592169523239136 +consul_memberlist_probeNode_sum{network="lan",partition="default",segment=""} 44756.27836251259 +consul_memberlist_probeNode_count{network="lan",partition="default",segment=""} 30847 +# HELP consul_memberlist_pushPullNode consul_memberlist_pushPullNode +# TYPE consul_memberlist_pushPullNode summary +consul_memberlist_pushPullNode{network="lan",partition="default",segment="",quantile="0.5"} 2.5498108863830566 +consul_memberlist_pushPullNode{network="lan",partition="default",segment="",quantile="0.9"} 2.5498108863830566 +consul_memberlist_pushPullNode{network="lan",partition="default",segment="",quantile="0.99"} 2.5498108863830566 +consul_memberlist_pushPullNode_sum{network="lan",partition="default",segment=""} 5021.0542075634 +consul_memberlist_pushPullNode_count{network="lan",partition="default",segment=""} 1773 +# HELP consul_memberlist_queue_broadcasts consul_memberlist_queue_broadcasts +# TYPE consul_memberlist_queue_broadcasts summary +consul_memberlist_queue_broadcasts{network="wan",quantile="0.5"} 0 +consul_memberlist_queue_broadcasts{network="wan",quantile="0.9"} 0 +consul_memberlist_queue_broadcasts{network="wan",quantile="0.99"} 0 +consul_memberlist_queue_broadcasts_sum{network="wan"} 0 +consul_memberlist_queue_broadcasts_count{network="wan"} 15060 +consul_memberlist_queue_broadcasts{network="lan",partition="default",segment="",quantile="0.5"} 0 +consul_memberlist_queue_broadcasts{network="lan",partition="default",segment="",quantile="0.9"} 0 +consul_memberlist_queue_broadcasts{network="lan",partition="default",segment="",quantile="0.99"} 0 +consul_memberlist_queue_broadcasts_sum{network="lan",partition="default",segment=""} 0 +consul_memberlist_queue_broadcasts_count{network="lan",partition="default",segment=""} 15060 +# HELP consul_memberlist_size_local_local consul_memberlist_size_local_local +# TYPE consul_memberlist_size_local_local gauge +consul_memberlist_size_local_local{network="lan",partition="default",segment=""} 2.208582144e+09 +# HELP consul_memberlist_size_remote consul_memberlist_size_remote +# TYPE consul_memberlist_size_remote summary +consul_memberlist_size_remote{network="lan",partition="default",segment="",quantile="0.5"} 717 +consul_memberlist_size_remote{network="lan",partition="default",segment="",quantile="0.9"} 717 +consul_memberlist_size_remote{network="lan",partition="default",segment="",quantile="0.99"} 717 +consul_memberlist_size_remote_sum{network="lan",partition="default",segment=""} 2.538313e+06 +consul_memberlist_size_remote_count{network="lan",partition="default",segment=""} 3549 +# HELP consul_memberlist_tcp_accept consul_memberlist_tcp_accept +# TYPE consul_memberlist_tcp_accept counter +consul_memberlist_tcp_accept{network="lan",partition="default",segment=""} 1776 +# HELP consul_memberlist_tcp_connect consul_memberlist_tcp_connect +# TYPE consul_memberlist_tcp_connect counter +consul_memberlist_tcp_connect{network="lan",partition="default",segment=""} 1773 +# HELP consul_memberlist_tcp_sent consul_memberlist_tcp_sent +# TYPE consul_memberlist_tcp_sent counter +consul_memberlist_tcp_sent{network="lan",partition="default",segment=""} 3.206921e+06 +# HELP consul_memberlist_udp_received consul_memberlist_udp_received +# TYPE consul_memberlist_udp_received counter +consul_memberlist_udp_received{network="lan"} 9.221042e+06 +# HELP consul_memberlist_udp_sent consul_memberlist_udp_sent +# TYPE consul_memberlist_udp_sent counter +consul_memberlist_udp_sent{network="lan",partition="default",segment=""} 9.218109e+06 +# HELP consul_members_clients Measures the current number of client agents registered with Consul. It is only emitted by Consul servers. Added in v1.9.6. +# TYPE consul_members_clients gauge +consul_members_clients 0 +# HELP consul_members_servers Measures the current number of server agents registered with Consul. It is only emitted by Consul servers. Added in v1.9.6. +# TYPE consul_members_servers gauge +consul_members_servers 0 +# HELP consul_mesh_active_root_ca_expiry Seconds until the service mesh root certificate expires. Updated every hour +# TYPE consul_mesh_active_root_ca_expiry gauge +consul_mesh_active_root_ca_expiry 0 +# HELP consul_mesh_active_signing_ca_expiry Seconds until the service mesh signing certificate expires. Updated every hour +# TYPE consul_mesh_active_signing_ca_expiry gauge +consul_mesh_active_signing_ca_expiry 0 +# HELP consul_namespace_read consul_namespace_read +# TYPE consul_namespace_read summary +consul_namespace_read{quantile="0.5"} 0.06529200077056885 +consul_namespace_read{quantile="0.9"} 0.12670400738716125 +consul_namespace_read{quantile="0.99"} 0.12670400738716125 +consul_namespace_read_sum 2885.675253532827 +consul_namespace_read_count 30042 +# HELP consul_partition_list consul_partition_list +# TYPE consul_partition_list summary +consul_partition_list{quantile="0.5"} NaN +consul_partition_list{quantile="0.9"} NaN +consul_partition_list{quantile="0.99"} NaN +consul_partition_list_sum 325.827104203403 +consul_partition_list_count 4138 +# HELP consul_peering_exported_services A gauge that tracks how many services are exported for the peering. The labels are "peer_name", "peer_id" and, for enterprise, "partition". We emit this metric every 9 seconds +# TYPE consul_peering_exported_services gauge +consul_peering_exported_services 0 +# HELP consul_peering_healthy A gauge that tracks how if a peering is healthy (1) or not (0). The labels are "peer_name", "peer_id" and, for enterprise, "partition". We emit this metric every 9 seconds +# TYPE consul_peering_healthy gauge +consul_peering_healthy 0 +# HELP consul_prepared_query_apply Measures the time it takes to apply a prepared query update. +# TYPE consul_prepared_query_apply summary +consul_prepared_query_apply{quantile="0.5"} NaN +consul_prepared_query_apply{quantile="0.9"} NaN +consul_prepared_query_apply{quantile="0.99"} NaN +consul_prepared_query_apply_sum 0 +consul_prepared_query_apply_count 0 +# HELP consul_prepared_query_execute Measures the time it takes to process a prepared query execute request. +# TYPE consul_prepared_query_execute summary +consul_prepared_query_execute{quantile="0.5"} NaN +consul_prepared_query_execute{quantile="0.9"} NaN +consul_prepared_query_execute{quantile="0.99"} NaN +consul_prepared_query_execute_sum 0 +consul_prepared_query_execute_count 0 +# HELP consul_prepared_query_execute_remote Measures the time it takes to process a prepared query execute request that was forwarded to another datacenter. +# TYPE consul_prepared_query_execute_remote summary +consul_prepared_query_execute_remote{quantile="0.5"} NaN +consul_prepared_query_execute_remote{quantile="0.9"} NaN +consul_prepared_query_execute_remote{quantile="0.99"} NaN +consul_prepared_query_execute_remote_sum 0 +consul_prepared_query_execute_remote_count 0 +# HELP consul_prepared_query_explain Measures the time it takes to process a prepared query explain request. +# TYPE consul_prepared_query_explain summary +consul_prepared_query_explain{quantile="0.5"} NaN +consul_prepared_query_explain{quantile="0.9"} NaN +consul_prepared_query_explain{quantile="0.99"} NaN +consul_prepared_query_explain_sum 0 +consul_prepared_query_explain_count 0 +# HELP consul_raft_applied_index Represents the raft applied index. +# TYPE consul_raft_applied_index gauge +consul_raft_applied_index 0 +# HELP consul_raft_applied_index_applied_index consul_raft_applied_index_applied_index +# TYPE consul_raft_applied_index_applied_index gauge +consul_raft_applied_index_applied_index 145203 +# HELP consul_raft_apply This counts the number of Raft transactions occurring over the interval. +# TYPE consul_raft_apply counter +consul_raft_apply 115252 +# HELP consul_raft_barrier consul_raft_barrier +# TYPE consul_raft_barrier counter +consul_raft_barrier 7530 +# HELP consul_raft_boltdb_freePageBytes_freePageBytes consul_raft_boltdb_freePageBytes_freePageBytes +# TYPE consul_raft_boltdb_freePageBytes_freePageBytes gauge +consul_raft_boltdb_freePageBytes_freePageBytes 1.3307904e+07 +# HELP consul_raft_boltdb_freelistBytes_freelistBytes consul_raft_boltdb_freelistBytes_freelistBytes +# TYPE consul_raft_boltdb_freelistBytes_freelistBytes gauge +consul_raft_boltdb_freelistBytes_freelistBytes 26008 +# HELP consul_raft_boltdb_getLog consul_raft_boltdb_getLog +# TYPE consul_raft_boltdb_getLog summary +consul_raft_boltdb_getLog{quantile="0.5"} 0.06123099848628044 +consul_raft_boltdb_getLog{quantile="0.9"} 0.06123099848628044 +consul_raft_boltdb_getLog{quantile="0.99"} 0.06123099848628044 +consul_raft_boltdb_getLog_sum 1990.6473612803966 +consul_raft_boltdb_getLog_count 45019 +# HELP consul_raft_boltdb_logBatchSize consul_raft_boltdb_logBatchSize +# TYPE consul_raft_boltdb_logBatchSize summary +consul_raft_boltdb_logBatchSize{quantile="0.5"} 1109 +consul_raft_boltdb_logBatchSize{quantile="0.9"} 1167 +consul_raft_boltdb_logBatchSize{quantile="0.99"} 1167 +consul_raft_boltdb_logBatchSize_sum 1.05877264e+08 +consul_raft_boltdb_logBatchSize_count 122794 +# HELP consul_raft_boltdb_logSize consul_raft_boltdb_logSize +# TYPE consul_raft_boltdb_logSize summary +consul_raft_boltdb_logSize{quantile="0.5"} 1109 +consul_raft_boltdb_logSize{quantile="0.9"} 1167 +consul_raft_boltdb_logSize{quantile="0.99"} 1167 +consul_raft_boltdb_logSize_sum 1.05877264e+08 +consul_raft_boltdb_logSize_count 122856 +# HELP consul_raft_boltdb_logsPerBatch consul_raft_boltdb_logsPerBatch +# TYPE consul_raft_boltdb_logsPerBatch summary +consul_raft_boltdb_logsPerBatch{quantile="0.5"} 1 +consul_raft_boltdb_logsPerBatch{quantile="0.9"} 1 +consul_raft_boltdb_logsPerBatch{quantile="0.99"} 1 +consul_raft_boltdb_logsPerBatch_sum 122856 +consul_raft_boltdb_logsPerBatch_count 122794 +# HELP consul_raft_boltdb_numFreePages_numFreePages consul_raft_boltdb_numFreePages_numFreePages +# TYPE consul_raft_boltdb_numFreePages_numFreePages gauge +consul_raft_boltdb_numFreePages_numFreePages 3238 +# HELP consul_raft_boltdb_numPendingPages_numPendingPages consul_raft_boltdb_numPendingPages_numPendingPages +# TYPE consul_raft_boltdb_numPendingPages_numPendingPages gauge +consul_raft_boltdb_numPendingPages_numPendingPages 11 +# HELP consul_raft_boltdb_openReadTxn_openReadTxn consul_raft_boltdb_openReadTxn_openReadTxn +# TYPE consul_raft_boltdb_openReadTxn_openReadTxn gauge +consul_raft_boltdb_openReadTxn_openReadTxn 0 +# HELP consul_raft_boltdb_storeLogs consul_raft_boltdb_storeLogs +# TYPE consul_raft_boltdb_storeLogs summary +consul_raft_boltdb_storeLogs{quantile="0.5"} 1.6733039617538452 +consul_raft_boltdb_storeLogs{quantile="0.9"} 2.21097993850708 +consul_raft_boltdb_storeLogs{quantile="0.99"} 2.21097993850708 +consul_raft_boltdb_storeLogs_sum 278437.40395510197 +consul_raft_boltdb_storeLogs_count 122794 +# HELP consul_raft_boltdb_totalReadTxn consul_raft_boltdb_totalReadTxn +# TYPE consul_raft_boltdb_totalReadTxn counter +consul_raft_boltdb_totalReadTxn 100198 +# HELP consul_raft_boltdb_txstats_cursorCount consul_raft_boltdb_txstats_cursorCount +# TYPE consul_raft_boltdb_txstats_cursorCount counter +consul_raft_boltdb_txstats_cursorCount 568889 +# HELP consul_raft_boltdb_txstats_nodeCount consul_raft_boltdb_txstats_nodeCount +# TYPE consul_raft_boltdb_txstats_nodeCount counter +consul_raft_boltdb_txstats_nodeCount 537103 +# HELP consul_raft_boltdb_txstats_nodeDeref consul_raft_boltdb_txstats_nodeDeref +# TYPE consul_raft_boltdb_txstats_nodeDeref counter +consul_raft_boltdb_txstats_nodeDeref 136 +# HELP consul_raft_boltdb_txstats_pageAlloc_pageAlloc consul_raft_boltdb_txstats_pageAlloc_pageAlloc +# TYPE consul_raft_boltdb_txstats_pageAlloc_pageAlloc gauge +consul_raft_boltdb_txstats_pageAlloc_pageAlloc 5.955145728e+09 +# HELP consul_raft_boltdb_txstats_pageCount_pageCount consul_raft_boltdb_txstats_pageCount_pageCount +# TYPE consul_raft_boltdb_txstats_pageCount_pageCount gauge +consul_raft_boltdb_txstats_pageCount_pageCount 1.453893e+06 +# HELP consul_raft_boltdb_txstats_rebalance consul_raft_boltdb_txstats_rebalance +# TYPE consul_raft_boltdb_txstats_rebalance counter +consul_raft_boltdb_txstats_rebalance 91912 +# HELP consul_raft_boltdb_txstats_rebalanceTime consul_raft_boltdb_txstats_rebalanceTime +# TYPE consul_raft_boltdb_txstats_rebalanceTime summary +consul_raft_boltdb_txstats_rebalanceTime{quantile="0.5"} 0 +consul_raft_boltdb_txstats_rebalanceTime{quantile="0.9"} 0 +consul_raft_boltdb_txstats_rebalanceTime{quantile="0.99"} 0 +consul_raft_boltdb_txstats_rebalanceTime_sum 61.22855579853058 +consul_raft_boltdb_txstats_rebalanceTime_count 90364 +# HELP consul_raft_boltdb_txstats_spill consul_raft_boltdb_txstats_spill +# TYPE consul_raft_boltdb_txstats_spill counter +consul_raft_boltdb_txstats_spill 545942 +# HELP consul_raft_boltdb_txstats_spillTime consul_raft_boltdb_txstats_spillTime +# TYPE consul_raft_boltdb_txstats_spillTime summary +consul_raft_boltdb_txstats_spillTime{quantile="0.5"} 0 +consul_raft_boltdb_txstats_spillTime{quantile="0.9"} 0.19511699676513672 +consul_raft_boltdb_txstats_spillTime{quantile="0.99"} 0.19511699676513672 +consul_raft_boltdb_txstats_spillTime_sum 3640.070483505726 +consul_raft_boltdb_txstats_spillTime_count 90364 +# HELP consul_raft_boltdb_txstats_split consul_raft_boltdb_txstats_split +# TYPE consul_raft_boltdb_txstats_split counter +consul_raft_boltdb_txstats_split 55070 +# HELP consul_raft_boltdb_txstats_write consul_raft_boltdb_txstats_write +# TYPE consul_raft_boltdb_txstats_write counter +consul_raft_boltdb_txstats_write 791562 +# HELP consul_raft_boltdb_txstats_writeTime consul_raft_boltdb_txstats_writeTime +# TYPE consul_raft_boltdb_txstats_writeTime summary +consul_raft_boltdb_txstats_writeTime{quantile="0.5"} 0 +consul_raft_boltdb_txstats_writeTime{quantile="0.9"} 11.23631763458252 +consul_raft_boltdb_txstats_writeTime{quantile="0.99"} 11.23631763458252 +consul_raft_boltdb_txstats_writeTime_sum 254982.9575778246 +consul_raft_boltdb_txstats_writeTime_count 90364 +# HELP consul_raft_boltdb_writeCapacity consul_raft_boltdb_writeCapacity +# TYPE consul_raft_boltdb_writeCapacity summary +consul_raft_boltdb_writeCapacity{quantile="0.5"} 601.9552612304688 +consul_raft_boltdb_writeCapacity{quantile="0.9"} 635.841064453125 +consul_raft_boltdb_writeCapacity{quantile="0.99"} 635.841064453125 +consul_raft_boltdb_writeCapacity_sum 6.307136215111172e+07 +consul_raft_boltdb_writeCapacity_count 122794 +# HELP consul_raft_commitNumLogs_commitNumLogs consul_raft_commitNumLogs_commitNumLogs +# TYPE consul_raft_commitNumLogs_commitNumLogs gauge +consul_raft_commitNumLogs_commitNumLogs 1 +# HELP consul_raft_commitTime This measures the time it takes to commit a new entry to the Raft log on the leader. +# TYPE consul_raft_commitTime summary +consul_raft_commitTime{quantile="0.5"} 1.7182049751281738 +consul_raft_commitTime{quantile="0.9"} 2.2621920108795166 +consul_raft_commitTime{quantile="0.99"} 2.2621920108795166 +consul_raft_commitTime_sum 284260.4287290573 +consul_raft_commitTime_count 122785 +# HELP consul_raft_fsm_apply consul_raft_fsm_apply +# TYPE consul_raft_fsm_apply summary +consul_raft_fsm_apply{quantile="0.5"} 0.16612499952316284 +consul_raft_fsm_apply{quantile="0.9"} 0.2391670048236847 +consul_raft_fsm_apply{quantile="0.99"} 0.2391670048236847 +consul_raft_fsm_apply_sum 24152.752846952528 +consul_raft_fsm_apply_count 115317 +# HELP consul_raft_fsm_enqueue consul_raft_fsm_enqueue +# TYPE consul_raft_fsm_enqueue summary +consul_raft_fsm_enqueue{quantile="0.5"} 0.015490000136196613 +consul_raft_fsm_enqueue{quantile="0.9"} 0.04627100005745888 +consul_raft_fsm_enqueue{quantile="0.99"} 0.04627100005745888 +consul_raft_fsm_enqueue_sum 3328.7210418977775 +consul_raft_fsm_enqueue_count 122763 +# HELP consul_raft_fsm_lastRestoreDuration This measures how long the last FSM restore (from disk or leader) took. +# TYPE consul_raft_fsm_lastRestoreDuration gauge +consul_raft_fsm_lastRestoreDuration 0 +# HELP consul_raft_last_index Represents the raft last index. +# TYPE consul_raft_last_index gauge +consul_raft_last_index 0 +# HELP consul_raft_last_index_last_index consul_raft_last_index_last_index +# TYPE consul_raft_last_index_last_index gauge +consul_raft_last_index_last_index 145203 +# HELP consul_raft_leader_dispatchLog consul_raft_leader_dispatchLog +# TYPE consul_raft_leader_dispatchLog summary +consul_raft_leader_dispatchLog{quantile="0.5"} 1.7106239795684814 +consul_raft_leader_dispatchLog{quantile="0.9"} 2.249191999435425 +consul_raft_leader_dispatchLog{quantile="0.99"} 2.249191999435425 +consul_raft_leader_dispatchLog_sum 282281.0580151081 +consul_raft_leader_dispatchLog_count 122780 +# HELP consul_raft_leader_dispatchNumLogs_dispatchNumLogs consul_raft_leader_dispatchNumLogs_dispatchNumLogs +# TYPE consul_raft_leader_dispatchNumLogs_dispatchNumLogs gauge +consul_raft_leader_dispatchNumLogs_dispatchNumLogs 1 +# HELP consul_raft_leader_lastContact Measures the time since the leader was last able to contact the follower nodes when checking its leader lease. +# TYPE consul_raft_leader_lastContact summary +consul_raft_leader_lastContact{quantile="0.5"} NaN +consul_raft_leader_lastContact{quantile="0.9"} NaN +consul_raft_leader_lastContact{quantile="0.99"} NaN +consul_raft_leader_lastContact_sum 598 +consul_raft_leader_lastContact_count 19 +# HELP consul_raft_leader_oldestLogAge This measures how old the oldest log in the leader's log store is. +# TYPE consul_raft_leader_oldestLogAge gauge +consul_raft_leader_oldestLogAge 0 +# HELP consul_raft_leader_oldestLogAge_oldestLogAge consul_raft_leader_oldestLogAge_oldestLogAge +# TYPE consul_raft_leader_oldestLogAge_oldestLogAge gauge +consul_raft_leader_oldestLogAge_oldestLogAge 6.8835264e+07 +# HELP consul_raft_rpc_installSnapshot Measures the time it takes the raft leader to install a snapshot on a follower that is catching up after being down or has just joined the cluster. +# TYPE consul_raft_rpc_installSnapshot summary +consul_raft_rpc_installSnapshot{quantile="0.5"} NaN +consul_raft_rpc_installSnapshot{quantile="0.9"} NaN +consul_raft_rpc_installSnapshot{quantile="0.99"} NaN +consul_raft_rpc_installSnapshot_sum 473.0382385253906 +consul_raft_rpc_installSnapshot_count 1 +# HELP consul_raft_snapshot_persist Measures the time it takes raft to write a new snapshot to disk. +# TYPE consul_raft_snapshot_persist summary +consul_raft_snapshot_persist{quantile="0.5"} NaN +consul_raft_snapshot_persist{quantile="0.9"} NaN +consul_raft_snapshot_persist{quantile="0.99"} NaN +consul_raft_snapshot_persist_sum 457.33628499507904 +consul_raft_snapshot_persist_count 10 +# HELP consul_raft_state_candidate This increments whenever a Consul server starts an election. +# TYPE consul_raft_state_candidate counter +consul_raft_state_candidate 1 +# HELP consul_raft_state_leader This increments whenever a Consul server becomes a leader. +# TYPE consul_raft_state_leader counter +consul_raft_state_leader 1 +# HELP consul_raft_thread_fsm_saturation consul_raft_thread_fsm_saturation +# TYPE consul_raft_thread_fsm_saturation summary +consul_raft_thread_fsm_saturation{quantile="0.5"} 0 +consul_raft_thread_fsm_saturation{quantile="0.9"} 0 +consul_raft_thread_fsm_saturation{quantile="0.99"} 0 +consul_raft_thread_fsm_saturation_sum 0.7299999818205833 +consul_raft_thread_fsm_saturation_count 44326 +# HELP consul_raft_thread_main_saturation consul_raft_thread_main_saturation +# TYPE consul_raft_thread_main_saturation summary +consul_raft_thread_main_saturation{quantile="0.5"} 0 +consul_raft_thread_main_saturation{quantile="0.9"} 0 +consul_raft_thread_main_saturation{quantile="0.99"} 0.009999999776482582 +consul_raft_thread_main_saturation_sum 213.059995315969 +consul_raft_thread_main_saturation_count 451221 +# HELP consul_raft_verify_leader consul_raft_verify_leader +# TYPE consul_raft_verify_leader counter +consul_raft_verify_leader 2 +# HELP consul_rpc_accept_conn Increments when a server accepts an RPC connection. +# TYPE consul_rpc_accept_conn counter +consul_rpc_accept_conn 39 +# HELP consul_rpc_consistentRead Measures the time spent confirming that a consistent read can be performed. +# TYPE consul_rpc_consistentRead summary +consul_rpc_consistentRead{quantile="0.5"} NaN +consul_rpc_consistentRead{quantile="0.9"} NaN +consul_rpc_consistentRead{quantile="0.99"} NaN +consul_rpc_consistentRead_sum 85.52406929805875 +consul_rpc_consistentRead_count 1600 +# HELP consul_rpc_cross_dc Increments when a server sends a (potentially blocking) cross datacenter RPC query. +# TYPE consul_rpc_cross_dc counter +consul_rpc_cross_dc 0 +# HELP consul_rpc_queries_blocking Shows the current number of in-flight blocking queries the server is handling. +# TYPE consul_rpc_queries_blocking gauge +consul_rpc_queries_blocking 0 +# HELP consul_rpc_queries_blocking_queries_blocking consul_rpc_queries_blocking_queries_blocking +# TYPE consul_rpc_queries_blocking_queries_blocking gauge +consul_rpc_queries_blocking_queries_blocking 20 +# HELP consul_rpc_query Increments when a server receives a read request, indicating the rate of new read queries. +# TYPE consul_rpc_query counter +consul_rpc_query 261853 +# HELP consul_rpc_raft_handoff Increments when a server accepts a Raft-related RPC connection. +# TYPE consul_rpc_raft_handoff counter +consul_rpc_raft_handoff 3 +# HELP consul_rpc_request Increments when a server receives a Consul-related RPC request. +# TYPE consul_rpc_request counter +consul_rpc_request 233395 +# HELP consul_rpc_request_error Increments when a server returns an error from an RPC request. +# TYPE consul_rpc_request_error counter +consul_rpc_request_error 0 +# HELP consul_runtime_alloc_bytes_alloc_bytes consul_runtime_alloc_bytes_alloc_bytes +# TYPE consul_runtime_alloc_bytes_alloc_bytes gauge +consul_runtime_alloc_bytes_alloc_bytes 5.1729856e+07 +# HELP consul_runtime_free_count_free_count consul_runtime_free_count_free_count +# TYPE consul_runtime_free_count_free_count gauge +consul_runtime_free_count_free_count 1.513573888e+09 +# HELP consul_runtime_gc_pause_ns consul_runtime_gc_pause_ns +# TYPE consul_runtime_gc_pause_ns summary +consul_runtime_gc_pause_ns{quantile="0.5"} NaN +consul_runtime_gc_pause_ns{quantile="0.9"} NaN +consul_runtime_gc_pause_ns{quantile="0.99"} NaN +consul_runtime_gc_pause_ns_sum 8.32754022e+08 +consul_runtime_gc_pause_ns_count 4172 +# HELP consul_runtime_heap_objects_heap_objects consul_runtime_heap_objects_heap_objects +# TYPE consul_runtime_heap_objects_heap_objects gauge +consul_runtime_heap_objects_heap_objects 309596 +# HELP consul_runtime_malloc_count_malloc_count consul_runtime_malloc_count_malloc_count +# TYPE consul_runtime_malloc_count_malloc_count gauge +consul_runtime_malloc_count_malloc_count 1.51388352e+09 +# HELP consul_runtime_num_goroutines_num_goroutines consul_runtime_num_goroutines_num_goroutines +# TYPE consul_runtime_num_goroutines_num_goroutines gauge +consul_runtime_num_goroutines_num_goroutines 305 +# HELP consul_runtime_sys_bytes_sys_bytes consul_runtime_sys_bytes_sys_bytes +# TYPE consul_runtime_sys_bytes_sys_bytes gauge +consul_runtime_sys_bytes_sys_bytes 1.6015696e+08 +# HELP consul_runtime_total_gc_pause_ns_total_gc_pause_ns consul_runtime_total_gc_pause_ns_total_gc_pause_ns +# TYPE consul_runtime_total_gc_pause_ns_total_gc_pause_ns gauge +consul_runtime_total_gc_pause_ns_total_gc_pause_ns 8.32754048e+08 +# HELP consul_runtime_total_gc_runs_total_gc_runs consul_runtime_total_gc_runs_total_gc_runs +# TYPE consul_runtime_total_gc_runs_total_gc_runs gauge +consul_runtime_total_gc_runs_total_gc_runs 4172 +# HELP consul_serf_coordinate_adjustment_ms consul_serf_coordinate_adjustment_ms +# TYPE consul_serf_coordinate_adjustment_ms summary +consul_serf_coordinate_adjustment_ms{network="lan",partition="default",segment="",quantile="0.5"} 0.31390100717544556 +consul_serf_coordinate_adjustment_ms{network="lan",partition="default",segment="",quantile="0.9"} 0.31821900606155396 +consul_serf_coordinate_adjustment_ms{network="lan",partition="default",segment="",quantile="0.99"} 0.31821900606155396 +consul_serf_coordinate_adjustment_ms_sum{network="lan",partition="default",segment=""} 23996.035400994588 +consul_serf_coordinate_adjustment_ms_count{network="lan",partition="default",segment=""} 30847 +# HELP consul_serf_queue_Event consul_serf_queue_Event +# TYPE consul_serf_queue_Event summary +consul_serf_queue_Event{network="wan",quantile="0.5"} 0 +consul_serf_queue_Event{network="wan",quantile="0.9"} 0 +consul_serf_queue_Event{network="wan",quantile="0.99"} 0 +consul_serf_queue_Event_sum{network="wan"} 0 +consul_serf_queue_Event_count{network="wan"} 15060 +consul_serf_queue_Event{network="lan",partition="default",segment="",quantile="0.5"} 0 +consul_serf_queue_Event{network="lan",partition="default",segment="",quantile="0.9"} 0 +consul_serf_queue_Event{network="lan",partition="default",segment="",quantile="0.99"} 0 +consul_serf_queue_Event_sum{network="lan",partition="default",segment=""} 6429 +consul_serf_queue_Event_count{network="lan",partition="default",segment=""} 15060 +# HELP consul_serf_queue_Intent consul_serf_queue_Intent +# TYPE consul_serf_queue_Intent summary +consul_serf_queue_Intent{network="wan",quantile="0.5"} 0 +consul_serf_queue_Intent{network="wan",quantile="0.9"} 0 +consul_serf_queue_Intent{network="wan",quantile="0.99"} 0 +consul_serf_queue_Intent_sum{network="wan"} 0 +consul_serf_queue_Intent_count{network="wan"} 15060 +consul_serf_queue_Intent{network="lan",partition="default",segment="",quantile="0.5"} 0 +consul_serf_queue_Intent{network="lan",partition="default",segment="",quantile="0.9"} 0 +consul_serf_queue_Intent{network="lan",partition="default",segment="",quantile="0.99"} 0 +consul_serf_queue_Intent_sum{network="lan",partition="default",segment=""} 0 +consul_serf_queue_Intent_count{network="lan",partition="default",segment=""} 15060 +# HELP consul_serf_queue_Query consul_serf_queue_Query +# TYPE consul_serf_queue_Query summary +consul_serf_queue_Query{network="wan",quantile="0.5"} 0 +consul_serf_queue_Query{network="wan",quantile="0.9"} 0 +consul_serf_queue_Query{network="wan",quantile="0.99"} 0 +consul_serf_queue_Query_sum{network="wan"} 0 +consul_serf_queue_Query_count{network="wan"} 15060 +consul_serf_queue_Query{network="lan",partition="default",segment="",quantile="0.5"} 0 +consul_serf_queue_Query{network="lan",partition="default",segment="",quantile="0.9"} 0 +consul_serf_queue_Query{network="lan",partition="default",segment="",quantile="0.99"} 0 +consul_serf_queue_Query_sum{network="lan",partition="default",segment=""} 0 +consul_serf_queue_Query_count{network="lan",partition="default",segment=""} 15060 +# HELP consul_server_isLeader Tracks if the server is a leader. +# TYPE consul_server_isLeader gauge +consul_server_isLeader 0 +# HELP consul_server_isLeader_isLeader consul_server_isLeader_isLeader +# TYPE consul_server_isLeader_isLeader gauge +consul_server_isLeader_isLeader 1 +# HELP consul_session_apply Measures the time spent applying a session update. +# TYPE consul_session_apply summary +consul_session_apply{quantile="0.5"} NaN +consul_session_apply{quantile="0.9"} NaN +consul_session_apply{quantile="0.99"} NaN +consul_session_apply_sum 0 +consul_session_apply_count 0 +# HELP consul_session_renew Measures the time spent renewing a session. +# TYPE consul_session_renew summary +consul_session_renew{quantile="0.5"} NaN +consul_session_renew{quantile="0.9"} NaN +consul_session_renew{quantile="0.99"} NaN +consul_session_renew_sum 0 +consul_session_renew_count 0 +# HELP consul_session_ttl_active Tracks the active number of sessions being tracked. +# TYPE consul_session_ttl_active gauge +consul_session_ttl_active 0 +# HELP consul_session_ttl_active_active consul_session_ttl_active_active +# TYPE consul_session_ttl_active_active gauge +consul_session_ttl_active_active 0 +# HELP consul_session_ttl_invalidate Measures the time spent invalidating an expired session. +# TYPE consul_session_ttl_invalidate summary +consul_session_ttl_invalidate{quantile="0.5"} NaN +consul_session_ttl_invalidate{quantile="0.9"} NaN +consul_session_ttl_invalidate{quantile="0.99"} NaN +consul_session_ttl_invalidate_sum 0 +consul_session_ttl_invalidate_count 0 +# HELP consul_state_config_entries Measures the current number of unique configuration entries registered with Consul, labeled by Kind. It is only emitted by Consul servers. Added in v1.10.4. +# TYPE consul_state_config_entries gauge +consul_state_config_entries 0 +# HELP consul_state_connect_instances Measures the current number of unique connect service instances registered with Consul, labeled by Kind. It is only emitted by Consul servers. Added in v1.10.4. +# TYPE consul_state_connect_instances gauge +consul_state_connect_instances 0 +# HELP consul_state_kv_entries Measures the current number of entries in the Consul KV store. It is only emitted by Consul servers. Added in v1.10.3. +# TYPE consul_state_kv_entries gauge +consul_state_kv_entries 0 +# HELP consul_state_nodes Measures the current number of nodes registered with Consul. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_state_nodes gauge +consul_state_nodes 0 +# HELP consul_state_peerings Measures the current number of peerings registered with Consul. It is only emitted by Consul servers. Added in v1.13.0. +# TYPE consul_state_peerings gauge +consul_state_peerings 0 +# HELP consul_state_service_instances Measures the current number of unique services registered with Consul, based on service name. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_state_service_instances gauge +consul_state_service_instances 0 +# HELP consul_state_services Measures the current number of unique services registered with Consul, based on service name. It is only emitted by Consul servers. Added in v1.9.0. +# TYPE consul_state_services gauge +consul_state_services 0 +# HELP consul_system_licenseExpiration Represents the number of hours until the current license is going to expire +# TYPE consul_system_licenseExpiration gauge +consul_system_licenseExpiration 0 +# HELP consul_system_licenseExpiration_licenseExpiration consul_system_licenseExpiration_licenseExpiration +# TYPE consul_system_licenseExpiration_licenseExpiration gauge +consul_system_licenseExpiration_licenseExpiration 819.429443359375 +# HELP consul_txn_apply Measures the time spent applying a transaction operation. +# TYPE consul_txn_apply summary +consul_txn_apply{quantile="0.5"} NaN +consul_txn_apply{quantile="0.9"} NaN +consul_txn_apply{quantile="0.99"} NaN +consul_txn_apply_sum 0 +consul_txn_apply_count 0 +# HELP consul_txn_read Measures the time spent returning a read transaction. +# TYPE consul_txn_read summary +consul_txn_read{quantile="0.5"} NaN +consul_txn_read{quantile="0.9"} NaN +consul_txn_read{quantile="0.99"} NaN +consul_txn_read_sum 0 +consul_txn_read_count 0 +# HELP consul_version Represents the Consul version. +# TYPE consul_version gauge +consul_version 0 +# HELP consul_xds_server_idealStreamsMax The maximum number of xDS streams per server, chosen to achieve a roughly even spread of load across servers. +# TYPE consul_xds_server_idealStreamsMax gauge +consul_xds_server_idealStreamsMax 0 +# HELP consul_xds_server_streamDrained Counts the number of xDS streams that are drained when rebalancing the load between servers. +# TYPE consul_xds_server_streamDrained counter +consul_xds_server_streamDrained 0 +# HELP consul_xds_server_streamStart Measures the time in milliseconds after an xDS stream is opened until xDS resources are first generated for the stream. +# TYPE consul_xds_server_streamStart summary +consul_xds_server_streamStart{quantile="0.5"} NaN +consul_xds_server_streamStart{quantile="0.9"} NaN +consul_xds_server_streamStart{quantile="0.99"} NaN +consul_xds_server_streamStart_sum 3501.488723754883 +consul_xds_server_streamStart_count 11 +# HELP consul_xds_server_streams Measures the number of active xDS streams handled by the server split by protocol version. +# TYPE consul_xds_server_streams gauge +consul_xds_server_streams 0 +# HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles. +# TYPE go_gc_duration_seconds summary +go_gc_duration_seconds{quantile="0"} 3.7191e-05 +go_gc_duration_seconds{quantile="0.25"} 6.1463e-05 +go_gc_duration_seconds{quantile="0.5"} 7.7062e-05 +go_gc_duration_seconds{quantile="0.75"} 0.000115923 +go_gc_duration_seconds{quantile="1"} 0.001147196 +go_gc_duration_seconds_sum 0.832754027 +go_gc_duration_seconds_count 4172 +# HELP go_goroutines Number of goroutines that currently exist. +# TYPE go_goroutines gauge +go_goroutines 313 +# HELP go_info Information about the Go environment. +# TYPE go_info gauge +go_info{version="go1.19.4"} 1 +# HELP go_memstats_alloc_bytes Number of bytes allocated and still in use. +# TYPE go_memstats_alloc_bytes gauge +go_memstats_alloc_bytes 5.195244e+07 +# HELP go_memstats_alloc_bytes_total Total number of bytes allocated, even if freed. +# TYPE go_memstats_alloc_bytes_total counter +go_memstats_alloc_bytes_total 1.0251245704e+11 +# HELP go_memstats_buck_hash_sys_bytes Number of bytes used by the profiling bucket hash table. +# TYPE go_memstats_buck_hash_sys_bytes gauge +go_memstats_buck_hash_sys_bytes 4.77878e+06 +# HELP go_memstats_frees_total Total number of frees. +# TYPE go_memstats_frees_total counter +go_memstats_frees_total 1.51357406e+09 +# HELP go_memstats_gc_cpu_fraction The fraction of this program's available CPU time used by the GC since the program started. +# TYPE go_memstats_gc_cpu_fraction gauge +go_memstats_gc_cpu_fraction 2.663750489550345e-05 +# HELP go_memstats_gc_sys_bytes Number of bytes used for garbage collection system metadata. +# TYPE go_memstats_gc_sys_bytes gauge +go_memstats_gc_sys_bytes 1.5347888e+07 +# HELP go_memstats_heap_alloc_bytes Number of heap bytes allocated and still in use. +# TYPE go_memstats_heap_alloc_bytes gauge +go_memstats_heap_alloc_bytes 5.195244e+07 +# HELP go_memstats_heap_idle_bytes Number of heap bytes waiting to be used. +# TYPE go_memstats_heap_idle_bytes gauge +go_memstats_heap_idle_bytes 7.4121216e+07 +# HELP go_memstats_heap_inuse_bytes Number of heap bytes that are in use. +# TYPE go_memstats_heap_inuse_bytes gauge +go_memstats_heap_inuse_bytes 6.1472768e+07 +# HELP go_memstats_heap_objects Number of allocated objects. +# TYPE go_memstats_heap_objects gauge +go_memstats_heap_objects 311688 +# HELP go_memstats_heap_released_bytes Number of heap bytes released to OS. +# TYPE go_memstats_heap_released_bytes gauge +go_memstats_heap_released_bytes 5.914624e+07 +# HELP go_memstats_heap_sys_bytes Number of heap bytes obtained from system. +# TYPE go_memstats_heap_sys_bytes gauge +go_memstats_heap_sys_bytes 1.35593984e+08 +# HELP go_memstats_last_gc_time_seconds Number of seconds since 1970 of last garbage collection. +# TYPE go_memstats_last_gc_time_seconds gauge +go_memstats_last_gc_time_seconds 1.6741251000160766e+09 +# HELP go_memstats_lookups_total Total number of pointer lookups. +# TYPE go_memstats_lookups_total counter +go_memstats_lookups_total 0 +# HELP go_memstats_mallocs_total Total number of mallocs. +# TYPE go_memstats_mallocs_total counter +go_memstats_mallocs_total 1.513885748e+09 +# HELP go_memstats_mcache_inuse_bytes Number of bytes in use by mcache structures. +# TYPE go_memstats_mcache_inuse_bytes gauge +go_memstats_mcache_inuse_bytes 2400 +# HELP go_memstats_mcache_sys_bytes Number of bytes used for mcache structures obtained from system. +# TYPE go_memstats_mcache_sys_bytes gauge +go_memstats_mcache_sys_bytes 15600 +# HELP go_memstats_mspan_inuse_bytes Number of bytes in use by mspan structures. +# TYPE go_memstats_mspan_inuse_bytes gauge +go_memstats_mspan_inuse_bytes 712656 +# HELP go_memstats_mspan_sys_bytes Number of bytes used for mspan structures obtained from system. +# TYPE go_memstats_mspan_sys_bytes gauge +go_memstats_mspan_sys_bytes 943776 +# HELP go_memstats_next_gc_bytes Number of heap bytes when next garbage collection will take place. +# TYPE go_memstats_next_gc_bytes gauge +go_memstats_next_gc_bytes 7.2274088e+07 +# HELP go_memstats_other_sys_bytes Number of bytes used for other system allocations. +# TYPE go_memstats_other_sys_bytes gauge +go_memstats_other_sys_bytes 658892 +# HELP go_memstats_stack_inuse_bytes Number of bytes in use by the stack allocator. +# TYPE go_memstats_stack_inuse_bytes gauge +go_memstats_stack_inuse_bytes 2.818048e+06 +# HELP go_memstats_stack_sys_bytes Number of bytes obtained from system for stack allocator. +# TYPE go_memstats_stack_sys_bytes gauge +go_memstats_stack_sys_bytes 2.818048e+06 +# HELP go_memstats_sys_bytes Number of bytes obtained from system. +# TYPE go_memstats_sys_bytes gauge +go_memstats_sys_bytes 1.60156968e+08 +# HELP go_threads Number of OS threads created. +# TYPE go_threads gauge +go_threads 10 +# HELP process_cpu_seconds_total Total user and system CPU time spent in seconds. +# TYPE process_cpu_seconds_total counter +process_cpu_seconds_total 4001.82 +# HELP process_max_fds Maximum number of open file descriptors. +# TYPE process_max_fds gauge +process_max_fds 65536 +# HELP process_open_fds Number of open file descriptors. +# TYPE process_open_fds gauge +process_open_fds 45 +# HELP process_resident_memory_bytes Resident memory size in bytes. +# TYPE process_resident_memory_bytes gauge +process_resident_memory_bytes 1.30408448e+08 +# HELP process_start_time_seconds Start time of the process since unix epoch in seconds. +# TYPE process_start_time_seconds gauge +process_start_time_seconds 1.67367331028e+09 +# HELP process_virtual_memory_bytes Virtual memory size in bytes. +# TYPE process_virtual_memory_bytes gauge +process_virtual_memory_bytes 1.046990848e+09 +# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes. +# TYPE process_virtual_memory_max_bytes gauge +process_virtual_memory_max_bytes -1
\ No newline at end of file diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/server_v1-agent-self.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/server_v1-agent-self.json new file mode 100644 index 000000000..8a11b7d0e --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/server_v1-agent-self.json @@ -0,0 +1,71 @@ +{ + "Config": { + "Datacenter": "consul-sandbox-cluster-0159c9d3", + "PrimaryDatacenter": "consul-sandbox-cluster-0159c9d3", + "NodeName": "ip-172-25-37-57", + "NodeID": "b1906d81-c585-7c2c-1236-a5404b7fa7ca", + "Revision": "55a184d3", + "Server": true, + "Version": "1.14.3+ent", + "BuildDate": "2022-12-13T17:12:10Z" + }, + "DebugConfig": { + "Cloud": { + "AuthURL": "", + "ClientID": "492e9e67-6386-4727-964f-8a41305f30a5", + "ClientSecret": "hidden", + "Hostname": "", + "ResourceID": "organization/1/project/2/hashicorp.consul.cluster/3", + "ScadaAddress": "" + }, + "Telemetry": { + "AllowedPrefixes": [], + "BlockedPrefixes": [ + "consul.rpc.server.call" + ], + "CirconusAPIApp": "", + "CirconusAPIToken": "hidden", + "CirconusAPIURL": "", + "CirconusBrokerID": "", + "CirconusBrokerSelectTag": "", + "CirconusCheckDisplayName": "", + "CirconusCheckForceMetricActivation": "", + "CirconusCheckID": "", + "CirconusCheckInstanceID": "", + "CirconusCheckSearchTag": "", + "CirconusCheckTags": "", + "CirconusSubmissionInterval": "", + "CirconusSubmissionURL": "", + "Disable": false, + "DisableHostname": false, + "DogstatsdAddr": "127.0.0.1:8125", + "DogstatsdTags": [], + "FilterDefault": true, + "MetricsPrefix": "consul", + "PrometheusOpts": { + "CounterDefinitions": [], + "Expiration": "5m0s", + "GaugeDefinitions": [], + "Name": "consul", + "Registerer": null, + "SummaryDefinitions": [] + }, + "RetryFailedConfiguration": true, + "StatsdAddr": "", + "StatsiteAddr": "" + } + }, + "Stats": { + "license": { + "customer": "a1c27ed4-43a4-4192-9f39-14e1166d2d2e", + "expiration_time": "2023-02-22 14:11:12.877172615 +0000 UTC", + "features": "Automated Backups, Automated Upgrades, Namespaces, SSO, Audit Logging, Admin Partitions", + "id": "492e9e67-6386-4727-964f-8a41305f30a5", + "install_id": "*", + "issue_time": "2023-01-15 14:11:12.877172615 +0000 UTC", + "modules": "Governance and Policy", + "product": "consul", + "start_time": "2023-01-15 14:11:12.877172615 +0000 UTC" + } + } +} diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/server_v1-coordinate-nodes.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/server_v1-coordinate-nodes.json new file mode 100644 index 000000000..bfe44c7fc --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/server_v1-coordinate-nodes.json @@ -0,0 +1,42 @@ +[ + { + "Node": "ip-10-50-133-93", + "Segment": "", + "Partition": "default", + "Coord": { + "Vec": [ + -0.0005406415790908119, + -0.005125240204547753, + -0.0010556502711423538, + -0.00223296135134459, + 0.002051567080576126, + -0.004494795954099239, + -0.0010621855776488467, + 0.0013985871196457514 + ], + "Error": 0.056466891936309965, + "Adjustment": -0.0004925342111843478, + "Height": 0.00043853135504766936 + } + }, + { + "Node": "ip-172-25-37-57", + "Segment": "", + "Partition": "default", + "Coord": { + "Vec": [ + -0.00041456488713690183, + -0.0039300429073992685, + -0.0008094743964577936, + -0.001712238560569221, + 0.0015731451331568297, + -0.00344661716784539, + -0.0008144857045591224, + 0.0010724389795601075 + ], + "Error": 0.0223287150164881, + "Adjustment": -0.0004893904130922427, + "Height": 5.5788597108650077e-05 + } + } +] diff --git a/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/v1-agent-checks.json b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/v1-agent-checks.json new file mode 100644 index 000000000..0daa492c0 --- /dev/null +++ b/src/go/collectors/go.d.plugin/modules/consul/testdata/v1.14.3-cloud/v1-agent-checks.json @@ -0,0 +1,68 @@ +{ + "chk1": { + "Node": "mysql1", + "CheckID": "chk1", + "Name": "ssh", + "Status": "passing", + "Notes": "", + "Output": "TCP connect 127.0.0.1:22: Success", + "ServiceID": "", + "ServiceName": "", + "ServiceTags": [ + ], + "Definition": { + }, + "CreateIndex": 0, + "ModifyIndex": 0 + }, + "chk2": { + "Node": "mysql1", + "CheckID": "chk2", + "Name": "telnet", + "Status": "critical", + "Notes": "", + "Output": "dial tcp 127.0.0.1:23: connect: connection refused", + "ServiceID": "", + "ServiceName": "", + "ServiceTags": [ + ], + "Definition": { + }, + "CreateIndex": 0, + "ModifyIndex": 0 + }, + "chk3": { + "Node": "mysql1", + "CheckID": "chk3", + "Name": "telnet", + "Status": "critical", + "Notes": "", + "Output": "dial tcp 127.0.0.1:23: connect: connection refused", + "ServiceID": "", + "ServiceName": "", + "ServiceTags": [ + ], + "Definition": { + }, + "CreateIndex": 0, + "ModifyIndex": 0 + }, + "mysql": { + "Node": "mysql1", + "CheckID": "mysql", + "Name": "MYSQL TCP on port 3336", + "Status": "critical", + "Notes": "", + "Output": "dial tcp 127.0.0.1:3336: connect: connection refused", + "ServiceID": "mysql0", + "ServiceName": "mysql", + "ServiceTags": [ + "primary", + "secondary" + ], + "Definition": { + }, + "CreateIndex": 0, + "ModifyIndex": 0 + } +} |