OpenTelemetry Metrics Reference
Look up supported metrics and their properties.
After you enable metrics streaming for your workspace, Render streams service metrics that pertain to the following categories:
All metrics use OpenTelemetry JSON format. The first component of each metric's name is render. (e.g., render.service.memory.usage).
Some observability providers transform metric names to match their conventions.
For example, Grafana converts the metric render.service.memory.usage to render_service_memory_usage_bytes.
After you set up your metrics stream, inspect incoming data in your provider's dashboard to verify how it formats Render metrics.
See names, descriptions, and included properties for each reported metric below.
Universal properties
All reported metrics include the following properties:
| Property | Description |
|---|---|
|
The name of the service (e.g., Grafana displays this property as |
|
The ID of the service (e.g., |
|
For most metrics, this is the ID of the metric's associated service instance (e.g., Everything before the final hyphen is the service ID ( This value enables you to segment metrics by individual instances of a scaled service, and to identify when a service's instances are cycled as part of a redeploy. |
The following properties are also universal but optional:
| Property | Description |
|---|---|
|
The name of the service's associated project, if it belongs to one (otherwise this property is omitted). |
|
The name of the service's associated environment, if it belongs to one (otherwise this property is omitted). |
CPU
These metrics apply to all compute instances and datastores.
render.service.cpu.limit
The maximum amount of CPU available to a particular service instance (as determined by its compute plan).
Includes universal properties only.
render.service.cpu.time
The cumulative amount of CPU time used by a particular service instance, in seconds.
To visualize changes to CPU load over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
Memory
These metrics apply to all compute instances and datastores.
render.service.memory.limit
The maximum amount of memory available to a particular service instance (as determined by its compute plan), in bytes.
Includes universal properties only.
render.service.memory.usage
The amount of memory that a particular service instance is currently using, in bytes.
Includes universal properties only.
render.service.memory.rss
The amount of anonymous and swap cache memory that a particular service instance is currently using, in bytes.
Includes universal properties only.
render.service.memory.cache
The amount of page cache memory that a particular service instance is currently using, in bytes.
Includes universal properties only.
Network
These metrics apply to all compute instances and datastores.
render.service.network.transmit.bytes
The cumulative number of bytes transmitted by a particular service instance to any destination, including both private network traffic and public internet traffic.
To visualize changes to network traffic over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
render.service.network.receive.bytes
The cumulative number of bytes received by a particular service instance from any source, including both private network traffic and public internet traffic.
To visualize changes to network traffic over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
HTTP requests
These metrics apply only to web services.
HTTP request metrics are not reported per instance.
Render aggregates these metrics across all instances of a given web service. For these metrics, the value of service.instance.id matches that of service.id.
render.service.http.requests.total
The cumulative number of HTTP requests that a given service has received across all instances, segmented by the properties below.
To visualize changes to request load over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The destination domain for incoming requests. This can be your service's |
|
The HTTP status code returned by the service ( |
render.service.http.requests.latency
Provides a particular web service's p50, p95, or p99 response time, in seconds, segmented by the properties below.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
Indicates the percentile of the provided latency value. One of the following:
|
|
The destination domain for incoming requests. This can be your service's |
|
The HTTP status code returned by the service ( |
Disk usage
Each of these metrics applies to one or more of Render Postgres, Render Key Value, and persistent disks.
render.service.disk.capacity
The total capacity of a service's persistent storage, in bytes.
Applies to Render Postgres databases and persistent disks.
Includes universal properties only.
render.service.disk.usage
The amount of occupied persistent storage for a service, in bytes.
Applies to Render Postgres databases and persistent disks.
Includes universal properties only.
Disk I/O
The following metrics apply to Render Postgres and Render Key Value instances.
These cumulative metrics reset whenever the datastore's instance is restarted or replaced, such as during a database upgrade or when changing compute plans.
render.service.disk.read.bytes
The cumulative number of bytes read from disk by a particular service instance.
To visualize changes to disk read activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
render.service.disk.read.count
The cumulative number of read operations performed on disk by a particular service instance.
To visualize changes to disk read activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
render.service.disk.write.bytes
The cumulative number of bytes written to disk by a particular service instance.
To visualize changes to disk write activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
render.service.disk.write.count
The cumulative number of write operations performed on disk by a particular service instance.
To visualize changes to disk write activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
Render Postgres
These metrics are reported only for Render Postgres databases.
Checkpoints
render.postgres.checkpoints.timed
The cumulative number of scheduled checkpoints performed on a particular Render Postgres instance.
PostgreSQL runs scheduled checkpoints at regular intervals, controlled by the value of checkpoint_timeout.
This metric's source depends on your PostgreSQL version:
- On PostgreSQL 17 and later, it corresponds to
num_timedin thepg_stat_checkpointerview. - On PostgreSQL 16 and earlier, it corresponds to
checkpoints_timedin thepg_stat_bgwriterview.
To visualize changes to checkpoint activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
render.postgres.checkpoints.requested
The cumulative number of requested checkpoints performed on a particular Render Postgres instance.
Requested checkpoints happen outside of the regular schedule. PostgreSQL requests one when the write-ahead log grows to max_wal_size, or when triggered explicitly (e.g., using the CHECKPOINT command).
To gauge checkpoint pressure, compare this value with render.postgres.checkpoints.timed. If requested checkpoints regularly outnumber scheduled ones, your write activity is outpacing the checkpoint schedule.
This metric's source depends on your PostgreSQL version:
- On PostgreSQL 17 and later, it corresponds to
num_requestedin thepg_stat_checkpointerview. - On PostgreSQL 16 and earlier, it corresponds to
checkpoints_reqin thepg_stat_bgwriterview.
To visualize changes to checkpoint activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
render.postgres.checkpoint.age
The time since the last completed checkpoint on a particular Render Postgres instance, in seconds.
As part of recovering after a crash, PostgreSQL replays all write-ahead log (WAL) records written after its last checkpoint. Recovery time increases with the number of WAL records to replay.
This metric is calculated using PostgreSQL's pg_control_checkpoint() function.
Includes universal properties only.
Connections
Direct connections
render.postgres.connections
The number of active connections to a particular PostgreSQL database within a Render Postgres instance.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., This value usually does not match the value of |
render.postgres.connection.limit
The maximum number of concurrent connections supported by a particular Render Postgres instance (as determined by its compute plan).
Includes universal properties only.
Connection pooling
Render only reports connection.pool metrics for Render Postgres instances that enable integrated connection pooling.
In the following metrics:
- Client connections are between clients and the connection pool.
- Server connections are between the connection pool and the Render Postgres database.
render.postgres.connection.pool.client.active
The number of client connections that either have an assigned server connection or are idle.
Because this value includes idle clients, it often exceeds render.postgres.connection.pool.server.active.
Includes universal properties only.
render.postgres.connection.pool.client.max_wait
The current wait time of the longest-waiting client connection, in seconds. This value is 0 when no clients are waiting.
Includes universal properties only.
render.postgres.connection.pool.client.waiting
The number of client connections that have sent a query and are waiting for an available server connection. A value above 0 means clients are queuing because the pool is saturated.
Includes universal properties only.
render.postgres.connection.pool.server.active
The number of server connections currently assigned to a client connection.
Includes universal properties only.
render.postgres.connection.pool.server.idle
The number of server connections that are idle and available to serve queries.
Includes universal properties only.
render.postgres.connection.pool.server.limit
The maximum number of server connections the pool can open to the database. To calculate your pool's utilization, divide render.postgres.connection.pool.server.total by this value.
Includes universal properties only.
render.postgres.connection.pool.server.total
The connection pool's total number of server connections.
Includes universal properties only.
render.postgres.connection.pool.wait_time
The cumulative time that client connections have spent waiting for a server connection, in seconds.
To visualize changes to queuing activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
Database activity
Block reads
render.postgres.blocks.hit
The cumulative number of block reads served from shared buffers for a particular PostgreSQL database.
This metric corresponds to blks_hit in PostgreSQL's pg_stat_database view.
To visualize changes to buffer cache activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
render.postgres.blocks.read
The cumulative number of block reads that went to disk or the operating system's page cache for a particular PostgreSQL database. To calculate your buffer cache hit rate, compare this value with render.postgres.blocks.hit.
This metric corresponds to blks_read in PostgreSQL's pg_stat_database view.
To visualize changes to buffer cache activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
render.postgres.index.blocks.hit
The cumulative number of block reads served from shared buffers across all indexes in a particular PostgreSQL database.
This metric corresponds to the sum of idx_blks_hit values in PostgreSQL's pg_statio_user_indexes view.
To visualize changes to index cache activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
render.postgres.index.blocks.read
The cumulative number of block reads that went to disk or the operating system's page cache across all indexes in a particular PostgreSQL database. To calculate your index cache hit rate, compare this value with render.postgres.index.blocks.hit.
This metric corresponds to the sum of idx_blks_read values in PostgreSQL's pg_statio_user_indexes view.
To visualize changes to index cache activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
Table scans
render.postgres.table.scans
The cumulative number of sequential table scans performed across tables in a particular database in a Render Postgres instance.
This metric corresponds to the sum of seq_scan values in PostgreSQL's pg_stat_user_tables view.
To visualize changes to table scan activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
Tuples
render.postgres.tuples.inserted
The cumulative number of rows inserted into a particular PostgreSQL database.
This metric corresponds to tup_inserted in PostgreSQL's pg_stat_database view.
To visualize changes to write activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
render.postgres.tuples.updated
The cumulative number of rows updated in a particular PostgreSQL database.
This metric corresponds to tup_updated in PostgreSQL's pg_stat_database view.
To visualize changes to write activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
render.postgres.tuples.deleted
The cumulative number of rows deleted from a particular PostgreSQL database.
This metric corresponds to tup_deleted in PostgreSQL's pg_stat_database view.
To visualize changes to write activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
render.postgres.tuples.fetched
The cumulative number of live rows fetched by queries on a particular PostgreSQL database.
This metric corresponds to tup_fetched in PostgreSQL's pg_stat_database view.
To visualize changes to read activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
Database size
render.postgres.database.size
The size of a particular PostgreSQL database, in bytes.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
render.postgres.indexes.size
The total size of all indexes in a particular PostgreSQL database, in bytes.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
Lock contention
render.postgres.deadlocks
The cumulative number of deadlocks detected on a particular PostgreSQL database.
This metric corresponds to deadlocks in PostgreSQL's pg_stat_database view.
To visualize changes to deadlock activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
render.postgres.slow.lock.count
The total number of slow locks on a particular Render Postgres instance. A slow lock occurs when a query waits an extended period to acquire a database lock.
Includes universal properties only.
render.postgres.slow.lock.time
The cumulative wait time for slow locks on a particular Render Postgres instance, in seconds.
Includes universal properties only.
Replication and recovery
render.postgres.replication.lag
The delay between when a change occurs on the primary Render Postgres instance and when its read replica (if it has any) fully replicates that change, in milliseconds.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The hostname or identifier of the read replica. |
render.postgres.replication.apply.lag
The delay between when a transaction commits on the primary Render Postgres instance and when its read replica (if it has any) applies those changes, in milliseconds.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The hostname or identifier of the read replica. |
render.postgres.recovery.conflicts
The cumulative number of queries canceled by recovery conflicts on a particular PostgreSQL database. Only read replicas increment this value.
This metric corresponds to conflicts in PostgreSQL's pg_stat_database view.
To visualize changes to conflict activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
Temporary files
render.postgres.temp.bytes
The cumulative number of bytes written to temporary files by a particular PostgreSQL database. Queries write temporary files when operations like sorts and hashes exceed available working memory (work_mem).
This metric corresponds to temp_bytes in PostgreSQL's pg_stat_database view.
To visualize changes to temporary file activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
render.postgres.temp.files
The cumulative number of temporary files written by a particular PostgreSQL database. Sustained growth indicates that queries are spilling to disk.
This metric corresponds to temp_files in PostgreSQL's pg_stat_database view.
To visualize changes to temporary file activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
Transactions
render.postgres.transaction.exhaustion
The percentage of a Render Postgres instance's progress toward transaction ID wraparound.
All databases in an instance draw from the same pool of transaction IDs, so Render reports one value per instance.
PostgreSQL uses transaction IDs to determine which database rows are included in a query's results. These IDs eventually wrap around and are reused, so PostgreSQL cannot rely on IDs more than approximately 2.1 billion transactions old.
If an instance gets close to wraparound, its databases stop accepting writes to prevent data loss. For more details, see the PostgreSQL documentation.
See the table below to interpret this metric's values:
| Value | Description |
|---|---|
|
10 or below |
The instance is healthy and requires no action. |
|
Above 10 and rising |
PostgreSQL is not clearing old transaction IDs quickly enough, raising the risk of wraparound. To reduce the risk of wraparound:
|
|
Approaching or above 100 |
The instance is running out of transaction IDs and can effectively become read-only. Database writes can fail with To restore access:
|
Includes universal properties only.
render.postgres.transaction.volume
The cumulative number of transactions (i.e., commits and rollbacks) on a particular Render Postgres instance.
To visualize changes to transaction activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
render.postgres.transactions.committed
The cumulative number of transactions committed on a particular PostgreSQL database.
This metric corresponds to xact_commit in PostgreSQL's pg_stat_database view.
To visualize changes to transaction activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
render.postgres.transactions.rolled.back
The cumulative number of transactions rolled back on a particular PostgreSQL database. To calculate your rollback rate, compare this value with render.postgres.transactions.committed.
This metric corresponds to xact_rollback in PostgreSQL's pg_stat_database view.
To visualize changes to transaction activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties, along with the following:
| Property | Description |
|---|---|
|
The name of the PostgreSQL database created in the instance (e.g., |
WAL archiving
render.postgres.archiver.failures
The cumulative number of failed WAL archive attempts on a particular Render Postgres instance.
This metric corresponds to failed_count in PostgreSQL's pg_stat_archiver view.
To visualize changes to archiver activity over time, apply a rate() function or similar in your observability provider.
Includes universal properties only.
Render Key Value
Render Key Value instances include disk I/O metrics, as well as the following metrics.
Connections
render.keyvalue.connections
The number of active connections to a particular Render Key Value instance.
Includes universal properties only.
render.keyvalue.connection.limit
The maximum number of concurrent connections supported for a particular Render Key Value instance (as determined by its compute plan).
Includes universal properties only.
History of changes to reported metrics
| Date | Change |
|---|---|
|
|
Added the following Render Postgres index cache metrics: |
|
|
Added the following Render Postgres checkpoint metrics: |
|
|
Added the following Render Postgres metrics: Block reads Temporary files Transactions Tuples
Additional metrics |
|
|
Added the following Render Postgres connection pool metrics:
|
|
|
Added the following Render Postgres transaction metrics: |
|
|
Added the following Render Postgres metrics: |
|
|
Added the following Render Postgres metrics:
Added the following disk I/O metrics: |
|
|
Added the following datastore connection metrics:
Added the following memory metrics: Added the following networking metrics: |
|
|
Added the following initial set of metrics: |