Query based pricing

What is query based pricing?

Our query based pricing plan bills on two factors:

• Ingested data (as described in our data ingest billing docs)
• Queries run to retrieve data

How billable queries are measured

The unit of measure for queries run is scanned events.

Scanned events are defined as the number of data points ingested that match a query request's account, type, and time window.

All successfully run customer-initiated queries in New Relic are counted towards the scanned event total, including but not limited to:

• Loads of curated views initiated by a user (for example, when you load an APM UI page, the distributed tracing UI, a browser monitoring UI page, or any UI that returns telemetry-related data).
• Custom queries run by a New Relic user (NRQL or NerdGraph).
• Widgets on custom dashboards that run queries.

Internal New Relic processes that are not linked to customer UI or API activity are not included.

Note that these actions are equivalent to what's counted for our limits on queries.

When a customer views or interacts with any portion of the New Relic platform, one or more queries are run to gather the data requested. A data point is scanned if it matches the account, type, and time range for a query. Some queries may be completed early or canceled by the user, in which case only data points which were scanned before the query stopped will be counted.

In the event of an error in the query service, failed queries may not be charged by New Relic. However, New Relic reserves the right to charge for such queries in certain circumstances that are caused by customers or users, such as repeated queries or behavior that could harm New Relic properties.

Customers are charged for scanned events during a billing period, rounded up to the nearest billion. This is denoted as the acronym BSE for billion scanned events.

For the small percentage of data types where a direct measurement of scanned rows is not possible, an equivalent consumption meter will be used.

Note about "event" language

Note that in the context of scanned events, "event" is being used generally, and is not related to our event data type.

Example query

In this example a query is run in the query builder to find the count of transactions. The query has selected the account Demotron, the data type Transaction, and the time window 1 day ago:

FROM Transaction SELECT count(*)
WHERE duration > 1
SINCE 1 day ago

The sum of the data points scanned that match these three criteria (account, type, and time window) equals the total scanned events for this query.

How to query your own scanned events

All New Relic organizations on query based pricing can see their own scanned events in real time by using the NrdbQuery event. This allows customers to track what and who is contributing the most scanned events.

Some example queries:

FROM NrdbQuery SELECT sum(scannedEvents)
TIMESERIES SINCE 1 week ago

Results can also be faceted by user:

FROM NrdbQuery SELECT sum(scannedEvents)
FACET user SINCE 1 week ago

Other attributes in NrdbQuery include the query run, the source.name, and the source.apiKeyId to assist in analyzing your data.

Querying across multiple accounts

NrdbQuery data reports data from a single account. If you have multiple accounts in your New Relic organization and want to query across them, here are two options.

Use NerdGraph to query across accounts

You can use our NerdGraph API to query across accounts.

Here's an example query that gives you the total scanned events for the past week across the five accounts listed, grouped by user.

{ 
   actor {
      nrql(accounts: [11111, 22222, 33333, 44444, 55555], 
      options: {}, 
      query: "FROM NrdbQuery SELECT sum(scannedEvents) FACET user SINCE 1 week ago", 
      timeout: 70) 
         {   results}  
   }  
}

Cross-account query preview

For our cross-account query feature, which is in preview, you can select up to five accounts in the query UI and aggregate your scanned events from those accounts.

To request access to this preview, reach out to your New Relic account representative.

List Prices

The preview of scanned events pricing is available with Pro and Enterprise edition through a tiered billing approach.

Scanned Events (in billions) is a "Unit of Measure" where the "Per Unit" rate is one billion Scanned Events. Pricing depends on your edition and data region. "EU" denoted options associated with the Scanned Events (in billions) price is applicable if you have selected the "EU" data region for your Account.

If you are using the Enterprise edition, the EU data region or other options available for Scanned Events (in billions), the applicable List Price is calculated by multiplying the value in above table's List Price column by these factors:

On a monthly basis, Scanned Events (in billions) usage will be charged for each Scanned Events (in billions) within each tier beginning at the initial tier at its corresponding price. Only those units exceeding the preceding tier(s) are entitled to the reduced List Price in the subsequent tier(s). Calculated charges are based on factors that have four decimal places. Amounts invoiced are rounded to the nearest cent where applicable.

Frequently asked questions

Question: How do I manage my scanned events to make sure my bill doesn't grow unexpectedly?

Answer: Using NrdbQuery, you can monitor your scanned events. If there is a spike in the metric, you can identify who, where, and what queries were run to cause the spike and contact you other users to adjust their queries.

You can't view aggregated scanned events at this time; however, New Relic is evaluating ways to make this aggregated information available in the UI.

Question: How can I minimize my scanned events?

Answer: Scanned events are based on account, type, and time window. You can shorten the time windows of queries. For example, SINCE 6 months AGO is a query that will scan significantly more data points than SINCE 6 hours AGO. Additionally, the more data that is stored in an account or type means the more data points need to be scanned to return the result. Sharding (or splitting) data into separate child accounts and/or event types that match the company's organizational or operating model can help reduce the SE count.

Question: Does a curated UI create SE?

Answer: Yes, any customer initiated action through the UI or API will query the New Relic database (NRDB), and account for scanned events.

Question: Are there any limitations for scanned events?

Answer: Limits on queries still exist to protect the New Relic systems as a whole, but these limits are very high for customers in the query based pricing plan. Customers familiar with IC-based query limits will find that their new limits with query based pricing allow for significantly greater query capacity.

Question: Will scanned events be consistent if I run the query more than once?

Answer: Yes, they'll be consistent when the same query is run over the same time window.

Question: Can I see what queries are causing the most scanned events?

Answer: Yes, you can FACET by query to see what queries are causing the most scanned events.

Question: Can I find out where large scanned events queries are coming from?

Answer: Yes, you can FACET off of attributes like source.name to see if the query is coming from the UI or API, as well as source.dashboardId to find the guid of the dashboard this query is on.

Question: Is there another attribute that I can group my queries by?

Answer: Yes, timeWindowMinutes is an attribute that shows how long a time window is per query. This attribute factors in when a time window is changed from a dashboard. Ex. Your query says SINCE 5 minutes AGO, but the dashboard has been changed to 60 minutes.

Question: Why does count(*) not match the scanned event count?

Answer: count(*) is counting the number of queries run which is not the same as scanned events. Scanned event total is the count of "...sum of the data points ingested that match a query request's account, type, and time window," and not the count of the queries themselves or the number of returned results.