The following Spanner metrics are provided to Cloud Monitoring. For the best performance debugging results, use server-side metrics with client-side metrics.
      The "metric type" strings in this table must be prefixed
      with spanner.googleapis.com/. That prefix has been
      omitted from the entries in the table.
      When querying a label, use the metric.labels. prefix; for
      example, metric.labels.LABEL="VALUE".
    
| Metric type Launch stage (Resource hierarchy levels) Display name | |
|---|---|
| Kind, Type, Unit Monitored resources | Description Labels | 
| api/adapter_request_countGA
             (project)Adapter API requests | |
| DELTA,INT64,1spanner_instance | Cloud Spanner Adapter API requests. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database.status:
              Request call result, ok=success.method:
              Cloud Spanner Adapter API method.protocol:
              Adapter protocol.message_type:
              Adapter protocol message type.adapter_status:
              Adapter protocol request result.op_type:
              Operation type. | 
| api/adapter_request_latenciesGA
             (project)Adapter request latencies | |
| DELTA,DISTRIBUTION,sspanner_instance | Distribution of server request latencies for a database. This includes latency of request processing in Cloud Spanner backends and API layer. It does not include network or reverse-proxy overhead between clients and servers. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database.method:
              Cloud Spanner Adapter API method.protocol:
              Adapter protocol.message_type:
              Adapter protocol message type.op_type:
              Operation type. | 
| api/api_request_countGA
             (project)API requests | |
| DELTA,INT64,1spanner_instance | Cloud Spanner API requests. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.status:
              Request call result, ok=success.method:
              Cloud Spanner API method. | 
| api/read_request_count_by_serving_locationBETA
             (project)Read API request by serving location | |
| DELTA,INT64,1spanner_instance | Cloud Spanner Read API requests by serving location, whether it is a directed read query, and whether it is a change stream query. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database.method:
              Cloud Spanner API method.is_change_stream:
                (BOOL)
              TRUE if it is a change stream query.is_directed_read:
                (BOOL)
              TRUE if it is a directed read query.status:
              Request call result, OK=success.serving_location:
              The location of serving replicas. | 
| api/read_request_latencies_by_change_streamGA
             (project)Read request latencies by change stream | |
| DELTA,DISTRIBUTION,sspanner_instance | Distribution of read request latencies by whether it is a change stream query. This includes latency of request processing in Cloud Spanner backends and API layer. It does not include network or reverse-proxy overhead between clients and servers. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.method:
              Cloud Spanner API method.is_change_stream:
                (BOOL)
              TRUE if it is a change stream query. | 
| api/read_request_latencies_by_serving_locationBETA
             (project)Read API request latencies by serving location | |
| DELTA,DISTRIBUTION,sspanner_instance | Distribution of read request latencies by serving location, whether it is a directed read query, and whether it is a change stream query. This includes latency of request processing in Cloud Spanner backends and API layer. It does not include network or reverse-proxy overhead between clients and servers. This is a superset of spanner.googleapis.com/api/read_request_latencies_by_change_stream. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database.method:
              Cloud Spanner API method.is_change_stream:
                (BOOL)
              TRUE if it is a change stream query.is_directed_read:
                (BOOL)
              TRUE if it is a directed read query.serving_location:
              The location of serving replicas. | 
| api/received_bytes_countGA
             (project)Bytes received by Cloud Spanner | |
| DELTA,INT64,Byspanner_instance | Uncompressed request bytes received by Cloud Spanner. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.method:
              Cloud Spanner API method. | 
| api/request_countGA
             (project)API request rate | |
| GAUGE,DOUBLE,1/sspanner_instance | Rate of Cloud Spanner API requests. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.status:
              Request call result, ok=success.method:
              Cloud Spanner API method. | 
| api/request_count_per_transaction_optionsGA
             (project)API requests by transaction options | |
| GAUGE,DOUBLE,1/sspanner_instance | Cloud Spanner API request rate by transaction options. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database.method:
              Cloud Spanner API method.status:
              Request call result, ok=success.op_type:
              Operation type ("read", "write" or "other").response_code:
              HTTP response code received, such as 200 or 500.lock_mode:
              The read lock mode used if within a read-write transaction ("PESSIMISTIC" or "OPTIMISTIC").isolation_level:
              The isolation level used if within a read-write transaction ("SERIALIZABLE" or "REPEATABLE_READ").region:
              The region where the request was served.transaction_type:
              Transaction type ("READ_ONLY", "READ_WRITE", "PARTITIONED_DML" or "NONE"). | 
| api/request_latenciesGA
             (project)Request latencies | |
| DELTA,DISTRIBUTION,sspanner_instance | Distribution of server request latencies for a database. This includes latency of request processing in Cloud Spanner backends and API layer. It does not include network or reverse-proxy overhead between clients and servers. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.method:
              Cloud Spanner API method. | 
| api/request_latencies_by_transaction_typeGA
             (project)Request latencies by transaction type | |
| DELTA,DISTRIBUTION,sspanner_instance | Distribution of server request latencies by transaction types. This includes latency of request processing in Cloud Spanner backends and API layer. It does not include network or reverse-proxy overhead between clients and servers. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.method:
              Cloud Spanner API method.transaction_type:
              Transaction type ("READ_ONLY" or "READ_WRITE").is_leader_involved:
                (BOOL)
              TRUE if the leader roundtrip call is issued. | 
| api/request_latencies_per_transaction_optionsGA
             (project)Request latencies by transaction options | |
| DELTA,DISTRIBUTION,sspanner_instance | Distribution of server request latencies by transaction options for a database. This includes latency of request processing in Cloud Spanner backends and API layer. It does not include network or reverse-proxy overhead between clients and servers. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database.method:
              Cloud Spanner API method.op_type:
              Operation type ("read", "write" or "other").lock_mode:
              The read lock mode used if within a read-write transaction ("PESSIMISTIC" or "OPTIMISTIC").isolation_level:
              The isolation level used if within a read-write transaction ("SERIALIZABLE" or "REPEATABLE_READ").is_leader_involved:
                (BOOL)
              TRUE if the leader roundtrip call is issued.region:
              The region where the request was served.transaction_type:
              Transaction type ("READ_ONLY", "READ_WRITE", "PARTITIONED_DML" or "NONE"). | 
| api/sent_bytes_countGA
             (project)Bytes sent by Cloud Spanner | |
| DELTA,INT64,Byspanner_instance | Uncompressed response bytes sent by Cloud Spanner. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.method:
              Cloud Spanner API method. | 
| client/afe_connectivity_error_countGA
             (project)AFE Connectivity Error Count | |
| DELTA,INT64,1spanner_instance | Number of requests that failed to reach the Spanner API Frontend. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. method:
              Cloud Spanner API method.database:
              Target database.status:
              Cloud Spanner operation status.client_name:
              Cloud Spanner client name.directpath_enabled:
                (BOOL)
              True if directpath is enabled.directpath_used:
                (BOOL)
              True if directpath is used for the RPC request. | 
| client/afe_latenciesGA
             (project)AFE Latencies | |
| DELTA,DISTRIBUTION,msspanner_instance | Latency between Spanner API Frontend receiving an RPC and starting to write back the response. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. method:
              Cloud Spanner API method.database:
              Target database.status:
              Cloud Spanner operation status.client_name:
              Cloud Spanner client name.directpath_enabled:
                (BOOL)
              True if directpath is enabled.directpath_used:
                (BOOL)
              True if directpath is used for the RPC request. | 
| client/attempt_countGA
             (project)Attempt Count | |
| DELTA,INT64,1spanner_instance | The total number of RPC attempt performed by the Spanner client. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. method:
              Cloud Spanner API method.database:
              Target database.status:
              Cloud Spanner attempt status.client_name:
              Cloud Spanner client name.directpath_enabled:
                (BOOL)
              True if directpath is enabled.directpath_used:
                (BOOL)
              True if directpath is used for the RPC request. | 
| client/attempt_latenciesGA
             (project)Attempt Latencies | |
| DELTA,DISTRIBUTION,msspanner_instance | Distribution of the total end-to-end latency across a RPC attempt. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. method:
              Cloud Spanner API method.database:
              Target database.status:
              Cloud Spanner attempt status.client_name:
              Cloud Spanner client name.directpath_enabled:
                (BOOL)
              True if directpath is enabled.directpath_used:
                (BOOL)
              True if directpath is used for the RPC request. | 
| client/gfe_connectivity_error_countGA
             (project)GFE Connectivity Error Count | |
| DELTA,INT64,1spanner_instance | Number of requests that failed to reach the Google network. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. method:
              Cloud Spanner API method.database:
              Target database.status:
              Cloud Spanner operation status.client_name:
              Cloud Spanner client name.directpath_enabled:
                (BOOL)
              True if directpath is enabled.directpath_used:
                (BOOL)
              True if directpath is used for the RPC request. | 
| client/gfe_latenciesGA
             (project)GFE Latencies | |
| DELTA,DISTRIBUTION,msspanner_instance | Latency between Google network(GFE) receiving an RPC and reading back the first byte of the response. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. method:
              Cloud Spanner API method.database:
              Target database.status:
              Cloud Spanner operation status.client_name:
              Cloud Spanner client name.directpath_enabled:
                (BOOL)
              True if directpath is enabled.directpath_used:
                (BOOL)
              True if directpath is used for the RPC request. | 
| client/operation_countGA
             (project)Operation Count | |
| DELTA,INT64,1spanner_instance | The total number of operations performed by the Spanner client. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. method:
              Cloud Spanner API method.database:
              Target database.status:
              Cloud Spanner operation status.client_name:
              Cloud Spanner client name.directpath_enabled:
                (BOOL)
              True if directpath is enabled.directpath_used:
                (BOOL)
              True if directpath is used for the RPC request. | 
| client/operation_latenciesGA
             (project)Operation Latencies | |
| DELTA,DISTRIBUTION,msspanner_instance | Distribution of the total end-to-end latency across all RPC attempts associated with a Spanner operation. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. method:
              Cloud Spanner API method.database:
              Target database.status:
              Cloud Spanner operation status.client_name:
              Cloud Spanner client name.directpath_enabled:
                (BOOL)
              True if directpath is enabled.directpath_used:
                (BOOL)
              True if directpath is used for the RPC request. | 
| graph_query_stat/total/bytes_returned_countGA
             (project)Graph query bytes returned count | |
| DELTA,INT64,Byspanner_instance | Number of data bytes that the graph queries returned, excluding transmission encoding overhead. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| graph_query_stat/total/execution_countGA
             (project)Graph query execution count | |
| DELTA,INT64,1spanner_instance | Number of times Cloud Spanner saw graph queries during the interval. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| graph_query_stat/total/failed_execution_countGA
             (project)Graph query failures | |
| DELTA,INT64,1spanner_instance | Number of times graph queries failed during the interval. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database.status:
              failed status, one of [cancelled, timeout, error]. | 
| graph_query_stat/total/query_latenciesGA
             (project)Graph query latencies | |
| DELTA,DISTRIBUTION,sspanner_instance | Distribution of total length of time, in seconds, for graph query executions within the database. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| graph_query_stat/total/returned_rows_countGA
             (project)Graph query rows returned count | |
| DELTA,INT64,1spanner_instance | Number of rows that the graph queries returned. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| graph_query_stat/total/scanned_rows_countGA
             (project)Graph query rows scanned count | |
| DELTA,INT64,1spanner_instance | Number of rows that the graph queries scanned excluding deleted values. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| instance/autoscaling/high_priority_cpu_utilization_targetGA
             (project)Autoscaling high priority cpu utilization target | |
| GAUGE,DOUBLE,10^2.%spanner_instance | High priority CPU utilization target used for autoscaling. Sampled every 60 seconds. After sampling, data is not visible for up to 210 seconds. | 
| instance/autoscaling/max_node_countGA
             (project)Autoscaling max nodes | |
| GAUGE,INT64,1spanner_instance | Maximum number of nodes autoscaler is allowed to allocate to the instance. Sampled every 60 seconds. After sampling, data is not visible for up to 210 seconds. | 
| instance/autoscaling/max_processing_unitsGA
             (project)Autoscaling max processing units | |
| GAUGE,INT64,1spanner_instance | Maximum number of processing units autoscaler is allowed to allocate to the instance. Sampled every 60 seconds. After sampling, data is not visible for up to 210 seconds. | 
| instance/autoscaling/min_node_countGA
             (project)Autoscaling min nodes | |
| GAUGE,INT64,1spanner_instance | Minimum number of nodes autoscaler is allowed to allocate to the instance. Sampled every 60 seconds. After sampling, data is not visible for up to 210 seconds. | 
| instance/autoscaling/min_processing_unitsGA
             (project)Autoscaling min processing units | |
| GAUGE,INT64,1spanner_instance | Minimum number of processing units autoscaler is allowed to allocate to the instance. Sampled every 60 seconds. After sampling, data is not visible for up to 210 seconds. | 
| instance/autoscaling/storage_utilization_targetGA
             (project)Autoscaling storage utilization target | |
| GAUGE,DOUBLE,10^2.%spanner_instance | Storage utilization target used for autoscaling. Sampled every 60 seconds. After sampling, data is not visible for up to 210 seconds. | 
| instance/backup/used_bytesGA
             (project)Backup storage used | |
| GAUGE,INT64,Byspanner_instance | Backup storage used in bytes. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.backup:
              Target backup. | 
| instance/cpu/smoothed_utilizationGA
             (project)Smoothed CPU utilization | |
| GAUGE,DOUBLE,10^2.%spanner_instance | 24-hour smoothed utilization of provisioned CPU. Values are typically numbers between 0.0 and 1.0 (but might exceed 1.0), charts display the values as a percentage between 0% and 100% (or more). Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database. | 
| instance/cpu/utilizationGA
             (project)CPU utilization | |
| GAUGE,DOUBLE,10^2.%spanner_instance | Percent utilization of provisioned CPU. Values are typically numbers between 0.0 and 1.0 (but might exceed 1.0), charts display the values as a percentage between 0% and 100% (or more). Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database. | 
| instance/cpu/utilization_by_operation_typeGA
             (project)CPU utilization by operation type | |
| GAUGE,DOUBLE,10^2.%spanner_instance | Percent utilization of provisioned CPU, by operation type. Values are typically numbers between 0.0 and 1.0 (but might exceed 1.0), charts display the values as a percentage between 0% and 100% (or more). Currently, it does not include CPU utilization for system tasks. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.is_system:
                (BOOL)
              TRUE if the number is system CPU utilization.priority:
              Task priority ("high" or "medium" or "low").category:
              Operation type ("read_readonly", "beginorcommit" etc). | 
| instance/cpu/utilization_by_priorityGA
             (project)CPU utilization by priority | |
| GAUGE,DOUBLE,10^2.%spanner_instance | Percent utilization of provisioned CPU, by priority. Values are typically numbers between 0.0 and 1.0 (but might exceed 1.0), charts display the values as a percentage between 0% and 100% (or more). Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.is_system:
                (BOOL)
              TRUE if the number is system CPU utilization.priority:
              Task priority ("high", "medium", or "low"). | 
| instance/cross_region_replicated_bytes_countGA
             (project)Cross region replicated bytes | |
| DELTA,INT64,Byspanner_instance | Number of bytes replicated from preferred leader to replicas across regions. Sampled every 60 seconds. After sampling, data is not visible for up to 240 seconds. database:
              Target database.source_region:
              Preferred leader region.destination_region:
              Cloud Spanner region the data is replicated to.tag:
              Type of transaction contributing to replication. | 
| instance/data_boost/processing_unit_second_countGA
             (project)Processing unit second | |
| DELTA,INT64,1spanner_instance | Total processing units used for DataBoost operations. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. credential_id:
              The IAM credential ID. | 
| instance/disk_loadGA
             (project)Disk load | |
| GAUGE,DOUBLE,10^2.%spanner_instance | Percent utilization of HDD disk load in an instance. Values are typically numbers between 0.0 and 1.0 (but might exceed 1.0), charts display the values as a percentage between 0% and 100% (or more). Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database. | 
| instance/dual_region_quorum_availabilityGA
             (project)Dual Region Quorum Availability | |
| GAUGE,BOOL,1spanner_instance | Quorum availability signal for dual region instance configs. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. quorum_availability:
              Quorum availability level. | 
| instance/edition/feature_usageBETA
             (project)Feature usage | |
| GAUGE,BOOL,1spanner_instance | Indicates if an edition feature is being used by the instance. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. feature:
              Edition feature.database:
              Database using the feature, if any.used_in_query_path:
                (BOOL)
              Used in query path, or not. | 
| instance/leader_percentage_by_regionGA
             (project)Leader percentage by region | |
| GAUGE,DOUBLE,10^2.%spanner_instance | Percentage of leaders by cloud region. Values are typically numbers between 0.0 and 1.0, charts display the values as a percentage between 0% and 100%. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.region:
              Cloud region containing the leaders. | 
| instance/node_countGA
             (project)Nodes | |
| GAUGE,INT64,1spanner_instance | Total number of nodes. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. | 
| instance/peak_split_cpu_usage_scoreGA
             (project)Peak split cpu usage score | |
| GAUGE,DOUBLE,1spanner_instance | Maximum cpu usage score observed in a database across all splits. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database. | 
| instance/placement_row_limitGA
             (project)Placement row limit | |
| GAUGE,INT64,1spanner_instance | Upper limit for placement rows. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. | 
| instance/placement_row_limit_per_processing_unitGA
             (project)Placement row limit per processing unit | |
| GAUGE,DOUBLE,1spanner_instance | Upper limit for placement rows per processing unit. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. | 
| instance/placement_rowsGA
             (project)Placement row count by database | |
| GAUGE,INT64,1spanner_instance | Number of placement rows in a database. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database. | 
| instance/processing_unitsGA
             (project)Processing units | |
| GAUGE,INT64,1spanner_instance | Total number of processing units. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. | 
| instance/replica/autoscaling/high_priority_cpu_utilization_targetGA
             (project)Autoscaling high priority cpu utilization target for replica | |
| GAUGE,DOUBLE,10^2.%spanner_instance | High priority CPU utilization target used for autoscaling replica. Sampled every 60 seconds. After sampling, data is not visible for up to 210 seconds. location:
              Replica location.replica_type:
              Replica type. | 
| instance/replica/autoscaling/max_node_countGA
             (project)Autoscaling max nodes for replica | |
| GAUGE,INT64,1spanner_instance | Maximum number of nodes autoscaler is allowed to allocate to the replica. Sampled every 60 seconds. After sampling, data is not visible for up to 210 seconds. location:
              Replica location.replica_type:
              Replica type. | 
| instance/replica/autoscaling/max_processing_unitsGA
             (project)Autoscaling max processing units for replica | |
| GAUGE,INT64,1spanner_instance | Maximum number of processing units autoscaler is allowed to allocate to the replica. Sampled every 60 seconds. After sampling, data is not visible for up to 210 seconds. location:
              Replica location.replica_type:
              Replica type. | 
| instance/replica/autoscaling/min_node_countGA
             (project)Autoscaling min nodes for replica | |
| GAUGE,INT64,1spanner_instance | Minimum number of nodes autoscaler is allowed to allocate to the replica. Sampled every 60 seconds. After sampling, data is not visible for up to 210 seconds. location:
              Replica location.replica_type:
              Replica type. | 
| instance/replica/autoscaling/min_processing_unitsGA
             (project)Autoscaling min processing units for replica | |
| GAUGE,INT64,1spanner_instance | Minimum number of processing units autoscaler is allowed to allocate to the replica. Sampled every 60 seconds. After sampling, data is not visible for up to 210 seconds. location:
              Replica location.replica_type:
              Replica type. | 
| instance/replica/cmek/total_keysBETA
             (project)CMEK keys | |
| GAUGE,INT64,1spanner_instance | Number of CMEK keys identified by database and key revocation status. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database.is_key_revoked:
                (BOOL)
              True if the CloudKMS key is revoked. | 
| instance/replica/node_countGA
             (project)Replica nodes | |
| GAUGE,INT64,1spanner_instance | Number of nodes allocated to each replica identified by location and replica type. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. location:
              Replica location.replica_type:
              Replica type. | 
| instance/replica/processing_unitsGA
             (project)Replica processing units. | |
| GAUGE,INT64,1spanner_instance | Number of processing units allocated to each replica identified by location and replica type. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. location:
              Replica location.replica_type:
              Replica type. | 
| instance/schema_object_count_limitGA
             (project)Schema objects count limit | |
| GAUGE,INT64,1spanner_instance | The schema object count limit for the instance. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. | 
| instance/schema_objectsGA
             (project)Schema object count | |
| GAUGE,INT64,1spanner_instance | The total count of schema objects in the database. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database. | 
| instance/session_countGA
             (project)Sessions | |
| GAUGE,INT64,1spanner_instance | Number of sessions in use. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database. | 
| instance/storage/columnar_used_bytesBETA
             (project)Storage used (logical) for columnar storage | |
| GAUGE,INT64,Byspanner_instance | Storage used (logical) in bytes for columnar storage. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.storage_class:
              Storage type. | 
| instance/storage/columnar_used_bytes_by_regionBETA
             (project)Storage used (logical) for columnar storage by region | |
| GAUGE,INT64,Byspanner_instance | Storage used (logical) in bytes for columnar storage by cloud region. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database.storage_class:
              Storage type. | 
| instance/storage/combined/limit_bytesGA
             (project)Storage limit (combined) | |
| GAUGE,INT64,Byspanner_instance | Storage limit (combined) for instance in bytes. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. | 
| instance/storage/combined/limit_bytes_per_processing_unitGA
             (project)Storage limit (combined) per processing unit | |
| GAUGE,INT64,Byspanner_instance | Storage limit (combined) per processing unit in bytes. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. | 
| instance/storage/combined/utilizationGA
             (project)Storage utilization (combined) | |
| GAUGE,DOUBLE,10^2.%spanner_instance | Storage used (combined) as a fraction of storage limit (combined). Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. | 
| instance/storage/limit_bytesGA
             (project)Storage limit | |
| GAUGE,INT64,Byspanner_instance | Storage limit for instance in bytes. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. storage_class:
              Storage type. | 
| instance/storage/limit_bytes_per_processing_unitGA
             (project)Storage limit per processing unit | |
| GAUGE,INT64,Byspanner_instance | Storage limit per processing unit in bytes. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. storage_class:
              Storage type. | 
| instance/storage/used_bytesGA
             (project)Storage used | |
| GAUGE,INT64,Byspanner_instance | Storage used in bytes. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. database:
              Target database.storage_class:
              Storage type. | 
| instance/storage/utilizationGA
             (project)Storage utilization | |
| GAUGE,DOUBLE,10^2.%spanner_instance | Storage used as a fraction of storage limit. Sampled every 60 seconds. After sampling, data is not visible for up to 180 seconds. storage_class:
              Storage type. | 
| lock_stat/total/lock_wait_timeGA
             (project)Lock wait time | |
| DELTA,DOUBLE,sspanner_instance | Total lock wait time for lock conflicts recorded for the entire database. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| pending_restore_countGA
             (project)Pending restore count | |
| GAUGE,INT64,1spanner.googleapis.com/Instance | Limits number of pending restores per instance. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. | 
| query_countGA
             (project)Count of queries | |
| DELTA,INT64,1spanner_instance | Count of queries by database name, status, query type, and used optimizer version. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database.status:
              Request call result, ok=success.query_type:
              Type of query.optimizer_version:
                (INT64)
              Optimizer version used by the query. | 
| query_stat/total/bytes_returned_countGA
             (project)Bytes returned count | |
| DELTA,INT64,Byspanner_instance | Number of data bytes that the queries returned, excluding transmission encoding overhead. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| query_stat/total/cpu_timeGA
             (project)Query cpu time | |
| DELTA,DOUBLE,sspanner_instance | Number of seconds of CPU time Cloud Spanner spent on operations to execute the queries. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| query_stat/total/execution_countGA
             (project)Query execution count | |
| DELTA,INT64,1spanner_instance | Number of times Cloud Spanner saw queries during the interval. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| query_stat/total/failed_execution_countGA
             (project)Query failures | |
| DELTA,INT64,1spanner_instance | Number of times queries failed during the interval. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database.status:
              failed status, one of [cancelled, timeout, error]. | 
| query_stat/total/query_latenciesGA
             (project)Query latencies | |
| DELTA,DISTRIBUTION,sspanner_instance | Distribution of total length of time, in seconds, for query executions within the database. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| query_stat/total/remote_service_calls_countGA
             (project)Remote service calls count | |
| DELTA,INT64,1spanner_instance | Count of remote service calls. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database.service:
              Target remote service.response_code:
                (INT64)
              HTTP response code received, such as 200 or 500. | 
| query_stat/total/remote_service_calls_latenciesGA
             (project)Remote service calls latencies | |
| DELTA,DISTRIBUTION,msspanner_instance | Latency of remote service calls. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database.service:
              Target remote service.response_code:
                (INT64)
              HTTP response code received, such as 200 or 500. | 
| query_stat/total/remote_service_network_bytes_sizesGA
             (project)Remote service network bytes | |
| DELTA,DISTRIBUTION,Byspanner_instance | Network bytes exchanged with remote service. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database.service:
              Target remote service.direction:
              Direction of traffic: sent or received. | 
| query_stat/total/remote_service_processed_rows_countGA
             (project)Remote service rows count | |
| DELTA,INT64,1spanner_instance | Count of rows processed by a remote service. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database.service:
              Target remote service.response_code:
                (INT64)
              HTTP response code received, such as 200 or 500. | 
| query_stat/total/remote_service_processed_rows_latenciesGA
             (project)Remote service rows latencies | |
| DELTA,DISTRIBUTION,msspanner_instance | Latency of rows processed by a remote service. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database.service:
              Target remote service.response_code:
                (INT64)
              HTTP response code received, such as 200 or 500. | 
| query_stat/total/returned_rows_countGA
             (project)Rows returned count | |
| DELTA,INT64,1spanner_instance | Number of rows that the queries returned. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| query_stat/total/scanned_rows_countGA
             (project)Rows scanned count | |
| DELTA,INT64,1spanner_instance | Number of rows that the queries scanned excluding deleted values. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| quota/pending_restore_count/exceededGA
             (project)Pending restore count quota exceeded error | |
| DELTA,INT64,1spanner.googleapis.com/Instance | Number of attempts to exceed the limit on quota metric spanner.googleapis.com/pending_restore_count. After sampling, data is not visible for up to 150 seconds. limit_name:
              The limit name. | 
| quota/pending_restore_count/limitGA
             (project)Pending restore count quota limit | |
| GAUGE,INT64,1spanner.googleapis.com/Instance | Current limit on quota metric spanner.googleapis.com/pending_restore_count. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. limit_name:
              The limit name. | 
| quota/pending_restore_count/usageGA
             (project)Pending restore count quota usage | |
| GAUGE,INT64,1spanner.googleapis.com/Instance | Current usage on quota metric spanner.googleapis.com/pending_restore_count. After sampling, data is not visible for up to 150 seconds. limit_name:
              The limit name. | 
| read_stat/total/bytes_returned_countGA
             (project)Bytes returned count | |
| DELTA,INT64,Byspanner_instance | Total number of data bytes that the reads returned excluding transmission encoding overhead. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| read_stat/total/client_wait_timeGA
             (project)Client wait time | |
| DELTA,DOUBLE,sspanner_instance | Number of seconds spent waiting due to throttling. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| read_stat/total/cpu_timeGA
             (project)Read cpu time | |
| DELTA,DOUBLE,sspanner_instance | Number of seconds of CPU time Cloud Spanner spent execute the reads excluding prefetch CPU and other overhead. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| read_stat/total/execution_countGA
             (project)Read execution count | |
| DELTA,INT64,1spanner_instance | Number of times Cloud Spanner executed the read shapesduring the interval. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| read_stat/total/leader_refresh_delayGA
             (project)Leader refresh delay | |
| DELTA,DOUBLE,sspanner_instance | Number of seconds spent coordinating reads across instances in multi-regionconfigurations. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| read_stat/total/locking_delaysGA
             (project)Locking delays | |
| DELTA,DISTRIBUTION,sspanner_instance | Distribution of total time in seconds spent waiting due to locking. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| read_stat/total/returned_rows_countGA
             (project)Rows returned count | |
| DELTA,INT64,1spanner_instance | Number of rows that the reads returned. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| row_deletion_policy/deleted_rows_countGA
             (project)Rows deleted | |
| DELTA,INT64,1spanner_instance | Count of rows deleted by the policy since the last sample. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database. | 
| row_deletion_policy/processed_watermark_ageGA
             (project)Processed watermark age | |
| GAUGE,INT64,sspanner_instance | Time between now and the read timestamp of the last successful execution. An execution happens as the background task deletes eligible data in batches and is successful even when there are rows that cannot be deleted. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database. | 
| row_deletion_policy/undeletable_rowsGA
             (project)Total number of undeletable rows | |
| GAUGE,INT64,1spanner_instance | Number of rows in all tables in the database that can't be deleted. A row can't be deleted if, for example, it has so many child rows that a delete would exceed the transaction limit. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds. database:
              Target database. | 
| transaction_stat/total/bytes_written_countGA
             (project)Bytes written | |
| DELTA,INT64,Byspanner_instance | Number of bytes written by transactions. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| transaction_stat/total/commit_attempt_countGA
             (project)Transaction commit attempts | |
| DELTA,INT64,1spanner_instance | Number of commit attempts for transactions. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database.status:
              Commit status ("success", "abort", or "precondition_failure") | 
| transaction_stat/total/commit_retry_countGA
             (project)Transaction commit retries | |
| DELTA,INT64,1spanner_instance | Number of commit attempts that are retries from previously aborted transaction attempts. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| transaction_stat/total/participantsGA
             (project)Transaction participants | |
| DELTA,DISTRIBUTION,1spanner_instance | Distribution of total number of participants in each commit attempt. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
| transaction_stat/total/transaction_latenciesGA
             (project)Transaction latencies | |
| DELTA,DISTRIBUTION,sspanner_instance | Distribution of total seconds takenfrom the first operation of the transaction to commit or abort. Sampled every 60 seconds. After sampling, data is not visible for up to 150 seconds. database:
              Target database. | 
Table generated at 2025-10-02 20:08:43 UTC.