.png)
New Relic Integration Guide
Integrate New Relic with enterprise systems through NerdGraph GraphQL, REST and telemetry ingestion APIs, OpenTelemetry, and selected alert notification webhooks.
New Relic integration options at a glance
New Relic provides NerdGraph, its GraphQL API, as the preferred interface for many entity, account, alerting, dashboard, and NRQL operations. REST APIs cover selected APM, Synthetics, alerting, account, and ingestion functions, while dedicated Events, Metrics, Logs, Trace, and OpenTelemetry endpoints support telemetry submission. Alerting workflows can send selected incident notifications to Martini through webhook-style destinations. Martini can orchestrate these APIs, query NRQL on a schedule, batch telemetry submissions, transform payloads, and route incidents to enterprise applications. Authentication must match the operation, using user API keys, ingest or license keys, query keys for selected legacy APIs, or approved OAuth 2.0 integrations.
| Integration point | Supported by New Relic? | Common use cases | How Martini supports it |
|---|---|---|---|
| GraphQL APIs | Yes | NerdGraph supports entity and relationship queries, NRQL execution, dashboards, alert policies, conditions, workflows, destinations, and selected account and user operations. It is the preferred interface for many newer administrative and query capabilities. | Martini can consume New Relic GraphQL APIs, submit queries and mutations, map responses, follow pagination cursors, and apply workflow error handling. |
| REST APIs | Yes | New Relic REST APIs cover selected APM application and deployment operations, alerting, Synthetics, account and user functions, legacy query functions, and specialized ingestion capabilities. | Martini can call the applicable REST endpoint, manage request configuration and authentication, transform responses, and route results to enterprise applications. |
| Telemetry ingestion APIs | Yes | Events, Metrics, Logs, Trace, browser, mobile, and other supported ingestion endpoints accept observability data. OpenTelemetry and agent-based ingestion are also available for supported scenarios. | Martini can validate, enrich, batch, and submit telemetry to the appropriate regional endpoint while isolating rejected records and handling transient failures. |
| Webhooks / outbound callbacks | Limited | Alerting workflows can send webhook-style notifications for selected alert and incident events. New Relic does not provide a universal webhook stream for every platform object or telemetry event. | Martini can expose an API to receive notifications, validate payloads, normalize incidents, apply routing rules, acknowledge the request, and prevent duplicate downstream actions. |
| Bulk / async / batch APIs | Limited | Telemetry ingestion APIs support multiple event or metric records in a request. Administrative bulk support is resource-specific rather than universal. | Martini can construct bounded batches, control payload size, retry transient failures, and route rejected items to error handling or replay workflows. |
| Database / analytics access | Yes | New Relic provides analytics access through NRQL over NerdGraph and selected query APIs rather than direct SQL database connectivity. | Martini can schedule NRQL queries, handle account scope, time windows, pagination, result limits, and retention constraints, then transform the results for reporting or downstream systems. |
| Authentication | Yes | Authentication options include user API keys, license or ingest keys, query keys for selected legacy APIs, and OAuth 2.0 for approved applications and integrations. | Martini can store credentials in secure environment configuration and use operation-specific authentication, regional endpoints, and permission-aware API requests. |
| File / attachment APIs | Not confirmed | New Relic is not primarily a file or document-management platform, and no general-purpose file or attachment API was confirmed. | Martini should exchange structured telemetry, alert payloads, metadata, and query results through APIs rather than treating New Relic as a file repository. |
How New Relic exposes data and business events
New Relic NerdGraph GraphQL APIs
NerdGraph is New Relic’s GraphQL API and the preferred interface for many entity, account, alerting, dashboard, and NRQL operations. It supports queries and mutations for selected New Relic platform resources, but it is not a replacement for dedicated telemetry ingestion endpoints.
Martini implementation pattern
Martini implementation pattern: Martini workflows consume the NerdGraph endpoint with a secured user API key or approved OAuth credential, submit the required query or mutation, follow cursors where results are paginated, and transform the response for downstream processing. Regional configuration and account scope remain environment-specific.
Implementation sequence
New Relic REST APIs
New Relic REST APIs provide selected APM, deployment, alerting, Synthetics, account, user, legacy query, and ingestion functions. Coverage varies by product area, so the required capability should be confirmed before selecting REST over NerdGraph.
Martini implementation pattern
Martini implementation pattern: Martini calls the product-specific REST endpoint, stores the endpoint and credentials in environment configuration, validates response status and payload shape, and routes the result through reusable workflow logic. REST error responses and rate limits are handled independently from GraphQL responses.
Implementation sequence
New Relic telemetry ingestion
New Relic provides dedicated Events, Metrics, Logs, Trace, browser, mobile, and OpenTelemetry ingestion paths for sending observability data. These endpoints commonly support batched submissions, but authentication, schema, region, and payload limits differ by ingestion product.
Martini implementation pattern
Martini implementation pattern: Martini receives source events through an API or trigger, validates timestamps and required attributes, maps the payload to the selected New Relic telemetry model, batches compatible records, and posts them to the correct regional ingest endpoint. Rejected records are separated where possible so valid telemetry can continue.
Implementation sequence
New Relic alert webhooks
New Relic alerting workflows can send webhook-style notifications for selected alert and incident events. This is targeted notification coverage, not a universal webhook stream for Accounts, Entities, Dashboards, Applications, or every telemetry event.
Martini implementation pattern
Martini implementation pattern: Martini exposes a secured API endpoint for the configured New Relic destination, validates the notification and any available authenticity information, normalizes the incident, applies ownership and severity routing, and acknowledges the request after durable processing or controlled queuing. Incident identifiers support idempotent downstream updates.
Implementation sequence
Common New Relic integration patterns
Pattern 1: Route incidents to ServiceNow
When to use this pattern
Use this pattern when New Relic alerting workflows need to create or update ServiceNow incidents with normalized severity, ownership, entity, and resolution information. It is appropriate when direct notification is insufficient and enterprise routing or enrichment is required.
Integration direction
Example Mapping
| New Relic Field | Canonical Field | Target Field |
|---|---|---|
| incident.id | sourceIncidentId | u_new_relic_incident_id |
| priority or severity | severity | priority |
| entity.name | affectedService | cmdb_ci |
| incident.state | status | state |
Martini implementation pattern
A Martini API receives the selected New Relic alert notification, validates the incident identifier, enriches the payload with ownership data, and uses a deterministic key to create or update the ServiceNow incident. The workflow acknowledges only after durable processing and routes rate-limit, duplicate, and transient failures through controlled retry handling.
Martini capabilities used
- APIs
- workflows
- data mapping
- business rules
- error handling
- secure environment configuration
Pattern 2: Submit enriched application events
When to use this pattern
Use this pattern when an operational, release, or business system produces events that should be correlated with New Relic application or entity telemetry. Martini can enrich the event with deployment, customer, or service metadata before ingestion.
Integration direction
Example Mapping
| New Relic Field | Canonical Field | Target Field |
|---|---|---|
| release.id | deploymentId | deploymentId |
| service.name | serviceName | appName |
| completedAt | eventTimestamp | timestamp |
| release.version | version | version |
Martini implementation pattern
Martini receives the source event, validates required identifiers and timestamps, enriches it from configured reference data, maps it to the applicable New Relic Events or telemetry model, and submits it to the correct regional endpoint. Batching, payload-size controls, rejected-record capture, and retries protect ingestion quality.
Martini capabilities used
- API consumption
- API exposure
- workflow orchestration
- data transformation
- validation
- retry and error handling
Pattern 3: Produce scheduled NRQL reports
When to use this pattern
Use this pattern when teams need recurring service-health, error, deployment, availability, or usage reports from New Relic data. It combines scheduled execution with account-scoped NRQL queries and downstream distribution.
Integration direction
Example Mapping
| New Relic Field | Canonical Field | Target Field |
|---|---|---|
| NRQL result.facets | serviceDimensions | service_name |
| NRQL result.count | eventCount | event_count |
| NRQL result.average | averageValue | average_value |
| query time window | reportPeriod | period_start and period_end |
Martini implementation pattern
A scheduled Martini workflow executes an NRQL query through NerdGraph or an applicable query API, follows pagination or result limits, validates the time window and account scope, transforms the result into a reporting model, and writes it to a database or reporting application. Query failures and incomplete results are recorded for retry or review.
Martini capabilities used
- scheduled workflows
- GraphQL API consumption
- data mapping
- pagination handling
- business rules
- monitoring and error handling
Pattern 4: Correlate deployment changes with telemetry
When to use this pattern
Use this pattern when a CI/CD or release-management system should submit deployment context to New Relic so performance and error data can be associated with a release. The exact operation depends on the New Relic product area and entity model.
Integration direction
Example Mapping
| New Relic Field | Canonical Field | Target Field |
|---|---|---|
| deployment.id | deploymentId | deploymentId |
| application.name | applicationName | application |
| commit.sha | sourceRevision | revision |
| environment | deploymentEnvironment | environment |
Martini implementation pattern
The release platform calls a Martini API after deployment completion. Martini validates the release payload, maps application or entity identity, applies environment and timestamp rules, and invokes the appropriate New Relic REST or ingestion capability. Correlation identifiers are stored so retries do not create duplicate deployment events.
Martini capabilities used
- API exposure
- workflow orchestration
- data transformation
- validation
- idempotency rules
- error handling
Applications commonly integrated with New Relic
New Relic can be integrated with the following named applications to route incidents, correlate operational data, enrich observability events, and distribute reporting. Martini can provide the orchestration layer when direct notification or application integrations do not provide the required transformation, routing, or correlation logic.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| ServiceNow | Create or update incidents and change records when New Relic detects an operational issue, while synchronizing ownership and resolution context. | New Relic → Martini → ServiceNow | Receive a New Relic alert workflow notification through a Martini API, validate and normalize the incident, look up routing data, apply idempotency using the incident identifier, and create or update the ServiceNow record through its API. |
| Jira | Create Jira issues from New Relic incidents and associate release or defect context with application telemetry. | New Relic → Martini → Jira | Accept the alert notification, map New Relic incident and entity fields to Jira issue fields, enrich the issue with ownership or deployment context, and retry safely when Jira or New Relic returns a transient error. |
| PagerDuty | Route New Relic incidents to on-call responders and coordinate acknowledgement or resolution state. | New Relic → Martini → PagerDuty | Use a Martini workflow to validate the New Relic notification, apply service and severity routing rules, call PagerDuty using the appropriate event interface, and retain correlation identifiers for subsequent updates. |
| Slack | Publish selected New Relic alerts, incidents, and deployment notifications to operational channels. | New Relic → Martini → Slack | Receive the New Relic alert payload, select the destination channel based on account, entity, or severity, transform the content into a concise Slack message, and handle delivery failures through workflow error handling. |
| Salesforce | Associate application incidents or service-impact events with customer, account, or case context. | New Relic → Martini → Salesforce | Query or receive New Relic incident data, enrich it with customer or case information from Salesforce, apply privacy and routing rules, and write a normalized operational event or case update through APIs. |
| AWS CloudWatch | Correlate infrastructure metrics and events with New Relic application and entity telemetry. | AWS CloudWatch → Martini → New Relic | Receive or retrieve selected CloudWatch data, normalize dimensions and timestamps, batch the resulting metrics or events, and submit them to the appropriate New Relic regional ingestion endpoint with controlled retries. |
| Microsoft Azure Monitor | Correlate Azure resource and platform telemetry with New Relic entities and application performance data. | Microsoft Azure Monitor → Martini → New Relic | Retrieve or receive selected Azure operational data, map resource identity and dimensions to New Relic attributes, enforce batch and payload-size limits, and submit valid telemetry while isolating rejected items. |
| Splunk | Route selected New Relic incidents or telemetry summaries to a central operations or security analytics environment. | New Relic → Martini → Splunk | Execute a New Relic query or receive an alert notification, transform the result into the agreed Splunk event model, add correlation metadata, and deliver through the relevant API with replay-safe handling. |
How to build a New Relic integration in Martini
Objective
Establish the New Relic API or ingestion connection with the correct regional endpoint and operation-specific credential.
Instructions in Martini
- Select NerdGraph, REST, telemetry ingestion, or alert notification integration based on the use case
- Store user API keys, ingest keys, license keys, query keys, or approved OAuth configuration in secure environment settings
- Keep US and EU endpoints configurable and separate management credentials from ingestion credentials
Objective
Select the event, API, or schedule that starts the integration workflow.
Instructions in Martini
- Expose a Martini API for selected New Relic alert notifications
- Use a Martini scheduler for recurring NRQL queries
- Use an API or workflow trigger for deployment and operational events
- Do not assume New Relic provides universal webhooks for all objects or telemetry
Objective
Acquire the current New Relic resource, query result, alert notification, or source event required by the workflow.
Instructions in Martini
- Receive and validate alert or incident payloads
- Call NerdGraph or a relevant REST API for current resource state
- Execute NRQL with explicit account scope and time windows
- Retrieve source telemetry or deployment data before transformation
Objective
Coordinate enrichment, pagination, batching, routing, and downstream calls in a maintainable Martini workflow.
Instructions in Martini
- Follow GraphQL cursors or REST pagination until the required data is complete
- Enrich entity, application, ownership, or deployment context
- Batch compatible telemetry records within documented payload limits
- Apply conditional routing for severity, account, environment, and target application
Objective
Convert New Relic payloads and source data into canonical models and target-specific formats.
Instructions in Martini
- Map stable identifiers such as account IDs, entity GUIDs, incident IDs, and deployment IDs
- Transform timestamps, severity values, dimensions, NRQL results, and telemetry attributes
- Validate required fields while tolerating optional schema additions
- Separate valid and rejected telemetry records where possible
Objective
Make the integration safe for enterprise operation by enforcing security, idempotency, and routing rules.
Instructions in Martini
- Use deterministic keys to avoid duplicate incidents, events, or deployment records
- Apply ownership, severity, account, and environment routing decisions
- Validate webhook authenticity or verification data where provided
- Prevent credentials and sensitive telemetry content from entering logs
Common New Relic data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Account | Defines the New Relic customer account containing telemetry, users, entities, dashboards, and alerting configuration. | ServiceNow, Salesforce, reporting databases, identity and governance systems | Martini can retrieve account information through NerdGraph or applicable REST APIs, map account identifiers, and use account scope in routing and query workflows. |
| Entity | Represents a monitored application, host, service, browser application, database, or synthetic monitor with globally addressable identity and metadata. | CMDBs, ServiceNow, Jira, reporting databases, cloud platforms | Martini should use stable entity GUIDs and metadata rather than display names alone, then enrich or synchronize entity context with downstream systems. |
| Application | Represents an application monitored by New Relic APM, including transactions, errors, performance data, and deployment information. | Release platforms, ServiceNow, Jira, Salesforce, reporting systems | Martini can query application data or correlate deployment events, map application identifiers and timestamps, and route performance or change information to target systems. |
| Alert policy | Groups alert conditions and thresholds that determine when an incident should be opened. | ServiceNow, Jira, PagerDuty, governance and configuration repositories | Martini can query or manage supported alerting resources through NerdGraph or REST, apply configuration rules, and synchronize policy metadata. |
| Incident | Represents an alerting event caused by one or more conditions breaching configured thresholds. | ServiceNow, Jira, PagerDuty, Slack, operational databases | Martini can receive selected incident notifications, normalize severity and status, apply idempotency using incident identifiers, and create or update downstream records. |
| Dashboard | Provides visualizations containing charts and NRQL-based widgets for operational or business monitoring. | Reporting portals, knowledge platforms, governance repositories | Martini can retrieve or manage supported dashboard resources through NerdGraph, transform metadata, and synchronize selected definitions or ownership information. |
Authentication and security considerations
Credential selection
New Relic credentials are operation-specific. Use appropriately permissioned user API keys or approved OAuth credentials for management and query operations, and use license or ingest keys for supported telemetry ingestion. Query keys may apply to selected legacy APIs.
Regional and permission controls
Configure US or EU API and ingestion endpoints according to the account region. Access depends on API key type, account permissions, organization roles, and OAuth scopes.
Secure Martini configuration
- Store credentials and regional endpoints in secure environment configuration.
- Do not reuse ingestion credentials as management credentials.
- Protect Martini webhook APIs with HTTPS, authentication, validation, and replay controls.
- Do not log API keys or sensitive telemetry content.
Operational considerations for New Relic integrations
Rate limits and retries
Handle HTTP 429 responses, transient 5xx responses, exponential backoff, maximum retry counts, and non-retryable failures. Preserve correlation data for replay and investigation.
Pagination and query limits
NerdGraph and REST resources may paginate. NRQL workflows should define time windows, result limits, account scope, retention expectations, and query timeout behavior.
Telemetry batching
Control batch size and payload size for event and metric ingestion. Where possible, isolate rejected telemetry records so valid records can continue.
Identity and idempotency
Use entity GUIDs and stable incident, alert, deployment, or event identifiers rather than display names alone. Deterministic keys prevent duplicate downstream records when notifications or workflows are retried.
Schema and testing
Use tolerant parsing for optional fields while validating required identifiers and timestamps. Test regional configuration, authentication, pagination, rate limits, rejected payloads, duplicate notifications, and incomplete query results before production deployment.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration beyond a single API call
New Relic integrations often combine alert notifications, NerdGraph queries, REST operations, telemetry ingestion, enrichment, and downstream application updates. Martini coordinates these steps in reusable workflows rather than scattering logic across scripts.
Consistent transformation and rules
Martini provides structured mapping, validation, transformation, routing, and business-rule execution for incidents, entities, NRQL results, deployments, and telemetry payloads.
Operational resilience
- Centralize authentication and regional configuration.
- Handle pagination, batching, rate limits, retries, and rejected records consistently.
- Apply idempotency and correlation rules across target systems.
- Use workflow logging, error handling, and reusable integration assets to simplify support and change management.
Frequently asked questions
New Relic can integrate through NerdGraph GraphQL, selected REST APIs, dedicated Events, Metrics, Logs, and Trace ingestion APIs, OpenTelemetry, and alerting workflow webhook notifications. Enterprise workflows commonly query NRQL, submit enriched telemetry, correlate deployments, or route incidents to service-management and collaboration applications.
Yes. Martini can consume New Relic’s NerdGraph and REST APIs, call telemetry ingestion endpoints, execute NRQL queries, expose an API for selected alert webhook notifications, and orchestrate mappings, enrichment, routing, retries, and downstream updates.
No. A dedicated New Relic connector is not required. Martini can integrate using New Relic’s confirmed native mechanisms, including GraphQL and REST APIs, telemetry endpoints, alert workflow notifications, and the applicable API-key or OAuth authentication methods.
Lonti does not charge an additional per-connector or per-vendor fee to integrate New Relic with Martini. Integrations are subject to the provisioned capacity of the Martini environment. Separate costs may apply from New Relic, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
Use NerdGraph when the required entity, account, alerting, dashboard, or NRQL capability is available there. Use REST or a specialized ingestion API for functions not exposed through NerdGraph or for product areas with documented REST or ingestion endpoints.
New Relic supports webhook-style notifications through alerting destinations and workflows for selected alert and incident events. It does not provide a universal webhook stream for all platform objects or every telemetry event, so scheduled queries may be needed for broader synchronization.
Martini can query New Relic on a schedule, receive selected alert notifications, or accept source events through an API. Workflows then map identifiers, timestamps, severity, dimensions, NRQL results, and telemetry attributes into canonical and target-specific models before applying routing and enrichment rules.
Martini workflows can distinguish validation failures, authentication errors, rate limits, transient 5xx responses, and non-retryable API errors. Exponential backoff, bounded retries, error handling, rejected-record capture, and deterministic keys based on incident, alert, deployment, or event identifiers help prevent duplicates and support replay.
Related Martini documentation
Workflows
Connect New Relic with Martini
Use Martini to build maintainable New Relic integrations for telemetry ingestion, NRQL reporting, deployment correlation, and alert-driven enterprise workflows.