May 28, 2024 25 min read

New Relic Glossary

Explore the big New Relic word list to discover important terms about watching how your apps do, fixing problems, and making them better.

New Relic Glossary
New Relic Glossary
Table of Contents


Navigating the world of app performance tracking and issue detection may seem like a puzzle without knowing the right terms and ideas.

Here, we break down all the crucial terms surrounding app tracking, issue detection, and performance improvement. Level up your knowledge of New Relic and elevate your grasp of managing applications effortlessly. Let's simplify app performance management together.

New Relic Terms


Account: In New Relic, an organization can encompass multiple accounts, each serving as a dedicated workspace for monitoring and analyzing data associated with a particular project or team. Each account is assigned a unique account ID, utilized for account-specific actions such as API interactions.

Account Family: In New Relic, an organization can possess multiple accounts. The concept of an 'account family' encompasses a primary account and its associated sub-accounts, forming a cluster of interconnected accounts linked through billing arrangements.

Account Switcher: When granted access to multiple accounts within a multi-account organization, you can utilize the account switcher to navigate between accounts. This feature is conveniently positioned in the top right corner of the New Relic homepage and certain entity list views.

Agent: A New Relic agent is an installable software component that integrates with various technologies, such as web frameworks, operating systems, and databases, and periodically reports data to New Relic. New Relic offers different types of agents, including APM agents, infrastructure agents, browser monitoring agents, and mobile monitoring agents.

Aggregation Delay: For the alerting feature, the aggregation window refers to the duration in seconds that the system waits to collect data before evaluating the alert condition. Required when using aggregation_method types CADENCE or EVENT_FLOW.

Aggregation Function: When working with NRQL alerts, NRQL functions like sum(), average(), or latest() can be applied to determine how data points within an aggregation window are consolidated into a single data point. This consolidated data point is then evaluated during the alert assessment.

Aggregation Method: In the context of New Relic alerts, data is aggregated into windows, and it's crucial to determine when the current window concludes and the next one begins. The aggregation_method defines the logic for determining when all data for a given aggregation window is collected. Once the window is closed, the data is consolidated into a single point and evaluated against the threshold. This field is optional and can be set to one of the following three values:

  • EVENT_FLOW: (Default) Every aggregation window will wait until it detects timestamps that exceed its designated delay setting before publishing the data. This method relies on the timestamps of incoming data, making wall-clock time irrelevant. It is most effective for sources that provide frequent data with minimal event spread, such as high throughput metrics.
  • CADENCE: The classic New Relic approach where each evaluation window waits precisely for the duration specified by the aggregation_delay setting, using the wall-clock time as a timer. The aggregation_delay parameter is required when selecting this option. Data arriving after the window has closed will be discarded, which can potentially trigger false alerts.
  • EVENT_TIMER: In this method, each aggregation window has a timer set to the aggregation_timer value. The timer begins as soon as the first data point for that window arrives, based on the data point's timestamp. The aggregation_timer is reset with the arrival of each new data point for that window. Once the aggregation_timer reaches 0, the aggregation window is published. This approach is well-suited for sparse and batched data, such as cloud integrations and infrequent error logs.

Aggregation Timer: In the context of New Relic alerts, the aggregation_delay refers to the duration in seconds to wait after each data point is received, ensuring the entire batch is processed. This setting is required when using the EVENT_TIMERaggregation_method type.

Aggregation Window: In the context of New Relic alerts, the streaming alerts feature collects data into customizable time-based windows. Data points are grouped together based on their timestamps and reported as a batch. This customizable aggregation window provides greater flexibility and reduces the likelihood of false incidents when alerting on irregular or infrequent data points.

Alert: Establish effective alerts to identify issues proactively and address them before they escalate.

Alert Condition: An alert condition, distinguished by its unique numeric condition_id, encompasses the criteria for triggering an incident. This condition specifies the threshold set for a metric timeslice or a custom metric over a selected target.

Alert Evaluation: In the context of alerts, streaming data is evaluated across a series of aggregation windows to determine if an alert condition is breaching or recovering. The aggregation window time defines the duration over which data is collected before executing the NRQL query condition. The offset evaluation time specifies the delay before assessing any late-arriving data. If an aggregation window lacks any data points, it is treated as a gap, indicating a loss of signal.

Alert Policy: When it comes to alerts, an alert policy comprises multiple alert conditions, notification channels, and an Incident preference setting.An alert condition within a policy can trigger an incident based on the incident preference settings. In such instances, all channels linked to the policy will send out notifications.

Anomaly: When a service or application exhibits unusual behavior, intelligent algorithms identify it as an anomaly. These anomalies can be observed in the activity feeds across New Relic. Additionally, you have the option to set up custom configurations to receive notifications or monitor anomalies in various entities such as hosts and mobile apps.

Apdex: Apdex is an industry-accepted method for measuring user satisfaction with the response time of an application or service. New Relic categorizes each response as Satisfied, Tolerated, or Frustrated, and then calculates an overall user satisfaction score based on these ratings.

apdex_f: The response time threshold above which a transaction is considered frustrating. This defaults to four times the apdex_t value.

  • Requests that complete in less than the apdex_t time are rated as satisfied.
  • Requests that take longer than the apdex_t, but less than four times the apdex_t (apdex_f), are considered tolerated.
  • Any requests that exceed the apdex_f threshold are rated as frustrating.

apdex_t: The response time threshold above which a transaction is considered tolerable. The default value is 0.5 seconds, but this can be customized in the Apdex settings.

  • Requests that complete within the apdex_t time are rated as satisfied.
  • Requests that exceed the apdex_t, but are less than the apdex_f threshold, are considered tolerated.
  • Any requests that take longer than the apdex_f time are rated as frustrating.

API (Application Programming Interface): New Relic provides a range of APIs and SDKs.

APM: New Relic APM (Application Performance Monitoring) offers performance monitoring for your web or non-web applications.

Application: In the context of New Relic, an application refers to any program that has been instrumented with New Relic monitoring.

Application ID: Several New Relic solutions allocate a distinct application ID to a monitored application, commonly referred to as an app ID. This identifier is accessible in the user interface, reported as an attribute, and can be queried.

Application Name: The name that New Relic associates with your license key to uniquely identify a specific application.

Applied Intelligence: Applied intelligence is a feature that helps you identify, troubleshoot, and resolve issues more efficiently. It is a hybrid machine learning engine that reduces alert noise, correlates incidents, and automatically detects anomalies.

Attribute: Attributes are key-value pairs linked to data objects reported to New Relic, providing additional context similar to tags or labels in other SaaS software. Examples:

  • In APM, a Transaction event includes timing details with a duration attribute, such as a value of .002.
  • In infrastructure monitoring, a ProcessSample event contains CPU usage attributes like cpuSystemPercent with values like .01.
  • Using our Telemetry SDK, Metric data types store metrics with attributes like metricName and newrelic.source attached.

Certain New Relic tools enable the reporting of custom attributes to enrich your monitoring capabilities.


Browser: For our solution aimed at monitoring end-user browsers.

Browser Monitoring: Measures the speed and performance experienced by your end users as they navigate to your site from various web browsers, devices, operating systems, and network conditions.

Background External: Refers to the time spent on calls to external services from within the non-web transactions of a service.


Clould-Based Integration: New Relic provides cloud-based integrations with leading providers like Amazon Web Services (AWS), Microsoft Azure, and Google Cloud Platform.

Collector: The component responsible for gathering data from New Relic agents operating on an application server, mobile device, or end-user browser. While the agent is deployed on the user's application server, the collectors are centrally situated in our data center. To communicate with the collector, the agent needs access to New Relic domains and IP addresses (specific to the New Relic monitoring tool in use). The collector receives, processes, and stores this data in a database. Subsequently, the information is accessed and displayed in the New Relic user interface and through our diverse REST APIs.

Command Line Interface (CLI): Our command line interface (CLI) is a tool that enables you to oversee New Relic, providing management and control capabilities for your New Relic operations on a larger scale.

Conditions: Utilize alert conditions to specify the circumstances under which your team will receive notifications if your entities deviate from the desired behavior. By setting up conditions, you define the parameters for alerts related to latency issues, code errors, Apdex scores, high CPU usage, and other metrics.

Container: A container is a standardized software unit that encapsulates all the necessary code and dependencies, enabling your application to run seamlessly across various computing environments.

CPM (calls per minute): The count of requests your application receives per minute, typically aligned with the number of page views or external connections, often equivalent to RPM (requests per minute).

CPU burn: The time consumed by code minus the wait time for a transaction. This is the time actually spent processing the transaction. It appears in the New Relic UI at the top of the transaction view for the agents that provide it (Ruby and PHP only).

Custom Attribute: A key-value pair attached to a transaction or event to provide additional context and details.

Custom Dashboard: A customizable dashboard that displays charts and tables with data aggregated from multiple New Relic data sources.

Custom Event: In the context of New Relic, an event is a data object with associated attributes. New Relic reports various default event types, such as Transaction and TransactionError, and you can also create your own custom events. These events can be queried and utilized in other New Relic features.You can generate custom events using APM agents, the browser monitoring agent, mobile monitoring agents, or the Event API. Additionally, you can add custom attributes to some of the existing default New Relic events.

Custom Instrumentation: Custom instrumentation enables you to expand New Relic monitoring by instrumenting code elements that are not automatically handled by New Relic. This feature is valuable when your framework is not natively supported by New Relic or when certain aspects of your application are not detected. Additionally, custom instrumentation can be utilized to prevent a transaction from being reported altogether.

Custom Metric: Custom metrics are manually recorded via API calls, allowing you to capture arbitrary metrics such as timing or resource utilization data. All custom metric names must begin with the prefix Custom/.


Degradation Period: In the context of alerting, when a data source enters a breaching state, a degradation period begins, as defined by the condition's threshold. An incident will only open if the source remains in the breaching state for the entire degradation period. However:

  • If the data source returns to a non-breaching state before the degradation period elapses, the countdown is reset, and an incident does not open.
  • If the alert condition threshold is set to at least once in, the degradation period is always a single minute.

Dependencies: A dependency refers to the code essential for your application's operation. New Relic offers a comprehensive list of applications, services, databases, and hosts that are identified as linked to an entity. Within the Dependencies UI page, you can access information about an entity's upstream and downstream dependencies, along with pathways to investigate them.

Destinations: When it comes to alerting, destinations are the designated recipients for notifications regarding your data. Each destination serves as a distinct identifier for a third-party system you utilize. These settings include connection information required to integrate with third-party systems and can be applied across different tools within New Relic.

Dimentional Metric: A dimensional metric is a metric that has multiple associated attributes, also referred to as dimensions. In New Relic, we report dimensional metrics using the Metric data type.

Distributed Tracking: Distributed tracing is a monitoring technique that follows requests as they move through diverse cloud environments. By assigning a unique identifier to each request, distributed tracing enables real-time insight into the interactions occurring within your entities, providing your team with a comprehensive view of the process.

Docker: An open platform for distributed applications that enables the assembly of portable, multi-container apps. This platform includes integrated Docker monitoring as part of its infrastructure monitoring capabilities.

Downtime: The period during which customers are unable to access your site and your application is not reporting data to New Relic.


Entity: In the context of New Relic, an entity refers to anything that can be identified and has data that can be monitored. This includes both direct monitoring targets, such as applications and microservices, as well as indirect monitoring subjects, like data centers.

Event: In the software domain, events can be conceptualized as occurrences within a system. For instance, modifying a server setting or a website user clicking a mouse are both considered events. Some of these events generate a stored record, which is also commonly referred to as an event.

Expected Error: An anticipated error is a frequent occurrence that should not impact your Apdex score or error rate.

External Service: An external service refers to a service that operates independently from a monitored service that reports data to New Relic. These external services either make calls to or receive calls from the instrumented service. Throughout the New Relic UI, external services typically denote unmonitored services that do not directly provide telemetry to New Relic. Instead, they are observed externally through the data reported by instrumented services regarding their interactions with these external services. For instance, an external service like is not monitored by New Relic and does not report data itself, but New Relic becomes aware of it when a service equipped with the New Relic agent interacts with it through an HTTP request.


Facet: A facet assists your team in analyzing data with multiple dimensions. By utilizing facets in NRQL queries, you can segment and compare data within New Relic. For instance, to analyze CPU usage across different hosts, you can segment CPU data by the hostname facet using a query like: SELECT average(cpuPercent) FROM SystemSample FACET hostname.

Flex: New Relic Flex is a versatile, all-encompassing infrastructure integration that is not tied to any specific application. It allows you to build your own integration to collect metric data from a wide range of services and instrument any application that exposes metrics through standard protocols (e.g., HTTP, file, shell) and formats (such as JSON or plain text) to the terminal. Flex is a recommended approach for creating custom integrations, as it does not require extensive coding expertise.

Framework: A framework is a organized set of predefined functions that developers incorporate their own code into to construct their applications. Unlike a library, which consists of functions that can be called as required, a framework serves as the foundation for an application. The functions within the framework subsequently invoke the developer's functions. New Relic automatically instruments numerous popular frameworks.


Golden Metrics: The critical metrics specific to an entity, scenario, or technology. Golden metrics may encompass key indicators known as golden signals: latency, traffic, errors, and saturation.


Harvest Cycle: The interval between each communication instance from a New Relic agent to the collector. During harvest cycles, an agent gathers and stores data, which is then transmitted to the collector at the cycle's conclusion before initiating a new harvest cycle.

Health Status Indicator: Several New Relic UI pages feature a health status indicator displayed alongside a list of monitored entities. This indicator, represented by a colored bar (typically green, yellow, red, or gray), reflects the status of your application or other entity under New Relic monitoring. It also signifies the presence of any assigned alert policies and ongoing incidents. In our REST API (v2), orange is used instead of yellow to denote the application's health and reporting status.

Host: At New Relic, a host refers to one of the following:

  • A physical machine, a hardware-based device with dedicated physical resources such as memory, processing power, and storage. Each machine operates on its own operating system where applications are executed.
  • A virtual machine (VM), a software representation of a physical machine that functions similarly to a physical device. Multiple virtual machines can operate on a single physical machine, each with its own operating system and allocated virtual resources like RAM and CPU.
  • A cloud instance, a form of virtual machine hosted in the public cloud. It's important to note that in this context, virtual machines and cloud instances are distinct from Java Virtual Machines (JVMs) and containers.


Ignored Error: An error that has been explicitly configured to be excluded from reporting to the collector by the APM agent.

Incident: When it comes to alerting, an incident is triggered when the criteria specified in an alert policy are surpassed. Each incident record contains timestamps for when it was opened and closed, along with visual snapshots of the data under evaluation during the incident.

Infinite Tracing: Infinite Tracing is a comprehensive distributed tracing service that meticulously monitors all your application traces, offering valuable insights to expedite issue resolution.

Infrastructure Monitoring: Infrastructure monitoring connects changes in host performance to changes in your configuration, providing real-time metrics and advanced analytics that significantly reduce mean-time-to-resolution (MTTR). This monitoring solution is tailored for complex environments that require flexible, dynamic server monitoring, spanning from physical data centers to large-scale deployments like Amazon Elastic Compute Cloud (Amazon EC2) instances and other integrations.

Insights: Insights was the former New Relic product responsible for managing custom event reporting, querying, and visualizing New Relic data. These functionalities have now been integrated into our platform as core features and are no longer tied to the Insights product name. Although the term 'Insights' is still used in certain contexts for historical reasons, such as:

  • For New Relic organizations under our original pricing model, Insights Pro remains the product governing custom event data ingestion and retention.
  • Some APM agents may still reference Insights in their codebase, like the Java agent's custom_insights_events configuration.
  • An API key known as the Insights insert key is utilized.

Instance ID: New Relic assigns a unique instance ID to every identified instance. While JVMs (Java Virtual Machines) typically have these IDs, they can also be present for other agents. This identifier is crucial for distinct identification and enables data retrieval about the specific instance through the API.

Instrumentation: The process of collecting data from an application or host. When New Relic instruments a framework, it identifies the methods and calls utilized by that framework, and intelligently aggregates them together.

Integration: At New Relic, an integration denotes a link between a technology and New Relic enabling the transmission of data to New Relic. For instance, our agents encompass diverse integrations facilitating data reporting from various application frameworks, operating systems, or database types. Other integrations may involve configurations or procedures, such as adjusting a setting or an API endpoint, enabling services like AWS Lambda or PagerDuty to transmit data to us.

Interaction: In our mobile monitoring, an interaction refers to a specific code path triggered by a user action, typically a button press. An interaction is the mobile counterpart of a transaction, and similar to a transaction, it can be traced and monitored. Much of the data associated with an interaction can be found in the BrowserInteraction event.

Interaction Trace: An interaction trace provides a comprehensive overview of a single interaction. Through interaction traces, New Relic offers enhanced visibility into individual slow interactions, aiding in the comprehension of larger issues. Interaction traces serve as the mobile version of a transaction trace.

Inventory Data: Inventory data comprises details regarding the status or setup of a service or host. Examples of inventory data encompass:

  • Configuration settings
  • Host name where the service is located
  • AWS region
  • Port in use

Issue: In the alerting context, an issue refers to a problem in your system requiring attention. An issue is composed of one or more incidents and anomalies that have been correlated through machine learning or other methods. You can receive notifications when issues are created, acknowledged, or resolved.


Key Transaction: In APM, a key transaction is a web transaction that the user has designated as particularly crucial, such as key business events (e.g., signups or purchase confirmations) or transactions with a significant performance impact (e.g., searches). Key transactions have dedicated pages in the user interface and other customized values.


Log: A log is a message about a system that provides insight into the system's activity and helps diagnose any issues that may arise.

Log Monitoring: Our log management and monitoring capabilities equip you with the tools to collect, process, explore, visualize, and set alerts on your log data using your existing log forwarder. By consolidating all your log data in one location, you'll be able to make more informed decisions, detect and resolve issues more swiftly, and troubleshoot faster by viewing your logs in the appropriate context.

Logs in Context: The 'Logs in Context' feature enables your log data to be viewed within other New Relic platform experiences.


Metrics and Events: The Metrics and Events UI provides a consistent and curated experience where you can access, query, and customize your data, create visualizations, and establish connections between your services.

Metric: In the software monitoring sector, a metric refers to a numerical measurement of an application or system.

Metric Timeslice: New Relic reports metrics using various methods. One type of metric data is known as metric timeslice data.

Metric Grouping Issue: A metric grouping issue arises when an account submits an excessive number of uniquely named metric timeslice data points to New Relic, preventing proper aggregation of the individual web transactions. For instance, instead of a single metric named /user/controlpanel/, you might see /user/controlpanel/alice, /user/controlpanel/bob, and /user/controlpanel/carol.

Minion: The software that receives synthetic monitor tasks from an internal location. A minion is a pre-packaged virtual appliance that runs within your hypervisor.

Mobile Monitoring: New Relic's mobile monitoring enables you to monitor and manage the performance of your mobile applications on Android, iOS, tvOS, and other platforms. Mobile monitoring delivers comprehensive insights, including crashes, throughput, HTTP requests, error traces, and more.

Monitor: In our synthetic monitoring, a monitor guarantees the availability of your website or API endpoint.


Namespace: At New Relic, namespaces are utilized to structure the data stored in the New Relic database (NRDB). From a customer standpoint, the most significant application of namespaces is their role in data retention. The namespace determines the default data retention period for different data types. For instance, within a particular account, data within the Logging namespace have a uniform retention period, as do data within the APM namespace.

New Relic Lookout:New Relic Lookout offers an intuitive visualization of entities exhibiting abnormal behavior, using a circle-based display. The color of the circles indicates severity, while their size conveys the scale of recent changes. No configuration is required, as New Relic Lookout automatically compares the performance within the last five minutes against the previous hour.

New Relic Navigator: New Relic Navigator simplifies the process of exploring a vast number of entities within a single view. Navigator presents your system's entire estate in a densely packed honeycomb layout, utilizing traffic light colors to indicate alert status.

NerdGraph: NerdGraph serves as our GraphQL API, offering an efficient and adaptable query language that allows you to retrieve precise data without unnecessary excess or shortfall. NerdGraph calls efficiently fetch all required data in a single request, simplifying API evolution and empowering robust developer tools. Utilize our NerdGraph API explorer to access the schema and locate definitions.

New Relic Catalog: Our catalog is a repository of applications developed on the New Relic platform. The catalog comprises custom applications we've created, publicly available open-source applications, and any applications you build.

NRQL (New Relic Query Language): NRQL is a query language, resembling SQL in structure, enabling you to retrieve data stored within your New Relic account.

Non-web Transaction: In APM, transactions are classified as either web or non-web. If New Relic determines that a transaction was not initiated by a web request, it is considered a non-web transaction.

Notification: When it comes to alerting, a notification is a message dispatched when an incident is triggered, acknowledged, or resolved. The specific notification method is determined by the alert policy's notification channel.

Notification Channel: In the alerting context, a notification channel is the destination where notifications are sent when an incident is opened, acknowledged, or closed. Available channels include email, mobile push notifications, webhooks, and more.


Obfuscating: Within our logging management functionality, this security protocol conceals sensitive information in your logs using hashing or masking techniques. Once you pinpoint the sensitive data requiring protection, you specify it using an expression. This expression is then used to establish an obfuscation rule that automatically identifies and masks or hashes instances of sensitive data in your logs.

On-host Integration: On-host integrations are integrations located on your servers or hosts, interacting with our infrastructure agent.

Organization: At New Relic, the term 'organization' can encompass multiple meanings:

  • In the context of New Relic account management, a 'New Relic organization' denotes all the assets and data associated with a New Relic customer, including their accounts, users, and data.
  • Occasionally, we use 'organization' in a broader sense to describe a business or non-profit entity.

Owner: For accounts on our original user model, the 'owner' is a specific user role, referring to the individual who initially created the account. For more details, please see the Users section. In the newer user model, there is no technical concept of an 'owner' role.


Page Loading Timing: New Relic's page load timing feature tracks the full load time for end-user browsers. New Relic application agents dynamically inject JavaScript into the page, capturing key load points as follows:

  • Navigation start: The user initiates the transaction.
  • First byte: The browser receives the requested page.
  • DOM ready: The browser has finished parsing the DOM.
  • Page ready: Page loading is complete.

This feature is sometimes referred to as RUM (real user monitoring), but unlike standard RUM, it also captures JavaScript errors and AJAX requests.

Parent Account: New Relic organizations can have a hierarchical structure, where one account serves as the parent and others are child accounts. This structure was particularly significant for organizations with users on our original user model, but it still plays a role in certain features for organizations with users on our newer user model. The initial account created within a New Relic organization functions as the parent account, which means that usage and billing data is reported to this account. Previously, parent accounts were referred to as master accounts, and child accounts were referred to as sub-accounts.

Permalink: A unique URL that links to a specific view of New Relic at a particular point in time. Permalinks are useful for troubleshooting and sharing interesting time windows with colleagues. On many New Relic UI pages, you can find the permalink icon at the top right of the UI. For more information, see Platform basics. As of May 2023, these links expire if they haven't been used within the past six months. Note the following about the six-month pruning routine:

  • Since permalinks are not user-specific, an older link you haven't used in six months may still be active if another user happens to make the same query.
  • Links using the old long-form URL with Base64 never expire.

Pinger: The New Relic component responsible for checking the accessibility of your website. New Relic operates pingers in Europe, Asia, and the United States, with each pinger attempting to contact your website at least once every two minutes. If a sufficient number of pingers fail to reach your website, your application will be marked as unavailable. For comprehensive scriptable testing, such as real browser tests and evaluations of API endpoints, refer to synthetic monitoring. Synthetic monitoring encompasses free ping monitoring, enabling you to monitor your website from various global locations.

Policy: In the alerting context, an alert policy is a container for related alert conditions, allowing you to view them collectively. For example, if your team wants to review all the conditions for your Java application, you would need to create a policy to house those conditions.

Polling Interval (AWS): Our Amazon integrations query your AWS services at a specific polling interval, which varies depending on the integration. Each polling interval occurs for every AWS entity. For instance, if you have thirteen Amazon Elastic Load Balancers (ELB), each one will be polled every 05 minutes. Depending on the AWS integration, there may be delays between the API request and the metric data being returned.

PPM (pages per minute): The rate at which your application serves pages per minute, typically referenced in browser monitoring or mobile monitoring contexts.

Private Location: A synthetic monitoring feature enabling the execution of synthetic monitors from your internal systems through the creation of private minions. Private locations expand your synthetic monitoring reach to additional geographical areas and enable monitoring of websites within your firewall, such as intranet sites.


Quickstart: At New Relic, the term quickstart encompasses all installation methods required to obtain one or both of the following:

  • Additional dashboards (beyond our curated dashboards) accessible through the Dashboards UI
  • Pre-built alerts

Quickstarts are featured on our Instant Observability pages. For example, the .NET quickstart on this page provides an extra dashboard and pre-built alerts in addition to the standard agent installation.


Recovery Period: When a data source transitions from a breaching state to a non-breaching state, a recovery period initiates. This recovery period duration is defined within the condition's threshold settings. An incident will be resolved if the data source remains non-breaching for the specified recovery period. However, if the data source breaches again before this period ends, the recovery period timer resets, and the incident will not close.

Regex: Regex is a shorthand term for regular expressions. Regular expressions are a sequence of characters and operators that, when used in conjunction with a programming language, can search a body of text for specific patterns. For instance, if you wanted to identify any social security numbers in your logs, you could create a regex that searches for a number pattern following the {3 digit-2 digit-4 digit} format.

Response Time: The time elapsed between a request for service and the corresponding response. These types of charts are utilized in our APM (Application Performance Monitoring) and browser monitoring features.

Rollup: In APM context, this typically involves assigning the same application name to multiple applications. This practice enables the consolidation of data in APM, whether it's from multiple applications or various instances of a single application.

Root Span: In distributed tracing, the root span denotes the initial span in a trace. In numerous scenarios, the duration of the root span mirrors the duration of the entire trace or closely approximates it. Nevertheless, in intricate, contemporary systems employing numerous asynchronous and non-blocking processes, this may not hold true. In such systems, the duration of the root span could be notably shorter than the overall trace duration.

RPM: The term RPM typically refers to the number of requests per minute received by your application from users. This is usually equivalent to CPM (calls per minute).Historically, some New Relic monitoring solutions, such as APM and browser monitoring, used to include RPM in the URL, for example, This terminology originated from the initial focus on Rails performance management, as the first iteration of New Relic monitored Ruby on Rails applications. However, New Relic now monitors a much broader range of languages and systems beyond just Ruby.

Runbook: In the alerting context, a runbook encompasses the standard procedures and operations typically utilized by system administrators, network operations staff, and other personnel to address outages, alert incidents, and other situations. If your organization stores runbook instructions as URLs, you can link this information to an alerts policy, providing your personnel with easy access to this information when an incident breaches the defined policy thresholds.


SAML(Security Assertion Markup Language): SAML is an XML-based data format used for exchanging authentication information between two parties.

Selenium: Selenium is a freely available browser testing suite. Synthetic monitoring employs Selenium to conduct real browser tests on monitored websites.

Service: A service comprises a group of runtime server processes dedicated to fulfilling specific tasks, typically service requests. Unlike an application, a service is not typically triggered by a human. However, there are instances where the terms 'application' and 'service' are used interchangeably.

Signal: When it comes to alerting, the signal refers to the continuous flow of telemetry data that is monitored and used for alerts. A NRQL query is employed to specify a signal. A distinct signal is produced when the condition detects a unique data stream that aligns with the NRQL query. Queries can incorporate a FACET clause to enable a single condition to generate multiple distinct signals, one for each matching facet.

Signal Filter: Upon receiving data that is directed to the streaming alerts platform, your NRQL WHERE clause is utilized to screen the incoming data. The filtered streaming data is then assessed for occurrences like signal loss incidents.

Span: In a distributed trace, a span represents a 'named, timed operation that constitutes a contiguous segment of work within that trace'. For distributed tracing, spans are visualized in the distributed tracing UI, and the Span data type is available for querying.

SSL Certificate: SSL (Secure Sockets Layer) certificates are used to encrypt data during transmission. Although New Relic uses the term SSL, as it is more widely recognized, all certificates comply with industry standards for secure encryption of data in transit.

SSO (single sign on): SSO (Single Sign-On) enables you to manage user authentication in New Relic by leveraging an external SSO provider.

Streaming Algorithm: Within the realm of alerting, this factor dictates when the data within an aggregation window is processed. The streaming algorithm utilizes your server's clock time and the size of the aggregation window to initiate the alert evaluation process.

Synthetic Monitoring: Synthetic monitoring enables you to monitor your website or API endpoint through automated, scriptable tools. You can use a free ping monitor to verify your website's accessibility, or expand your monitoring with browser monitors that test your website using real browsers. You can further enhance your monitoring by scripting browser or API monitors for more sophisticated testing.


Target: When it comes to alerting, a target refers to a resource or component monitored by a New Relic monitoring tool that is specified in an alert condition. If the data from that target surpasses the set critical threshold, an incident is triggered. Depending on the incident preference setting in your policy, alerts can generate an incident record and send notifications through designated channels.

Tag: Tags are key:value metadata attached to monitored applications, hosts, dashboards, and other entities to aid in data organization and enhance usability.

Telementry: When utilizing New Relic, you are collecting telemetry data. New Relic enables you to monitor your systems and gather data in the form of metrics, events, logs, and traces. This collected data is then stored on New Relic's servers, which you can access and analyze through your dashboards.

Thresholds: Thresholds are settings within alert conditions that determine the criteria for triggering an incident. These settings include the threshold values that a data source must exceed to initiate an incident, as well as the time-related parameters that define an incident, such as:

  • Exceeding a specific value for a minimum of x minutes
  • Exceeding a specific value only once within x minutes

When a data source surpasses a particular value, a degradation period commences. Similarly, when the data source no longer exceeds that value, a recovery period begins. The durations of these two time periods are specified in the alert condition threshold settings. Thresholds consist of a mandatory critical (red) threshold and an optional warning (yellow) threshold. In the user interface, the entity's health status indicator will change to yellow or red when a threshold is breached, resulting in the opening of an incident.

Throughput: Throughput quantifies user engagement within a monitored application. APM throughput and browser monitoring throughput are assessed using distinct metrics:

  • APM: Requests per minute (RPM)
  • Browser: Page views per minute (PPM)

Tier: A tier can denote how New Relic organizes or presents the different agent language ecosystems it supports. For instance:

  • In APM, the color-coded groupings displayed on your application's primary Overview chart represent time spent on different functions, processes, or agents as tiers, such as request queuing, garbage collection, Middleware, JVMs, and more.
  • Within New Relic labels, TIER can be employed to specify or categorize the client-server architecture, like frontend and backend tiers.

Time Picker: Typically, the New Relic user interface displays data for the past 30 minutes, up to the current time. To modify the time window, you can use the time picker located in the upper right section of the UI.

Time Range: A time range in the New Relic UI pertains to a specific duration of time chosen by the user. The displayed time range in New Relic varies based on the selection made using the time picker.

Trace: A trace outlines the path a request follows within a system. Trace data aids in comprehending the system's performance and diagnosing issues.

Transcation: A transaction represents a single logical operation within an application, typically associated with server-side transactions monitored by APM.In the context of browser monitoring, the term transaction is occasionally utilized to describe the process starting from a browser-side web request and concluding with the full page load.

Transaction Trace: In New Relic APM, a transaction trace provides a comprehensive view of a single transaction, including details such as database queries and exact invocation patterns. Transaction traces offer significantly greater visibility into a single slow transaction, which can aid in understanding and addressing broader issues.


UI: The New Relic graphical user interface.

User Menu: The user menu is located at the bottom left of the New Relic platform and provides access to settings related to your organization and account.

UTC: Universal Time Coordinated (UTC), also known as Coordinated Universal Time, is a standardized timestamp used for synchronizing time globally.


Value Function (metrics): The numerical value derived from metric timeslice data, such as an average, minimum, maximum, total, sample size, and more.


Web External: In the context of APM (Application Performance Monitoring), web external refers to the time spent in web transactions communicating with external services from within the code of the monitored service. This time could be a call to a third-party service (e.g., a payment provider) or a call to another microservice within your own organization. Web external time illustrates how network-based calls to code executing outside the measured application can impact performance.

Web Transaction: A transaction is a single logical operation within an application, typically associated with server-side transactions monitored by APM.Web transactions are triggered by an HTTP request and often represent customer-centric interactions, making them crucial transactions to monitor for most organizations.

WebDriverJS: WebDriver is a component of Selenium, used to control synthetic scripted browsers. More specifically, synthetic monitoring in New Relic utilizes WebDriverJS, a Node.js-based implementation of Selenium.

Workflows: Workflows determine how alert notifications are directed to the appropriate individuals during incidents. To streamline troubleshooting, you can incorporate queries into workflows to automatically enhance notifications with additional information regarding the incidents.

Workload: Workloads enable you to cluster entities that collaborate to deliver a particular business function. This allows you to conveniently monitor availability and resource usage for the components that are pertinent to your operations. For instance, you could create a workload containing all the hosts that form a data center.

Great! You’ve successfully signed up.
Welcome back! You've successfully signed in.
You've successfully subscribed to DevOps Tutorials - VegaStack.
Your link has expired.
Success! Check your email for magic link to sign-in.
Success! Your billing info has been updated.
Your billing was not updated.