ServiceNow Opsgenie Integration Guide

Architecture Overview

Implementation Steps

// Example REST Message variable default values
// endpoint: https://api.opsgenie.com
// message: ${incident.short_description}
// description: ${incident.description}
// priority: ${incident.priority}
// tags: ServiceNow,${incident.category}

{
  "message": "${message}",
  "description": "${description}",
  "priority": "${priority}",
  "tags": ["${tags}"],
  "details": {
    "ServiceNow Incident": "${incident_number}",
    "ServiceNow SysID": "${incident_sys_id}",
    "Assignment Group": "${assignment_group}"
  },
  "entity": "${incident_number}",
  "source": "ServiceNow"
}

// Flow Designer script step for priority mapping
(function execute(inputs, outputs) {
    var incidentPriority = inputs.incident_priority;
    var opsgeniePriority = 'P3'; // default
    
    switch(incidentPriority) {
        case '1': opsgeniePriority = 'P1'; break;
        case '2': opsgeniePriority = 'P2'; break;
        case '3': opsgeniePriority = 'P3'; break;
        case '4': opsgeniePriority = 'P4'; break;
        case '5': opsgeniePriority = 'P5'; break;
    }
    
    outputs.opsgenie_priority = opsgeniePriority;
})(inputs, outputs);

(function process(request, response) {
    try {
        var payload = request.body.data;
        var alertId = payload.alert.id;
        var alertStatus = payload.action; // 'Create', 'Close', 'Acknowledge'
        
        // Find corresponding incident
        var incidentGR = new GlideRecord('incident');
        incidentGR.addQuery('u_opsgenie_alert_id', alertId);
        incidentGR.query();
        
        if (incidentGR.next()) {
            if (alertStatus === 'Close') {
                incidentGR.incident_state = '6'; // Resolved
                incidentGR.close_code = 'Resolved by Opsgenie';
            } else if (alertStatus === 'Acknowledge') {
                incidentGR.incident_state = '2'; // In Progress
            }
            incidentGR.work_notes = 'Updated by Opsgenie: ' + alertStatus;
            incidentGR.update();
            response.setStatus(200);
        } else {
            response.setStatus(404);
        }
    } catch (e) {
        gs.error('Opsgenie webhook error: ' + e.message);
        response.setStatus(500);
    }
})(request, response);

// Monitoring script for scheduled execution
(function() {
    var restMessage = new sn_ws.RESTMessageV2('Opsgenie Alert Management', 'GetAlert');
    restMessage.setStringParameterNoEscape('endpoint', 'https://api.opsgenie.com');
    
    var response = restMessage.execute();
    if (response.getStatusCode() !== 200) {
        gs.error('Opsgenie integration health check failed: ' + response.getErrorMessage());
        // Send notification to integration team
    } else {
        gs.info('Opsgenie integration health check passed');
    }
})();

Common Use Cases

Troubleshooting

Pro Tips

• →Implement exponential backoff retry logic in your Flow Designer REST steps to handle Opsgenie API rate limiting gracefully, using Flow Designer's built-in retry mechanisms combined with custom delay calculations based on HTTP response headers. Store retry counts in incident work notes for visibility and set maximum retry limits to prevent infinite loops during extended API outages.
• →Create custom ServiceNow incident fields to store Opsgenie-specific metadata like alert ID, team assignments, and escalation policy names, enabling rich bidirectional data correlation and advanced reporting on integration effectiveness. Use these fields in ServiceNow dashboards to track response times and escalation patterns across different teams and incident types.
• →Configure Opsgenie alert descriptions with deep links back to ServiceNow incidents using URL templates, and include dynamic content like current incident state, assignment group, and resolution notes to provide responders with immediate context without switching systems. This reduces context switching and improves response efficiency during critical incidents.
• →Implement webhook signature verification in your Scripted REST API using HMAC validation to ensure webhook authenticity and prevent unauthorized incident updates from malicious sources. Store the webhook secret in ServiceNow's encrypted credential store and validate each incoming payload's signature before processing any data.
• →Use ServiceNow's Event Management integration alongside Opsgenie to create a comprehensive alerting ecosystem where monitoring events flow through Event Management rules into incidents, which then create Opsgenie alerts with enriched context from the CMDB and service maps. This provides multi-layered incident correlation and reduces alert noise.
• →Set up automated metrics collection by creating scheduled jobs that query both ServiceNow and Opsgenie APIs to generate integration health reports, tracking metrics like API response times, failed synchronizations, and average incident-to-alert creation time. Use these metrics to optimize integration performance and demonstrate business value to stakeholders.

Known Limitations

• —Opsgenie API rate limits are set at 600 requests per minute per API key, which can be restrictive for large ServiceNow instances with high incident volumes during major outages. The integration requires careful implementation of request queuing and batching strategies to avoid hitting these limits during peak usage periods.
• —Real-time bidirectional synchronization is dependent on webhook reliability and network connectivity, with potential delays of several minutes during network issues or Opsgenie service disruptions. ServiceNow administrators should implement fallback polling mechanisms and status reconciliation processes to handle synchronization gaps.
• —The integration cannot automatically sync Opsgenie user assignments back to ServiceNow incident assigned_to fields due to user identity mapping complexities between the two systems. Organizations must implement custom user correlation logic or accept that detailed assignment tracking remains system-specific, requiring manual coordination for complete audit trails.
• —Complex Opsgenie routing rules and escalation policies cannot be directly replicated in ServiceNow's assignment group logic, creating potential inconsistencies between the systems' understanding of incident ownership and responsibility. Integration architects must carefully design team mapping strategies to maintain operational clarity across both platforms.
• —Historical alert data synchronization is not supported through standard webhook mechanisms, requiring custom batch processing solutions for organizations migrating from other alerting systems or needing to backfill correlation data. This limitation affects reporting continuity and may require separate data migration projects to achieve complete historical integration.

Frequently Asked Questions