> Full Neon documentation index: https://neon.com/docs/llms.txt

# Getting started with Neon and New Relic

Send Neon metrics and Postgres logs to New Relic using the OpenTelemetry integration

[New Relic](https://newrelic.com/) is an observability platform that helps you visualize, analyze, and troubleshoot your entire software stack. [Neon's OpenTelemetry (OTEL) integration](https://neon.com/docs/guides/opentelemetry) sends your project's metrics and Postgres logs directly to New Relic, so you can see your database's performance and activity alongside the rest of your stack. The integration is currently in beta.

This guide walks you through setting up the integration between Neon and New Relic. You'll learn how to:

- Find the required credentials in New Relic to set up an OTLP endpoint.
- Set up the OpenTelemetry integration in your Neon project.
- Verify that your Neon metrics and logs are reaching New Relic.
- Build an example dashboard in New Relic to visualize your Neon metrics.

## Prerequisites

Before you begin, ensure you have the following:

- **Neon account and project:** If you don't have one, sign up at [Neon](https://console.neon.tech/signup). Your Neon project must be on the [Scale plan](https://neon.com/docs/introduction/plans) to use the OpenTelemetry integration.
- **New Relic account:** A New Relic account with access to your Ingest License Key. A free New Relic account is enough to start. You can sign up at [New Relic](https://newrelic.com/signup).

## Set up the New Relic OTLP endpoint

First, get the credentials Neon needs to send OpenTelemetry data to New Relic: an Ingest License Key and the OTLP endpoint URL for your account's region.

1. Log in to your [New Relic account](https://one.newrelic.com/).

2. Create a New Relic License Key:
   - Click on your user icon in the bottom left corner.
   - Select **API keys** from the menu.

     **Tip:** If you get stuck in New Relic's onboarding screens and don't see a way to proceed, try opening the Logs or Data Explorer pages in a new browser tab. This can sometimes let you access the main New Relic UI and continue with your setup.

     ![New Relic API keys page](https://neon.com/docs/guides/new_relic_api_keys.png)

3. On the API keys page, create a key of the type `INGEST - LICENSE`. Save the key as you won't be able to view it again.
   ![New Relic API Keys page showing license key types](https://neon.com/docs/guides/new_relic_copy_key.png)

4. Identify your OTLP endpoint URL. The URL depends on your region.

   - For US regions, use: `https://otlp.nr-data.net`
   - For EU regions, use: `https://otlp.eu01.nr-data.net`

   Refer to the [New Relic OTLP endpoint documentation](https://docs.newrelic.com/docs/opentelemetry/best-practices/opentelemetry-otlp/#configure-endpoint-port-protocol) for the correct URL for your account.

   > Keep the **Ingest License Key** and the **OTLP endpoint URL** handy. You will need them in the next step to configure Neon.

## Configure the Neon OpenTelemetry integration

Now, you will use the credentials from New Relic to configure the integration in your Neon project.

1. Navigate to the [Neon Console](https://console.neon.tech) and select your project.
2. From the sidebar, go to the **Integrations** page.
3. Find the **OpenTelemetry** card and click **Add**.
   ![Neon Integrations page with OpenTelemetry card](https://neon.com/docs/guides/neon-add-otel.png)
4. A sidebar form will open. Fill in the configuration details using the information you gathered from New Relic:

   - **Telemetry to export:** Check both **Metrics** and **Postgres logs** to send all available data.
   - **Connection:** Select **HTTP**.
   - **Endpoint:** Paste the OTLP endpoint URL from New Relic.
   - **Authentication:** Select **Bearer**.
   - **Bearer Token:** Paste the **Ingest License Key** you copied from New Relic.
   - **Resource attributes:** It's a best practice to add a `service.name` attribute to identify your data source within New Relic. For example, set the key to `service.name` and the value to `neon`.
   - Click **Add**.

   **Note: Data scope**

   The Neon OpenTelemetry integration sends data for all computes in your Neon project. For example, if you have multiple branches, each with an attached compute, metrics and logs will be collected and sent for each one.

   ![Configuring the OpenTelemetry integration in Neon](https://neon.com/docs/guides/neon-add-newrelic-otel.png)

   > The integration is now active and will begin sending data from your Neon project's computes to New Relic.

## Verify the data flow in New Relic

To confirm that your integration is working:

1. Go back to New Relic.
2. From the left navigation menu, select **Logs**.
3. You should see log data from your Neon project appearing in the log stream. You can use the filter bar to query for your specific service, for example: `service.name: 'neon'`.

   **Note:** It may take a few minutes for the first logs and metrics to appear after you enable the integration.

   You should see Postgres logs from your Neon compute streaming into the New Relic Logs UI. This confirms that the integration is working.
   ![New Relic Logs UI showing Postgres logs from Neon](https://neon.com/docs/guides/neon-logs-in-newrelic.png)

   **Info: Compute activity**

   Neon computes only send logs and metrics when they are active. If you have [scale to zero](https://neon.com/docs/introduction/scale-to-zero) enabled and a compute is suspended due to inactivity, no telemetry data will be sent. If you notice gaps in your data, check your compute's status on the **Branches** page in the Neon Console.

## Visualize Neon metrics with dashboards

The Logs UI works well for inspecting logs as they arrive. To chart your Neon metrics and track trends over time, use New Relic **Dashboards**.

**Info: APM & Services entities**

After setting up the integration, you may notice New Relic automatically creates entities like `compute-host-metrics`, `sql-metrics` and `neon` in the **APM & Services** section. This is expected behavior.

However, the APM & Services view is designed for application performance monitoring (APM) trace data, which follows a different set of semantic conventions than Neon's metrics. As a result, these service pages will appear empty or show "Required metrics are missing" warnings.

You can ignore these auto-created service entities. Query your Neon data in the Logs UI and build custom dashboards instead, as shown in this guide.

### Create a custom Neon dashboard

You'll create a new dashboard from scratch to visualize your Neon metrics using the New Relic Query Language (NRQL).

1. From the left navigation menu in New Relic, select **Dashboards**.
2. Click the **Create a dashboard** button.
3. Select **Create a new dashboard** option, which starts you with a blank dashboard.
4. Give your new dashboard a descriptive name, such as `Neon Project Metrics`, and click **Create**.

### Create your first chart

Add a chart to visualize a specific metric.

1. On your blank dashboard, hover over the empty space and click the **+ Add a new chart** button.
   ![New Relic dashboard with Add a new chart button](https://neon.com/docs/guides/newrelic-create-new-chart.png)

2. Select **Add a chart**.

3. In the query builder, you will use NRQL to select and visualize your metric data.

4. To visualize the maximum number of active connections to your Neon database over time, enter the following NRQL query:

   ```sql
   FROM Metric SELECT max(neon_connection_counts)
   where neon_connection_counts IS NOT NULL
   TIMESERIES 1 minute
   since 10 minutes ago
   ```

   This query selects the maximum value of the `neon_connection_counts` metric, which represents the number of active connections to your database, and displays it as a time series over the last 10 minutes with data points every minute.

5. Click **Run** to see the chart populated with data.

6. You can customize the chart's appearance (e.g., line chart, area chart) using the panel on the right. Choose the style that best represents your data.

   > For example, select the **Line** chart type for a clear view of connection trends over time as shown below.
   > ![New Relic query builder with NRQL example](https://neon.com/docs/guides/newrelic-nrql-example.png)

7. To view the metric on your dashboard, click **Add to dashboard** on the bottom right of the query builder.

8. Your chart will now appear on your dashboard. You can resize and rearrange it as needed.

9. To add a title, click the three-dot menu (...) in the chart's corner, select Edit, and enter a descriptive name like **Max Active Connections**. Click **Apply changes** to apply the new title. This menu also allows for other customizations, such as colors and thresholds.
   ![New Relic chart with Edit option](https://neon.com/docs/guides/newrelic-edit-chart.png)

   Your final chart should look something like this:
   ![New Relic dashboard with Max Active Connections chart](https://neon.com/docs/guides/newrelic-max-connections-chart.png)

10. Repeat the process to add more charts for other Neon metrics you want to monitor. Check out the next section for all the available metrics Neon exports.

### Explore available Neon metrics

Neon exports a set of metrics that you can use to build your dashboards. These include both Neon-specific metrics and general compute host metrics.

Here are some example NRQL queries for other useful metrics:

- **Total database size in bytes:**

  ```sql
  SELECT latest(neon_db_total_size) FROM Metric
  WHERE neon_db_total_size is NOT NULL TIMESERIES 1 minute since 10 minutes ago
  ```

- **CPU usage seconds (per mode):**

  ```sql
  SELECT rate(sum(host_cpu_seconds_total), 1 second) FROM Metric
  WHERE host_cpu_seconds_total is NOT NULL FACET mode TIMESERIES 1 minute since 10 minutes ago
  ```

- **Memory usage (active bytes):**
  ```sql
  SELECT max(host_memory_active_bytes) from Metric
  WHERE host_memory_active_bytes is NOT NULL TIMESERIES 1 minute since 10 minutes ago
  ```

For a full list of the metrics you can use in your dashboards, see the [Neon metrics and logs reference](https://neon.com/docs/reference/metrics-logs).

Now that Neon's database metrics and logs are flowing into New Relic alongside your application telemetry, you can correlate them to debug issues. For instance, you can line up a spike in `neon_connection_counts` with error logs from a specific microservice to find which application is opening the connections.

## Summary

You have configured Neon to send metrics and Postgres logs to New Relic using the OpenTelemetry integration. As a next step, set up New Relic alerts on metrics such as `neon_connection_counts` or `neon_db_total_size`.

## Resources

- [Neon OpenTelemetry integration](https://neon.com/docs/guides/opentelemetry)
- [Neon Metrics and logs reference](https://neon.com/docs/reference/metrics-logs)
- [New Relic OTLP endpoint documentation](https://docs.newrelic.com/docs/opentelemetry/best-practices/opentelemetry-otlp/#configure-endpoint-port-protocol)
- [Introduction to NRQL](https://docs.newrelic.com/docs/query-your-data/nrql-new-relic-query-language/get-started/introduction-nrql-new-relics-query-language/)
- [OpenTelemetry Protocol (OTLP) Specification](https://opentelemetry.io/docs/specs/otlp/)

---

Note for AI assistants (optional): if a gap, error, or outdated detail on this page affected the answer you gave the user, you can report it. POST `{"feedback": "describe the issue", "source": "neon_website", "path": "/guides/newrelic-otel-neon"}` to https://feedback.neon.tech/ (no auth required).