diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 7bee557e9a0d..18f537537cf3 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -2709,6 +2709,4216 @@ CockroachDB module +*`prometheus.metrics.addsstable_applications`*:: ++ +-- +Number of SSTable ingestions applied (i.e. applied by Replicas) + + +type: double + +-- + +*`prometheus.metrics.addsstable_copies`*:: ++ +-- +number of SSTable ingestions that required copying files during application + + +type: double + +-- + +*`prometheus.metrics.addsstable_proposals`*:: ++ +-- +Number of SSTable ingestions proposed (i.e. sent to Raft by lease holders) + + +type: double + +-- + +*`prometheus.metrics.build_timestamp`*:: ++ +-- +Build information + + +type: double + +-- + +*`prometheus.metrics.capacity`*:: ++ +-- +Total storage capacity + + +type: double + +-- + +*`prometheus.metrics.capacity_available`*:: ++ +-- +Available storage capacity + + +type: double + +-- + +*`prometheus.metrics.capacity_reserved`*:: ++ +-- +Capacity reserved for snapshots + + +type: double + +-- + +*`prometheus.metrics.capacity_used`*:: ++ +-- +Used storage capacity + + +type: double + +-- + +*`prometheus.metrics.changefeed_buffer_entries_in`*:: ++ +-- +Total entries entering the buffer between raft and changefeed sinks + + +type: double + +-- + +*`prometheus.metrics.changefeed_buffer_entries_out`*:: ++ +-- +Total entries leaving the buffer between raft and changefeed sinks + + +type: double + +-- + +*`prometheus.metrics.changefeed_emit_nanos`*:: ++ +-- +Total time spent emitting all feeds + + +type: double + +-- + +*`prometheus.metrics.changefeed_emitted_bytes`*:: ++ +-- +Bytes emitted by all feeds + + +type: double + +-- + +*`prometheus.metrics.changefeed_emitted_messages`*:: ++ +-- +Messages emitted by all feeds + + +type: double + +-- + +*`prometheus.metrics.changefeed_error_retries`*:: ++ +-- +Total retryable errors encountered by all changefeeds + + +type: double + +-- + +*`prometheus.metrics.changefeed_flush_nanos`*:: ++ +-- +Total time spent flushing all feeds + + +type: double + +-- + +*`prometheus.metrics.changefeed_flushes`*:: ++ +-- +Total flushes across all feeds + + +type: double + +-- + +*`prometheus.metrics.changefeed_max_behind_nanos`*:: ++ +-- +Largest commit-to-emit duration of any running feed + + +type: double + +-- + +*`prometheus.metrics.changefeed_min_high_water`*:: ++ +-- +Latest high-water timestamp of most behind feed + + +type: double + +-- + +*`prometheus.metrics.changefeed_poll_request_nanos_bucket`*:: ++ +-- +Time spent fetching changes + + +type: double + +-- + +*`prometheus.metrics.changefeed_poll_request_nanos_sum`*:: ++ +-- +Sum of Time spent fetching changes + + +type: double + +-- + +*`prometheus.metrics.changefeed_poll_request_nanos_count`*:: ++ +-- +Count of Time spent fetching changes + + +type: double + +-- + +*`prometheus.metrics.changefeed_processing_nanos`*:: ++ +-- +Time spent processing KV changes into SQL rows + + +type: double + +-- + +*`prometheus.metrics.changefeed_table_metadata_nanos`*:: ++ +-- +Time blocked while verifying table metadata histories + + +type: double + +-- + +*`prometheus.metrics.clock_offset_meannanos`*:: ++ +-- +Mean clock offset with other nodes + + +type: double + +-- + +*`prometheus.metrics.clock_offset_stddevnanos`*:: ++ +-- +Stddev clock offset with other nodes + + +type: double + +-- + +*`prometheus.metrics.compactor_compactingnanos`*:: ++ +-- +Number of nanoseconds spent compacting ranges + + +type: double + +-- + +*`prometheus.metrics.compactor_compactions_failure`*:: ++ +-- +Number of failed compaction requests sent to the storage engine + + +type: double + +-- + +*`prometheus.metrics.compactor_compactions_success`*:: ++ +-- +Number of successful compaction requests sent to the storage engine + + +type: double + +-- + +*`prometheus.metrics.compactor_suggestionbytes_compacted`*:: ++ +-- +Number of logical bytes compacted from suggested compactions + + +type: double + +-- + +*`prometheus.metrics.compactor_suggestionbytes_queued`*:: ++ +-- +Number of logical bytes in suggested compactions in the queue + + +type: double + +-- + +*`prometheus.metrics.compactor_suggestionbytes_skipped`*:: ++ +-- +Number of logical bytes in suggested compactions which were not compacted + + +type: double + +-- + +*`prometheus.metrics.distsender_batches`*:: ++ +-- +Number of batches processed + + +type: double + +-- + +*`prometheus.metrics.distsender_batches_async_sent`*:: ++ +-- +Number of partial batches sent asynchronously + + +type: double + +-- + +*`prometheus.metrics.distsender_batches_async_throttled`*:: ++ +-- +Number of partial batches not sent asynchronously due to throttling + + +type: double + +-- + +*`prometheus.metrics.distsender_batches_partial`*:: ++ +-- +Number of partial batches processed after being divided on range boundaries + + +type: double + +-- + +*`prometheus.metrics.distsender_errors_inleasetransferbackoffs`*:: ++ +-- +Number of times backed off due to NotLeaseHolderErrors during lease transfer. + + +type: double + +-- + +*`prometheus.metrics.distsender_errors_notleaseholder`*:: ++ +-- +Number of NotLeaseHolderErrors encountered + + +type: double + +-- + +*`prometheus.metrics.distsender_rpc_sent`*:: ++ +-- +Number of RPCs sent + + +type: double + +-- + +*`prometheus.metrics.distsender_rpc_sent_local`*:: ++ +-- +Number of local RPCs sent + + +type: double + +-- + +*`prometheus.metrics.distsender_rpc_sent_nextreplicaerror`*:: ++ +-- +Number of RPCs sent due to per-replica errors + + +type: double + +-- + +*`prometheus.metrics.exec_error`*:: ++ +-- +Number of batch KV requests that failed to execute on this node + + +type: double + +-- + +*`prometheus.metrics.exec_latency_bucket`*:: ++ +-- +Latency of batch KV requests executed on this node + + +type: double + +-- + +*`prometheus.metrics.exec_latency_sum`*:: ++ +-- +Sum of Latency of batch KV requests executed on this node + + +type: double + +-- + +*`prometheus.metrics.exec_latency_count`*:: ++ +-- +Count of Latency of batch KV requests executed on this node + + +type: double + +-- + +*`prometheus.metrics.exec_success`*:: ++ +-- +Number of batch KV requests executed successfully on this node + + +type: double + +-- + +*`prometheus.metrics.follower_reads_success_count`*:: ++ +-- +Number of reads successfully processed by any replica + + +type: double + +-- + +*`prometheus.metrics.gcbytesage`*:: ++ +-- +Cumulative age of non-live data + + +type: double + +-- + +*`prometheus.metrics.gossip_bytes_received`*:: ++ +-- +Number of received gossip bytes + + +type: double + +-- + +*`prometheus.metrics.gossip_bytes_sent`*:: ++ +-- +Number of sent gossip bytes + + +type: double + +-- + +*`prometheus.metrics.gossip_connections_incoming`*:: ++ +-- +Number of active incoming gossip connections + + +type: double + +-- + +*`prometheus.metrics.gossip_connections_outgoing`*:: ++ +-- +Number of active outgoing gossip connections + + +type: double + +-- + +*`prometheus.metrics.gossip_connections_refused`*:: ++ +-- +Number of refused incoming gossip connections + + +type: double + +-- + +*`prometheus.metrics.gossip_infos_received`*:: ++ +-- +Number of received gossip Info objects + + +type: double + +-- + +*`prometheus.metrics.gossip_infos_sent`*:: ++ +-- +Number of sent gossip Info objects + + +type: double + +-- + +*`prometheus.metrics.intentage`*:: ++ +-- +Cumulative age of intents + + +type: double + +-- + +*`prometheus.metrics.intentbytes`*:: ++ +-- +Number of bytes in intent KV pairs + + +type: double + +-- + +*`prometheus.metrics.intentcount`*:: ++ +-- +Count of intent keys + + +type: double + +-- + +*`prometheus.metrics.intentresolver_async_throttled`*:: ++ +-- +Number of intent resolution attempts not run asynchronously due to throttling + + +type: double + +-- + +*`prometheus.metrics.intents_abort_attempts`*:: ++ +-- +Count of (point or range) non-poisoning intent abort evaluation attempts + + +type: double + +-- + +*`prometheus.metrics.intents_poison_attempts`*:: ++ +-- +Count of (point or range) poisoning intent abort evaluation attempts + + +type: double + +-- + +*`prometheus.metrics.intents_resolve_attempts`*:: ++ +-- +Count of (point or range) intent commit evaluation attempts + + +type: double + +-- + +*`prometheus.metrics.keybytes`*:: ++ +-- +Number of bytes taken up by keys + + +type: double + +-- + +*`prometheus.metrics.keycount`*:: ++ +-- +Count of all keys + + +type: double + +-- + +*`prometheus.metrics.kv_closed_timestamp_max_behind_nanos`*:: ++ +-- +Largest latency between realtime and replica max closed timestamp + + +type: double + +-- + +*`prometheus.metrics.kv_rangefeed_catchup_scan_nanos`*:: ++ +-- +Time spent in RangeFeed catchup scan + + +type: double + +-- + +*`prometheus.metrics.lastupdatenanos`*:: ++ +-- +Timestamp at which bytes/keys/intents metrics were last updated + + +type: double + +-- + +*`prometheus.metrics.leases_epoch`*:: ++ +-- +Number of replica leaseholders using epoch-based leases + + +type: double + +-- + +*`prometheus.metrics.leases_error`*:: ++ +-- +Number of failed lease requests + + +type: double + +-- + +*`prometheus.metrics.leases_expiration`*:: ++ +-- +Number of replica leaseholders using expiration-based leases + + +type: double + +-- + +*`prometheus.metrics.leases_success`*:: ++ +-- +Number of successful lease requests + + +type: double + +-- + +*`prometheus.metrics.leases_transfers_error`*:: ++ +-- +Number of failed lease transfers + + +type: double + +-- + +*`prometheus.metrics.leases_transfers_success`*:: ++ +-- +Number of successful lease transfers + + +type: double + +-- + +*`prometheus.metrics.livebytes`*:: ++ +-- +Number of bytes of live data (keys plus values) + + +type: double + +-- + +*`prometheus.metrics.livecount`*:: ++ +-- +Count of live keys + + +type: double + +-- + +*`prometheus.metrics.liveness_epochincrements`*:: ++ +-- +Number of times this node has incremented its liveness epoch + + +type: double + +-- + +*`prometheus.metrics.liveness_heartbeatfailures`*:: ++ +-- +Number of failed node liveness heartbeats from this node + + +type: double + +-- + +*`prometheus.metrics.liveness_heartbeatlatency_bucket`*:: ++ +-- +Node liveness heartbeat latency + + +type: double + +-- + +*`prometheus.metrics.liveness_heartbeatlatency_sum`*:: ++ +-- +Sum of Node liveness heartbeat latency + + +type: double + +-- + +*`prometheus.metrics.liveness_heartbeatlatency_count`*:: ++ +-- +Count of Node liveness heartbeat latency + + +type: double + +-- + +*`prometheus.metrics.liveness_heartbeatsuccesses`*:: ++ +-- +Number of successful node liveness heartbeats from this node + + +type: double + +-- + +*`prometheus.metrics.liveness_livenodes`*:: ++ +-- +Number of live nodes in the cluster (will be 0 if this node is not itself live) + + +type: double + +-- + +*`prometheus.metrics.node_id`*:: ++ +-- +node ID with labels for advertised RPC and HTTP addresses + + +type: double + +-- + +*`prometheus.metrics.queue_consistency_pending`*:: ++ +-- +Number of pending replicas in the consistency checker queue + + +type: double + +-- + +*`prometheus.metrics.queue_consistency_process_failure`*:: ++ +-- +Number of replicas which failed processing in the consistency checker queue + + +type: double + +-- + +*`prometheus.metrics.queue_consistency_process_success`*:: ++ +-- +Number of replicas successfully processed by the consistency checker queue + + +type: double + +-- + +*`prometheus.metrics.queue_consistency_processingnanos`*:: ++ +-- +Nanoseconds spent processing replicas in the consistency checker queue + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_abortspanconsidered`*:: ++ +-- +Number of AbortSpan entries old enough to be considered for removal + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_abortspangcnum`*:: ++ +-- +Number of AbortSpan entries fit for removal + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_abortspanscanned`*:: ++ +-- +Number of transactions present in the AbortSpan scanned from the engine + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_intentsconsidered`*:: ++ +-- +Number of 'old' intents + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_intenttxns`*:: ++ +-- +Number of associated distinct transactions + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_numkeysaffected`*:: ++ +-- +Number of keys with GC'able data + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_pushtxn`*:: ++ +-- +Number of attempted pushes + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_resolvesuccess`*:: ++ +-- +Number of successful intent resolutions + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_resolvetotal`*:: ++ +-- +Number of attempted intent resolutions + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_transactionspangcaborted`*:: ++ +-- +Number of GC'able entries corresponding to aborted txns + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_transactionspangccommitted`*:: ++ +-- +Number of GC'able entries corresponding to committed txns + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_transactionspangcpending`*:: ++ +-- +Number of GC'able entries corresponding to pending txns + + +type: double + +-- + +*`prometheus.metrics.queue_gc_info_transactionspanscanned`*:: ++ +-- +Number of entries in transaction spans scanned from the engine + + +type: double + +-- + +*`prometheus.metrics.queue_gc_pending`*:: ++ +-- +Number of pending replicas in the GC queue + + +type: double + +-- + +*`prometheus.metrics.queue_gc_process_failure`*:: ++ +-- +Number of replicas which failed processing in the GC queue + + +type: double + +-- + +*`prometheus.metrics.queue_gc_process_success`*:: ++ +-- +Number of replicas successfully processed by the GC queue + + +type: double + +-- + +*`prometheus.metrics.queue_gc_processingnanos`*:: ++ +-- +Nanoseconds spent processing replicas in the GC queue + + +type: double + +-- + +*`prometheus.metrics.queue_merge_pending`*:: ++ +-- +Number of pending replicas in the merge queue + + +type: double + +-- + +*`prometheus.metrics.queue_merge_process_failure`*:: ++ +-- +Number of replicas which failed processing in the merge queue + + +type: double + +-- + +*`prometheus.metrics.queue_merge_process_success`*:: ++ +-- +Number of replicas successfully processed by the merge queue + + +type: double + +-- + +*`prometheus.metrics.queue_merge_processingnanos`*:: ++ +-- +Nanoseconds spent processing replicas in the merge queue + + +type: double + +-- + +*`prometheus.metrics.queue_merge_purgatory`*:: ++ +-- +Number of replicas in the merge queue's purgatory, waiting to become mergeable + + +type: double + +-- + +*`prometheus.metrics.queue_raftlog_pending`*:: ++ +-- +Number of pending replicas in the Raft log queue + + +type: double + +-- + +*`prometheus.metrics.queue_raftlog_process_failure`*:: ++ +-- +Number of replicas which failed processing in the Raft log queue + + +type: double + +-- + +*`prometheus.metrics.queue_raftlog_process_success`*:: ++ +-- +Number of replicas successfully processed by the Raft log queue + + +type: double + +-- + +*`prometheus.metrics.queue_raftlog_processingnanos`*:: ++ +-- +Nanoseconds spent processing replicas in the Raft log queue + + +type: double + +-- + +*`prometheus.metrics.queue_raftsnapshot_pending`*:: ++ +-- +Number of pending replicas in the Raft repair queue + + +type: double + +-- + +*`prometheus.metrics.queue_raftsnapshot_process_failure`*:: ++ +-- +Number of replicas which failed processing in the Raft repair queue + + +type: double + +-- + +*`prometheus.metrics.queue_raftsnapshot_process_success`*:: ++ +-- +Number of replicas successfully processed by the Raft repair queue + + +type: double + +-- + +*`prometheus.metrics.queue_raftsnapshot_processingnanos`*:: ++ +-- +Nanoseconds spent processing replicas in the Raft repair queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicagc_pending`*:: ++ +-- +Number of pending replicas in the replica GC queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicagc_process_failure`*:: ++ +-- +Number of replicas which failed processing in the replica GC queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicagc_process_success`*:: ++ +-- +Number of replicas successfully processed by the replica GC queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicagc_processingnanos`*:: ++ +-- +Nanoseconds spent processing replicas in the replica GC queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicagc_removereplica`*:: ++ +-- +Number of replica removals attempted by the replica gc queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicate_addreplica`*:: ++ +-- +Number of replica additions attempted by the replicate queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicate_pending`*:: ++ +-- +Number of pending replicas in the replicate queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicate_process_failure`*:: ++ +-- +Number of replicas which failed processing in the replicate queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicate_process_success`*:: ++ +-- +Number of replicas successfully processed by the replicate queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicate_processingnanos`*:: ++ +-- +Nanoseconds spent processing replicas in the replicate queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicate_purgatory`*:: ++ +-- +Number of replicas in the replicate queue's purgatory, awaiting allocation options + + +type: double + +-- + +*`prometheus.metrics.queue_replicate_rebalancereplica`*:: ++ +-- +Number of replica rebalancer-initiated additions attempted by the replicate queue + + +type: double + +-- + +*`prometheus.metrics.queue_replicate_removedeadreplica`*:: ++ +-- +Number of dead replica removals attempted by the replicate queue (typically in response to a node outage) + + +type: double + +-- + +*`prometheus.metrics.queue_replicate_removereplica`*:: ++ +-- +Number of replica removals attempted by the replicate queue (typically in response to a rebalancer-initiated addition) + + +type: double + +-- + +*`prometheus.metrics.queue_replicate_transferlease`*:: ++ +-- +Number of range lease transfers attempted by the replicate queue + + +type: double + +-- + +*`prometheus.metrics.queue_split_pending`*:: ++ +-- +Number of pending replicas in the split queue + + +type: double + +-- + +*`prometheus.metrics.queue_split_process_failure`*:: ++ +-- +Number of replicas which failed processing in the split queue + + +type: double + +-- + +*`prometheus.metrics.queue_split_process_success`*:: ++ +-- +Number of replicas successfully processed by the split queue + + +type: double + +-- + +*`prometheus.metrics.queue_split_processingnanos`*:: ++ +-- +Nanoseconds spent processing replicas in the split queue + + +type: double + +-- + +*`prometheus.metrics.queue_split_purgatory`*:: ++ +-- +Number of replicas in the split queue's purgatory, waiting to become splittable + + +type: double + +-- + +*`prometheus.metrics.queue_tsmaintenance_pending`*:: ++ +-- +Number of pending replicas in the time series maintenance queue + + +type: double + +-- + +*`prometheus.metrics.queue_tsmaintenance_process_failure`*:: ++ +-- +Number of replicas which failed processing in the time series maintenance queue + + +type: double + +-- + +*`prometheus.metrics.queue_tsmaintenance_process_success`*:: ++ +-- +Number of replicas successfully processed by the time series maintenance queue + + +type: double + +-- + +*`prometheus.metrics.queue_tsmaintenance_processingnanos`*:: ++ +-- +Nanoseconds spent processing replicas in the time series maintenance queue + + +type: double + +-- + +*`prometheus.metrics.raft_commandsapplied`*:: ++ +-- +Count of Raft commands applied + + +type: double + +-- + +*`prometheus.metrics.raft_enqueued_pending`*:: ++ +-- +Number of pending outgoing messages in the Raft Transport queue + + +type: double + +-- + +*`prometheus.metrics.raft_entrycache_accesses`*:: ++ +-- +Number of cache lookups in the Raft entry cache + + +type: double + +-- + +*`prometheus.metrics.raft_entrycache_bytes`*:: ++ +-- +Aggregate size of all Raft entries in the Raft entry cache + + +type: double + +-- + +*`prometheus.metrics.raft_entrycache_hits`*:: ++ +-- +Number of successful cache lookups in the Raft entry cache + + +type: double + +-- + +*`prometheus.metrics.raft_entrycache_size`*:: ++ +-- +Number of Raft entries in the Raft entry cache + + +type: double + +-- + +*`prometheus.metrics.raft_heartbeats_pending`*:: ++ +-- +Number of pending heartbeats and responses waiting to be coalesced + + +type: double + +-- + +*`prometheus.metrics.raft_process_applycommitted_latency_bucket`*:: ++ +-- +Latency histogram for applying all committed Raft commands in a Raft ready + + +type: double + +-- + +*`prometheus.metrics.raft_process_applycommitted_latency_sum`*:: ++ +-- +Sum of Latency histogram for applying all committed Raft commands in a Raft ready + + +type: double + +-- + +*`prometheus.metrics.raft_process_applycommitted_latency_count`*:: ++ +-- +Count of Latency histogram for applying all committed Raft commands in a Raft ready + + +type: double + +-- + +*`prometheus.metrics.raft_process_commandcommit_latency_bucket`*:: ++ +-- +Latency histogram for committing Raft commands + + +type: double + +-- + +*`prometheus.metrics.raft_process_commandcommit_latency_sum`*:: ++ +-- +Sum of Latency histogram for committing Raft commands + + +type: double + +-- + +*`prometheus.metrics.raft_process_commandcommit_latency_count`*:: ++ +-- +Count of Latency histogram for committing Raft commands + + +type: double + +-- + +*`prometheus.metrics.raft_process_handleready_latency_bucket`*:: ++ +-- +Latency histogram for handling a Raft ready + + +type: double + +-- + +*`prometheus.metrics.raft_process_handleready_latency_sum`*:: ++ +-- +Sum of Latency histogram for handling a Raft ready + + +type: double + +-- + +*`prometheus.metrics.raft_process_handleready_latency_count`*:: ++ +-- +Count of Latency histogram for handling a Raft ready + + +type: double + +-- + +*`prometheus.metrics.raft_process_logcommit_latency_bucket`*:: ++ +-- +Latency histogram for committing Raft log entries + + +type: double + +-- + +*`prometheus.metrics.raft_process_logcommit_latency_sum`*:: ++ +-- +Sum of Latency histogram for committing Raft log entries + + +type: double + +-- + +*`prometheus.metrics.raft_process_logcommit_latency_count`*:: ++ +-- +Count of Latency histogram for committing Raft log entries + + +type: double + +-- + +*`prometheus.metrics.raft_process_tickingnanos`*:: ++ +-- +Nanoseconds spent in store.processRaft() processing replica.Tick() + + +type: double + +-- + +*`prometheus.metrics.raft_process_workingnanos`*:: ++ +-- +Nanoseconds spent in store.processRaft() working + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_app`*:: ++ +-- +Number of MsgApp messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_appresp`*:: ++ +-- +Number of MsgAppResp messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_dropped`*:: ++ +-- +Number of dropped incoming Raft messages + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_heartbeat`*:: ++ +-- +Number of (coalesced, if enabled) MsgHeartbeat messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_heartbeatresp`*:: ++ +-- +Number of (coalesced, if enabled) MsgHeartbeatResp messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_prevote`*:: ++ +-- +Number of MsgPreVote messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_prevoteresp`*:: ++ +-- +Number of MsgPreVoteResp messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_prop`*:: ++ +-- +Number of MsgProp messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_snap`*:: ++ +-- +Number of MsgSnap messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_timeoutnow`*:: ++ +-- +Number of MsgTimeoutNow messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_transferleader`*:: ++ +-- +Number of MsgTransferLeader messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_vote`*:: ++ +-- +Number of MsgVote messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_rcvd_voteresp`*:: ++ +-- +Number of MsgVoteResp messages received by this store + + +type: double + +-- + +*`prometheus.metrics.raft_ticks`*:: ++ +-- +Number of Raft ticks queued + + +type: double + +-- + +*`prometheus.metrics.raftlog_behind`*:: ++ +-- +Number of Raft log entries followers on other stores are behind + + +type: double + +-- + +*`prometheus.metrics.raftlog_truncated`*:: ++ +-- +Number of Raft log entries truncated + + +type: double + +-- + +*`prometheus.metrics.range_adds`*:: ++ +-- +Number of range additions + + +type: double + +-- + +*`prometheus.metrics.range_merges`*:: ++ +-- +Number of range merges + + +type: double + +-- + +*`prometheus.metrics.range_raftleadertransfers`*:: ++ +-- +Number of raft leader transfers + + +type: double + +-- + +*`prometheus.metrics.range_removes`*:: ++ +-- +Number of range removals + + +type: double + +-- + +*`prometheus.metrics.range_snapshots_generated`*:: ++ +-- +Number of generated snapshots + + +type: double + +-- + +*`prometheus.metrics.range_snapshots_normal_applied`*:: ++ +-- +Number of applied snapshots + + +type: double + +-- + +*`prometheus.metrics.range_snapshots_preemptive_applied`*:: ++ +-- +Number of applied pre-emptive snapshots + + +type: double + +-- + +*`prometheus.metrics.range_splits`*:: ++ +-- +Number of range splits + + +type: double + +-- + +*`prometheus.metrics.ranges`*:: ++ +-- +Number of ranges + + +type: double + +-- + +*`prometheus.metrics.ranges_overreplicated`*:: ++ +-- +Number of ranges with more live replicas than the replication target + + +type: double + +-- + +*`prometheus.metrics.ranges_unavailable`*:: ++ +-- +Number of ranges with fewer live replicas than needed for quorum + + +type: double + +-- + +*`prometheus.metrics.ranges_underreplicated`*:: ++ +-- +Number of ranges with fewer live replicas than the replication target + + +type: double + +-- + +*`prometheus.metrics.rebalancing_lease_transfers`*:: ++ +-- +Number of lease transfers motivated by store-level load imbalances + + +type: double + +-- + +*`prometheus.metrics.rebalancing_queriespersecond`*:: ++ +-- +Number of kv-level requests received per second by the store, averaged over a large time period as used in rebalancing decisions + + +type: double + +-- + +*`prometheus.metrics.rebalancing_range_rebalances`*:: ++ +-- +Number of range rebalance operations motivated by store-level load imbalances + + +type: double + +-- + +*`prometheus.metrics.rebalancing_writespersecond`*:: ++ +-- +Number of keys written (i.e. applied by raft) per second to the store, averaged over a large time period as used in rebalancing decisions + + +type: double + +-- + +*`prometheus.metrics.replicas`*:: ++ +-- +Number of replicas + + +type: double + +-- + +*`prometheus.metrics.replicas_leaders`*:: ++ +-- +Number of raft leaders + + +type: double + +-- + +*`prometheus.metrics.replicas_leaders_not_leaseholders`*:: ++ +-- +Number of replicas that are Raft leaders whose range lease is held by another store + + +type: double + +-- + +*`prometheus.metrics.replicas_leaseholders`*:: ++ +-- +Number of lease holders + + +type: double + +-- + +*`prometheus.metrics.replicas_quiescent`*:: ++ +-- +Number of quiesced replicas + + +type: double + +-- + +*`prometheus.metrics.replicas_reserved`*:: ++ +-- +Number of replicas reserved for snapshots + + +type: double + +-- + +*`prometheus.metrics.requests_backpressure_split`*:: ++ +-- +Number of backpressured writes waiting on a Range split + + +type: double + +-- + +*`prometheus.metrics.requests_slow_latch`*:: ++ +-- +Number of requests that have been stuck for a long time acquiring latches + + +type: double + +-- + +*`prometheus.metrics.requests_slow_lease`*:: ++ +-- +Number of requests that have been stuck for a long time acquiring a lease + + +type: double + +-- + +*`prometheus.metrics.requests_slow_raft`*:: ++ +-- +Number of requests that have been stuck for a long time in raft + + +type: double + +-- + +*`prometheus.metrics.rocksdb_block_cache_hits`*:: ++ +-- +Count of block cache hits + + +type: double + +-- + +*`prometheus.metrics.rocksdb_block_cache_misses`*:: ++ +-- +Count of block cache misses + + +type: double + +-- + +*`prometheus.metrics.rocksdb_block_cache_pinned_usage`*:: ++ +-- +Bytes pinned by the block cache + + +type: double + +-- + +*`prometheus.metrics.rocksdb_block_cache_usage`*:: ++ +-- +Bytes used by the block cache + + +type: double + +-- + +*`prometheus.metrics.rocksdb_bloom_filter_prefix_checked`*:: ++ +-- +Number of times the bloom filter was checked + + +type: double + +-- + +*`prometheus.metrics.rocksdb_bloom_filter_prefix_useful`*:: ++ +-- +Number of times the bloom filter helped avoid iterator creation + + +type: double + +-- + +*`prometheus.metrics.rocksdb_compactions`*:: ++ +-- +Number of table compactions + + +type: double + +-- + +*`prometheus.metrics.rocksdb_encryption_algorithm`*:: ++ +-- +algorithm in use for encryption-at-rest, see ccl/storageccl/engineccl/enginepbccl/key_registry.proto + + +type: double + +-- + +*`prometheus.metrics.rocksdb_flushes`*:: ++ +-- +Number of table flushes + + +type: double + +-- + +*`prometheus.metrics.rocksdb_memtable_total_size`*:: ++ +-- +Current size of memtable in bytes + + +type: double + +-- + +*`prometheus.metrics.rocksdb_num_sstables`*:: ++ +-- +Number of rocksdb SSTables + + +type: double + +-- + +*`prometheus.metrics.rocksdb_read_amplification`*:: ++ +-- +Number of disk reads per query + + +type: double + +-- + +*`prometheus.metrics.rocksdb_table_readers_mem_estimate`*:: ++ +-- +Memory used by index and filter blocks + + +type: double + +-- + +*`prometheus.metrics.round_trip_latency_bucket`*:: ++ +-- +Distribution of round-trip latencies with other nodes + + +type: double + +-- + +*`prometheus.metrics.round_trip_latency_sum`*:: ++ +-- +Sum of Distribution of round-trip latencies with other nodes + + +type: double + +-- + +*`prometheus.metrics.round_trip_latency_count`*:: ++ +-- +Count of Distribution of round-trip latencies with other nodes + + +type: double + +-- + +*`prometheus.metrics.sql_bytesin`*:: ++ +-- +Number of sql bytes received + + +type: double + +-- + +*`prometheus.metrics.sql_bytesout`*:: ++ +-- +Number of sql bytes sent + + +type: double + +-- + +*`prometheus.metrics.sql_conns`*:: ++ +-- +Number of active sql connections + + +type: double + +-- + +*`prometheus.metrics.sql_ddl_count`*:: ++ +-- +Number of SQL DDL statements + + +type: double + +-- + +*`prometheus.metrics.sql_ddl_count_internal`*:: ++ +-- +Number of SQL DDL statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_delete_count`*:: ++ +-- +Number of SQL DELETE statements + + +type: double + +-- + +*`prometheus.metrics.sql_delete_count_internal`*:: ++ +-- +Number of SQL DELETE statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_exec_latency_bucket`*:: ++ +-- +Latency of DistSQL statement execution + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_exec_latency_sum`*:: ++ +-- +Sum of Latency of DistSQL statement execution + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_exec_latency_count`*:: ++ +-- +Count of Latency of DistSQL statement execution + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_exec_latency_internal_bucket`*:: ++ +-- +Latency of DistSQL statement execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_exec_latency_internal_sum`*:: ++ +-- +Sum of Latency of DistSQL statement execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_exec_latency_internal_count`*:: ++ +-- +Count of Latency of DistSQL statement execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_flows_active`*:: ++ +-- +Number of distributed SQL flows currently active + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_flows_queue_wait_bucket`*:: ++ +-- +Duration of time flows spend waiting in the queue + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_flows_queue_wait_sum`*:: ++ +-- +Sum of Duration of time flows spend waiting in the queue + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_flows_queue_wait_count`*:: ++ +-- +Count of Duration of time flows spend waiting in the queue + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_flows_queued`*:: ++ +-- +Number of distributed SQL flows currently queued + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_flows_total`*:: ++ +-- +Number of distributed SQL flows executed + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_queries_active`*:: ++ +-- +Number of distributed SQL queries currently active + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_queries_total`*:: ++ +-- +Number of distributed SQL queries executed + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_select_count`*:: ++ +-- +Number of DistSQL SELECT statements + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_select_count_internal`*:: ++ +-- +Number of DistSQL SELECT statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_service_latency_bucket`*:: ++ +-- +Latency of DistSQL request execution + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_service_latency_sum`*:: ++ +-- +Sum of Latency of DistSQL request execution + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_service_latency_count`*:: ++ +-- +Count of Latency of DistSQL request execution + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_service_latency_internal_bucket`*:: ++ +-- +Latency of DistSQL request execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_service_latency_internal_sum`*:: ++ +-- +Sum of Latency of DistSQL request execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_distsql_service_latency_internal_count`*:: ++ +-- +Count of Latency of DistSQL request execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_exec_latency_bucket`*:: ++ +-- +Latency of SQL statement execution + + +type: double + +-- + +*`prometheus.metrics.sql_exec_latency_sum`*:: ++ +-- +Sum of Latency of SQL statement execution + + +type: double + +-- + +*`prometheus.metrics.sql_exec_latency_count`*:: ++ +-- +Count of Latency of SQL statement execution + + +type: double + +-- + +*`prometheus.metrics.sql_exec_latency_internal_bucket`*:: ++ +-- +Latency of SQL statement execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_exec_latency_internal_sum`*:: ++ +-- +Sum of Latency of SQL statement execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_exec_latency_internal_count`*:: ++ +-- +Count of Latency of SQL statement execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_failure_count`*:: ++ +-- +Number of statements resulting in a planning or runtime error + + +type: double + +-- + +*`prometheus.metrics.sql_failure_count_internal`*:: ++ +-- +Number of statements resulting in a planning or runtime error (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_insert_count`*:: ++ +-- +Number of SQL INSERT statements + + +type: double + +-- + +*`prometheus.metrics.sql_insert_count_internal`*:: ++ +-- +Number of SQL INSERT statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_current`*:: ++ +-- +Current sql statement memory usage for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_max_bucket`*:: ++ +-- +Memory usage per sql statement for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_max_sum`*:: ++ +-- +Sum of Memory usage per sql statement for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_max_count`*:: ++ +-- +Count of Memory usage per sql statement for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_session_current`*:: ++ +-- +Current sql session memory usage for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_session_max_bucket`*:: ++ +-- +Memory usage per sql session for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_session_max_sum`*:: ++ +-- +Sum of Memory usage per sql session for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_session_max_count`*:: ++ +-- +Count of Memory usage per sql session for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_txn_current`*:: ++ +-- +Current sql transaction memory usage for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_txn_max_bucket`*:: ++ +-- +Memory usage per sql transaction for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_txn_max_sum`*:: ++ +-- +Sum of Memory usage per sql transaction for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_admin_txn_max_count`*:: ++ +-- +Count of Memory usage per sql transaction for admin + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_current`*:: ++ +-- +Current sql statement memory usage for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_max_bucket`*:: ++ +-- +Memory usage per sql statement for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_max_sum`*:: ++ +-- +Sum of Memory usage per sql statement for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_max_count`*:: ++ +-- +Count of Memory usage per sql statement for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_session_current`*:: ++ +-- +Current sql session memory usage for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_session_max_bucket`*:: ++ +-- +Memory usage per sql session for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_session_max_sum`*:: ++ +-- +Sum of Memory usage per sql session for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_session_max_count`*:: ++ +-- +Count of Memory usage per sql session for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_txn_current`*:: ++ +-- +Current sql transaction memory usage for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_txn_max_bucket`*:: ++ +-- +Memory usage per sql transaction for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_txn_max_sum`*:: ++ +-- +Sum of Memory usage per sql transaction for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_conns_txn_max_count`*:: ++ +-- +Count of Memory usage per sql transaction for conns + + +type: double + +-- + +*`prometheus.metrics.sql_mem_distsql_current`*:: ++ +-- +Current sql statement memory usage for distsql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_distsql_max_bucket`*:: ++ +-- +Memory usage per sql statement for distsql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_distsql_max_sum`*:: ++ +-- +Sum of Memory usage per sql statement for distsql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_distsql_max_count`*:: ++ +-- +Count of Memory usage per sql statement for distsql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_current`*:: ++ +-- +Current sql statement memory usage for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_max_bucket`*:: ++ +-- +Memory usage per sql statement for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_max_sum`*:: ++ +-- +Sum of Memory usage per sql statement for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_max_count`*:: ++ +-- +Count of Memory usage per sql statement for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_session_current`*:: ++ +-- +Current sql session memory usage for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_session_max_bucket`*:: ++ +-- +Memory usage per sql session for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_session_max_sum`*:: ++ +-- +Sum of Memory usage per sql session for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_session_max_count`*:: ++ +-- +Count of Memory usage per sql session for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_txn_current`*:: ++ +-- +Current sql transaction memory usage for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_txn_max_bucket`*:: ++ +-- +Memory usage per sql transaction for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_txn_max_sum`*:: ++ +-- +Sum of Memory usage per sql transaction for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_internal_txn_max_count`*:: ++ +-- +Count of Memory usage per sql transaction for internal + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_current`*:: ++ +-- +Current sql statement memory usage for sql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_max_bucket`*:: ++ +-- +Memory usage per sql statement for sql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_max_sum`*:: ++ +-- +Sum of Memory usage per sql statement for sql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_max_count`*:: ++ +-- +Count of Memory usage per sql statement for sql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_session_current`*:: ++ +-- +Current sql session memory usage for sql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_session_max_bucket`*:: ++ +-- +Memory usage per sql session for sql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_session_max_sum`*:: ++ +-- +Sum of Memory usage per sql session for sql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_session_max_count`*:: ++ +-- +Count of Memory usage per sql session for sql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_txn_current`*:: ++ +-- +Current sql transaction memory usage for sql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_txn_max_bucket`*:: ++ +-- +Memory usage per sql transaction for sql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_txn_max_sum`*:: ++ +-- +Sum of Memory usage per sql transaction for sql + + +type: double + +-- + +*`prometheus.metrics.sql_mem_sql_txn_max_count`*:: ++ +-- +Count of Memory usage per sql transaction for sql + + +type: double + +-- + +*`prometheus.metrics.sql_misc_count`*:: ++ +-- +Number of other SQL statements + + +type: double + +-- + +*`prometheus.metrics.sql_misc_count_internal`*:: ++ +-- +Number of other SQL statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_optimizer_count`*:: ++ +-- +Number of statements which ran with the cost-based optimizer + + +type: double + +-- + +*`prometheus.metrics.sql_optimizer_count_internal`*:: ++ +-- +Number of statements which ran with the cost-based optimizer (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_optimizer_fallback_count`*:: ++ +-- +Number of statements which the cost-based optimizer was unable to plan + + +type: double + +-- + +*`prometheus.metrics.sql_optimizer_fallback_count_internal`*:: ++ +-- +Number of statements which the cost-based optimizer was unable to plan (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_optimizer_plan_cache_hits`*:: ++ +-- +Number of non-prepared statements for which a cached plan was used + + +type: double + +-- + +*`prometheus.metrics.sql_optimizer_plan_cache_hits_internal`*:: ++ +-- +Number of non-prepared statements for which a cached plan was used (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_optimizer_plan_cache_misses`*:: ++ +-- +Number of non-prepared statements for which a cached plan was not used + + +type: double + +-- + +*`prometheus.metrics.sql_optimizer_plan_cache_misses_internal`*:: ++ +-- +Number of non-prepared statements for which a cached plan was not used (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_query_count`*:: ++ +-- +Number of SQL queries + + +type: double + +-- + +*`prometheus.metrics.sql_query_count_internal`*:: ++ +-- +Number of SQL queries (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_restart_savepoint_count`*:: ++ +-- +Number of `SAVEPOINT cockroach_restart` statements + + +type: double + +-- + +*`prometheus.metrics.sql_restart_savepoint_count_internal`*:: ++ +-- +Number of `SAVEPOINT cockroach_restart` statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_restart_savepoint_release_count`*:: ++ +-- +Number of `RELEASE SAVEPOINT cockroach_restart` statements + + +type: double + +-- + +*`prometheus.metrics.sql_restart_savepoint_release_count_internal`*:: ++ +-- +Number of `RELEASE SAVEPOINT cockroach_restart` statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_restart_savepoint_rollback_count`*:: ++ +-- +Number of `ROLLBACK TO SAVEPOINT cockroach_restart` statements + + +type: double + +-- + +*`prometheus.metrics.sql_restart_savepoint_rollback_count_internal`*:: ++ +-- +Number of `ROLLBACK TO SAVEPOINT cockroach_restart` statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_savepoint_count`*:: ++ +-- +Number of SQL SAVEPOINT statements + + +type: double + +-- + +*`prometheus.metrics.sql_savepoint_count_internal`*:: ++ +-- +Number of SQL SAVEPOINT statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_select_count`*:: ++ +-- +Number of SQL SELECT statements + + +type: double + +-- + +*`prometheus.metrics.sql_select_count_internal`*:: ++ +-- +Number of SQL SELECT statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_service_latency_bucket`*:: ++ +-- +Latency of SQL request execution + + +type: double + +-- + +*`prometheus.metrics.sql_service_latency_sum`*:: ++ +-- +Sum of Latency of SQL request execution + + +type: double + +-- + +*`prometheus.metrics.sql_service_latency_count`*:: ++ +-- +Count of Latency of SQL request execution + + +type: double + +-- + +*`prometheus.metrics.sql_service_latency_internal_bucket`*:: ++ +-- +Latency of SQL request execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_service_latency_internal_sum`*:: ++ +-- +Sum of Latency of SQL request execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_service_latency_internal_count`*:: ++ +-- +Count of Latency of SQL request execution (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_txn_abort_count`*:: ++ +-- +Number of SQL transaction abort errors + + +type: double + +-- + +*`prometheus.metrics.sql_txn_abort_count_internal`*:: ++ +-- +Number of SQL transaction abort errors (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_txn_begin_count`*:: ++ +-- +Number of SQL transaction BEGIN statements + + +type: double + +-- + +*`prometheus.metrics.sql_txn_begin_count_internal`*:: ++ +-- +Number of SQL transaction BEGIN statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_txn_commit_count`*:: ++ +-- +Number of SQL transaction COMMIT statements + + +type: double + +-- + +*`prometheus.metrics.sql_txn_commit_count_internal`*:: ++ +-- +Number of SQL transaction COMMIT statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_txn_rollback_count`*:: ++ +-- +Number of SQL transaction ROLLBACK statements + + +type: double + +-- + +*`prometheus.metrics.sql_txn_rollback_count_internal`*:: ++ +-- +Number of SQL transaction ROLLBACK statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sql_update_count`*:: ++ +-- +Number of SQL UPDATE statements + + +type: double + +-- + +*`prometheus.metrics.sql_update_count_internal`*:: ++ +-- +Number of SQL UPDATE statements (internal queries) + + +type: double + +-- + +*`prometheus.metrics.sys_cgo_allocbytes`*:: ++ +-- +Current bytes of memory allocated by cgo + + +type: double + +-- + +*`prometheus.metrics.sys_cgo_totalbytes`*:: ++ +-- +Total bytes of memory allocated by cgo, but not released + + +type: double + +-- + +*`prometheus.metrics.sys_cgocalls`*:: ++ +-- +Total number of cgo calls + + +type: double + +-- + +*`prometheus.metrics.sys_cpu_combined_percent_normalized`*:: ++ +-- +Current user+system cpu percentage, normalized 0-1 by number of cores + + +type: double + +-- + +*`prometheus.metrics.sys_cpu_sys_ns`*:: ++ +-- +Total system cpu time + + +type: double + +-- + +*`prometheus.metrics.sys_cpu_sys_percent`*:: ++ +-- +Current system cpu percentage + + +type: double + +-- + +*`prometheus.metrics.sys_cpu_user_ns`*:: ++ +-- +Total user cpu time + + +type: double + +-- + +*`prometheus.metrics.sys_cpu_user_percent`*:: ++ +-- +Current user cpu percentage + + +type: double + +-- + +*`prometheus.metrics.sys_fd_open`*:: ++ +-- +Process open file descriptors + + +type: double + +-- + +*`prometheus.metrics.sys_fd_softlimit`*:: ++ +-- +Process open FD soft limit + + +type: double + +-- + +*`prometheus.metrics.sys_gc_count`*:: ++ +-- +Total number of GC runs + + +type: double + +-- + +*`prometheus.metrics.sys_gc_pause_ns`*:: ++ +-- +Total GC pause + + +type: double + +-- + +*`prometheus.metrics.sys_gc_pause_percent`*:: ++ +-- +Current GC pause percentage + + +type: double + +-- + +*`prometheus.metrics.sys_go_allocbytes`*:: ++ +-- +Current bytes of memory allocated by go + + +type: double + +-- + +*`prometheus.metrics.sys_go_totalbytes`*:: ++ +-- +Total bytes of memory allocated by go, but not released + + +type: double + +-- + +*`prometheus.metrics.sys_goroutines`*:: ++ +-- +Current number of goroutines + + +type: double + +-- + +*`prometheus.metrics.sys_host_disk_io_time`*:: ++ +-- +Time spent reading from or writing to all disks since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_host_disk_iopsinprogress`*:: ++ +-- +IO operations currently in progress on this host + + +type: double + +-- + +*`prometheus.metrics.sys_host_disk_read_bytes`*:: ++ +-- +Bytes read from all disks since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_host_disk_read_count`*:: ++ +-- +Disk read operations across all disks since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_host_disk_read_time`*:: ++ +-- +Time spent reading from all disks since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_host_disk_weightedio_time`*:: ++ +-- +Weighted time spent reading from or writing to to all disks since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_host_disk_write_bytes`*:: ++ +-- +Bytes written to all disks since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_host_disk_write_count`*:: ++ +-- +Disk write operations across all disks since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_host_disk_write_time`*:: ++ +-- +Time spent writing to all disks since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_host_net_recv_bytes`*:: ++ +-- +Bytes received on all network interfaces since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_host_net_recv_packets`*:: ++ +-- +Packets received on all network interfaces since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_host_net_send_bytes`*:: ++ +-- +Bytes sent on all network interfaces since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_host_net_send_packets`*:: ++ +-- +Packets sent on all network interfaces since this process started + + +type: double + +-- + +*`prometheus.metrics.sys_rss`*:: ++ +-- +Current process RSS + + +type: double + +-- + +*`prometheus.metrics.sys_uptime`*:: ++ +-- +Process uptime + + +type: double + +-- + +*`prometheus.metrics.sysbytes`*:: ++ +-- +Number of bytes in system KV pairs + + +type: double + +-- + +*`prometheus.metrics.syscount`*:: ++ +-- +Count of system KV pairs + + +type: double + +-- + +*`prometheus.metrics.timeseries_write_bytes`*:: ++ +-- +Total size in bytes of metric samples written to disk + + +type: double + +-- + +*`prometheus.metrics.timeseries_write_errors`*:: ++ +-- +Total errors encountered while attempting to write metrics to disk + + +type: double + +-- + +*`prometheus.metrics.timeseries_write_samples`*:: ++ +-- +Total number of metric samples written to disk + + +type: double + +-- + +*`prometheus.metrics.totalbytes`*:: ++ +-- +Total number of bytes taken up by keys and values including non-live data + + +type: double + +-- + +*`prometheus.metrics.tscache_skl_read_pages`*:: ++ +-- +Number of pages in the read timestamp cache + + +type: double + +-- + +*`prometheus.metrics.tscache_skl_read_rotations`*:: ++ +-- +Number of page rotations in the read timestamp cache + + +type: double + +-- + +*`prometheus.metrics.tscache_skl_write_pages`*:: ++ +-- +Number of pages in the write timestamp cache + + +type: double + +-- + +*`prometheus.metrics.tscache_skl_write_rotations`*:: ++ +-- +Number of page rotations in the write timestamp cache + + +type: double + +-- + +*`prometheus.metrics.txn_aborts`*:: ++ +-- +Number of aborted KV transactions + + +type: double + +-- + +*`prometheus.metrics.txn_autoretries`*:: ++ +-- +Number of automatic retries to avoid serializable restarts + + +type: double + +-- + +*`prometheus.metrics.txn_commits`*:: ++ +-- +Number of committed KV transactions (including 1PC) + + +type: double + +-- + +*`prometheus.metrics.txn_commits1PC`*:: ++ +-- +Number of committed one-phase KV transactions + + +type: double + +-- + +*`prometheus.metrics.txn_durations_bucket`*:: ++ +-- +KV transaction durations + + +type: double + +-- + +*`prometheus.metrics.txn_durations_sum`*:: ++ +-- +Sum of KV transaction durations + + +type: double + +-- + +*`prometheus.metrics.txn_durations_count`*:: ++ +-- +Count of KV transaction durations + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_bucket`*:: ++ +-- +Number of restarted KV transactions + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_sum`*:: ++ +-- +Sum of Number of restarted KV transactions + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_count`*:: ++ +-- +Count of Number of restarted KV transactions + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_asyncwritefailure`*:: ++ +-- +Number of restarts due to async consensus writes that failed to leave intents + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_possiblereplay`*:: ++ +-- +Number of restarts due to possible replays of command batches at the storage layer + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_readwithinuncertainty`*:: ++ +-- +Number of restarts due to reading a new value within the uncertainty interval + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_serializable`*:: ++ +-- +Number of restarts due to a forwarded commit timestamp and isolation=SERIALIZABLE + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_txnaborted`*:: ++ +-- +Number of restarts due to an abort by a concurrent transaction (usually due to deadlock) + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_txnpush`*:: ++ +-- +Number of restarts due to a transaction push failure + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_unknown`*:: ++ +-- +Number of restarts due to a unknown reasons + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_writetooold`*:: ++ +-- +Number of restarts due to a concurrent writer committing first + + +type: double + +-- + +*`prometheus.metrics.txn_restarts_writetoooldmulti`*:: ++ +-- +Number of restarts due to multiple concurrent writers committing first + + +type: double + +-- + +*`prometheus.metrics.txnwaitqueue_deadlocks_total`*:: ++ +-- +Number of deadlocks detected by the txn wait queue + + +type: double + +-- + +*`prometheus.metrics.txnwaitqueue_pushee_waiting`*:: ++ +-- +Number of pushees on the txn wait queue + + +type: double + +-- + +*`prometheus.metrics.txnwaitqueue_pusher_slow`*:: ++ +-- +The total number of cases where a pusher waited more than the excessive wait threshold + + +type: double + +-- + +*`prometheus.metrics.txnwaitqueue_pusher_wait_time_bucket`*:: ++ +-- +Histogram of durations spent in queue by pushers + + +type: double + +-- + +*`prometheus.metrics.txnwaitqueue_pusher_wait_time_sum`*:: ++ +-- +Sum of Histogram of durations spent in queue by pushers + + +type: double + +-- + +*`prometheus.metrics.txnwaitqueue_pusher_wait_time_count`*:: ++ +-- +Count of Histogram of durations spent in queue by pushers + + +type: double + +-- + +*`prometheus.metrics.txnwaitqueue_pusher_waiting`*:: ++ +-- +Number of pushers on the txn wait queue + + +type: double + +-- + +*`prometheus.metrics.txnwaitqueue_query_wait_time_bucket`*:: ++ +-- +Histogram of durations spent in queue by queries + + +type: double + +-- + +*`prometheus.metrics.txnwaitqueue_query_wait_time_sum`*:: ++ +-- +Sum of Histogram of durations spent in queue by queries + + +type: double + +-- + +*`prometheus.metrics.txnwaitqueue_query_wait_time_count`*:: ++ +-- +Count of Histogram of durations spent in queue by queries + + +type: double + +-- + +*`prometheus.metrics.txnwaitqueue_query_waiting`*:: ++ +-- +Number of transaction status queries waiting for an updated transaction record + + +type: double + +-- + +*`prometheus.metrics.valbytes`*:: ++ +-- +Number of bytes taken up by values + + +type: double + +-- + +*`prometheus.metrics.valcount`*:: ++ +-- +Count of all values + + +type: double + +-- + [[exported-fields-common]] == Common fields diff --git a/metricbeat/helper/prometheus/prometheus.go b/metricbeat/helper/prometheus/prometheus.go index 7638f58c3658..8a527b2c8d42 100644 --- a/metricbeat/helper/prometheus/prometheus.go +++ b/metricbeat/helper/prometheus/prometheus.go @@ -67,18 +67,23 @@ func (p *prometheus) GetFamilies() ([]*dto.MetricFamily, error) { format := expfmt.ResponseFormat(resp.Header) if format == "" { - return nil, fmt.Errorf("Invalid format for response of response") + return nil, fmt.Errorf("invalid format for response of response") } - decoder := expfmt.NewDecoder(resp.Body, format) + return GetFamilies(resp.Body, format) +} + +// GetFamilies parses families from a reader +func GetFamilies(input io.Reader, format expfmt.Format) ([]*dto.MetricFamily, error) { + decoder := expfmt.NewDecoder(input, format) if decoder == nil { - return nil, fmt.Errorf("Unable to create decoder to decode response") + return nil, fmt.Errorf("unable to create decoder to decode prometheus input") } families := []*dto.MetricFamily{} for { mf := &dto.MetricFamily{} - err = decoder.Decode(mf) + err := decoder.Decode(mf) if err != nil { if err == io.EOF { break diff --git a/metricbeat/module/prometheus/collector/cmd/generate_fields/generate_fields.go b/metricbeat/module/prometheus/collector/cmd/generate_fields/generate_fields.go new file mode 100644 index 000000000000..68d9dcd1003e --- /dev/null +++ b/metricbeat/module/prometheus/collector/cmd/generate_fields/generate_fields.go @@ -0,0 +1,94 @@ +package main + +import ( + "flag" + "fmt" + "io" + "os" + "sort" + "strings" + + dto "github.com/prometheus/client_model/go" + "github.com/prometheus/common/expfmt" + + "github.com/elastic/beats/metricbeat/helper/prometheus" +) + +type FamiliesByName []*dto.MetricFamily + +func (f FamiliesByName) Len() int { return len(f) } +func (f FamiliesByName) Swap(i, j int) { f[i], f[j] = f[j], f[i] } +func (f FamiliesByName) Less(i, j int) bool { return f[i].GetName() < f[j].GetName() } + +func filterIncomplete(families []*dto.MetricFamily) { + k := 0 + for i, f := range families { + if f.Name == nil { + continue + } + families[k] = families[i] + k++ + } +} + +type FieldsEntry struct { + Name string + Type string + Description string +} + +func (e FieldsEntry) Print(w io.Writer, spaces int) { + indent := strings.Repeat(" ", spaces) + fmt.Fprintf(w, "%s- name: %s\n", indent, e.Name) + fmt.Fprintf(w, "%s type: %s\n", indent, e.Type) + if e.Description != "" { + fmt.Fprintf(w, "%s description: >\n%s %s\n", indent, indent, e.Description) + } +} + +func main() { + flag.Parse() + + format := expfmt.FmtText + families, err := prometheus.GetFamilies(os.Stdin, format) + if err != nil { + fmt.Printf("failed to get families from stdin: %v", err) + os.Exit(1) + } + + filterIncomplete(families) + sort.Sort(FamiliesByName(families)) + + for _, f := range families { + switch *f.Type { + case dto.MetricType_SUMMARY, dto.MetricType_HISTOGRAM: + bucket := FieldsEntry{ + Name: fmt.Sprintf("prometheus.metrics.%s_bucket", *f.Name), + Type: "double", + Description: *f.Help, + } + sum := FieldsEntry{ + Name: fmt.Sprintf("prometheus.metrics.%s_sum", *f.Name), + Type: "double", + } + count := FieldsEntry{ + Name: fmt.Sprintf("prometheus.metrics.%s_count", *f.Name), + Type: "double", + } + if f.Help != nil && len(*f.Help) > 0 { + sum.Description = "Sum of " + *f.Help + count.Description = "Count of " + *f.Help + } + bucket.Print(os.Stdout, 1) + sum.Print(os.Stdout, 1) + count.Print(os.Stdout, 1) + default: + entry := FieldsEntry{ + Name: fmt.Sprintf("prometheus.metrics.%s", *f.Name), + Type: "double", + Description: *f.Help, + } + entry.Print(os.Stdout, 1) + } + } +} diff --git a/x-pack/metricbeat/module/cockroachdb/_meta/fields.yml b/x-pack/metricbeat/module/cockroachdb/_meta/fields.yml index 5b82017d688c..de0a0b74f636 100644 --- a/x-pack/metricbeat/module/cockroachdb/_meta/fields.yml +++ b/x-pack/metricbeat/module/cockroachdb/_meta/fields.yml @@ -5,6 +5,1690 @@ CockroachDB module settings: ["ssl", "http"] fields: - - name: cockroachdb - type: group - fields: + - name: prometheus.metrics.addsstable_applications + type: double + description: > + Number of SSTable ingestions applied (i.e. applied by Replicas) + - name: prometheus.metrics.addsstable_copies + type: double + description: > + number of SSTable ingestions that required copying files during application + - name: prometheus.metrics.addsstable_proposals + type: double + description: > + Number of SSTable ingestions proposed (i.e. sent to Raft by lease holders) + - name: prometheus.metrics.build_timestamp + type: double + description: > + Build information + - name: prometheus.metrics.capacity + type: double + description: > + Total storage capacity + - name: prometheus.metrics.capacity_available + type: double + description: > + Available storage capacity + - name: prometheus.metrics.capacity_reserved + type: double + description: > + Capacity reserved for snapshots + - name: prometheus.metrics.capacity_used + type: double + description: > + Used storage capacity + - name: prometheus.metrics.changefeed_buffer_entries_in + type: double + description: > + Total entries entering the buffer between raft and changefeed sinks + - name: prometheus.metrics.changefeed_buffer_entries_out + type: double + description: > + Total entries leaving the buffer between raft and changefeed sinks + - name: prometheus.metrics.changefeed_emit_nanos + type: double + description: > + Total time spent emitting all feeds + - name: prometheus.metrics.changefeed_emitted_bytes + type: double + description: > + Bytes emitted by all feeds + - name: prometheus.metrics.changefeed_emitted_messages + type: double + description: > + Messages emitted by all feeds + - name: prometheus.metrics.changefeed_error_retries + type: double + description: > + Total retryable errors encountered by all changefeeds + - name: prometheus.metrics.changefeed_flush_nanos + type: double + description: > + Total time spent flushing all feeds + - name: prometheus.metrics.changefeed_flushes + type: double + description: > + Total flushes across all feeds + - name: prometheus.metrics.changefeed_max_behind_nanos + type: double + description: > + Largest commit-to-emit duration of any running feed + - name: prometheus.metrics.changefeed_min_high_water + type: double + description: > + Latest high-water timestamp of most behind feed + - name: prometheus.metrics.changefeed_poll_request_nanos_bucket + type: double + description: > + Time spent fetching changes + - name: prometheus.metrics.changefeed_poll_request_nanos_sum + type: double + description: > + Sum of Time spent fetching changes + - name: prometheus.metrics.changefeed_poll_request_nanos_count + type: double + description: > + Count of Time spent fetching changes + - name: prometheus.metrics.changefeed_processing_nanos + type: double + description: > + Time spent processing KV changes into SQL rows + - name: prometheus.metrics.changefeed_table_metadata_nanos + type: double + description: > + Time blocked while verifying table metadata histories + - name: prometheus.metrics.clock_offset_meannanos + type: double + description: > + Mean clock offset with other nodes + - name: prometheus.metrics.clock_offset_stddevnanos + type: double + description: > + Stddev clock offset with other nodes + - name: prometheus.metrics.compactor_compactingnanos + type: double + description: > + Number of nanoseconds spent compacting ranges + - name: prometheus.metrics.compactor_compactions_failure + type: double + description: > + Number of failed compaction requests sent to the storage engine + - name: prometheus.metrics.compactor_compactions_success + type: double + description: > + Number of successful compaction requests sent to the storage engine + - name: prometheus.metrics.compactor_suggestionbytes_compacted + type: double + description: > + Number of logical bytes compacted from suggested compactions + - name: prometheus.metrics.compactor_suggestionbytes_queued + type: double + description: > + Number of logical bytes in suggested compactions in the queue + - name: prometheus.metrics.compactor_suggestionbytes_skipped + type: double + description: > + Number of logical bytes in suggested compactions which were not compacted + - name: prometheus.metrics.distsender_batches + type: double + description: > + Number of batches processed + - name: prometheus.metrics.distsender_batches_async_sent + type: double + description: > + Number of partial batches sent asynchronously + - name: prometheus.metrics.distsender_batches_async_throttled + type: double + description: > + Number of partial batches not sent asynchronously due to throttling + - name: prometheus.metrics.distsender_batches_partial + type: double + description: > + Number of partial batches processed after being divided on range boundaries + - name: prometheus.metrics.distsender_errors_inleasetransferbackoffs + type: double + description: > + Number of times backed off due to NotLeaseHolderErrors during lease transfer. + - name: prometheus.metrics.distsender_errors_notleaseholder + type: double + description: > + Number of NotLeaseHolderErrors encountered + - name: prometheus.metrics.distsender_rpc_sent + type: double + description: > + Number of RPCs sent + - name: prometheus.metrics.distsender_rpc_sent_local + type: double + description: > + Number of local RPCs sent + - name: prometheus.metrics.distsender_rpc_sent_nextreplicaerror + type: double + description: > + Number of RPCs sent due to per-replica errors + - name: prometheus.metrics.exec_error + type: double + description: > + Number of batch KV requests that failed to execute on this node + - name: prometheus.metrics.exec_latency_bucket + type: double + description: > + Latency of batch KV requests executed on this node + - name: prometheus.metrics.exec_latency_sum + type: double + description: > + Sum of Latency of batch KV requests executed on this node + - name: prometheus.metrics.exec_latency_count + type: double + description: > + Count of Latency of batch KV requests executed on this node + - name: prometheus.metrics.exec_success + type: double + description: > + Number of batch KV requests executed successfully on this node + - name: prometheus.metrics.follower_reads_success_count + type: double + description: > + Number of reads successfully processed by any replica + - name: prometheus.metrics.gcbytesage + type: double + description: > + Cumulative age of non-live data + - name: prometheus.metrics.gossip_bytes_received + type: double + description: > + Number of received gossip bytes + - name: prometheus.metrics.gossip_bytes_sent + type: double + description: > + Number of sent gossip bytes + - name: prometheus.metrics.gossip_connections_incoming + type: double + description: > + Number of active incoming gossip connections + - name: prometheus.metrics.gossip_connections_outgoing + type: double + description: > + Number of active outgoing gossip connections + - name: prometheus.metrics.gossip_connections_refused + type: double + description: > + Number of refused incoming gossip connections + - name: prometheus.metrics.gossip_infos_received + type: double + description: > + Number of received gossip Info objects + - name: prometheus.metrics.gossip_infos_sent + type: double + description: > + Number of sent gossip Info objects + - name: prometheus.metrics.intentage + type: double + description: > + Cumulative age of intents + - name: prometheus.metrics.intentbytes + type: double + description: > + Number of bytes in intent KV pairs + - name: prometheus.metrics.intentcount + type: double + description: > + Count of intent keys + - name: prometheus.metrics.intentresolver_async_throttled + type: double + description: > + Number of intent resolution attempts not run asynchronously due to throttling + - name: prometheus.metrics.intents_abort_attempts + type: double + description: > + Count of (point or range) non-poisoning intent abort evaluation attempts + - name: prometheus.metrics.intents_poison_attempts + type: double + description: > + Count of (point or range) poisoning intent abort evaluation attempts + - name: prometheus.metrics.intents_resolve_attempts + type: double + description: > + Count of (point or range) intent commit evaluation attempts + - name: prometheus.metrics.keybytes + type: double + description: > + Number of bytes taken up by keys + - name: prometheus.metrics.keycount + type: double + description: > + Count of all keys + - name: prometheus.metrics.kv_closed_timestamp_max_behind_nanos + type: double + description: > + Largest latency between realtime and replica max closed timestamp + - name: prometheus.metrics.kv_rangefeed_catchup_scan_nanos + type: double + description: > + Time spent in RangeFeed catchup scan + - name: prometheus.metrics.lastupdatenanos + type: double + description: > + Timestamp at which bytes/keys/intents metrics were last updated + - name: prometheus.metrics.leases_epoch + type: double + description: > + Number of replica leaseholders using epoch-based leases + - name: prometheus.metrics.leases_error + type: double + description: > + Number of failed lease requests + - name: prometheus.metrics.leases_expiration + type: double + description: > + Number of replica leaseholders using expiration-based leases + - name: prometheus.metrics.leases_success + type: double + description: > + Number of successful lease requests + - name: prometheus.metrics.leases_transfers_error + type: double + description: > + Number of failed lease transfers + - name: prometheus.metrics.leases_transfers_success + type: double + description: > + Number of successful lease transfers + - name: prometheus.metrics.livebytes + type: double + description: > + Number of bytes of live data (keys plus values) + - name: prometheus.metrics.livecount + type: double + description: > + Count of live keys + - name: prometheus.metrics.liveness_epochincrements + type: double + description: > + Number of times this node has incremented its liveness epoch + - name: prometheus.metrics.liveness_heartbeatfailures + type: double + description: > + Number of failed node liveness heartbeats from this node + - name: prometheus.metrics.liveness_heartbeatlatency_bucket + type: double + description: > + Node liveness heartbeat latency + - name: prometheus.metrics.liveness_heartbeatlatency_sum + type: double + description: > + Sum of Node liveness heartbeat latency + - name: prometheus.metrics.liveness_heartbeatlatency_count + type: double + description: > + Count of Node liveness heartbeat latency + - name: prometheus.metrics.liveness_heartbeatsuccesses + type: double + description: > + Number of successful node liveness heartbeats from this node + - name: prometheus.metrics.liveness_livenodes + type: double + description: > + Number of live nodes in the cluster (will be 0 if this node is not itself live) + - name: prometheus.metrics.node_id + type: double + description: > + node ID with labels for advertised RPC and HTTP addresses + - name: prometheus.metrics.queue_consistency_pending + type: double + description: > + Number of pending replicas in the consistency checker queue + - name: prometheus.metrics.queue_consistency_process_failure + type: double + description: > + Number of replicas which failed processing in the consistency checker queue + - name: prometheus.metrics.queue_consistency_process_success + type: double + description: > + Number of replicas successfully processed by the consistency checker queue + - name: prometheus.metrics.queue_consistency_processingnanos + type: double + description: > + Nanoseconds spent processing replicas in the consistency checker queue + - name: prometheus.metrics.queue_gc_info_abortspanconsidered + type: double + description: > + Number of AbortSpan entries old enough to be considered for removal + - name: prometheus.metrics.queue_gc_info_abortspangcnum + type: double + description: > + Number of AbortSpan entries fit for removal + - name: prometheus.metrics.queue_gc_info_abortspanscanned + type: double + description: > + Number of transactions present in the AbortSpan scanned from the engine + - name: prometheus.metrics.queue_gc_info_intentsconsidered + type: double + description: > + Number of 'old' intents + - name: prometheus.metrics.queue_gc_info_intenttxns + type: double + description: > + Number of associated distinct transactions + - name: prometheus.metrics.queue_gc_info_numkeysaffected + type: double + description: > + Number of keys with GC'able data + - name: prometheus.metrics.queue_gc_info_pushtxn + type: double + description: > + Number of attempted pushes + - name: prometheus.metrics.queue_gc_info_resolvesuccess + type: double + description: > + Number of successful intent resolutions + - name: prometheus.metrics.queue_gc_info_resolvetotal + type: double + description: > + Number of attempted intent resolutions + - name: prometheus.metrics.queue_gc_info_transactionspangcaborted + type: double + description: > + Number of GC'able entries corresponding to aborted txns + - name: prometheus.metrics.queue_gc_info_transactionspangccommitted + type: double + description: > + Number of GC'able entries corresponding to committed txns + - name: prometheus.metrics.queue_gc_info_transactionspangcpending + type: double + description: > + Number of GC'able entries corresponding to pending txns + - name: prometheus.metrics.queue_gc_info_transactionspanscanned + type: double + description: > + Number of entries in transaction spans scanned from the engine + - name: prometheus.metrics.queue_gc_pending + type: double + description: > + Number of pending replicas in the GC queue + - name: prometheus.metrics.queue_gc_process_failure + type: double + description: > + Number of replicas which failed processing in the GC queue + - name: prometheus.metrics.queue_gc_process_success + type: double + description: > + Number of replicas successfully processed by the GC queue + - name: prometheus.metrics.queue_gc_processingnanos + type: double + description: > + Nanoseconds spent processing replicas in the GC queue + - name: prometheus.metrics.queue_merge_pending + type: double + description: > + Number of pending replicas in the merge queue + - name: prometheus.metrics.queue_merge_process_failure + type: double + description: > + Number of replicas which failed processing in the merge queue + - name: prometheus.metrics.queue_merge_process_success + type: double + description: > + Number of replicas successfully processed by the merge queue + - name: prometheus.metrics.queue_merge_processingnanos + type: double + description: > + Nanoseconds spent processing replicas in the merge queue + - name: prometheus.metrics.queue_merge_purgatory + type: double + description: > + Number of replicas in the merge queue's purgatory, waiting to become mergeable + - name: prometheus.metrics.queue_raftlog_pending + type: double + description: > + Number of pending replicas in the Raft log queue + - name: prometheus.metrics.queue_raftlog_process_failure + type: double + description: > + Number of replicas which failed processing in the Raft log queue + - name: prometheus.metrics.queue_raftlog_process_success + type: double + description: > + Number of replicas successfully processed by the Raft log queue + - name: prometheus.metrics.queue_raftlog_processingnanos + type: double + description: > + Nanoseconds spent processing replicas in the Raft log queue + - name: prometheus.metrics.queue_raftsnapshot_pending + type: double + description: > + Number of pending replicas in the Raft repair queue + - name: prometheus.metrics.queue_raftsnapshot_process_failure + type: double + description: > + Number of replicas which failed processing in the Raft repair queue + - name: prometheus.metrics.queue_raftsnapshot_process_success + type: double + description: > + Number of replicas successfully processed by the Raft repair queue + - name: prometheus.metrics.queue_raftsnapshot_processingnanos + type: double + description: > + Nanoseconds spent processing replicas in the Raft repair queue + - name: prometheus.metrics.queue_replicagc_pending + type: double + description: > + Number of pending replicas in the replica GC queue + - name: prometheus.metrics.queue_replicagc_process_failure + type: double + description: > + Number of replicas which failed processing in the replica GC queue + - name: prometheus.metrics.queue_replicagc_process_success + type: double + description: > + Number of replicas successfully processed by the replica GC queue + - name: prometheus.metrics.queue_replicagc_processingnanos + type: double + description: > + Nanoseconds spent processing replicas in the replica GC queue + - name: prometheus.metrics.queue_replicagc_removereplica + type: double + description: > + Number of replica removals attempted by the replica gc queue + - name: prometheus.metrics.queue_replicate_addreplica + type: double + description: > + Number of replica additions attempted by the replicate queue + - name: prometheus.metrics.queue_replicate_pending + type: double + description: > + Number of pending replicas in the replicate queue + - name: prometheus.metrics.queue_replicate_process_failure + type: double + description: > + Number of replicas which failed processing in the replicate queue + - name: prometheus.metrics.queue_replicate_process_success + type: double + description: > + Number of replicas successfully processed by the replicate queue + - name: prometheus.metrics.queue_replicate_processingnanos + type: double + description: > + Nanoseconds spent processing replicas in the replicate queue + - name: prometheus.metrics.queue_replicate_purgatory + type: double + description: > + Number of replicas in the replicate queue's purgatory, awaiting allocation options + - name: prometheus.metrics.queue_replicate_rebalancereplica + type: double + description: > + Number of replica rebalancer-initiated additions attempted by the replicate queue + - name: prometheus.metrics.queue_replicate_removedeadreplica + type: double + description: > + Number of dead replica removals attempted by the replicate queue (typically in response to a node outage) + - name: prometheus.metrics.queue_replicate_removereplica + type: double + description: > + Number of replica removals attempted by the replicate queue (typically in response to a rebalancer-initiated addition) + - name: prometheus.metrics.queue_replicate_transferlease + type: double + description: > + Number of range lease transfers attempted by the replicate queue + - name: prometheus.metrics.queue_split_pending + type: double + description: > + Number of pending replicas in the split queue + - name: prometheus.metrics.queue_split_process_failure + type: double + description: > + Number of replicas which failed processing in the split queue + - name: prometheus.metrics.queue_split_process_success + type: double + description: > + Number of replicas successfully processed by the split queue + - name: prometheus.metrics.queue_split_processingnanos + type: double + description: > + Nanoseconds spent processing replicas in the split queue + - name: prometheus.metrics.queue_split_purgatory + type: double + description: > + Number of replicas in the split queue's purgatory, waiting to become splittable + - name: prometheus.metrics.queue_tsmaintenance_pending + type: double + description: > + Number of pending replicas in the time series maintenance queue + - name: prometheus.metrics.queue_tsmaintenance_process_failure + type: double + description: > + Number of replicas which failed processing in the time series maintenance queue + - name: prometheus.metrics.queue_tsmaintenance_process_success + type: double + description: > + Number of replicas successfully processed by the time series maintenance queue + - name: prometheus.metrics.queue_tsmaintenance_processingnanos + type: double + description: > + Nanoseconds spent processing replicas in the time series maintenance queue + - name: prometheus.metrics.raft_commandsapplied + type: double + description: > + Count of Raft commands applied + - name: prometheus.metrics.raft_enqueued_pending + type: double + description: > + Number of pending outgoing messages in the Raft Transport queue + - name: prometheus.metrics.raft_entrycache_accesses + type: double + description: > + Number of cache lookups in the Raft entry cache + - name: prometheus.metrics.raft_entrycache_bytes + type: double + description: > + Aggregate size of all Raft entries in the Raft entry cache + - name: prometheus.metrics.raft_entrycache_hits + type: double + description: > + Number of successful cache lookups in the Raft entry cache + - name: prometheus.metrics.raft_entrycache_size + type: double + description: > + Number of Raft entries in the Raft entry cache + - name: prometheus.metrics.raft_heartbeats_pending + type: double + description: > + Number of pending heartbeats and responses waiting to be coalesced + - name: prometheus.metrics.raft_process_applycommitted_latency_bucket + type: double + description: > + Latency histogram for applying all committed Raft commands in a Raft ready + - name: prometheus.metrics.raft_process_applycommitted_latency_sum + type: double + description: > + Sum of Latency histogram for applying all committed Raft commands in a Raft ready + - name: prometheus.metrics.raft_process_applycommitted_latency_count + type: double + description: > + Count of Latency histogram for applying all committed Raft commands in a Raft ready + - name: prometheus.metrics.raft_process_commandcommit_latency_bucket + type: double + description: > + Latency histogram for committing Raft commands + - name: prometheus.metrics.raft_process_commandcommit_latency_sum + type: double + description: > + Sum of Latency histogram for committing Raft commands + - name: prometheus.metrics.raft_process_commandcommit_latency_count + type: double + description: > + Count of Latency histogram for committing Raft commands + - name: prometheus.metrics.raft_process_handleready_latency_bucket + type: double + description: > + Latency histogram for handling a Raft ready + - name: prometheus.metrics.raft_process_handleready_latency_sum + type: double + description: > + Sum of Latency histogram for handling a Raft ready + - name: prometheus.metrics.raft_process_handleready_latency_count + type: double + description: > + Count of Latency histogram for handling a Raft ready + - name: prometheus.metrics.raft_process_logcommit_latency_bucket + type: double + description: > + Latency histogram for committing Raft log entries + - name: prometheus.metrics.raft_process_logcommit_latency_sum + type: double + description: > + Sum of Latency histogram for committing Raft log entries + - name: prometheus.metrics.raft_process_logcommit_latency_count + type: double + description: > + Count of Latency histogram for committing Raft log entries + - name: prometheus.metrics.raft_process_tickingnanos + type: double + description: > + Nanoseconds spent in store.processRaft() processing replica.Tick() + - name: prometheus.metrics.raft_process_workingnanos + type: double + description: > + Nanoseconds spent in store.processRaft() working + - name: prometheus.metrics.raft_rcvd_app + type: double + description: > + Number of MsgApp messages received by this store + - name: prometheus.metrics.raft_rcvd_appresp + type: double + description: > + Number of MsgAppResp messages received by this store + - name: prometheus.metrics.raft_rcvd_dropped + type: double + description: > + Number of dropped incoming Raft messages + - name: prometheus.metrics.raft_rcvd_heartbeat + type: double + description: > + Number of (coalesced, if enabled) MsgHeartbeat messages received by this store + - name: prometheus.metrics.raft_rcvd_heartbeatresp + type: double + description: > + Number of (coalesced, if enabled) MsgHeartbeatResp messages received by this store + - name: prometheus.metrics.raft_rcvd_prevote + type: double + description: > + Number of MsgPreVote messages received by this store + - name: prometheus.metrics.raft_rcvd_prevoteresp + type: double + description: > + Number of MsgPreVoteResp messages received by this store + - name: prometheus.metrics.raft_rcvd_prop + type: double + description: > + Number of MsgProp messages received by this store + - name: prometheus.metrics.raft_rcvd_snap + type: double + description: > + Number of MsgSnap messages received by this store + - name: prometheus.metrics.raft_rcvd_timeoutnow + type: double + description: > + Number of MsgTimeoutNow messages received by this store + - name: prometheus.metrics.raft_rcvd_transferleader + type: double + description: > + Number of MsgTransferLeader messages received by this store + - name: prometheus.metrics.raft_rcvd_vote + type: double + description: > + Number of MsgVote messages received by this store + - name: prometheus.metrics.raft_rcvd_voteresp + type: double + description: > + Number of MsgVoteResp messages received by this store + - name: prometheus.metrics.raft_ticks + type: double + description: > + Number of Raft ticks queued + - name: prometheus.metrics.raftlog_behind + type: double + description: > + Number of Raft log entries followers on other stores are behind + - name: prometheus.metrics.raftlog_truncated + type: double + description: > + Number of Raft log entries truncated + - name: prometheus.metrics.range_adds + type: double + description: > + Number of range additions + - name: prometheus.metrics.range_merges + type: double + description: > + Number of range merges + - name: prometheus.metrics.range_raftleadertransfers + type: double + description: > + Number of raft leader transfers + - name: prometheus.metrics.range_removes + type: double + description: > + Number of range removals + - name: prometheus.metrics.range_snapshots_generated + type: double + description: > + Number of generated snapshots + - name: prometheus.metrics.range_snapshots_normal_applied + type: double + description: > + Number of applied snapshots + - name: prometheus.metrics.range_snapshots_preemptive_applied + type: double + description: > + Number of applied pre-emptive snapshots + - name: prometheus.metrics.range_splits + type: double + description: > + Number of range splits + - name: prometheus.metrics.ranges + type: double + description: > + Number of ranges + - name: prometheus.metrics.ranges_overreplicated + type: double + description: > + Number of ranges with more live replicas than the replication target + - name: prometheus.metrics.ranges_unavailable + type: double + description: > + Number of ranges with fewer live replicas than needed for quorum + - name: prometheus.metrics.ranges_underreplicated + type: double + description: > + Number of ranges with fewer live replicas than the replication target + - name: prometheus.metrics.rebalancing_lease_transfers + type: double + description: > + Number of lease transfers motivated by store-level load imbalances + - name: prometheus.metrics.rebalancing_queriespersecond + type: double + description: > + Number of kv-level requests received per second by the store, averaged over a large time period as used in rebalancing decisions + - name: prometheus.metrics.rebalancing_range_rebalances + type: double + description: > + Number of range rebalance operations motivated by store-level load imbalances + - name: prometheus.metrics.rebalancing_writespersecond + type: double + description: > + Number of keys written (i.e. applied by raft) per second to the store, averaged over a large time period as used in rebalancing decisions + - name: prometheus.metrics.replicas + type: double + description: > + Number of replicas + - name: prometheus.metrics.replicas_leaders + type: double + description: > + Number of raft leaders + - name: prometheus.metrics.replicas_leaders_not_leaseholders + type: double + description: > + Number of replicas that are Raft leaders whose range lease is held by another store + - name: prometheus.metrics.replicas_leaseholders + type: double + description: > + Number of lease holders + - name: prometheus.metrics.replicas_quiescent + type: double + description: > + Number of quiesced replicas + - name: prometheus.metrics.replicas_reserved + type: double + description: > + Number of replicas reserved for snapshots + - name: prometheus.metrics.requests_backpressure_split + type: double + description: > + Number of backpressured writes waiting on a Range split + - name: prometheus.metrics.requests_slow_latch + type: double + description: > + Number of requests that have been stuck for a long time acquiring latches + - name: prometheus.metrics.requests_slow_lease + type: double + description: > + Number of requests that have been stuck for a long time acquiring a lease + - name: prometheus.metrics.requests_slow_raft + type: double + description: > + Number of requests that have been stuck for a long time in raft + - name: prometheus.metrics.rocksdb_block_cache_hits + type: double + description: > + Count of block cache hits + - name: prometheus.metrics.rocksdb_block_cache_misses + type: double + description: > + Count of block cache misses + - name: prometheus.metrics.rocksdb_block_cache_pinned_usage + type: double + description: > + Bytes pinned by the block cache + - name: prometheus.metrics.rocksdb_block_cache_usage + type: double + description: > + Bytes used by the block cache + - name: prometheus.metrics.rocksdb_bloom_filter_prefix_checked + type: double + description: > + Number of times the bloom filter was checked + - name: prometheus.metrics.rocksdb_bloom_filter_prefix_useful + type: double + description: > + Number of times the bloom filter helped avoid iterator creation + - name: prometheus.metrics.rocksdb_compactions + type: double + description: > + Number of table compactions + - name: prometheus.metrics.rocksdb_encryption_algorithm + type: double + description: > + algorithm in use for encryption-at-rest, see ccl/storageccl/engineccl/enginepbccl/key_registry.proto + - name: prometheus.metrics.rocksdb_flushes + type: double + description: > + Number of table flushes + - name: prometheus.metrics.rocksdb_memtable_total_size + type: double + description: > + Current size of memtable in bytes + - name: prometheus.metrics.rocksdb_num_sstables + type: double + description: > + Number of rocksdb SSTables + - name: prometheus.metrics.rocksdb_read_amplification + type: double + description: > + Number of disk reads per query + - name: prometheus.metrics.rocksdb_table_readers_mem_estimate + type: double + description: > + Memory used by index and filter blocks + - name: prometheus.metrics.round_trip_latency_bucket + type: double + description: > + Distribution of round-trip latencies with other nodes + - name: prometheus.metrics.round_trip_latency_sum + type: double + description: > + Sum of Distribution of round-trip latencies with other nodes + - name: prometheus.metrics.round_trip_latency_count + type: double + description: > + Count of Distribution of round-trip latencies with other nodes + - name: prometheus.metrics.sql_bytesin + type: double + description: > + Number of sql bytes received + - name: prometheus.metrics.sql_bytesout + type: double + description: > + Number of sql bytes sent + - name: prometheus.metrics.sql_conns + type: double + description: > + Number of active sql connections + - name: prometheus.metrics.sql_ddl_count + type: double + description: > + Number of SQL DDL statements + - name: prometheus.metrics.sql_ddl_count_internal + type: double + description: > + Number of SQL DDL statements (internal queries) + - name: prometheus.metrics.sql_delete_count + type: double + description: > + Number of SQL DELETE statements + - name: prometheus.metrics.sql_delete_count_internal + type: double + description: > + Number of SQL DELETE statements (internal queries) + - name: prometheus.metrics.sql_distsql_exec_latency_bucket + type: double + description: > + Latency of DistSQL statement execution + - name: prometheus.metrics.sql_distsql_exec_latency_sum + type: double + description: > + Sum of Latency of DistSQL statement execution + - name: prometheus.metrics.sql_distsql_exec_latency_count + type: double + description: > + Count of Latency of DistSQL statement execution + - name: prometheus.metrics.sql_distsql_exec_latency_internal_bucket + type: double + description: > + Latency of DistSQL statement execution (internal queries) + - name: prometheus.metrics.sql_distsql_exec_latency_internal_sum + type: double + description: > + Sum of Latency of DistSQL statement execution (internal queries) + - name: prometheus.metrics.sql_distsql_exec_latency_internal_count + type: double + description: > + Count of Latency of DistSQL statement execution (internal queries) + - name: prometheus.metrics.sql_distsql_flows_active + type: double + description: > + Number of distributed SQL flows currently active + - name: prometheus.metrics.sql_distsql_flows_queue_wait_bucket + type: double + description: > + Duration of time flows spend waiting in the queue + - name: prometheus.metrics.sql_distsql_flows_queue_wait_sum + type: double + description: > + Sum of Duration of time flows spend waiting in the queue + - name: prometheus.metrics.sql_distsql_flows_queue_wait_count + type: double + description: > + Count of Duration of time flows spend waiting in the queue + - name: prometheus.metrics.sql_distsql_flows_queued + type: double + description: > + Number of distributed SQL flows currently queued + - name: prometheus.metrics.sql_distsql_flows_total + type: double + description: > + Number of distributed SQL flows executed + - name: prometheus.metrics.sql_distsql_queries_active + type: double + description: > + Number of distributed SQL queries currently active + - name: prometheus.metrics.sql_distsql_queries_total + type: double + description: > + Number of distributed SQL queries executed + - name: prometheus.metrics.sql_distsql_select_count + type: double + description: > + Number of DistSQL SELECT statements + - name: prometheus.metrics.sql_distsql_select_count_internal + type: double + description: > + Number of DistSQL SELECT statements (internal queries) + - name: prometheus.metrics.sql_distsql_service_latency_bucket + type: double + description: > + Latency of DistSQL request execution + - name: prometheus.metrics.sql_distsql_service_latency_sum + type: double + description: > + Sum of Latency of DistSQL request execution + - name: prometheus.metrics.sql_distsql_service_latency_count + type: double + description: > + Count of Latency of DistSQL request execution + - name: prometheus.metrics.sql_distsql_service_latency_internal_bucket + type: double + description: > + Latency of DistSQL request execution (internal queries) + - name: prometheus.metrics.sql_distsql_service_latency_internal_sum + type: double + description: > + Sum of Latency of DistSQL request execution (internal queries) + - name: prometheus.metrics.sql_distsql_service_latency_internal_count + type: double + description: > + Count of Latency of DistSQL request execution (internal queries) + - name: prometheus.metrics.sql_exec_latency_bucket + type: double + description: > + Latency of SQL statement execution + - name: prometheus.metrics.sql_exec_latency_sum + type: double + description: > + Sum of Latency of SQL statement execution + - name: prometheus.metrics.sql_exec_latency_count + type: double + description: > + Count of Latency of SQL statement execution + - name: prometheus.metrics.sql_exec_latency_internal_bucket + type: double + description: > + Latency of SQL statement execution (internal queries) + - name: prometheus.metrics.sql_exec_latency_internal_sum + type: double + description: > + Sum of Latency of SQL statement execution (internal queries) + - name: prometheus.metrics.sql_exec_latency_internal_count + type: double + description: > + Count of Latency of SQL statement execution (internal queries) + - name: prometheus.metrics.sql_failure_count + type: double + description: > + Number of statements resulting in a planning or runtime error + - name: prometheus.metrics.sql_failure_count_internal + type: double + description: > + Number of statements resulting in a planning or runtime error (internal queries) + - name: prometheus.metrics.sql_insert_count + type: double + description: > + Number of SQL INSERT statements + - name: prometheus.metrics.sql_insert_count_internal + type: double + description: > + Number of SQL INSERT statements (internal queries) + - name: prometheus.metrics.sql_mem_admin_current + type: double + description: > + Current sql statement memory usage for admin + - name: prometheus.metrics.sql_mem_admin_max_bucket + type: double + description: > + Memory usage per sql statement for admin + - name: prometheus.metrics.sql_mem_admin_max_sum + type: double + description: > + Sum of Memory usage per sql statement for admin + - name: prometheus.metrics.sql_mem_admin_max_count + type: double + description: > + Count of Memory usage per sql statement for admin + - name: prometheus.metrics.sql_mem_admin_session_current + type: double + description: > + Current sql session memory usage for admin + - name: prometheus.metrics.sql_mem_admin_session_max_bucket + type: double + description: > + Memory usage per sql session for admin + - name: prometheus.metrics.sql_mem_admin_session_max_sum + type: double + description: > + Sum of Memory usage per sql session for admin + - name: prometheus.metrics.sql_mem_admin_session_max_count + type: double + description: > + Count of Memory usage per sql session for admin + - name: prometheus.metrics.sql_mem_admin_txn_current + type: double + description: > + Current sql transaction memory usage for admin + - name: prometheus.metrics.sql_mem_admin_txn_max_bucket + type: double + description: > + Memory usage per sql transaction for admin + - name: prometheus.metrics.sql_mem_admin_txn_max_sum + type: double + description: > + Sum of Memory usage per sql transaction for admin + - name: prometheus.metrics.sql_mem_admin_txn_max_count + type: double + description: > + Count of Memory usage per sql transaction for admin + - name: prometheus.metrics.sql_mem_conns_current + type: double + description: > + Current sql statement memory usage for conns + - name: prometheus.metrics.sql_mem_conns_max_bucket + type: double + description: > + Memory usage per sql statement for conns + - name: prometheus.metrics.sql_mem_conns_max_sum + type: double + description: > + Sum of Memory usage per sql statement for conns + - name: prometheus.metrics.sql_mem_conns_max_count + type: double + description: > + Count of Memory usage per sql statement for conns + - name: prometheus.metrics.sql_mem_conns_session_current + type: double + description: > + Current sql session memory usage for conns + - name: prometheus.metrics.sql_mem_conns_session_max_bucket + type: double + description: > + Memory usage per sql session for conns + - name: prometheus.metrics.sql_mem_conns_session_max_sum + type: double + description: > + Sum of Memory usage per sql session for conns + - name: prometheus.metrics.sql_mem_conns_session_max_count + type: double + description: > + Count of Memory usage per sql session for conns + - name: prometheus.metrics.sql_mem_conns_txn_current + type: double + description: > + Current sql transaction memory usage for conns + - name: prometheus.metrics.sql_mem_conns_txn_max_bucket + type: double + description: > + Memory usage per sql transaction for conns + - name: prometheus.metrics.sql_mem_conns_txn_max_sum + type: double + description: > + Sum of Memory usage per sql transaction for conns + - name: prometheus.metrics.sql_mem_conns_txn_max_count + type: double + description: > + Count of Memory usage per sql transaction for conns + - name: prometheus.metrics.sql_mem_distsql_current + type: double + description: > + Current sql statement memory usage for distsql + - name: prometheus.metrics.sql_mem_distsql_max_bucket + type: double + description: > + Memory usage per sql statement for distsql + - name: prometheus.metrics.sql_mem_distsql_max_sum + type: double + description: > + Sum of Memory usage per sql statement for distsql + - name: prometheus.metrics.sql_mem_distsql_max_count + type: double + description: > + Count of Memory usage per sql statement for distsql + - name: prometheus.metrics.sql_mem_internal_current + type: double + description: > + Current sql statement memory usage for internal + - name: prometheus.metrics.sql_mem_internal_max_bucket + type: double + description: > + Memory usage per sql statement for internal + - name: prometheus.metrics.sql_mem_internal_max_sum + type: double + description: > + Sum of Memory usage per sql statement for internal + - name: prometheus.metrics.sql_mem_internal_max_count + type: double + description: > + Count of Memory usage per sql statement for internal + - name: prometheus.metrics.sql_mem_internal_session_current + type: double + description: > + Current sql session memory usage for internal + - name: prometheus.metrics.sql_mem_internal_session_max_bucket + type: double + description: > + Memory usage per sql session for internal + - name: prometheus.metrics.sql_mem_internal_session_max_sum + type: double + description: > + Sum of Memory usage per sql session for internal + - name: prometheus.metrics.sql_mem_internal_session_max_count + type: double + description: > + Count of Memory usage per sql session for internal + - name: prometheus.metrics.sql_mem_internal_txn_current + type: double + description: > + Current sql transaction memory usage for internal + - name: prometheus.metrics.sql_mem_internal_txn_max_bucket + type: double + description: > + Memory usage per sql transaction for internal + - name: prometheus.metrics.sql_mem_internal_txn_max_sum + type: double + description: > + Sum of Memory usage per sql transaction for internal + - name: prometheus.metrics.sql_mem_internal_txn_max_count + type: double + description: > + Count of Memory usage per sql transaction for internal + - name: prometheus.metrics.sql_mem_sql_current + type: double + description: > + Current sql statement memory usage for sql + - name: prometheus.metrics.sql_mem_sql_max_bucket + type: double + description: > + Memory usage per sql statement for sql + - name: prometheus.metrics.sql_mem_sql_max_sum + type: double + description: > + Sum of Memory usage per sql statement for sql + - name: prometheus.metrics.sql_mem_sql_max_count + type: double + description: > + Count of Memory usage per sql statement for sql + - name: prometheus.metrics.sql_mem_sql_session_current + type: double + description: > + Current sql session memory usage for sql + - name: prometheus.metrics.sql_mem_sql_session_max_bucket + type: double + description: > + Memory usage per sql session for sql + - name: prometheus.metrics.sql_mem_sql_session_max_sum + type: double + description: > + Sum of Memory usage per sql session for sql + - name: prometheus.metrics.sql_mem_sql_session_max_count + type: double + description: > + Count of Memory usage per sql session for sql + - name: prometheus.metrics.sql_mem_sql_txn_current + type: double + description: > + Current sql transaction memory usage for sql + - name: prometheus.metrics.sql_mem_sql_txn_max_bucket + type: double + description: > + Memory usage per sql transaction for sql + - name: prometheus.metrics.sql_mem_sql_txn_max_sum + type: double + description: > + Sum of Memory usage per sql transaction for sql + - name: prometheus.metrics.sql_mem_sql_txn_max_count + type: double + description: > + Count of Memory usage per sql transaction for sql + - name: prometheus.metrics.sql_misc_count + type: double + description: > + Number of other SQL statements + - name: prometheus.metrics.sql_misc_count_internal + type: double + description: > + Number of other SQL statements (internal queries) + - name: prometheus.metrics.sql_optimizer_count + type: double + description: > + Number of statements which ran with the cost-based optimizer + - name: prometheus.metrics.sql_optimizer_count_internal + type: double + description: > + Number of statements which ran with the cost-based optimizer (internal queries) + - name: prometheus.metrics.sql_optimizer_fallback_count + type: double + description: > + Number of statements which the cost-based optimizer was unable to plan + - name: prometheus.metrics.sql_optimizer_fallback_count_internal + type: double + description: > + Number of statements which the cost-based optimizer was unable to plan (internal queries) + - name: prometheus.metrics.sql_optimizer_plan_cache_hits + type: double + description: > + Number of non-prepared statements for which a cached plan was used + - name: prometheus.metrics.sql_optimizer_plan_cache_hits_internal + type: double + description: > + Number of non-prepared statements for which a cached plan was used (internal queries) + - name: prometheus.metrics.sql_optimizer_plan_cache_misses + type: double + description: > + Number of non-prepared statements for which a cached plan was not used + - name: prometheus.metrics.sql_optimizer_plan_cache_misses_internal + type: double + description: > + Number of non-prepared statements for which a cached plan was not used (internal queries) + - name: prometheus.metrics.sql_query_count + type: double + description: > + Number of SQL queries + - name: prometheus.metrics.sql_query_count_internal + type: double + description: > + Number of SQL queries (internal queries) + - name: prometheus.metrics.sql_restart_savepoint_count + type: double + description: > + Number of `SAVEPOINT cockroach_restart` statements + - name: prometheus.metrics.sql_restart_savepoint_count_internal + type: double + description: > + Number of `SAVEPOINT cockroach_restart` statements (internal queries) + - name: prometheus.metrics.sql_restart_savepoint_release_count + type: double + description: > + Number of `RELEASE SAVEPOINT cockroach_restart` statements + - name: prometheus.metrics.sql_restart_savepoint_release_count_internal + type: double + description: > + Number of `RELEASE SAVEPOINT cockroach_restart` statements (internal queries) + - name: prometheus.metrics.sql_restart_savepoint_rollback_count + type: double + description: > + Number of `ROLLBACK TO SAVEPOINT cockroach_restart` statements + - name: prometheus.metrics.sql_restart_savepoint_rollback_count_internal + type: double + description: > + Number of `ROLLBACK TO SAVEPOINT cockroach_restart` statements (internal queries) + - name: prometheus.metrics.sql_savepoint_count + type: double + description: > + Number of SQL SAVEPOINT statements + - name: prometheus.metrics.sql_savepoint_count_internal + type: double + description: > + Number of SQL SAVEPOINT statements (internal queries) + - name: prometheus.metrics.sql_select_count + type: double + description: > + Number of SQL SELECT statements + - name: prometheus.metrics.sql_select_count_internal + type: double + description: > + Number of SQL SELECT statements (internal queries) + - name: prometheus.metrics.sql_service_latency_bucket + type: double + description: > + Latency of SQL request execution + - name: prometheus.metrics.sql_service_latency_sum + type: double + description: > + Sum of Latency of SQL request execution + - name: prometheus.metrics.sql_service_latency_count + type: double + description: > + Count of Latency of SQL request execution + - name: prometheus.metrics.sql_service_latency_internal_bucket + type: double + description: > + Latency of SQL request execution (internal queries) + - name: prometheus.metrics.sql_service_latency_internal_sum + type: double + description: > + Sum of Latency of SQL request execution (internal queries) + - name: prometheus.metrics.sql_service_latency_internal_count + type: double + description: > + Count of Latency of SQL request execution (internal queries) + - name: prometheus.metrics.sql_txn_abort_count + type: double + description: > + Number of SQL transaction abort errors + - name: prometheus.metrics.sql_txn_abort_count_internal + type: double + description: > + Number of SQL transaction abort errors (internal queries) + - name: prometheus.metrics.sql_txn_begin_count + type: double + description: > + Number of SQL transaction BEGIN statements + - name: prometheus.metrics.sql_txn_begin_count_internal + type: double + description: > + Number of SQL transaction BEGIN statements (internal queries) + - name: prometheus.metrics.sql_txn_commit_count + type: double + description: > + Number of SQL transaction COMMIT statements + - name: prometheus.metrics.sql_txn_commit_count_internal + type: double + description: > + Number of SQL transaction COMMIT statements (internal queries) + - name: prometheus.metrics.sql_txn_rollback_count + type: double + description: > + Number of SQL transaction ROLLBACK statements + - name: prometheus.metrics.sql_txn_rollback_count_internal + type: double + description: > + Number of SQL transaction ROLLBACK statements (internal queries) + - name: prometheus.metrics.sql_update_count + type: double + description: > + Number of SQL UPDATE statements + - name: prometheus.metrics.sql_update_count_internal + type: double + description: > + Number of SQL UPDATE statements (internal queries) + - name: prometheus.metrics.sys_cgo_allocbytes + type: double + description: > + Current bytes of memory allocated by cgo + - name: prometheus.metrics.sys_cgo_totalbytes + type: double + description: > + Total bytes of memory allocated by cgo, but not released + - name: prometheus.metrics.sys_cgocalls + type: double + description: > + Total number of cgo calls + - name: prometheus.metrics.sys_cpu_combined_percent_normalized + type: double + description: > + Current user+system cpu percentage, normalized 0-1 by number of cores + - name: prometheus.metrics.sys_cpu_sys_ns + type: double + description: > + Total system cpu time + - name: prometheus.metrics.sys_cpu_sys_percent + type: double + description: > + Current system cpu percentage + - name: prometheus.metrics.sys_cpu_user_ns + type: double + description: > + Total user cpu time + - name: prometheus.metrics.sys_cpu_user_percent + type: double + description: > + Current user cpu percentage + - name: prometheus.metrics.sys_fd_open + type: double + description: > + Process open file descriptors + - name: prometheus.metrics.sys_fd_softlimit + type: double + description: > + Process open FD soft limit + - name: prometheus.metrics.sys_gc_count + type: double + description: > + Total number of GC runs + - name: prometheus.metrics.sys_gc_pause_ns + type: double + description: > + Total GC pause + - name: prometheus.metrics.sys_gc_pause_percent + type: double + description: > + Current GC pause percentage + - name: prometheus.metrics.sys_go_allocbytes + type: double + description: > + Current bytes of memory allocated by go + - name: prometheus.metrics.sys_go_totalbytes + type: double + description: > + Total bytes of memory allocated by go, but not released + - name: prometheus.metrics.sys_goroutines + type: double + description: > + Current number of goroutines + - name: prometheus.metrics.sys_host_disk_io_time + type: double + description: > + Time spent reading from or writing to all disks since this process started + - name: prometheus.metrics.sys_host_disk_iopsinprogress + type: double + description: > + IO operations currently in progress on this host + - name: prometheus.metrics.sys_host_disk_read_bytes + type: double + description: > + Bytes read from all disks since this process started + - name: prometheus.metrics.sys_host_disk_read_count + type: double + description: > + Disk read operations across all disks since this process started + - name: prometheus.metrics.sys_host_disk_read_time + type: double + description: > + Time spent reading from all disks since this process started + - name: prometheus.metrics.sys_host_disk_weightedio_time + type: double + description: > + Weighted time spent reading from or writing to to all disks since this process started + - name: prometheus.metrics.sys_host_disk_write_bytes + type: double + description: > + Bytes written to all disks since this process started + - name: prometheus.metrics.sys_host_disk_write_count + type: double + description: > + Disk write operations across all disks since this process started + - name: prometheus.metrics.sys_host_disk_write_time + type: double + description: > + Time spent writing to all disks since this process started + - name: prometheus.metrics.sys_host_net_recv_bytes + type: double + description: > + Bytes received on all network interfaces since this process started + - name: prometheus.metrics.sys_host_net_recv_packets + type: double + description: > + Packets received on all network interfaces since this process started + - name: prometheus.metrics.sys_host_net_send_bytes + type: double + description: > + Bytes sent on all network interfaces since this process started + - name: prometheus.metrics.sys_host_net_send_packets + type: double + description: > + Packets sent on all network interfaces since this process started + - name: prometheus.metrics.sys_rss + type: double + description: > + Current process RSS + - name: prometheus.metrics.sys_uptime + type: double + description: > + Process uptime + - name: prometheus.metrics.sysbytes + type: double + description: > + Number of bytes in system KV pairs + - name: prometheus.metrics.syscount + type: double + description: > + Count of system KV pairs + - name: prometheus.metrics.timeseries_write_bytes + type: double + description: > + Total size in bytes of metric samples written to disk + - name: prometheus.metrics.timeseries_write_errors + type: double + description: > + Total errors encountered while attempting to write metrics to disk + - name: prometheus.metrics.timeseries_write_samples + type: double + description: > + Total number of metric samples written to disk + - name: prometheus.metrics.totalbytes + type: double + description: > + Total number of bytes taken up by keys and values including non-live data + - name: prometheus.metrics.tscache_skl_read_pages + type: double + description: > + Number of pages in the read timestamp cache + - name: prometheus.metrics.tscache_skl_read_rotations + type: double + description: > + Number of page rotations in the read timestamp cache + - name: prometheus.metrics.tscache_skl_write_pages + type: double + description: > + Number of pages in the write timestamp cache + - name: prometheus.metrics.tscache_skl_write_rotations + type: double + description: > + Number of page rotations in the write timestamp cache + - name: prometheus.metrics.txn_aborts + type: double + description: > + Number of aborted KV transactions + - name: prometheus.metrics.txn_autoretries + type: double + description: > + Number of automatic retries to avoid serializable restarts + - name: prometheus.metrics.txn_commits + type: double + description: > + Number of committed KV transactions (including 1PC) + - name: prometheus.metrics.txn_commits1PC + type: double + description: > + Number of committed one-phase KV transactions + - name: prometheus.metrics.txn_durations_bucket + type: double + description: > + KV transaction durations + - name: prometheus.metrics.txn_durations_sum + type: double + description: > + Sum of KV transaction durations + - name: prometheus.metrics.txn_durations_count + type: double + description: > + Count of KV transaction durations + - name: prometheus.metrics.txn_restarts_bucket + type: double + description: > + Number of restarted KV transactions + - name: prometheus.metrics.txn_restarts_sum + type: double + description: > + Sum of Number of restarted KV transactions + - name: prometheus.metrics.txn_restarts_count + type: double + description: > + Count of Number of restarted KV transactions + - name: prometheus.metrics.txn_restarts_asyncwritefailure + type: double + description: > + Number of restarts due to async consensus writes that failed to leave intents + - name: prometheus.metrics.txn_restarts_possiblereplay + type: double + description: > + Number of restarts due to possible replays of command batches at the storage layer + - name: prometheus.metrics.txn_restarts_readwithinuncertainty + type: double + description: > + Number of restarts due to reading a new value within the uncertainty interval + - name: prometheus.metrics.txn_restarts_serializable + type: double + description: > + Number of restarts due to a forwarded commit timestamp and isolation=SERIALIZABLE + - name: prometheus.metrics.txn_restarts_txnaborted + type: double + description: > + Number of restarts due to an abort by a concurrent transaction (usually due to deadlock) + - name: prometheus.metrics.txn_restarts_txnpush + type: double + description: > + Number of restarts due to a transaction push failure + - name: prometheus.metrics.txn_restarts_unknown + type: double + description: > + Number of restarts due to a unknown reasons + - name: prometheus.metrics.txn_restarts_writetooold + type: double + description: > + Number of restarts due to a concurrent writer committing first + - name: prometheus.metrics.txn_restarts_writetoooldmulti + type: double + description: > + Number of restarts due to multiple concurrent writers committing first + - name: prometheus.metrics.txnwaitqueue_deadlocks_total + type: double + description: > + Number of deadlocks detected by the txn wait queue + - name: prometheus.metrics.txnwaitqueue_pushee_waiting + type: double + description: > + Number of pushees on the txn wait queue + - name: prometheus.metrics.txnwaitqueue_pusher_slow + type: double + description: > + The total number of cases where a pusher waited more than the excessive wait threshold + - name: prometheus.metrics.txnwaitqueue_pusher_wait_time_bucket + type: double + description: > + Histogram of durations spent in queue by pushers + - name: prometheus.metrics.txnwaitqueue_pusher_wait_time_sum + type: double + description: > + Sum of Histogram of durations spent in queue by pushers + - name: prometheus.metrics.txnwaitqueue_pusher_wait_time_count + type: double + description: > + Count of Histogram of durations spent in queue by pushers + - name: prometheus.metrics.txnwaitqueue_pusher_waiting + type: double + description: > + Number of pushers on the txn wait queue + - name: prometheus.metrics.txnwaitqueue_query_wait_time_bucket + type: double + description: > + Histogram of durations spent in queue by queries + - name: prometheus.metrics.txnwaitqueue_query_wait_time_sum + type: double + description: > + Sum of Histogram of durations spent in queue by queries + - name: prometheus.metrics.txnwaitqueue_query_wait_time_count + type: double + description: > + Count of Histogram of durations spent in queue by queries + - name: prometheus.metrics.txnwaitqueue_query_waiting + type: double + description: > + Number of transaction status queries waiting for an updated transaction record + - name: prometheus.metrics.valbytes + type: double + description: > + Number of bytes taken up by values + - name: prometheus.metrics.valcount + type: double + description: > + Count of all values + - name: cockroachdb + type: group + fields: diff --git a/x-pack/metricbeat/module/cockroachdb/fields.go b/x-pack/metricbeat/module/cockroachdb/fields.go index 1bf66b84593f..9de470a87f06 100644 --- a/x-pack/metricbeat/module/cockroachdb/fields.go +++ b/x-pack/metricbeat/module/cockroachdb/fields.go @@ -19,5 +19,5 @@ func init() { // AssetCockroachdb returns asset data. // This is the base64 encoded gzipped contents of module/cockroachdb. func AssetCockroachdb() string { - return "eJxczjsOwjAQhOHepxi5SUMusAUFcAtE4dhLYsWxLe+myO0RLykw5Uif9PeYeSP44udWnJ/CYACNmpjQnb/v5dQZoHFiJ0wYWJ0BAotvsWosmXA0ALATWEpYExtAWDXmUQhXK5LsAXZSrfZmgHvkFIReuEd2C//HPKdbZcLYylo/z9697W/dIwAA//+zakEu" + return "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" }