---
title: Render Metrics
description: >-
  Collects metrics from your Render services and datastores, including CPU,
  memory, HTTP, network, and disk usage.
breadcrumbs: Docs > Integrations > Render Metrics
---

> For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt).

# Render Metrics
Integration version1.0.0
{% callout %}
# Important note for users on the following Datadog sites: us2.ddog-gov.com

{% alert level="info" %}
To find out if this integration is available in your organization, see your [Datadog Integrations](https://app.datadoghq.com/integrations) page or ask your organization administrator.

To initiate an exception request to enable this integration for your organization, email [support@ddog-gov.com](mailto:support@ddog-gov.com).
{% /alert %}

{% /callout %}
         Render — OverviewRender — CPU & Memory UtilizationRender — HTTP ThroughputRender — Instance DetailsRender — Network Usage
## Overview{% #overview %}

[Render](https://render.com) is a cloud application platform for deploying web services, static sites, background workers, cron jobs, private services, and managed datastores.

This integration collects resource utilization, HTTP traffic, network, and disk metrics for each active Render service, along with metrics from Render's managed datastores, using Render's [Metrics Stream](https://render.com/docs/metrics-streams).

Metrics are not emitted for static sites, cron jobs, or one-off jobs.

### Resource metrics{% #resource-metrics %}

Reported for all compute instances and datastores. For each one, this integration tracks CPU and memory consumption against configured limits.

- **CPU limit**: Configured CPU limit, in CPU cores.
- **CPU time**: Cumulative CPU time consumed, in seconds. Divide the rate of change by the CPU limit to get utilization.
- **Memory limit**: Configured memory limit, in bytes.
- **Memory usage**: Total memory currently in use.
- **Memory RSS**: Resident set size memory in use.
- **Memory cache**: Page cache memory in use.

### HTTP metrics{% #http-metrics %}

Reported for web services only. Render aggregates these across every instance of a service, so they cannot be split per instance.

- **HTTP requests**: Total request counts, broken down by host and status code.
- **HTTP latency**: Latency at the p50, p95, and p99 quantiles, broken down by host and status code.

### Network metrics{% #network-metrics %}

Reported for web services only; cron jobs and background workers do not populate this data. Both metrics cover private and public traffic.

- **Network transmit**: Total bytes transmitted by the service.
- **Network receive**: Total bytes received by the service.

### Disk metrics{% #disk-metrics %}

Capacity and usage are reported for datastores and for services with a persistent disk attached. Read and write throughput is reported for datastores only.

- **Disk capacity**: Total size of the volume.
- **Disk usage**: Space currently in use.
- **Disk read and write**: Bytes transferred and operations performed against the volume.

### PostgreSQL metrics{% #postgresql-metrics %}

Reported for Render PostgreSQL instances. Connection counts and most activity metrics are broken down by database using a `database_name` tag.

- **Connections**: Open client connections and the instance connection limit.
- **Connection pool**: Client and server pool state, including active, idle, and waiting connections and time spent waiting for a pooled connection. Emitted only when integrated connection pooling is enabled, which requires a paid compute plan.
- **Throughput**: Transactions committed and rolled back, rows inserted, updated, deleted, and fetched, and sequential scans across user tables.
- **Cache efficiency**: Blocks served from the buffer cache versus blocks read from disk.
- **Storage**: On-disk size of the database and its indexes, plus temporary files written by queries that exceed `work_mem`.
- **Contention**: Deadlocks detected and locks held beyond the slow-lock threshold.
- **Maintenance**: Checkpoint activity, progress toward transaction ID exhaustion, and write-ahead log archiving failures.
- **Replication**: Replication lag and apply lag against each replication host, and queries cancelled because of conflicts with recovery. Emitted only when a read replica or high-availability standby exists.

### Key-value metrics{% #key-value-metrics %}

Reported for Render Key Value instances.

- **Connections**: Open client connections and the configured connection limit.

## Setup{% #setup %}

### Prerequisites{% #prerequisites %}

- A Render account with at least one active service or datastore.
- Your Render workspace must be on the **Pro plan** or higher to stream metrics to an external provider.
- Workspace admin access in Render. Metrics Stream destinations are admin-only.

### In Datadog{% #in-datadog %}

1. Generate a Datadog API key and save it for later use. This must be an **organization-level** API key. Render's Datadog destination does not accept personal or application keys.
Copy the generated webhook URL from the **Configure** tab on the [Render Metrics integration tile](https://app.datadoghq.com/integrations/render-metrics).

### In Render{% #in-render %}

1. From your workspace's home in the Render [Dashboard](https://dashboard.render.com), select **Observability** in the left sidebar.
1. Under **Metrics Stream**, click **+ Add destination**.
1. Select **Datadog** as the observability provider from the dropdown.
1. Select your Datadog site, according to where your Datadog data is hosted.
1. Enter the Datadog API key you generated earlier.
1. Click **Add destination**.

Metrics streaming traffic does not count against your workspace's outbound bandwidth usage.

### Validation{% #validation %}

After a few minutes, Render metrics appear in the [Metrics Explorer](https://app.datadoghq.com/metric/explorer) filtered by `render.*`.

## Uninstallation{% #uninstallation %}

In Render, navigate to **Observability** and remove the Datadog destination under **Metrics Stream**. Afterward, uninstall the Render integration tile in Datadog.

## Data Collected{% #data-collected %}

### Metrics{% #metrics %}

|  |
|  |
| **render.service.cpu.limit**(gauge)                         | Configured CPU limit for the service in CPU cores                                                |
| **render.service.cpu.time**(count)                          | Cumulative CPU time consumed by the service. Use a rate function to derive load*Shown as second* |
| **render.service.memory.limit**(gauge)                      | Configured memory limit for the service*Shown as byte*                                           |
| **render.service.memory.usage**(gauge)                      | Total memory currently in use by the service*Shown as byte*                                      |
| **render.service.memory.rss**(gauge)                        | Resident set size memory used by the service*Shown as byte*                                      |
| **render.service.memory.cache**(gauge)                      | Page cache memory used by the service*Shown as byte*                                             |
| **render.service.network.transmit.bytes**(count)            | Total bytes transmitted by the service across public and private traffic*Shown as byte*          |
| **render.service.network.receive.bytes**(count)             | Total bytes received by the service across public and private traffic*Shown as byte*             |
| **render.service.http.requests.total**(count)               | Total number of HTTP requests handled by the service, by host and status code*Shown as request*  |
| **render.service.http.requests.latency**(gauge)             | HTTP request latency at the requested quantile*Shown as second*                                  |
| **render.service.disk.capacity**(gauge)                     | Total capacity of the persistent disk or datastore volume*Shown as byte*                         |
| **render.service.disk.usage**(gauge)                        | Space currently used on the persistent disk or datastore volume*Shown as byte*                   |
| **render.service.disk.read.bytes**(count)                   | Total bytes read from disk by the datastore*Shown as byte*                                       |
| **render.service.disk.read.count**(count)                   | Total number of disk read operations performed by the datastore*Shown as operation*              |
| **render.service.disk.write.bytes**(count)                  | Total bytes written to disk by the datastore*Shown as byte*                                      |
| **render.service.disk.write.count**(count)                  | Total number of disk write operations performed by the datastore*Shown as operation*             |
| **render.postgres.checkpoints.timed**(count)                | Number of scheduled checkpoints completed by the Postgres instance                               |
| **render.postgres.checkpoints.requested**(count)            | Number of on-demand checkpoints requested on the Postgres instance                               |
| **render.postgres.checkpoint.age**(gauge)                   | Time elapsed since the last completed checkpoint*Shown as second*                                |
| **render.postgres.connections**(gauge)                      | Number of direct client connections currently open to the database*Shown as connection*          |
| **render.postgres.connection.limit**(gauge)                 | Maximum number of direct connections the database accepts*Shown as connection*                   |
| **render.postgres.connection.pool.client.active**(gauge)    | Client connections currently served by the connection pool*Shown as connection*                  |
| **render.postgres.connection.pool.client.waiting**(gauge)   | Client connections waiting for a free server connection in the pool*Shown as connection*         |
| **render.postgres.connection.pool.client.max_wait**(gauge) | Longest time any client has currently been waiting for a pooled connection*Shown as second*      |
| **render.postgres.connection.pool.server.active**(gauge)    | Server connections in the pool actively running a query*Shown as connection*                     |
| **render.postgres.connection.pool.server.idle**(gauge)      | Server connections in the pool sitting idle*Shown as connection*                                 |
| **render.postgres.connection.pool.server.total**(gauge)     | Total server connections currently established by the pool*Shown as connection*                  |
| **render.postgres.connection.pool.server.limit**(gauge)     | Maximum server connections the pool may establish*Shown as connection*                           |
| **render.postgres.connection.pool.wait_time**(count)       | Cumulative time clients have spent waiting for a pooled connection*Shown as second*              |
| **render.postgres.blocks.hit**(count)                       | Blocks served from the Postgres buffer cache*Shown as block*                                     |
| **render.postgres.blocks.read**(count)                      | Blocks read from disk because they were not in the buffer cache*Shown as block*                  |
| **render.postgres.table.scans**(count)                      | Total sequential scans performed across user tables*Shown as scan*                               |
| **render.postgres.tuples.inserted**(count)                  | Rows inserted into the database*Shown as row*                                                    |
| **render.postgres.tuples.updated**(count)                   | Rows updated in the database*Shown as row*                                                       |
| **render.postgres.tuples.deleted**(count)                   | Rows deleted from the database*Shown as row*                                                     |
| **render.postgres.tuples.fetched**(count)                   | Rows fetched by queries against the database*Shown as row*                                       |
| **render.postgres.database.size**(gauge)                    | On-disk size of the database*Shown as byte*                                                      |
| **render.postgres.indexes.size**(gauge)                     | Combined on-disk size of the database indexes*Shown as byte*                                     |
| **render.postgres.deadlocks**(count)                        | Deadlocks detected and resolved by the database*Shown as lock*                                   |
| **render.postgres.slow.lock.count**(gauge)                  | Number of locks currently held longer than the slow lock threshold*Shown as lock*                |
| **render.postgres.slow.lock.time**(gauge)                   | Time currently accumulated by locks held longer than the slow lock threshold                     |
| **render.postgres.replication.lag**(gauge)                  | Replication lag between the primary and the replication host*Shown as millisecond*               |
| **render.postgres.replication.apply.lag**(gauge)            | Time the replication host takes to apply changes received from the primary*Shown as millisecond* |
| **render.postgres.recovery.conflicts**(count)               | Queries cancelled on a read replica because of conflicts with recovery                           |
| **render.postgres.temp.bytes**(count)                       | Bytes written to temporary files by queries that exceeded work_mem*Shown as byte*                |
| **render.postgres.temp.files**(count)                       | Temporary files created by queries that exceeded work_mem*Shown as file*                         |
| **render.postgres.transaction.exhaustion**(gauge)           | Progress of the database toward transaction ID exhaustion                                        |
| **render.postgres.transaction.volume**(count)               | Total transactions processed by the database*Shown as transaction*                               |
| **render.postgres.transactions.committed**(count)           | Transactions committed by the database*Shown as transaction*                                     |
| **render.postgres.transactions.rolled.back**(count)         | Transactions rolled back by the database*Shown as transaction*                                   |
| **render.postgres.archiver.failures**(count)                | Failed attempts to archive write-ahead log files                                                 |
| **render.keyvalue.connections**(gauge)                      | Number of client connections currently open to the Key Value instance*Shown as connection*       |
| **render.keyvalue.connection.limit**(gauge)                 | Maximum number of connections the Key Value instance accepts*Shown as connection*                |

### Logs{% #logs %}

Render does not include any logs.

### Events{% #events %}

Render does not include any events.

### Service Checks{% #service-checks %}

Render does not include any service checks.

## Support{% #support %}

Need help? Contact [Datadog support](https://docs.datadoghq.com/help/).