ServiceNow New Relic Integration Guide

Architecture Overview

Implementation Steps

var rm = new sn_ws.RESTMessageV2('New Relic Integration API', 'Get Application Performance Data');
rm.setStringParameterNoEscape('app_id', current.u_application_id);
rm.setRequestHeader('Api-Key', gs.getProperty('new_relic.api_key'));
var response = rm.execute();
var responseBody = response.getBody();
var httpStatus = response.getStatusCode();
if (httpStatus == 200) {
    var perfData = JSON.parse(responseBody);
    current.u_apm_data = JSON.stringify(perfData.application);
    current.update();
}

(function process(request, response) {
    try {
        var payload = JSON.parse(request.body.data);
        var alert = payload.current_state;
        
        var incident = new GlideRecord('incident');
        incident.initialize();
        incident.short_description = alert.policy_name + ': ' + alert.condition_name;
        incident.description = 'New Relic Alert: ' + alert.details;
        incident.urgency = (alert.severity === 'critical') ? 1 : 2;
        incident.impact = 2;
        incident.u_alert_id = alert.incident_id;
        incident.u_source = 'New Relic';
        
        var sys_id = incident.insert();
        
        response.setStatus(201);
        response.setHeader('Content-Type', 'application/json');
        response.getStreamWriter().writeString(JSON.stringify({incident_id: sys_id, status: 'created'}));
        
        gs.info('New Relic incident created: ' + sys_id);
    } catch (e) {
        gs.error('Error processing New Relic webhook: ' + e.message);
        response.setStatus(400);
        response.getStreamWriter().writeString(JSON.stringify({error: e.message}));
    }
})(request, response);

var enrichmentData = {
    'u_response_time': perfData.application.response_time,
    'u_throughput': perfData.application.throughput,
    'u_error_rate': perfData.application.error_rate,
    'u_apdex_score': perfData.application.apdex_target
};

for (var field in enrichmentData) {
    if (enrichmentData[field] !== undefined) {
        current[field] = enrichmentData[field];
    }
}
current.update();

var stateMapping = {
    '6': 'closed',     // ServiceNow Resolved -> New Relic Closed
    '7': 'closed',     // ServiceNow Closed -> New Relic Closed
    '2': 'acknowledged' // ServiceNow In Progress -> New Relic Acknowledged
};

var newRelicStatus = stateMapping[current.state.toString()];
if (newRelicStatus && !gs.nil(current.u_alert_id)) {
    var rm = new sn_ws.RESTMessageV2('New Relic Integration API', 'Update Incident Status');
    rm.setStringParameterNoEscape('incident_id', current.u_alert_id);
    rm.setRequestBody(JSON.stringify({status: newRelicStatus, notes: current.work_notes}));
    var response = rm.execute();
}

// Test webhook processing
gs.info('Testing New Relic webhook integration');
var testPayload = {
    current_state: {
        policy_name: 'Test Policy',
        condition_name: 'Response Time Alert',
        severity: 'critical',
        incident_id: 'test_123',
        details: 'Response time exceeded 2 seconds'
    }
};

// Verify incident creation and field population
var testIncident = new GlideRecord('incident');
if (testIncident.get('u_alert_id', 'test_123')) {
    gs.info('Test incident found with sys_id: ' + testIncident.sys_id);
} else {
    gs.error('Test incident not created properly');
}

Common Use Cases

Troubleshooting

Pro Tips

• →Implement intelligent alert correlation by leveraging ServiceNow's CMDB relationships to group related New Relic alerts into single incidents, preventing alert fatigue while maintaining comprehensive visibility. Create custom correlation rules that examine application dependencies and infrastructure relationships to automatically link related performance issues across different New Relic monitoring domains like APM, Infrastructure, and Browser monitoring.
• →Design robust error handling and retry mechanisms in your Flow Designer workflows using exponential backoff patterns and circuit breaker logic to handle New Relic API rate limits gracefully. Store failed API calls in a retry queue table and implement scheduled jobs to reprocess failed enrichment requests during off-peak hours, ensuring no performance data is permanently lost due to temporary connectivity issues.
• →Optimize webhook processing performance by implementing payload validation and early filtering to reject malformed or duplicate notifications before expensive database operations. Use ServiceNow's Event Management capabilities to pre-process New Relic webhooks through correlation engines and noise reduction algorithms, significantly reducing the volume of incidents created while improving signal-to-noise ratio for operations teams.
• →Enhance incident response effectiveness by creating dynamic ServiceNow knowledge articles populated with New Relic runbook data and historical resolution patterns. Implement machine learning-assisted assignment rules that analyze New Relic alert characteristics, application context, and historical assignment patterns to route incidents to the most qualified resolver groups automatically.
• →Establish comprehensive monitoring and alerting for the integration itself by creating ServiceNow events when webhook processing fails, API quotas are approaching limits, or sync operations encounter errors. Build operational dashboards that track integration health metrics like webhook success rates, average enrichment processing times, and bidirectional sync accuracy to proactively identify and resolve integration issues.
• →Implement data retention and archival strategies for New Relic performance data stored in ServiceNow custom fields to prevent database bloat while maintaining historical analysis capabilities. Create automated cleanup jobs that archive detailed APM data to external storage systems after incident resolution while preserving key performance indicators and resolution patterns for future correlation and trending analysis.

Known Limitations

• —New Relic enforces API rate limits of 1000 requests per minute per account, which can impact real-time data enrichment for high-volume incident environments requiring careful throttling and prioritization strategies. The GraphQL API has separate rate limits that may further constrain advanced querying capabilities for detailed performance analytics integration scenarios.
• —ServiceNow's Integration Hub Professional license is required for advanced Flow Designer capabilities and complex webhook processing workflows, limiting integration sophistication for organizations with basic ServiceNow licensing tiers. Custom Scripted REST API endpoints require elevated development privileges and may not be available in strictly governed ServiceNow environments with restricted customization policies.
• —New Relic webhook notifications have a maximum payload size limitation and may not include all available context data for complex applications with extensive metadata, requiring additional API calls for complete incident enrichment. Webhook delivery guarantees are limited to a 72-hour retry window, potentially causing data loss during extended ServiceNow maintenance periods or network connectivity issues.
• —Bidirectional synchronization introduces potential race conditions and data consistency challenges when incidents are simultaneously updated in both systems, requiring careful state management and conflict resolution strategies. Real-time sync capabilities are limited by both platforms' API processing times and may introduce noticeable delays during peak usage periods.
• —New Relic's incident correlation and deduplication features may conflict with ServiceNow's event management correlation rules, potentially creating duplicate or contradictory incident states that require manual intervention. The integration cannot automatically map all New Relic alert severity levels to ServiceNow priority/urgency matrices without custom business logic and organizational alignment on escalation procedures.

Frequently Asked Questions