New Relic — що це, спостережність та платформа

What is New Relic in Observability

New Relic is one of the oldest and most mature observability platforms, founded in 2008. Initially, New Relic positioned itself as an APM for web applications (Ruby on Rails), but over the years it has grown into a full-stack platform covering mobile applications, browsers, microservices, serverless functions, and infrastructure.

In 2020, New Relic introduced New Relic One — a completely redesigned platform with support for custom dashboards, NRQL queries, and data integration from any source. Unlike competitors (Datadog, Dynatrace), New Relic offers a generous free tier: 100 GB of data per month (includes all telemetry types — metrics, tracing, logs) with no time limit on retention for basic metrics.

According to the New Relic State of Observability Report (2024), 74% of organizations use New Relic for mobile monitoring, and the mean time to detect incidents drops from 3 hours to 12 minutes after platform adoption. The main use cases are APM for microservices, mobile application monitoring, and full-stack debugging.

New Relic One Architecture: Dashboards and NRQL

New Relic One is the central console of the platform, combining all data types in a single interface. Users can create an unlimited number of dashboards with widgets: line charts, heat maps, tables, lists. Each widget is built on a query to NRDB (New Relic Database) — a proprietary database optimized for time-series data.

Custom Dashboards

New Relic One allows creating dashboards for different audiences: a technical dashboard with detailed metrics (latency p95, throughput, error rate), a business dashboard with Apdex score and custom metrics (conversion, checkout time), and an infrastructure dashboard (CPU, memory, network). Dashboard-as-code is supported via Terraform provider and the New Relic API.

NRQL — Query Language

NRQL (New Relic Query Language) is an SQL-like language for querying telemetry data. It allows selecting, aggregating, and visualizing data without external tools. NRQL supports time-series functions (TIMESERIES, SINCE, UNTIL), attribute filtering, grouping (FACET), and percentile calculation.

SELECT average(duration) as "Avg Response"
FROM Transaction
WHERE appName = "MobileApp"
FACET endpoint
SINCE 1 hour ago
TIMESERIES auto
LIMIT 10

An NRQL query shows the average response time for each mobile app endpoint over the past hour, broken down by time intervals. The result is visualized as a line chart in the New Relic One dashboard.

Setting Up New Relic Mobile SDK for iOS and Android

New Relic Mobile agent provides SDKs for iOS (Swift, Objective-C) and Android (Kotlin, Java) with automatic collection of performance metrics, crashes, ANRs, and HTTP requests. Setup takes 10 minutes and includes adding the dependency and initializing with an application token.

Android Setup

The Android SDK is added via a Gradle plugin that automatically instruments Activity, HTTP clients (OkHttp, Retrofit, Volley), and background services. New Relic Android agent also tracks WebView, image loading, and Room database operations.

import com.newrelic.agent.android.NewRelic

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        NewRelic.withApplicationToken("YOUR_TOKEN")
            .withCrashReporting(true)
            .withHttpResponseBodyCapture(true)
            .start(this)
    }
}

The code initializes the New Relic SDK with crash reporting enabled and HTTP response body capture. The withHttpResponseBodyCapture parameter allows viewing response content on 4xx/5xx errors, which is critical for diagnosing API issues.

iOS Setup

The iOS SDK supports Swift Package Manager and CocoaPods. After installation, the agent automatically intercepts URLSession requests, UIApplication metrics, and Swift errors. New Relic iOS agent also collects battery metrics, launch counts, and device temperature — data useful for assessing the application’s impact on the device.

import NewRelic

class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions options: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        NewRelic.enableFeatures(NRFeatureFlag.SwiftAsyncURLSession)
        NewRelic.start(withApplicationToken: "YOUR_TOKEN")
        return true
    }
}

The code activates monitoring of Swift async/await requests via URLSession (iOS 15+) and starts the New Relic agent. NRFeatureFlag.SwiftAsyncURLSession enables instrumentation of modern Swift Concurrency calls.

Distributed Tracing and Service Maps

New Relic Distributed Tracing combines requests from the mobile client through API Gateway, microservices, and databases into a single trace. It supports W3C Trace Context and OpenTelemetry standards, allowing data from third-party tools to be integrated into the overall trace.

Service Map

Service Map is an automatically built dependency map between services based on tracing data. Each service is displayed as a graph node, and arrows between them represent calls from one service to another. The node color indicates health status: green (everything normal), yellow (increased errors), red (service unavailable). The Service Map updates in real time as the architecture changes.

According to New Relic (2024), teams using Service Map find the root cause of slowdowns 55% faster than with manual log analysis. The graph is especially useful for microservice architectures, where a cascading failure in one service can appear as a problem in several unrelated components.

Mobile Client Integration

New Relic links mobile sessions with server-side tracing via headers. If the mobile application sends a request with a New Relic header, the server agent picks up the context, and the trace is displayed from the user’s device to the database. Mobile instrumentation automatically adds the necessary headers to all outgoing HTTP requests.

Analytics with NRDB and NRQL

NRDB is New Relic’s proprietary database, optimized for storing and analyzing time-series data. Unlike traditional SQL databases, NRDB supports unlimited cardinality (the number of unique attribute values), which is critical for telemetry with millions of unique combinations (device_id, endpoint, version).

NRQL in Action

NRQL enables complex analytical queries without exporting data to a BI system. For example, it can calculate “what percentage of iOS 17 users experience cold start times over 3 seconds, grouped by device model.” This helps make decisions about supporting older devices and optimizing for specific models.

SELECT percentile(coldStartTime, 95)
FROM MobileSession
WHERE osVersion LIKE "iOS 17%"
AND coldStartTime > 3
FACET deviceModel
SINCE 7 days ago
LIMIT 20

An NRQL query returns the p95 cold start time for iOS 17 applications where the cold start exceeds 3 seconds, grouped by device model. This makes it possible to identify that the iPhone XS shows 40% slower startup than the iPhone 15, and take optimization decisions.

Alerting and AI Anomaly Detection

New Relic provides a flexible alerting system with support for static and dynamic thresholds. Static alert triggers when a fixed value is exceeded: Apdex < 0.85. Dynamic alert uses machine learning to detect anomalies: the system learns the typical metric behavior over the past 4 weeks and triggers when the deviation exceeds 3 standard deviations.

AI Anomaly Detection

New Relic AI (formerly Applied Intelligence) automatically detects anomalies across all data types — metrics, events, logs — without manual threshold configuration. AI anomaly detection accounts for seasonality (daytime traffic is higher than nighttime, weekdays higher than weekends) and avoids false positives on expected fluctuations. When an anomaly is detected, AI creates an incident with a suggested root cause based on correlation with other metrics.

PagerDuty and Slack Integration

New Relic supports sending notifications to PagerDuty, Slack, Opsgenie, Webhook, and email. Notification channels are configured at the alert policy level and allow sending different notifications to different teams: critical errors to the on-call engineer via PagerDuty, warnings to the team’s Slack channel.