> ## Documentation Index
> Fetch the complete documentation index at: https://cockroachlabs.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Cluster Metric Scopes with Cluster Virtualization enabled

export const InternalLink = ({version, path = "", children, ...props}) => {
  let detectedVersion = version || "stable";
  if (typeof window !== 'undefined' && !version) {
    const match = window.location.pathname.match(/\/docs\/([^/]+)/);
    if (match) {
      detectedVersion = match[1];
    }
  }
  const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
  return <a href={`/docs/${detectedVersion}/${normalizedPath}`} {...props}>
      {children}
    </a>;
};

Refer to the <InternalLink path="cluster-virtualization-overview#known-limitations">Cluster Virtualization Overview</InternalLink> for further detail.
When <InternalLink path="cluster-virtualization-overview">cluster virtualization</InternalLink> is enabled, each metric has a scope. For descriptions and details about each cluster metric, refer to <InternalLink path="metrics">Metrics</InternalLink>.

* When a metric is scoped to a non-system virtual cluster, the metric is tracked separately for each virtual cluster (including the system virtual cluster). Most metrics are scoped to a virtual cluster. Refer to [Metrics scoped to a virtual cluster](#metrics-scoped-to-a-virtual-cluster).
* When a metric is scoped to the system virtual cluster, it is included only in the metrics for the system virtual cluster. These metrics provide information about the underlying CockroachDB cluster's performance. Refer to [Metrics scoped to the system virtual cluster](#metrics-scoped-to-the-system-virtual-cluster).

<Note>
  To retrieve both system (node-level) and virtual cluster metrics, scrape the <InternalLink path="monitoring-and-alerting#prometheus-endpoint">Prometheus endpoint</InternalLink> with the `cluster=system` query parameter. If you set the <InternalLink path="cluster-settings">`server.controller.default_target_cluster` cluster setting</InternalLink>, the endpoint without this parameter exposes metrics only for the specified virtual cluster.
</Note>

## Metrics scoped to a virtual cluster

* `auth.cert.conn.latency`
* `auth.gss.conn.latency`
* `auth.jwt.conn.latency`
* `auth.ldap.conn.latency`
* `auth.password.conn.latency`
* `auth.scram.conn.latency`
* `backup.last-failed-time.kms-inaccessible`
* `changefeed.admit_latency`
* `changefeed.aggregator_progress`
* `changefeed.backfill_count`
* `changefeed.backfill_pending_ranges`
* `changefeed.batch_reduction_count`
* `changefeed.buffer_entries_mem.acquired`
* `changefeed.buffer_entries_mem.acquired.aggregator`
* `changefeed.buffer_entries_mem.acquired.rangefeed`
* `changefeed.buffer_entries_mem.released`
* `changefeed.buffer_entries_mem.released.aggregator`
* `changefeed.buffer_entries_mem.released.rangefeed`
* `changefeed.buffer_entries.allocated_mem`
* `changefeed.buffer_entries.allocated_mem.aggregator`
* `changefeed.buffer_entries.allocated_mem.rangefeed`
* `changefeed.buffer_entries.flush`
* `changefeed.buffer_entries.flush.aggregator`
* `changefeed.buffer_entries.flush.rangefeed`
* `changefeed.buffer_entries.in`
* `changefeed.buffer_entries.in.aggregator`
* `changefeed.buffer_entries.in.rangefeed`
* `changefeed.buffer_entries.kv`
* `changefeed.buffer_entries.kv.aggregator`
* `changefeed.buffer_entries.kv.rangefeed`
* `changefeed.buffer_entries.out`
* `changefeed.buffer_entries.out.aggregator`
* `changefeed.buffer_entries.out.rangefeed`
* `changefeed.buffer_entries.released`
* `changefeed.buffer_entries.released.aggregator`
* `changefeed.buffer_entries.released.rangefeed`
* `changefeed.buffer_entries.resolved`
* `changefeed.buffer_entries.resolved.aggregator`
* `changefeed.buffer_entries.resolved.rangefeed`
* `changefeed.buffer_pushback_nanos`
* `changefeed.buffer_pushback_nanos.aggregator`
* `changefeed.buffer_pushback_nanos.rangefeed`
* `changefeed.bytes.messages_pushback_nanos`
* `changefeed.checkpoint_hist_nanos`
* `changefeed.checkpoint_progress`
* `changefeed.cloudstorage_buffered_bytes`
* `changefeed.commit_latency`
* `changefeed.emitted_batch_sizes`
* `changefeed.emitted_bytes`
* `changefeed.emitted_messages`
* `changefeed.error_retries`
* `changefeed.failures`
* `changefeed.filtered_messages`
* `changefeed.flush_hist_nanos`
* `changefeed.flush.messages_pushback_nanos`
* `changefeed.flushed_bytes`
* `changefeed.flushes`
* `changefeed.forwarded_resolved_messages`
* `changefeed.frontier_updates`
* `changefeed.internal_retry_message_count`
* `changefeed.kafka_throttling_hist_nanos`
* `changefeed.lagging_ranges`
* `changefeed.max_behind_nanos`
* `changefeed.message_size_hist`
* `changefeed.messages.messages_pushback_nanos`
* `changefeed.network.bytes_in`
* `changefeed.network.bytes_out`
* `changefeed.nprocs_consume_event_nanos`
* `changefeed.nprocs_flush_nanos`
* `changefeed.nprocs_in_flight_count`
* `changefeed.parallel_io_in_flight_keys`
* `changefeed.parallel_io_pending_rows`
* `changefeed.parallel_io_queue_nanos`
* `changefeed.parallel_io_result_queue_nanos`
* `changefeed.queue_time_nanos`
* `changefeed.running`
* `changefeed.schema_registry.registrations`
* `changefeed.schema_registry.retry_count`
* `changefeed.schemafeed.table_history_scans`
* `changefeed.schemafeed.table_metadata_nanos`
* `changefeed.sink_batch_hist_nanos`
* `changefeed.sink_errors`
* `changefeed.sink_io_inflight`
* `changefeed.size_based_flushes`
* `changefeed.total_ranges`
* `changefeed.usage.error_count`
* `changefeed.usage.query_duration`
* `changefeed.usage.table_bytes`
* `clock-offset.meannanos`
* `clock-offset.stddevnanos`
* `cloud.conns_opened`
* `cloud.conns_reused`
* `cloud.listing_results`
* `cloud.listings`
* `cloud.open_readers`
* `cloud.open_writers`
* `cloud.read_bytes`
* `cloud.readers_opened`
* `cloud.tls_handshakes`
* `cloud.write_bytes`
* `cloud.writers_opened`
* `cluster.preserve-downgrade-option.last-updated`
* `distsender.batch_requests.cross_region.bytes`
* `distsender.batch_requests.cross_zone.bytes`
* `distsender.batch_requests.replica_addressed.bytes`
* `distsender.batch_responses.cross_region.bytes`
* `distsender.batch_responses.cross_zone.bytes`
* `distsender.batch_responses.replica_addressed.bytes`
* `distsender.batches`
* `distsender.batches.async.sent`
* `distsender.batches.async.throttled`
* `distsender.batches.partial`
* `distsender.circuit_breaker.replicas.count`
* `distsender.circuit_breaker.replicas.probes.failure`
* `distsender.circuit_breaker.replicas.probes.running`
* `distsender.circuit_breaker.replicas.probes.success`
* `distsender.circuit_breaker.replicas.requests.cancelled`
* `distsender.circuit_breaker.replicas.requests.rejected`
* `distsender.circuit_breaker.replicas.tripped`
* `distsender.circuit_breaker.replicas.tripped_events`
* `distsender.errors.inleasetransferbackoffs`
* `distsender.errors.notleaseholder`
* `distsender.rangefeed.catchup_ranges`
* `distsender.rangefeed.error_catchup_ranges`
* `distsender.rangefeed.local_ranges`
* `distsender.rangefeed.restart_ranges`
* `distsender.rangefeed.retry.logical_ops_missing`
* `distsender.rangefeed.retry.manual_range_split`
* `distsender.rangefeed.retry.no_leaseholder`
* `distsender.rangefeed.retry.node_not_found`
* `distsender.rangefeed.retry.raft_snapshot`
* `distsender.rangefeed.retry.range_key_mismatch`
* `distsender.rangefeed.retry.range_merged`
* `distsender.rangefeed.retry.range_not_found`
* `distsender.rangefeed.retry.range_split`
* `distsender.rangefeed.retry.rangefeed_closed`
* `distsender.rangefeed.retry.replica_removed`
* `distsender.rangefeed.retry.send`
* `distsender.rangefeed.retry.slow_consumer`
* `distsender.rangefeed.retry.store_not_found`
* `distsender.rangefeed.total_ranges`
* `distsender.rangelookups`
* `distsender.rpc.addsstable.sent`
* `distsender.rpc.adminchangereplicas.sent`
* `distsender.rpc.adminmerge.sent`
* `distsender.rpc.adminrelocaterange.sent`
* `distsender.rpc.adminscatter.sent`
* `distsender.rpc.adminsplit.sent`
* `distsender.rpc.admintransferlease.sent`
* `distsender.rpc.adminunsplit.sent`
* `distsender.rpc.adminverifyprotectedtimestamp.sent`
* `distsender.rpc.barrier.sent`
* `distsender.rpc.checkconsistency.sent`
* `distsender.rpc.clearrange.sent`
* `distsender.rpc.computechecksum.sent`
* `distsender.rpc.conditionalput.sent`
* `distsender.rpc.delete.sent`
* `distsender.rpc.deleterange.sent`
* `distsender.rpc.endtxn.sent`
* `distsender.rpc.err.ambiguousresulterrtype`
* `distsender.rpc.err.batchtimestampbeforegcerrtype`
* `distsender.rpc.err.communicationerrtype`
* `distsender.rpc.err.conditionfailederrtype`
* `distsender.rpc.err.errordetailtype(0)`
* `distsender.rpc.err.errordetailtype(15)`
* `distsender.rpc.err.errordetailtype(19)`
* `distsender.rpc.err.errordetailtype(20)`
* `distsender.rpc.err.errordetailtype(21)`
* `distsender.rpc.err.errordetailtype(23)`
* `distsender.rpc.err.errordetailtype(24)`
* `distsender.rpc.err.errordetailtype(29)`
* `distsender.rpc.err.errordetailtype(30)`
* `distsender.rpc.err.errordetailtype(33)`
* `distsender.rpc.err.indeterminatecommiterrtype`
* `distsender.rpc.err.integeroverflowerrtype`
* `distsender.rpc.err.intentmissingerrtype`
* `distsender.rpc.err.internalerrtype`
* `distsender.rpc.err.invalidleaseerrtype`
* `distsender.rpc.err.leaserejectederrtype`
* `distsender.rpc.err.lockconflicterrtype`
* `distsender.rpc.err.mergeinprogresserrtype`
* `distsender.rpc.err.mintimestampboundunsatisfiableerrtype`
* `distsender.rpc.err.mvcchistorymutationerrtype`
* `distsender.rpc.err.nodeunavailableerrtype`
* `distsender.rpc.err.notleaseholdererrtype`
* `distsender.rpc.err.oprequirestxnerrtype`
* `distsender.rpc.err.optimisticevalconflictserrtype`
* `distsender.rpc.err.proxyfailederrtype`
* `distsender.rpc.err.raftgroupdeletederrtype`
* `distsender.rpc.err.rangefeedretryerrtype`
* `distsender.rpc.err.rangekeymismatcherrtype`
* `distsender.rpc.err.rangenotfounderrtype`
* `distsender.rpc.err.readwithinuncertaintyintervalerrtype`
* `distsender.rpc.err.refreshfailederrtype`
* `distsender.rpc.err.replicacorruptionerrtype`
* `distsender.rpc.err.replicatooolderrtype`
* `distsender.rpc.err.replicaunavailableerrtype`
* `distsender.rpc.err.storenotfounderrtype`
* `distsender.rpc.err.transactionabortederrtype`
* `distsender.rpc.err.transactionpusherrtype`
* `distsender.rpc.err.transactionretryerrtype`
* `distsender.rpc.err.transactionretrywithprotorefresherrtype`
* `distsender.rpc.err.transactionstatuserrtype`
* `distsender.rpc.err.txnalreadyencounterederrtype`
* `distsender.rpc.err.unsupportedrequesterrtype`
* `distsender.rpc.err.writeintenterrtype`
* `distsender.rpc.err.writetooolderrtype`
* `distsender.rpc.export.sent`
* `distsender.rpc.gc.sent`
* `distsender.rpc.get.sent`
* `distsender.rpc.heartbeattxn.sent`
* `distsender.rpc.increment.sent`
* `distsender.rpc.initput.sent`
* `distsender.rpc.isspanempty.sent`
* `distsender.rpc.leaseinfo.sent`
* `distsender.rpc.linkexternalsstable.sent`
* `distsender.rpc.merge.sent`
* `distsender.rpc.migrate.sent`
* `distsender.rpc.probe.sent`
* `distsender.rpc.proxy.err`
* `distsender.rpc.proxy.forward.err`
* `distsender.rpc.proxy.forward.sent`
* `distsender.rpc.proxy.sent`
* `distsender.rpc.pushtxn.sent`
* `distsender.rpc.put.sent`
* `distsender.rpc.queryintent.sent`
* `distsender.rpc.querylocks.sent`
* `distsender.rpc.queryresolvedtimestamp.sent`
* `distsender.rpc.querytxn.sent`
* `distsender.rpc.rangestats.sent`
* `distsender.rpc.recomputestats.sent`
* `distsender.rpc.recovertxn.sent`
* `distsender.rpc.refresh.sent`
* `distsender.rpc.refreshrange.sent`
* `distsender.rpc.requestlease.sent`
* `distsender.rpc.resolveintent.sent`
* `distsender.rpc.resolveintentrange.sent`
* `distsender.rpc.reversescan.sent`
* `distsender.rpc.revertrange.sent`
* `distsender.rpc.scan.sent`
* `distsender.rpc.sent`
* `distsender.rpc.sent.local`
* `distsender.rpc.sent.nextreplicaerror`
* `distsender.rpc.subsume.sent`
* `distsender.rpc.transferlease.sent`
* `distsender.rpc.truncatelog.sent`
* `distsender.rpc.writebatch.sent`
* `distsender.slow.replicarpcs`
* `jobs.adopt_iterations`
* `jobs.auto_config_env_runner.currently_idle`
* `jobs.auto_config_env_runner.currently_paused`
* `jobs.auto_config_env_runner.currently_running`
* `jobs.auto_config_env_runner.expired_pts_records`
* `jobs.auto_config_env_runner.fail_or_cancel_completed`
* `jobs.auto_config_env_runner.fail_or_cancel_failed`
* `jobs.auto_config_env_runner.fail_or_cancel_retry_error`
* `jobs.auto_config_env_runner.protected_age_sec`
* `jobs.auto_config_env_runner.protected_record_count`
* `jobs.auto_config_env_runner.resume_completed`
* `jobs.auto_config_env_runner.resume_failed`
* `jobs.auto_config_env_runner.resume_retry_error`
* `jobs.auto_config_runner.currently_idle`
* `jobs.auto_config_runner.currently_paused`
* `jobs.auto_config_runner.currently_running`
* `jobs.auto_config_runner.expired_pts_records`
* `jobs.auto_config_runner.fail_or_cancel_completed`
* `jobs.auto_config_runner.fail_or_cancel_failed`
* `jobs.auto_config_runner.fail_or_cancel_retry_error`
* `jobs.auto_config_runner.protected_age_sec`
* `jobs.auto_config_runner.protected_record_count`
* `jobs.auto_config_runner.resume_completed`
* `jobs.auto_config_runner.resume_failed`
* `jobs.auto_config_runner.resume_retry_error`
* `jobs.auto_config_task.currently_idle`
* `jobs.auto_config_task.currently_paused`
* `jobs.auto_config_task.currently_running`
* `jobs.auto_config_task.expired_pts_records`
* `jobs.auto_config_task.fail_or_cancel_completed`
* `jobs.auto_config_task.fail_or_cancel_failed`
* `jobs.auto_config_task.fail_or_cancel_retry_error`
* `jobs.auto_config_task.protected_age_sec`
* `jobs.auto_config_task.protected_record_count`
* `jobs.auto_config_task.resume_completed`
* `jobs.auto_config_task.resume_failed`
* `jobs.auto_config_task.resume_retry_error`
* `jobs.auto_create_partial_stats.currently_idle`
* `jobs.auto_create_partial_stats.currently_paused`
* `jobs.auto_create_partial_stats.currently_running`
* `jobs.auto_create_partial_stats.expired_pts_records`
* `jobs.auto_create_partial_stats.fail_or_cancel_completed`
* `jobs.auto_create_partial_stats.fail_or_cancel_failed`
* `jobs.auto_create_partial_stats.fail_or_cancel_retry_error`
* `jobs.auto_create_partial_stats.protected_age_sec`
* `jobs.auto_create_partial_stats.protected_record_count`
* `jobs.auto_create_partial_stats.resume_completed`
* `jobs.auto_create_partial_stats.resume_failed`
* `jobs.auto_create_partial_stats.resume_retry_error`
* `jobs.auto_create_stats.currently_idle`
* `jobs.auto_create_stats.currently_paused`
* `jobs.auto_create_stats.currently_running`
* `jobs.auto_create_stats.expired_pts_records`
* `jobs.auto_create_stats.fail_or_cancel_completed`
* `jobs.auto_create_stats.fail_or_cancel_failed`
* `jobs.auto_create_stats.fail_or_cancel_retry_error`
* `jobs.auto_create_stats.protected_age_sec`
* `jobs.auto_create_stats.protected_record_count`
* `jobs.auto_create_stats.resume_completed`
* `jobs.auto_create_stats.resume_failed`
* `jobs.auto_create_stats.resume_retry_error`
* `jobs.auto_schema_telemetry.currently_idle`
* `jobs.auto_schema_telemetry.currently_paused`
* `jobs.auto_schema_telemetry.currently_running`
* `jobs.auto_schema_telemetry.expired_pts_records`
* `jobs.auto_schema_telemetry.fail_or_cancel_completed`
* `jobs.auto_schema_telemetry.fail_or_cancel_failed`
* `jobs.auto_schema_telemetry.fail_or_cancel_retry_error`
* `jobs.auto_schema_telemetry.protected_age_sec`
* `jobs.auto_schema_telemetry.protected_record_count`
* `jobs.auto_schema_telemetry.resume_completed`
* `jobs.auto_schema_telemetry.resume_failed`
* `jobs.auto_schema_telemetry.resume_retry_error`
* `jobs.auto_span_config_reconciliation.currently_idle`
* `jobs.auto_span_config_reconciliation.currently_paused`
* `jobs.auto_span_config_reconciliation.currently_running`
* `jobs.auto_span_config_reconciliation.expired_pts_records`
* `jobs.auto_span_config_reconciliation.fail_or_cancel_completed`
* `jobs.auto_span_config_reconciliation.fail_or_cancel_failed`
* `jobs.auto_span_config_reconciliation.fail_or_cancel_retry_error`
* `jobs.auto_span_config_reconciliation.protected_age_sec`
* `jobs.auto_span_config_reconciliation.protected_record_count`
* `jobs.auto_span_config_reconciliation.resume_completed`
* `jobs.auto_span_config_reconciliation.resume_failed`
* `jobs.auto_span_config_reconciliation.resume_retry_error`
* `jobs.auto_sql_stats_compaction.currently_idle`
* `jobs.auto_sql_stats_compaction.currently_paused`
* `jobs.auto_sql_stats_compaction.currently_running`
* `jobs.auto_sql_stats_compaction.expired_pts_records`
* `jobs.auto_sql_stats_compaction.fail_or_cancel_completed`
* `jobs.auto_sql_stats_compaction.fail_or_cancel_failed`
* `jobs.auto_sql_stats_compaction.fail_or_cancel_retry_error`
* `jobs.auto_sql_stats_compaction.protected_age_sec`
* `jobs.auto_sql_stats_compaction.protected_record_count`
* `jobs.auto_sql_stats_compaction.resume_completed`
* `jobs.auto_sql_stats_compaction.resume_failed`
* `jobs.auto_sql_stats_compaction.resume_retry_error`
* `jobs.auto_update_sql_activity.currently_idle`
* `jobs.auto_update_sql_activity.currently_paused`
* `jobs.auto_update_sql_activity.currently_running`
* `jobs.auto_update_sql_activity.expired_pts_records`
* `jobs.auto_update_sql_activity.fail_or_cancel_completed`
* `jobs.auto_update_sql_activity.fail_or_cancel_failed`
* `jobs.auto_update_sql_activity.fail_or_cancel_retry_error`
* `jobs.auto_update_sql_activity.protected_age_sec`
* `jobs.auto_update_sql_activity.protected_record_count`
* `jobs.auto_update_sql_activity.resume_completed`
* `jobs.auto_update_sql_activity.resume_failed`
* `jobs.auto_update_sql_activity.resume_retry_error`
* `jobs.backup.currently_idle`
* `jobs.backup.currently_paused`
* `jobs.backup.currently_running`
* `jobs.backup.expired_pts_records`
* `jobs.backup.fail_or_cancel_completed`
* `jobs.backup.fail_or_cancel_failed`
* `jobs.backup.fail_or_cancel_retry_error`
* `jobs.backup.protected_age_sec`
* `jobs.backup.protected_record_count`
* `jobs.backup.resume_completed`
* `jobs.backup.resume_failed`
* `jobs.backup.resume_retry_error`
* `jobs.changefeed.currently_idle`
* `jobs.changefeed.currently_paused`
* `jobs.changefeed.currently_running`
* `jobs.changefeed.expired_pts_records`
* `jobs.changefeed.fail_or_cancel_completed`
* `jobs.changefeed.fail_or_cancel_failed`
* `jobs.changefeed.fail_or_cancel_retry_error`
* `jobs.changefeed.protected_age_sec`
* `jobs.changefeed.protected_record_count`
* `jobs.changefeed.resume_completed`
* `jobs.changefeed.resume_failed`
* `jobs.changefeed.resume_retry_error`
* `jobs.claimed_jobs`
* `jobs.create_stats.currently_idle`
* `jobs.create_stats.currently_paused`
* `jobs.create_stats.currently_running`
* `jobs.create_stats.expired_pts_records`
* `jobs.create_stats.fail_or_cancel_completed`
* `jobs.create_stats.fail_or_cancel_failed`
* `jobs.create_stats.fail_or_cancel_retry_error`
* `jobs.create_stats.protected_age_sec`
* `jobs.create_stats.protected_record_count`
* `jobs.create_stats.resume_completed`
* `jobs.create_stats.resume_failed`
* `jobs.create_stats.resume_retry_error`
* `jobs.history_retention.currently_idle`
* `jobs.history_retention.currently_paused`
* `jobs.history_retention.currently_running`
* `jobs.history_retention.expired_pts_records`
* `jobs.history_retention.fail_or_cancel_completed`
* `jobs.history_retention.fail_or_cancel_failed`
* `jobs.history_retention.fail_or_cancel_retry_error`
* `jobs.history_retention.protected_age_sec`
* `jobs.history_retention.protected_record_count`
* `jobs.history_retention.resume_completed`
* `jobs.history_retention.resume_failed`
* `jobs.history_retention.resume_retry_error`
* `jobs.import_rollback.currently_idle`
* `jobs.import_rollback.currently_paused`
* `jobs.import_rollback.currently_running`
* `jobs.import_rollback.expired_pts_records`
* `jobs.import_rollback.fail_or_cancel_completed`
* `jobs.import_rollback.fail_or_cancel_failed`
* `jobs.import_rollback.fail_or_cancel_retry_error`
* `jobs.import_rollback.protected_age_sec`
* `jobs.import_rollback.protected_record_count`
* `jobs.import_rollback.resume_completed`
* `jobs.import_rollback.resume_failed`
* `jobs.import_rollback.resume_retry_error`
* `jobs.import.currently_idle`
* `jobs.import.currently_paused`
* `jobs.import.currently_running`
* `jobs.import.expired_pts_records`
* `jobs.import.fail_or_cancel_completed`
* `jobs.import.fail_or_cancel_failed`
* `jobs.import.fail_or_cancel_retry_error`
* `jobs.import.protected_age_sec`
* `jobs.import.protected_record_count`
* `jobs.import.resume_completed`
* `jobs.import.resume_failed`
* `jobs.import.resume_retry_error`
* `jobs.key_visualizer.currently_idle`
* `jobs.key_visualizer.currently_paused`
* `jobs.key_visualizer.currently_running`
* `jobs.key_visualizer.expired_pts_records`
* `jobs.key_visualizer.fail_or_cancel_completed`
* `jobs.key_visualizer.fail_or_cancel_failed`
* `jobs.key_visualizer.fail_or_cancel_retry_error`
* `jobs.key_visualizer.protected_age_sec`
* `jobs.key_visualizer.protected_record_count`
* `jobs.key_visualizer.resume_completed`
* `jobs.key_visualizer.resume_failed`
* `jobs.key_visualizer.resume_retry_error`
* `jobs.logical_replication.currently_idle`
* `jobs.logical_replication.currently_paused`
* `jobs.logical_replication.currently_running`
* `jobs.logical_replication.expired_pts_records`
* `jobs.logical_replication.fail_or_cancel_completed`
* `jobs.logical_replication.fail_or_cancel_failed`
* `jobs.logical_replication.fail_or_cancel_retry_error`
* `jobs.logical_replication.protected_age_sec`
* `jobs.logical_replication.protected_record_count`
* `jobs.logical_replication.resume_completed`
* `jobs.logical_replication.resume_failed`
* `jobs.logical_replication.resume_retry_error`
* `jobs.metrics.task_failed`
* `jobs.migration.currently_idle`
* `jobs.migration.currently_paused`
* `jobs.migration.currently_running`
* `jobs.migration.expired_pts_records`
* `jobs.migration.fail_or_cancel_completed`
* `jobs.migration.fail_or_cancel_failed`
* `jobs.migration.fail_or_cancel_retry_error`
* `jobs.migration.protected_age_sec`
* `jobs.migration.protected_record_count`
* `jobs.migration.resume_completed`
* `jobs.migration.resume_failed`
* `jobs.migration.resume_retry_error`
* `jobs.mvcc_statistics_update.currently_idle`
* `jobs.mvcc_statistics_update.currently_paused`
* `jobs.mvcc_statistics_update.currently_running`
* `jobs.mvcc_statistics_update.expired_pts_records`
* `jobs.mvcc_statistics_update.fail_or_cancel_completed`
* `jobs.mvcc_statistics_update.fail_or_cancel_failed`
* `jobs.mvcc_statistics_update.fail_or_cancel_retry_error`
* `jobs.mvcc_statistics_update.protected_age_sec`
* `jobs.mvcc_statistics_update.protected_record_count`
* `jobs.mvcc_statistics_update.resume_completed`
* `jobs.mvcc_statistics_update.resume_failed`
* `jobs.mvcc_statistics_update.resume_retry_error`
* `jobs.new_schema_change.currently_idle`
* `jobs.new_schema_change.currently_paused`
* `jobs.new_schema_change.currently_running`
* `jobs.new_schema_change.expired_pts_records`
* `jobs.new_schema_change.fail_or_cancel_completed`
* `jobs.new_schema_change.fail_or_cancel_failed`
* `jobs.new_schema_change.fail_or_cancel_retry_error`
* `jobs.new_schema_change.protected_age_sec`
* `jobs.new_schema_change.protected_record_count`
* `jobs.new_schema_change.resume_completed`
* `jobs.new_schema_change.resume_failed`
* `jobs.new_schema_change.resume_retry_error`
* `jobs.poll_jobs_stats.currently_idle`
* `jobs.poll_jobs_stats.currently_paused`
* `jobs.poll_jobs_stats.currently_running`
* `jobs.poll_jobs_stats.expired_pts_records`
* `jobs.poll_jobs_stats.fail_or_cancel_completed`
* `jobs.poll_jobs_stats.fail_or_cancel_failed`
* `jobs.poll_jobs_stats.fail_or_cancel_retry_error`
* `jobs.poll_jobs_stats.protected_age_sec`
* `jobs.poll_jobs_stats.protected_record_count`
* `jobs.poll_jobs_stats.resume_completed`
* `jobs.poll_jobs_stats.resume_failed`
* `jobs.poll_jobs_stats.resume_retry_error`
* `jobs.replication_stream_ingestion.currently_idle`
* `jobs.replication_stream_ingestion.currently_paused`
* `jobs.replication_stream_ingestion.currently_running`
* `jobs.replication_stream_ingestion.expired_pts_records`
* `jobs.replication_stream_ingestion.fail_or_cancel_completed`
* `jobs.replication_stream_ingestion.fail_or_cancel_failed`
* `jobs.replication_stream_ingestion.fail_or_cancel_retry_error`
* `jobs.replication_stream_ingestion.protected_age_sec`
* `jobs.replication_stream_ingestion.protected_record_count`
* `jobs.replication_stream_ingestion.resume_completed`
* `jobs.replication_stream_ingestion.resume_failed`
* `jobs.replication_stream_ingestion.resume_retry_error`
* `jobs.replication_stream_producer.currently_idle`
* `jobs.replication_stream_producer.currently_paused`
* `jobs.replication_stream_producer.currently_running`
* `jobs.replication_stream_producer.expired_pts_records`
* `jobs.replication_stream_producer.fail_or_cancel_completed`
* `jobs.replication_stream_producer.fail_or_cancel_failed`
* `jobs.replication_stream_producer.fail_or_cancel_retry_error`
* `jobs.replication_stream_producer.protected_age_sec`
* `jobs.replication_stream_producer.protected_record_count`
* `jobs.replication_stream_producer.resume_completed`
* `jobs.replication_stream_producer.resume_failed`
* `jobs.replication_stream_producer.resume_retry_error`
* `jobs.restore.currently_idle`
* `jobs.restore.currently_paused`
* `jobs.restore.currently_running`
* `jobs.restore.expired_pts_records`
* `jobs.restore.fail_or_cancel_completed`
* `jobs.restore.fail_or_cancel_failed`
* `jobs.restore.fail_or_cancel_retry_error`
* `jobs.restore.protected_age_sec`
* `jobs.restore.protected_record_count`
* `jobs.restore.resume_completed`
* `jobs.restore.resume_failed`
* `jobs.restore.resume_retry_error`
* `jobs.resumed_claimed_jobs`
* `jobs.row_level_ttl.currently_idle`
* `jobs.row_level_ttl.currently_paused`
* `jobs.row_level_ttl.currently_running`
* `jobs.row_level_ttl.delete_duration`
* `jobs.row_level_ttl.expired_pts_records`
* `jobs.row_level_ttl.fail_or_cancel_completed`
* `jobs.row_level_ttl.fail_or_cancel_failed`
* `jobs.row_level_ttl.fail_or_cancel_retry_error`
* `jobs.row_level_ttl.num_active_spans`
* `jobs.row_level_ttl.protected_age_sec`
* `jobs.row_level_ttl.protected_record_count`
* `jobs.row_level_ttl.resume_completed`
* `jobs.row_level_ttl.resume_failed`
* `jobs.row_level_ttl.resume_retry_error`
* `jobs.row_level_ttl.rows_deleted`
* `jobs.row_level_ttl.rows_selected`
* `jobs.row_level_ttl.select_duration`
* `jobs.row_level_ttl.span_total_duration`
* `jobs.row_level_ttl.total_expired_rows`
* `jobs.row_level_ttl.total_rows`
* `jobs.running_non_idle`
* `jobs.schema_change_gc.currently_idle`
* `jobs.schema_change_gc.currently_paused`
* `jobs.schema_change_gc.currently_running`
* `jobs.schema_change_gc.expired_pts_records`
* `jobs.schema_change_gc.fail_or_cancel_completed`
* `jobs.schema_change_gc.fail_or_cancel_failed`
* `jobs.schema_change_gc.fail_or_cancel_retry_error`
* `jobs.schema_change_gc.protected_age_sec`
* `jobs.schema_change_gc.protected_record_count`
* `jobs.schema_change_gc.resume_completed`
* `jobs.schema_change_gc.resume_failed`
* `jobs.schema_change_gc.resume_retry_error`
* `jobs.schema_change.currently_idle`
* `jobs.schema_change.currently_paused`
* `jobs.schema_change.currently_running`
* `jobs.schema_change.expired_pts_records`
* `jobs.schema_change.fail_or_cancel_completed`
* `jobs.schema_change.fail_or_cancel_failed`
* `jobs.schema_change.fail_or_cancel_retry_error`
* `jobs.schema_change.protected_age_sec`
* `jobs.schema_change.protected_record_count`
* `jobs.schema_change.resume_completed`
* `jobs.schema_change.resume_failed`
* `jobs.schema_change.resume_retry_error`
* `jobs.standby_read_ts_poller.currently_idle`
* `jobs.standby_read_ts_poller.currently_paused`
* `jobs.standby_read_ts_poller.currently_running`
* `jobs.standby_read_ts_poller.expired_pts_records`
* `jobs.standby_read_ts_poller.fail_or_cancel_completed`
* `jobs.standby_read_ts_poller.fail_or_cancel_failed`
* `jobs.standby_read_ts_poller.fail_or_cancel_retry_error`
* `jobs.standby_read_ts_poller.protected_age_sec`
* `jobs.standby_read_ts_poller.protected_record_count`
* `jobs.standby_read_ts_poller.resume_completed`
* `jobs.standby_read_ts_poller.resume_failed`
* `jobs.standby_read_ts_poller.resume_retry_error`
* `jobs.typedesc_schema_change.currently_idle`
* `jobs.typedesc_schema_change.currently_paused`
* `jobs.typedesc_schema_change.currently_running`
* `jobs.typedesc_schema_change.expired_pts_records`
* `jobs.typedesc_schema_change.fail_or_cancel_completed`
* `jobs.typedesc_schema_change.fail_or_cancel_failed`
* `jobs.typedesc_schema_change.fail_or_cancel_retry_error`
* `jobs.typedesc_schema_change.protected_age_sec`
* `jobs.typedesc_schema_change.protected_record_count`
* `jobs.typedesc_schema_change.resume_completed`
* `jobs.typedesc_schema_change.resume_failed`
* `jobs.typedesc_schema_change.resume_retry_error`
* `jobs.update_table_metadata_cache.currently_idle`
* `jobs.update_table_metadata_cache.currently_paused`
* `jobs.update_table_metadata_cache.currently_running`
* `jobs.update_table_metadata_cache.expired_pts_records`
* `jobs.update_table_metadata_cache.fail_or_cancel_completed`
* `jobs.update_table_metadata_cache.fail_or_cancel_failed`
* `jobs.update_table_metadata_cache.fail_or_cancel_retry_error`
* `jobs.update_table_metadata_cache.protected_age_sec`
* `jobs.update_table_metadata_cache.protected_record_count`
* `jobs.update_table_metadata_cache.resume_completed`
* `jobs.update_table_metadata_cache.resume_failed`
* `jobs.update_table_metadata_cache.resume_retry_error`
* `kv.protectedts.reconciliation.errors`
* `kv.protectedts.reconciliation.num_runs`
* `kv.protectedts.reconciliation.records_processed`
* `kv.protectedts.reconciliation.records_removed`
* `logical_replication.batch_hist_nanos`
* `logical_replication.checkpoint_events_ingested`
* `logical_replication.commit_latency`
* `logical_replication.events_dlqed`
* `logical_replication.events_dlqed_age`
* `logical_replication.events_dlqed_by_label`
* `logical_replication.events_dlqed_errtype`
* `logical_replication.events_dlqed_space`
* `logical_replication.events_ingested`
* `logical_replication.events_ingested_by_label`
* `logical_replication.events_initial_failure`
* `logical_replication.events_initial_success`
* `logical_replication.events_retry_failure`
* `logical_replication.events_retry_success`
* `logical_replication.logical_bytes`
* `logical_replication.replan_count`
* `logical_replication.replicated_time_by_label`
* `logical_replication.replicated_time_seconds`
* `logical_replication.retry_queue_bytes`
* `logical_replication.retry_queue_events`
* `obs.tablemetadata.update_job.duration`
* `obs.tablemetadata.update_job.errors`
* `obs.tablemetadata.update_job.runs`
* `obs.tablemetadata.update_job.table_updates`
* `physical_replication.admit_latency`
* `physical_replication.commit_latency`
* `physical_replication.cutover_progress`
* `physical_replication.distsql_replan_count`
* `physical_replication.events_ingested`
* `physical_replication.flush_hist_nanos`
* `physical_replication.flushes`
* `physical_replication.logical_bytes`
* `physical_replication.replicated_time_seconds`
* `physical_replication.resolved_events_ingested`
* `physical_replication.running`
* `requests.slow.distsender`
* `round-trip-latency`
* `rpc.client.bytes.egress`
* `rpc.client.bytes.ingress`
* `rpc.connection.avg_round_trip_latency`
* `rpc.connection.connected`
* `rpc.connection.failures`
* `rpc.connection.healthy`
* `rpc.connection.healthy_nanos`
* `rpc.connection.heartbeats`
* `rpc.connection.inactive`
* `rpc.connection.unhealthy`
* `rpc.connection.unhealthy_nanos`
* `schedules.BACKUP.failed`
* `schedules.BACKUP.last-completed-time`
* `schedules.BACKUP.protected_age_sec`
* `schedules.BACKUP.protected_record_count`
* `schedules.BACKUP.started`
* `schedules.BACKUP.succeeded`
* `schedules.CHANGEFEED.failed`
* `schedules.CHANGEFEED.started`
* `schedules.CHANGEFEED.succeeded`
* `schedules.error`
* `schedules.malformed`
* `schedules.round.jobs-started`
* `schedules.round.reschedule-skip`
* `schedules.round.reschedule-wait`
* `schedules.scheduled-row-level-ttl-executor.failed`
* `schedules.scheduled-row-level-ttl-executor.started`
* `schedules.scheduled-row-level-ttl-executor.succeeded`
* `schedules.scheduled-schema-telemetry-executor.failed`
* `schedules.scheduled-schema-telemetry-executor.started`
* `schedules.scheduled-schema-telemetry-executor.succeeded`
* `schedules.scheduled-sql-stats-compaction-executor.failed`
* `schedules.scheduled-sql-stats-compaction-executor.started`
* `schedules.scheduled-sql-stats-compaction-executor.succeeded`
* `sql.bytesin`
* `sql.bytesout`
* `sql.conn.failures`
* `sql.conn.latency`
* `sql.conns`
* `sql.conns_waiting_to_hash`
* `sql.contention.resolver.failed_resolutions`
* `sql.contention.resolver.queue_size`
* `sql.contention.resolver.retries`
* `sql.contention.txn_id_cache.miss`
* `sql.contention.txn_id_cache.read`
* `sql.copy.count`
* `sql.copy.count.internal`
* `sql.copy.nonatomic.count`
* `sql.copy.nonatomic.count.internal`
* `sql.copy.nonatomic.started.count`
* `sql.copy.nonatomic.started.count.internal`
* `sql.copy.started.count`
* `sql.copy.started.count.internal`
* `sql.ddl.count`
* `sql.ddl.count.internal`
* `sql.ddl.started.count`
* `sql.ddl.started.count.internal`
* `sql.delete.count`
* `sql.delete.count.internal`
* `sql.delete.started.count`
* `sql.delete.started.count.internal`
* `sql.disk.distsql.current`
* `sql.disk.distsql.max`
* `sql.disk.distsql.spilled.bytes.read`
* `sql.disk.distsql.spilled.bytes.written`
* `sql.distsql.contended_queries.count`
* `sql.distsql.cumulative_contention_nanos`
* `sql.distsql.dist_query_rerun_locally.count`
* `sql.distsql.dist_query_rerun_locally.failure_count`
* `sql.distsql.exec.latency`
* `sql.distsql.exec.latency.internal`
* `sql.distsql.flows.active`
* `sql.distsql.flows.total`
* `sql.distsql.queries.active`
* `sql.distsql.queries.spilled`
* `sql.distsql.queries.total`
* `sql.distsql.select.count`
* `sql.distsql.select.count.internal`
* `sql.distsql.service.latency`
* `sql.distsql.service.latency.internal`
* `sql.distsql.vec.openfds`
* `sql.exec.latency`
* `sql.exec.latency.internal`
* `sql.failure.count`
* `sql.failure.count.internal`
* `sql.feature_flag_denial`
* `sql.full.scan.count`
* `sql.full.scan.count.internal`
* `sql.guardrails.full_scan_rejected.count`
* `sql.guardrails.full_scan_rejected.count.internal`
* `sql.guardrails.max_row_size_err.count`
* `sql.guardrails.max_row_size_err.count.internal`
* `sql.guardrails.max_row_size_log.count`
* `sql.guardrails.max_row_size_log.count.internal`
* `sql.guardrails.transaction_rows_read_err.count`
* `sql.guardrails.transaction_rows_read_err.count.internal`
* `sql.guardrails.transaction_rows_read_log.count`
* `sql.guardrails.transaction_rows_read_log.count.internal`
* `sql.guardrails.transaction_rows_written_err.count`
* `sql.guardrails.transaction_rows_written_err.count.internal`
* `sql.guardrails.transaction_rows_written_log.count`
* `sql.guardrails.transaction_rows_written_log.count.internal`
* `sql.hydrated_schema_cache.hits`
* `sql.hydrated_schema_cache.misses`
* `sql.hydrated_table_cache.hits`
* `sql.hydrated_table_cache.misses`
* `sql.hydrated_type_cache.hits`
* `sql.hydrated_type_cache.misses`
* `sql.hydrated_udf_cache.hits`
* `sql.hydrated_udf_cache.misses`
* `sql.insert.count`
* `sql.insert.count.internal`
* `sql.insert.started.count`
* `sql.insert.started.count.internal`
* `sql.insights.anomaly_detection.evictions`
* `sql.insights.anomaly_detection.fingerprints`
* `sql.insights.anomaly_detection.memory`
* `sql.leases.active`
* `sql.leases.expired`
* `sql.leases.long_wait_for_no_version`
* `sql.leases.long_wait_for_one_version`
* `sql.leases.long_wait_for_two_version_invariant`
* `sql.leases.waiting_to_expire`
* `sql.mem.bulk.current`
* `sql.mem.bulk.max`
* `sql.mem.conns.current`
* `sql.mem.conns.max`
* `sql.mem.distsql.current`
* `sql.mem.distsql.max`
* `sql.mem.internal.current`
* `sql.mem.internal.max`
* `sql.mem.internal.session.current`
* `sql.mem.internal.session.max`
* `sql.mem.internal.session.prepared.current`
* `sql.mem.internal.session.prepared.max`
* `sql.mem.internal.txn.current`
* `sql.mem.internal.txn.max`
* `sql.mem.root.current`
* `sql.mem.root.max`
* `sql.mem.sql.current`
* `sql.mem.sql.max`
* `sql.mem.sql.session.current`
* `sql.mem.sql.session.max`
* `sql.mem.sql.session.prepared.current`
* `sql.mem.sql.session.prepared.max`
* `sql.mem.sql.txn.current`
* `sql.mem.sql.txn.max`
* `sql.misc.count`
* `sql.misc.count.internal`
* `sql.misc.started.count`
* `sql.misc.started.count.internal`
* `sql.new_conns`
* `sql.optimizer.fallback.count`
* `sql.optimizer.fallback.count.internal`
* `sql.optimizer.plan_cache.hits`
* `sql.optimizer.plan_cache.hits.internal`
* `sql.optimizer.plan_cache.misses`
* `sql.optimizer.plan_cache.misses.internal`
* `sql.pgwire_cancel.ignored`
* `sql.pgwire_cancel.successful`
* `sql.pgwire_cancel.total`
* `sql.pgwire.pipeline.count`
* `sql.pre_serve.bytesin`
* `sql.pre_serve.bytesout`
* `sql.pre_serve.conn.failures`
* `sql.pre_serve.mem.cur`
* `sql.pre_serve.mem.max`
* `sql.pre_serve.new_conns`
* `sql.query.count`
* `sql.query.count.internal`
* `sql.query.started.count`
* `sql.query.started.count.internal`
* `sql.restart_savepoint.count`
* `sql.restart_savepoint.count.internal`
* `sql.restart_savepoint.release.count`
* `sql.restart_savepoint.release.count.internal`
* `sql.restart_savepoint.release.started.count`
* `sql.restart_savepoint.release.started.count.internal`
* `sql.restart_savepoint.rollback.count`
* `sql.restart_savepoint.rollback.count.internal`
* `sql.restart_savepoint.rollback.started.count`
* `sql.restart_savepoint.rollback.started.count.internal`
* `sql.restart_savepoint.started.count`
* `sql.restart_savepoint.started.count.internal`
* `sql.savepoint.count`
* `sql.savepoint.count.internal`
* `sql.savepoint.release.count`
* `sql.savepoint.release.count.internal`
* `sql.savepoint.release.started.count`
* `sql.savepoint.release.started.count.internal`
* `sql.savepoint.rollback.count`
* `sql.savepoint.rollback.count.internal`
* `sql.savepoint.rollback.started.count`
* `sql.savepoint.rollback.started.count.internal`
* `sql.savepoint.started.count`
* `sql.savepoint.started.count.internal`
* `sql.schema_changer.permanent_errors`
* `sql.schema_changer.retry_errors`
* `sql.schema_changer.running`
* `sql.schema_changer.successes`
* `sql.schema.invalid_objects`
* `sql.select.count`
* `sql.select.count.internal`
* `sql.select.started.count`
* `sql.select.started.count.internal`
* `sql.service.latency`
* `sql.service.latency.internal`
* `sql.statements.active`
* `sql.statements.active.internal`
* `sql.stats.activity.update.latency`
* `sql.stats.activity.updates.failed`
* `sql.stats.activity.updates.successful`
* `sql.stats.cleanup.rows_removed`
* `sql.stats.discarded.current`
* `sql.stats.flush.done_signals.ignored`
* `sql.stats.flush.fingerprint.count`
* `sql.stats.flush.latency`
* `sql.stats.flushes.failed`
* `sql.stats.flushes.successful`
* `sql.stats.mem.current`
* `sql.stats.mem.max`
* `sql.stats.reported.mem.current`
* `sql.stats.reported.mem.max`
* `sql.stats.txn_stats_collection.duration`
* `sql.temp_object_cleaner.active_cleaners`
* `sql.temp_object_cleaner.schemas_deletion_error`
* `sql.temp_object_cleaner.schemas_deletion_success`
* `sql.temp_object_cleaner.schemas_to_delete`
* `sql.txn.abort.count`
* `sql.txn.abort.count.internal`
* `sql.txn.begin.count`
* `sql.txn.begin.count.internal`
* `sql.txn.begin.started.count`
* `sql.txn.begin.started.count.internal`
* `sql.txn.commit.count`
* `sql.txn.commit.count.internal`
* `sql.txn.commit.started.count`
* `sql.txn.commit.started.count.internal`
* `sql.txn.contended.count`
* `sql.txn.contended.count.internal`
* `sql.txn.latency`
* `sql.txn.latency.internal`
* `sql.txn.rollback.count`
* `sql.txn.rollback.count.internal`
* `sql.txn.rollback.started.count`
* `sql.txn.rollback.started.count.internal`
* `sql.txn.upgraded_iso_level.count`
* `sql.txn.upgraded_iso_level.count.internal`
* `sql.txns.open`
* `sql.txns.open.internal`
* `sql.update.count`
* `sql.update.count.internal`
* `sql.update.started.count`
* `sql.update.started.count.internal`
* `sqlliveness.is_alive.cache_hits`
* `sqlliveness.is_alive.cache_misses`
* `sqlliveness.sessions_deleted`
* `sqlliveness.sessions_deletion_runs`
* `sqlliveness.write_failures`
* `sqlliveness.write_successes`
* `tenant.cost_client.blocked_requests`
* `tenant.sql_usage.cross_region_network_ru`
* `tenant.sql_usage.estimated_cpu_seconds`
* `tenant.sql_usage.estimated_kv_cpu_seconds`
* `tenant.sql_usage.estimated_replication_bytes`
* `tenant.sql_usage.external_io_egress_bytes`
* `tenant.sql_usage.external_io_ingress_bytes`
* `tenant.sql_usage.kv_request_units`
* `tenant.sql_usage.pgwire_egress_bytes`
* `tenant.sql_usage.provisioned_vcpus`
* `tenant.sql_usage.read_batches`
* `tenant.sql_usage.read_bytes`
* `tenant.sql_usage.read_requests`
* `tenant.sql_usage.request_units`
* `tenant.sql_usage.sql_pods_cpu_seconds`
* `tenant.sql_usage.write_batches`
* `tenant.sql_usage.write_bytes`
* `tenant.sql_usage.write_requests`
* `txn.aborts`
* `txn.commit_waits`
* `txn.commits`
* `txn.commits_read_only`
* `txn.commits1PC`
* `txn.condensed_intent_spans`
* `txn.condensed_intent_spans_gauge`
* `txn.condensed_intent_spans_rejected`
* `txn.durations`
* `txn.inflight_locks_over_tracking_budget`
* `txn.parallelcommits`
* `txn.parallelcommits.auto_retries`
* `txn.refresh.auto_retries`
* `txn.refresh.fail`
* `txn.refresh.fail_with_condensed_spans`
* `txn.refresh.memory_limit_exceeded`
* `txn.refresh.success`
* `txn.refresh.success_server_side`
* `txn.restarts`
* `txn.restarts.asyncwritefailure`
* `txn.restarts.commitdeadlineexceeded`
* `txn.restarts.readwithinuncertainty`
* `txn.restarts.serializable`
* `txn.restarts.txnaborted`
* `txn.restarts.txnpush`
* `txn.restarts.unknown`
* `txn.restarts.writetooold`
* `txn.rollbacks.async.failed`
* `txn.rollbacks.failed`

## Metrics scoped to the system virtual cluster

* `abortspanbytes`
* `addsstable.applications`
* `addsstable.aswrites`
* `addsstable.copies`
* `addsstable.delay.enginebackpressure`
* `addsstable.delay.total`
* `addsstable.proposals`
* `admission.admitted.elastic-cpu`
* `admission.admitted.elastic-cpu.bulk-normal-pri`
* `admission.admitted.elastic-cpu.normal-pri`
* `admission.admitted.elastic-stores`
* `admission.admitted.elastic-stores.bulk-low-pri`
* `admission.admitted.elastic-stores.bulk-normal-pri`
* `admission.admitted.kv`
* `admission.admitted.kv-stores`
* `admission.admitted.kv-stores.high-pri`
* `admission.admitted.kv-stores.locking-normal-pri`
* `admission.admitted.kv-stores.normal-pri`
* `admission.admitted.kv.high-pri`
* `admission.admitted.kv.locking-normal-pri`
* `admission.admitted.kv.normal-pri`
* `admission.admitted.sql-kv-response`
* `admission.admitted.sql-kv-response.locking-normal-pri`
* `admission.admitted.sql-kv-response.normal-pri`
* `admission.admitted.sql-leaf-start`
* `admission.admitted.sql-leaf-start.locking-normal-pri`
* `admission.admitted.sql-leaf-start.normal-pri`
* `admission.admitted.sql-root-start`
* `admission.admitted.sql-root-start.locking-normal-pri`
* `admission.admitted.sql-root-start.normal-pri`
* `admission.admitted.sql-sql-response`
* `admission.admitted.sql-sql-response.locking-normal-pri`
* `admission.admitted.sql-sql-response.normal-pri`
* `admission.elastic_cpu.acquired_nanos`
* `admission.elastic_cpu.available_nanos`
* `admission.elastic_cpu.max_available_nanos`
* `admission.elastic_cpu.nanos_exhausted_duration`
* `admission.elastic_cpu.over_limit_durations`
* `admission.elastic_cpu.pre_work_nanos`
* `admission.elastic_cpu.returned_nanos`
* `admission.elastic_cpu.utilization`
* `admission.elastic_cpu.utilization_limit`
* `admission.errored.elastic-cpu`
* `admission.errored.elastic-cpu.bulk-normal-pri`
* `admission.errored.elastic-cpu.normal-pri`
* `admission.errored.elastic-stores`
* `admission.errored.elastic-stores.bulk-low-pri`
* `admission.errored.elastic-stores.bulk-normal-pri`
* `admission.errored.kv`
* `admission.errored.kv-stores`
* `admission.errored.kv-stores.high-pri`
* `admission.errored.kv-stores.locking-normal-pri`
* `admission.errored.kv-stores.normal-pri`
* `admission.errored.kv.high-pri`
* `admission.errored.kv.locking-normal-pri`
* `admission.errored.kv.normal-pri`
* `admission.errored.sql-kv-response`
* `admission.errored.sql-kv-response.locking-normal-pri`
* `admission.errored.sql-kv-response.normal-pri`
* `admission.errored.sql-leaf-start`
* `admission.errored.sql-leaf-start.locking-normal-pri`
* `admission.errored.sql-leaf-start.normal-pri`
* `admission.errored.sql-root-start`
* `admission.errored.sql-root-start.locking-normal-pri`
* `admission.errored.sql-root-start.normal-pri`
* `admission.errored.sql-sql-response`
* `admission.errored.sql-sql-response.locking-normal-pri`
* `admission.errored.sql-sql-response.normal-pri`
* `admission.granter.cpu_load_long_period_duration.kv`
* `admission.granter.cpu_load_short_period_duration.kv`
* `admission.granter.elastic_io_tokens_available.kv`
* `admission.granter.elastic_io_tokens_exhausted_duration.kv`
* `admission.granter.io_tokens_available.kv`
* `admission.granter.io_tokens_bypassed.kv`
* `admission.granter.io_tokens_exhausted_duration.kv`
* `admission.granter.io_tokens_returned.kv`
* `admission.granter.io_tokens_taken.kv`
* `admission.granter.slot_adjuster_decrements.kv`
* `admission.granter.slot_adjuster_increments.kv`
* `admission.granter.slots_exhausted_duration.kv`
* `admission.granter.total_slots.kv`
* `admission.granter.used_slots.kv`
* `admission.granter.used_slots.sql-leaf-start`
* `admission.granter.used_slots.sql-root-start`
* `admission.io.overload`
* `admission.l0_compacted_bytes.kv`
* `admission.l0_tokens_produced.kv`
* `admission.raft.paused_replicas`
* `admission.raft.paused_replicas_dropped_msgs`
* `admission.requested.elastic-cpu`
* `admission.requested.elastic-cpu.bulk-normal-pri`
* `admission.requested.elastic-cpu.normal-pri`
* `admission.requested.elastic-stores`
* `admission.requested.elastic-stores.bulk-low-pri`
* `admission.requested.elastic-stores.bulk-normal-pri`
* `admission.requested.kv`
* `admission.requested.kv-stores`
* `admission.requested.kv-stores.high-pri`
* `admission.requested.kv-stores.locking-normal-pri`
* `admission.requested.kv-stores.normal-pri`
* `admission.requested.kv.high-pri`
* `admission.requested.kv.locking-normal-pri`
* `admission.requested.kv.normal-pri`
* `admission.requested.sql-kv-response`
* `admission.requested.sql-kv-response.locking-normal-pri`
* `admission.requested.sql-kv-response.normal-pri`
* `admission.requested.sql-leaf-start`
* `admission.requested.sql-leaf-start.locking-normal-pri`
* `admission.requested.sql-leaf-start.normal-pri`
* `admission.requested.sql-root-start`
* `admission.requested.sql-root-start.locking-normal-pri`
* `admission.requested.sql-root-start.normal-pri`
* `admission.requested.sql-sql-response`
* `admission.requested.sql-sql-response.locking-normal-pri`
* `admission.requested.sql-sql-response.normal-pri`
* `admission.scheduler_latency_listener.p99_nanos`
* `admission.wait_durations.elastic-cpu`
* `admission.wait_durations.elastic-cpu.bulk-normal-pri`
* `admission.wait_durations.elastic-cpu.normal-pri`
* `admission.wait_durations.elastic-stores`
* `admission.wait_durations.elastic-stores.bulk-low-pri`
* `admission.wait_durations.elastic-stores.bulk-normal-pri`
* `admission.wait_durations.kv`
* `admission.wait_durations.kv-stores`
* `admission.wait_durations.kv-stores.high-pri`
* `admission.wait_durations.kv-stores.locking-normal-pri`
* `admission.wait_durations.kv-stores.normal-pri`
* `admission.wait_durations.kv.high-pri`
* `admission.wait_durations.kv.locking-normal-pri`
* `admission.wait_durations.kv.normal-pri`
* `admission.wait_durations.snapshot_ingest`
* `admission.wait_durations.sql-kv-response`
* `admission.wait_durations.sql-kv-response.locking-normal-pri`
* `admission.wait_durations.sql-kv-response.normal-pri`
* `admission.wait_durations.sql-leaf-start`
* `admission.wait_durations.sql-leaf-start.locking-normal-pri`
* `admission.wait_durations.sql-leaf-start.normal-pri`
* `admission.wait_durations.sql-root-start`
* `admission.wait_durations.sql-root-start.locking-normal-pri`
* `admission.wait_durations.sql-root-start.normal-pri`
* `admission.wait_durations.sql-sql-response`
* `admission.wait_durations.sql-sql-response.locking-normal-pri`
* `admission.wait_durations.sql-sql-response.normal-pri`
* `admission.wait_queue_length.elastic-cpu`
* `admission.wait_queue_length.elastic-cpu.bulk-normal-pri`
* `admission.wait_queue_length.elastic-cpu.normal-pri`
* `admission.wait_queue_length.elastic-stores`
* `admission.wait_queue_length.elastic-stores.bulk-low-pri`
* `admission.wait_queue_length.elastic-stores.bulk-normal-pri`
* `admission.wait_queue_length.kv`
* `admission.wait_queue_length.kv-stores`
* `admission.wait_queue_length.kv-stores.high-pri`
* `admission.wait_queue_length.kv-stores.locking-normal-pri`
* `admission.wait_queue_length.kv-stores.normal-pri`
* `admission.wait_queue_length.kv.high-pri`
* `admission.wait_queue_length.kv.locking-normal-pri`
* `admission.wait_queue_length.kv.normal-pri`
* `admission.wait_queue_length.sql-kv-response`
* `admission.wait_queue_length.sql-kv-response.locking-normal-pri`
* `admission.wait_queue_length.sql-kv-response.normal-pri`
* `admission.wait_queue_length.sql-leaf-start`
* `admission.wait_queue_length.sql-leaf-start.locking-normal-pri`
* `admission.wait_queue_length.sql-leaf-start.normal-pri`
* `admission.wait_queue_length.sql-root-start`
* `admission.wait_queue_length.sql-root-start.locking-normal-pri`
* `admission.wait_queue_length.sql-root-start.normal-pri`
* `admission.wait_queue_length.sql-sql-response`
* `admission.wait_queue_length.sql-sql-response.locking-normal-pri`
* `admission.wait_queue_length.sql-sql-response.normal-pri`
* `batch_requests.bytes`
* `batch_requests.cross_region.bytes`
* `batch_requests.cross_zone.bytes`
* `batch_responses.bytes`
* `batch_responses.cross_region.bytes`
* `batch_responses.cross_zone.bytes`
* `capacity`
* `capacity.available`
* `capacity.reserved`
* `capacity.used`
* `exec.error`
* `exec.latency`
* `exec.success`
* `exportrequest.delay.total`
* `follower_reads.success_count`
* `gcbytesage`
* `gossip.bytes.received`
* `gossip.bytes.sent`
* `gossip.callbacks.pending`
* `gossip.callbacks.pending_duration`
* `gossip.callbacks.processed`
* `gossip.callbacks.processing_duration`
* `gossip.connections.incoming`
* `gossip.connections.outgoing`
* `gossip.connections.refused`
* `gossip.infos.received`
* `gossip.infos.sent`
* `intentage`
* `intentbytes`
* `intentcount`
* `intentresolver.async.throttled`
* `intentresolver.finalized_txns.failed`
* `intentresolver.intents.failed`
* `intents.abort-attempts`
* `intents.poison-attempts`
* `intents.resolve-attempts`
* `keybytes`
* `keycount`
* `kv.allocator.load_based_lease_transfers.cannot_find_better_candidate`
* `kv.allocator.load_based_lease_transfers.delta_not_significant`
* `kv.allocator.load_based_lease_transfers.existing_not_overfull`
* `kv.allocator.load_based_lease_transfers.follow_the_workload`
* `kv.allocator.load_based_lease_transfers.missing_stats_for_existing_stores`
* `kv.allocator.load_based_lease_transfers.should_transfer`
* `kv.allocator.load_based_replica_rebalancing.cannot_find_better_candidate`
* `kv.allocator.load_based_replica_rebalancing.delta_not_significant`
* `kv.allocator.load_based_replica_rebalancing.existing_not_overfull`
* `kv.allocator.load_based_replica_rebalancing.missing_stats_for_existing_store`
* `kv.allocator.load_based_replica_rebalancing.should_transfer`
* `kv.closed_timestamp.max_behind_nanos`
* `kv.concurrency.avg_lock_hold_duration_nanos`
* `kv.concurrency.avg_lock_wait_duration_nanos`
* `kv.concurrency.latch_conflict_wait_durations`
* `kv.concurrency.lock_wait_queue_waiters`
* `kv.concurrency.locks`
* `kv.concurrency.locks_with_wait_queues`
* `kv.concurrency.max_lock_hold_duration_nanos`
* `kv.concurrency.max_lock_wait_duration_nanos`
* `kv.concurrency.max_lock_wait_queue_waiters_for_lock`
* `kv.loadsplitter.nosplitkey`
* `kv.loadsplitter.popularkey`
* `kv.prober.planning_attempts`
* `kv.prober.planning_failures`
* `kv.prober.read.attempts`
* `kv.prober.read.failures`
* `kv.prober.read.latency`
* `kv.prober.write.attempts`
* `kv.prober.write.failures`
* `kv.prober.write.latency`
* `kv.prober.write.quarantine.oldest_duration`
* `kv.rangefeed.budget_allocation_blocked`
* `kv.rangefeed.budget_allocation_failed`
* `kv.rangefeed.catchup_scan_nanos`
* `kv.rangefeed.closed_timestamp_max_behind_nanos`
* `kv.rangefeed.closed_timestamp.slow_ranges`
* `kv.rangefeed.mem_shared`
* `kv.rangefeed.mem_system`
* `kv.rangefeed.processors_goroutine`
* `kv.rangefeed.processors_scheduler`
* `kv.rangefeed.registrations`
* `kv.rangefeed.scheduler.normal.latency`
* `kv.rangefeed.scheduler.normal.queue_size`
* `kv.rangefeed.scheduler.system.latency`
* `kv.rangefeed.scheduler.system.queue_size`
* `kv.replica_circuit_breaker.num_tripped_events`
* `kv.replica_circuit_breaker.num_tripped_replicas`
* `kv.replica_read_batch_evaluate.dropped_latches_before_eval`
* `kv.replica_read_batch_evaluate.latency`
* `kv.replica_read_batch_evaluate.without_interleaving_iter`
* `kv.replica_write_batch_evaluate.latency`
* `kv.split.estimated_stats`
* `kv.split.total_bytes_estimates`
* `kv.tenant_rate_limit.current_blocked`
* `kv.tenant_rate_limit.num_tenants`
* `kv.tenant_rate_limit.read_batches_admitted`
* `kv.tenant_rate_limit.read_bytes_admitted`
* `kv.tenant_rate_limit.read_requests_admitted`
* `kv.tenant_rate_limit.write_batches_admitted`
* `kv.tenant_rate_limit.write_bytes_admitted`
* `kv.tenant_rate_limit.write_requests_admitted`
* `kvadmission.flow_controller.elastic_blocked_stream_count`
* `kvadmission.flow_controller.elastic_requests_admitted`
* `kvadmission.flow_controller.elastic_requests_bypassed`
* `kvadmission.flow_controller.elastic_requests_errored`
* `kvadmission.flow_controller.elastic_requests_waiting`
* `kvadmission.flow_controller.elastic_stream_count`
* `kvadmission.flow_controller.elastic_tokens_available`
* `kvadmission.flow_controller.elastic_tokens_deducted`
* `kvadmission.flow_controller.elastic_tokens_returned`
* `kvadmission.flow_controller.elastic_tokens_unaccounted`
* `kvadmission.flow_controller.elastic_wait_duration`
* `kvadmission.flow_controller.regular_blocked_stream_count`
* `kvadmission.flow_controller.regular_requests_admitted`
* `kvadmission.flow_controller.regular_requests_bypassed`
* `kvadmission.flow_controller.regular_requests_errored`
* `kvadmission.flow_controller.regular_requests_waiting`
* `kvadmission.flow_controller.regular_stream_count`
* `kvadmission.flow_controller.regular_tokens_available`
* `kvadmission.flow_controller.regular_tokens_deducted`
* `kvadmission.flow_controller.regular_tokens_returned`
* `kvadmission.flow_controller.regular_tokens_unaccounted`
* `kvadmission.flow_controller.regular_wait_duration`
* `kvadmission.flow_handle.elastic_requests_admitted`
* `kvadmission.flow_handle.elastic_requests_errored`
* `kvadmission.flow_handle.elastic_requests_waiting`
* `kvadmission.flow_handle.elastic_wait_duration`
* `kvadmission.flow_handle.regular_requests_admitted`
* `kvadmission.flow_handle.regular_requests_errored`
* `kvadmission.flow_handle.regular_requests_waiting`
* `kvadmission.flow_handle.regular_wait_duration`
* `kvadmission.flow_handle.streams_connected`
* `kvadmission.flow_handle.streams_disconnected`
* `kvadmission.flow_token_dispatch.coalesced_elastic`
* `kvadmission.flow_token_dispatch.coalesced_regular`
* `kvadmission.flow_token_dispatch.local_elastic`
* `kvadmission.flow_token_dispatch.local_regular`
* `kvadmission.flow_token_dispatch.pending_elastic`
* `kvadmission.flow_token_dispatch.pending_nodes`
* `kvadmission.flow_token_dispatch.pending_regular`
* `kvadmission.flow_token_dispatch.remote_elastic`
* `kvadmission.flow_token_dispatch.remote_regular`
* `kvflowcontrol.eval_wait.elastic.duration`
* `kvflowcontrol.eval_wait.elastic.requests.admitted`
* `kvflowcontrol.eval_wait.elastic.requests.bypassed`
* `kvflowcontrol.eval_wait.elastic.requests.errored`
* `kvflowcontrol.eval_wait.elastic.requests.waiting`
* `kvflowcontrol.eval_wait.regular.duration`
* `kvflowcontrol.eval_wait.regular.requests.admitted`
* `kvflowcontrol.eval_wait.regular.requests.bypassed`
* `kvflowcontrol.eval_wait.regular.requests.errored`
* `kvflowcontrol.eval_wait.regular.requests.waiting`
* `kvflowcontrol.range_controller.count`
* `kvflowcontrol.send_queue.bytes`
* `kvflowcontrol.send_queue.count`
* `kvflowcontrol.send_queue.prevent.count`
* `kvflowcontrol.send_queue.scheduled.deducted_bytes`
* `kvflowcontrol.send_queue.scheduled.force_flush`
* `kvflowcontrol.streams.eval.elastic.blocked_count`
* `kvflowcontrol.streams.eval.elastic.total_count`
* `kvflowcontrol.streams.eval.regular.blocked_count`
* `kvflowcontrol.streams.eval.regular.total_count`
* `kvflowcontrol.streams.send.elastic.blocked_count`
* `kvflowcontrol.streams.send.elastic.total_count`
* `kvflowcontrol.streams.send.regular.blocked_count`
* `kvflowcontrol.streams.send.regular.total_count`
* `kvflowcontrol.tokens.eval.elastic.available`
* `kvflowcontrol.tokens.eval.elastic.deducted`
* `kvflowcontrol.tokens.eval.elastic.returned`
* `kvflowcontrol.tokens.eval.elastic.returned.disconnect`
* `kvflowcontrol.tokens.eval.elastic.unaccounted`
* `kvflowcontrol.tokens.eval.regular.available`
* `kvflowcontrol.tokens.eval.regular.deducted`
* `kvflowcontrol.tokens.eval.regular.returned`
* `kvflowcontrol.tokens.eval.regular.returned.disconnect`
* `kvflowcontrol.tokens.eval.regular.unaccounted`
* `kvflowcontrol.tokens.send.elastic.available`
* `kvflowcontrol.tokens.send.elastic.deducted`
* `kvflowcontrol.tokens.send.elastic.deducted.force_flush_send_queue`
* `kvflowcontrol.tokens.send.elastic.deducted.prevent_send_queue`
* `kvflowcontrol.tokens.send.elastic.returned`
* `kvflowcontrol.tokens.send.elastic.returned.disconnect`
* `kvflowcontrol.tokens.send.elastic.unaccounted`
* `kvflowcontrol.tokens.send.regular.available`
* `kvflowcontrol.tokens.send.regular.deducted`
* `kvflowcontrol.tokens.send.regular.deducted.prevent_send_queue`
* `kvflowcontrol.tokens.send.regular.returned`
* `kvflowcontrol.tokens.send.regular.returned.disconnect`
* `kvflowcontrol.tokens.send.regular.unaccounted`
* `leases.epoch`
* `leases.error`
* `leases.expiration`
* `leases.leader`
* `leases.liveness`
* `leases.preferences.less-preferred`
* `leases.preferences.violating`
* `leases.requests.latency`
* `leases.success`
* `leases.transfers.error`
* `leases.transfers.success`
* `livebytes`
* `livecount`
* `liveness.epochincrements`
* `liveness.heartbeatfailures`
* `liveness.heartbeatlatency`
* `liveness.heartbeatsinflight`
* `liveness.heartbeatsuccesses`
* `liveness.livenodes`
* `lockbytes`
* `lockcount`
* `node-id`
* `queue.consistency.pending`
* `queue.consistency.process.failure`
* `queue.consistency.process.success`
* `queue.consistency.processingnanos`
* `queue.gc.info.abortspanconsidered`
* `queue.gc.info.abortspangcnum`
* `queue.gc.info.abortspanscanned`
* `queue.gc.info.clearrangefailed`
* `queue.gc.info.clearrangesuccess`
* `queue.gc.info.enqueuehighpriority`
* `queue.gc.info.intentsconsidered`
* `queue.gc.info.intenttxns`
* `queue.gc.info.numkeysaffected`
* `queue.gc.info.numrangekeysaffected`
* `queue.gc.info.pushtxn`
* `queue.gc.info.resolvefailed`
* `queue.gc.info.resolvesuccess`
* `queue.gc.info.resolvetotal`
* `queue.gc.info.transactionresolvefailed`
* `queue.gc.info.transactionspangcaborted`
* `queue.gc.info.transactionspangccommitted`
* `queue.gc.info.transactionspangcpending`
* `queue.gc.info.transactionspangcstaging`
* `queue.gc.info.transactionspanscanned`
* `queue.gc.pending`
* `queue.gc.process.failure`
* `queue.gc.process.success`
* `queue.gc.processingnanos`
* `queue.lease.pending`
* `queue.lease.process.failure`
* `queue.lease.process.success`
* `queue.lease.processingnanos`
* `queue.lease.purgatory`
* `queue.merge.pending`
* `queue.merge.process.failure`
* `queue.merge.process.success`
* `queue.merge.processingnanos`
* `queue.merge.purgatory`
* `queue.raftlog.pending`
* `queue.raftlog.process.failure`
* `queue.raftlog.process.success`
* `queue.raftlog.processingnanos`
* `queue.raftsnapshot.pending`
* `queue.raftsnapshot.process.failure`
* `queue.raftsnapshot.process.success`
* `queue.raftsnapshot.processingnanos`
* `queue.replicagc.pending`
* `queue.replicagc.process.failure`
* `queue.replicagc.process.success`
* `queue.replicagc.processingnanos`
* `queue.replicagc.removereplica`
* `queue.replicate.addnonvoterreplica`
* `queue.replicate.addreplica`
* `queue.replicate.addreplica.error`
* `queue.replicate.addreplica.success`
* `queue.replicate.addvoterreplica`
* `queue.replicate.nonvoterpromotions`
* `queue.replicate.pending`
* `queue.replicate.process.failure`
* `queue.replicate.process.success`
* `queue.replicate.processingnanos`
* `queue.replicate.purgatory`
* `queue.replicate.rebalancenonvoterreplica`
* `queue.replicate.rebalancereplica`
* `queue.replicate.rebalancevoterreplica`
* `queue.replicate.removedeadnonvoterreplica`
* `queue.replicate.removedeadreplica`
* `queue.replicate.removedeadreplica.error`
* `queue.replicate.removedeadreplica.success`
* `queue.replicate.removedeadvoterreplica`
* `queue.replicate.removedecommissioningnonvoterreplica`
* `queue.replicate.removedecommissioningreplica`
* `queue.replicate.removedecommissioningreplica.error`
* `queue.replicate.removedecommissioningreplica.success`
* `queue.replicate.removedecommissioningvoterreplica`
* `queue.replicate.removelearnerreplica`
* `queue.replicate.removenonvoterreplica`
* `queue.replicate.removereplica`
* `queue.replicate.removereplica.error`
* `queue.replicate.removereplica.success`
* `queue.replicate.removevoterreplica`
* `queue.replicate.replacedeadreplica.error`
* `queue.replicate.replacedeadreplica.success`
* `queue.replicate.replacedecommissioningreplica.error`
* `queue.replicate.replacedecommissioningreplica.success`
* `queue.replicate.transferlease`
* `queue.replicate.voterdemotions`
* `queue.split.load_based`
* `queue.split.pending`
* `queue.split.process.failure`
* `queue.split.process.success`
* `queue.split.processingnanos`
* `queue.split.purgatory`
* `queue.split.size_based`
* `queue.split.span_config_based`
* `queue.tsmaintenance.pending`
* `queue.tsmaintenance.process.failure`
* `queue.tsmaintenance.process.success`
* `queue.tsmaintenance.processingnanos`
* `raft.commands.pending`
* `raft.commands.proposed`
* `raft.commands.reproposed.new-lai`
* `raft.commands.reproposed.unchanged`
* `raft.commandsapplied`
* `raft.dropped`
* `raft.dropped_leader`
* `raft.entrycache.accesses`
* `raft.entrycache.bytes`
* `raft.entrycache.hits`
* `raft.entrycache.read_bytes`
* `raft.entrycache.size`
* `raft.heartbeats.pending`
* `raft.loaded_entries.bytes`
* `raft.loaded_entries.reserved.bytes`
* `raft.process.applycommitted.latency`
* `raft.process.commandcommit.latency`
* `raft.process.handleready.latency`
* `raft.process.logcommit.latency`
* `raft.process.tickingnanos`
* `raft.process.workingnanos`
* `raft.quota_pool.percent_used`
* `raft.rcvd.app`
* `raft.rcvd.appresp`
* `raft.rcvd.bytes`
* `raft.rcvd.cross_region.bytes`
* `raft.rcvd.cross_zone.bytes`
* `raft.rcvd.defortifyleader`
* `raft.rcvd.dropped`
* `raft.rcvd.dropped_bytes`
* `raft.rcvd.fortifyleader`
* `raft.rcvd.fortifyleaderresp`
* `raft.rcvd.heartbeat`
* `raft.rcvd.heartbeatresp`
* `raft.rcvd.prevote`
* `raft.rcvd.prevoteresp`
* `raft.rcvd.prop`
* `raft.rcvd.queued_bytes`
* `raft.rcvd.snap`
* `raft.rcvd.stepped_bytes`
* `raft.rcvd.timeoutnow`
* `raft.rcvd.transferleader`
* `raft.rcvd.vote`
* `raft.rcvd.voteresp`
* `raft.replication.latency`
* `raft.scheduler.latency`
* `raft.sent.bytes`
* `raft.sent.cross_region.bytes`
* `raft.sent.cross_zone.bytes`
* `raft.storage.error`
* `raft.storage.read_bytes`
* `raft.ticks`
* `raft.timeoutcampaign`
* `raft.transport.flow-token-dispatches-dropped`
* `raft.transport.rcvd`
* `raft.transport.reverse-rcvd`
* `raft.transport.reverse-sent`
* `raft.transport.send-queue-bytes`
* `raft.transport.send-queue-size`
* `raft.transport.sends-dropped`
* `raft.transport.sent`
* `raftlog.behind`
* `raftlog.truncated`
* `range.adds`
* `range.merges`
* `range.raftleaderremovals`
* `range.raftleadertransfers`
* `range.recoveries`
* `range.removes`
* `range.snapshots.applied-initial`
* `range.snapshots.applied-non-voter`
* `range.snapshots.applied-voter`
* `range.snapshots.cross-region.rcvd-bytes`
* `range.snapshots.cross-region.sent-bytes`
* `range.snapshots.cross-zone.rcvd-bytes`
* `range.snapshots.cross-zone.sent-bytes`
* `range.snapshots.delegate.failures`
* `range.snapshots.delegate.in-progress`
* `range.snapshots.delegate.sent-bytes`
* `range.snapshots.delegate.successes`
* `range.snapshots.generated`
* `range.snapshots.rcvd-bytes`
* `range.snapshots.rebalancing.rcvd-bytes`
* `range.snapshots.rebalancing.sent-bytes`
* `range.snapshots.recovery.rcvd-bytes`
* `range.snapshots.recovery.sent-bytes`
* `range.snapshots.recv-failed`
* `range.snapshots.recv-in-progress`
* `range.snapshots.recv-queue`
* `range.snapshots.recv-queue-bytes`
* `range.snapshots.recv-total-in-progress`
* `range.snapshots.recv-unusable`
* `range.snapshots.send-in-progress`
* `range.snapshots.send-queue`
* `range.snapshots.send-queue-bytes`
* `range.snapshots.send-total-in-progress`
* `range.snapshots.sent-bytes`
* `range.snapshots.unknown.rcvd-bytes`
* `range.snapshots.unknown.sent-bytes`
* `range.snapshots.upreplication.rcvd-bytes`
* `range.snapshots.upreplication.sent-bytes`
* `range.splits`
* `rangekeybytes`
* `rangekeycount`
* `ranges`
* `ranges.decommissioning`
* `ranges.overreplicated`
* `ranges.unavailable`
* `ranges.underreplicated`
* `rangevalbytes`
* `rangevalcount`
* `rebalancing.cpunanospersecond`
* `rebalancing.lease.transfers`
* `rebalancing.queriespersecond`
* `rebalancing.range.rebalances`
* `rebalancing.readbytespersecond`
* `rebalancing.readspersecond`
* `rebalancing.replicas.cpunanospersecond`
* `rebalancing.replicas.queriespersecond`
* `rebalancing.requestspersecond`
* `rebalancing.state.imbalanced_overfull_options_exhausted`
* `rebalancing.writebytespersecond`
* `rebalancing.writespersecond`
* `replicas`
* `replicas.leaders`
* `replicas.leaders_invalid_lease`
* `replicas.leaders_not_leaseholders`
* `replicas.leaseholders`
* `replicas.quiescent`
* `replicas.reserved`
* `replicas.uninitialized`
* `requests.backpressure.split`
* `requests.slow.latch`
* `requests.slow.lease`
* `requests.slow.raft`
* `rocksdb.block.cache.hits`
* `rocksdb.block.cache.misses`
* `rocksdb.block.cache.usage`
* `rocksdb.bloom.filter.prefix.checked`
* `rocksdb.bloom.filter.prefix.useful`
* `rocksdb.compacted-bytes-read`
* `rocksdb.compacted-bytes-written`
* `rocksdb.compactions`
* `rocksdb.encryption.algorithm`
* `rocksdb.estimated-pending-compaction`
* `rocksdb.flushed-bytes`
* `rocksdb.flushes`
* `rocksdb.ingested-bytes`
* `rocksdb.memtable.total-size`
* `rocksdb.num-sstables`
* `rocksdb.read-amplification`
* `rocksdb.table-readers-mem-estimate`
* `rpc.batches.recv`
* `rpc.method.addsstable.recv`
* `rpc.method.adminchangereplicas.recv`
* `rpc.method.adminmerge.recv`
* `rpc.method.adminrelocaterange.recv`
* `rpc.method.adminscatter.recv`
* `rpc.method.adminsplit.recv`
* `rpc.method.admintransferlease.recv`
* `rpc.method.adminunsplit.recv`
* `rpc.method.adminverifyprotectedtimestamp.recv`
* `rpc.method.barrier.recv`
* `rpc.method.checkconsistency.recv`
* `rpc.method.clearrange.recv`
* `rpc.method.computechecksum.recv`
* `rpc.method.conditionalput.recv`
* `rpc.method.delete.recv`
* `rpc.method.deleterange.recv`
* `rpc.method.endtxn.recv`
* `rpc.method.export.recv`
* `rpc.method.gc.recv`
* `rpc.method.get.recv`
* `rpc.method.heartbeattxn.recv`
* `rpc.method.increment.recv`
* `rpc.method.initput.recv`
* `rpc.method.isspanempty.recv`
* `rpc.method.leaseinfo.recv`
* `rpc.method.linkexternalsstable.recv`
* `rpc.method.merge.recv`
* `rpc.method.migrate.recv`
* `rpc.method.probe.recv`
* `rpc.method.pushtxn.recv`
* `rpc.method.put.recv`
* `rpc.method.queryintent.recv`
* `rpc.method.querylocks.recv`
* `rpc.method.queryresolvedtimestamp.recv`
* `rpc.method.querytxn.recv`
* `rpc.method.rangestats.recv`
* `rpc.method.recomputestats.recv`
* `rpc.method.recovertxn.recv`
* `rpc.method.refresh.recv`
* `rpc.method.refreshrange.recv`
* `rpc.method.requestlease.recv`
* `rpc.method.resolveintent.recv`
* `rpc.method.resolveintentrange.recv`
* `rpc.method.reversescan.recv`
* `rpc.method.revertrange.recv`
* `rpc.method.scan.recv`
* `rpc.method.subsume.recv`
* `rpc.method.transferlease.recv`
* `rpc.method.truncatelog.recv`
* `rpc.method.writebatch.recv`
* `rpc.streams.mux_rangefeed.active`
* `rpc.streams.mux_rangefeed.recv`
* `spanconfig.kvsubscriber.oldest_protected_record_nanos`
* `spanconfig.kvsubscriber.protected_record_count`
* `spanconfig.kvsubscriber.update_behind_nanos`
* `storage.batch-commit.commit-wait.duration`
* `storage.batch-commit.count`
* `storage.batch-commit.duration`
* `storage.batch-commit.l0-stall.duration`
* `storage.batch-commit.mem-stall.duration`
* `storage.batch-commit.sem-wait.duration`
* `storage.batch-commit.wal-queue-wait.duration`
* `storage.batch-commit.wal-rotation.duration`
* `storage.block-load.active`
* `storage.block-load.queued`
* `storage.checkpoints`
* `storage.compactions.duration`
* `storage.compactions.keys.pinned.bytes`
* `storage.compactions.keys.pinned.count`
* `storage.disk-slow`
* `storage.disk-stalled`
* `storage.disk.io.time`
* `storage.disk.iopsinprogress`
* `storage.disk.read-max.bytespersecond`
* `storage.disk.read.bytes`
* `storage.disk.read.count`
* `storage.disk.read.time`
* `storage.disk.weightedio.time`
* `storage.disk.write-max.bytespersecond`
* `storage.disk.write.bytes`
* `storage.disk.write.count`
* `storage.disk.write.time`
* `storage.flush.ingest.count`
* `storage.flush.ingest.table.bytes`
* `storage.flush.ingest.table.count`
* `storage.flush.utilization`
* `storage.ingest.count`
* `storage.iterator.block-load.bytes`
* `storage.iterator.block-load.cached-bytes`
* `storage.iterator.block-load.read-duration`
* `storage.iterator.external.seeks`
* `storage.iterator.external.steps`
* `storage.iterator.internal.seeks`
* `storage.iterator.internal.steps`
* `storage.keys.range-key-set.count`
* `storage.keys.tombstone.count`
* `storage.l0-bytes-flushed`
* `storage.l0-bytes-ingested`
* `storage.l0-level-score`
* `storage.l0-level-size`
* `storage.l0-num-files`
* `storage.l0-sublevels`
* `storage.l1-bytes-ingested`
* `storage.l1-level-score`
* `storage.l1-level-size`
* `storage.l2-bytes-ingested`
* `storage.l2-level-score`
* `storage.l2-level-size`
* `storage.l3-bytes-ingested`
* `storage.l3-level-score`
* `storage.l3-level-size`
* `storage.l4-bytes-ingested`
* `storage.l4-level-score`
* `storage.l4-level-size`
* `storage.l5-bytes-ingested`
* `storage.l5-level-score`
* `storage.l5-level-size`
* `storage.l6-bytes-ingested`
* `storage.l6-level-score`
* `storage.l6-level-size`
* `storage.marked-for-compaction-files`
* `storage.queue.store-failures`
* `storage.secondary-cache.count`
* `storage.secondary-cache.evictions`
* `storage.secondary-cache.reads-full-hit`
* `storage.secondary-cache.reads-multi-block`
* `storage.secondary-cache.reads-multi-shard`
* `storage.secondary-cache.reads-no-hit`
* `storage.secondary-cache.reads-partial-hit`
* `storage.secondary-cache.reads-total`
* `storage.secondary-cache.size`
* `storage.secondary-cache.write-back-failures`
* `storage.shared-storage.read`
* `storage.shared-storage.write`
* `storage.single-delete.ineffectual`
* `storage.single-delete.invariant-violation`
* `storage.sstable.compression.none.count`
* `storage.sstable.compression.snappy.count`
* `storage.sstable.compression.unknown.count`
* `storage.sstable.compression.zstd.count`
* `storage.sstable.zombie.bytes`
* `storage.wal.bytes_in`
* `storage.wal.bytes_written`
* `storage.wal.failover.primary.duration`
* `storage.wal.failover.secondary.duration`
* `storage.wal.failover.switch.count`
* `storage.wal.failover.write_and_sync.latency`
* `storage.wal.fsync.latency`
* `storage.write-amplification`
* `storage.write-stall-nanos`
* `storage.write-stalls`
* `storeliveness.heartbeat.failures`
* `storeliveness.heartbeat.successes`
* `storeliveness.message_handle.failures`
* `storeliveness.message_handle.successes`
* `storeliveness.support_for.stores`
* `storeliveness.support_from.stores`
* `storeliveness.support_withdraw.failures`
* `storeliveness.support_withdraw.successes`
* `storeliveness.transport.receive_dropped`
* `storeliveness.transport.receive-queue-bytes`
* `storeliveness.transport.receive-queue-size`
* `storeliveness.transport.received`
* `storeliveness.transport.send_dropped`
* `storeliveness.transport.send-queue-bytes`
* `storeliveness.transport.send-queue-idle`
* `storeliveness.transport.send-queue-size`
* `storeliveness.transport.sent`
* `sysbytes`
* `syscount`
* `tenant.consumption.cross_region_network_ru`
* `tenant.consumption.external_io_egress_bytes`
* `tenant.consumption.external_io_ingress_bytes`
* `tenant.consumption.kv_request_units`
* `tenant.consumption.pgwire_egress_bytes`
* `tenant.consumption.read_batches`
* `tenant.consumption.read_bytes`
* `tenant.consumption.read_requests`
* `tenant.consumption.request_units`
* `tenant.consumption.sql_pods_cpu_seconds`
* `tenant.consumption.write_batches`
* `tenant.consumption.write_bytes`
* `tenant.consumption.write_requests`
* `timeseries.write.bytes`
* `timeseries.write.errors`
* `timeseries.write.samples`
* `totalbytes`
* `tscache.skl.pages`
* `tscache.skl.rotations`
* `txn.commit_waits.before_commit_trigger`
* `txn.server_side_retry.read_evaluation.failure`
* `txn.server_side_retry.read_evaluation.success`
* `txn.server_side_retry.uncertainty_interval_error.failure`
* `txn.server_side_retry.uncertainty_interval_error.success`
* `txn.server_side_retry.write_evaluation.failure`
* `txn.server_side_retry.write_evaluation.success`
* `txn.server_side.1PC.failure`
* `txn.server_side.1PC.success`
* `txnrecovery.attempts.pending`
* `txnrecovery.attempts.total`
* `txnrecovery.failures`
* `txnrecovery.successes.aborted`
* `txnrecovery.successes.committed`
* `txnrecovery.successes.pending`
* `txnwaitqueue.deadlocks_total`
* `txnwaitqueue.pushee.waiting`
* `txnwaitqueue.pusher.slow`
* `txnwaitqueue.pusher.wait_time`
* `txnwaitqueue.pusher.waiting`
* `txnwaitqueue.query.wait_time`
* `txnwaitqueue.query.waiting`
* `valbytes`
* `valcount`

## See also

* <InternalLink path="cluster-virtualization-overview">Cluster Virtualization Overview</InternalLink>
* <InternalLink path="cluster-virtualization-setting-scopes">Cluster Setting Scopes with Cluster Virtualization Enabled</InternalLink>
* <InternalLink path="physical-cluster-replication-overview">Physical Cluster Replication</InternalLink>