ServiceNow Google Chat Integration Guide

Architecture Overview

Implementation Steps

(function process(request, response) {
    var requestBody = request.body;
    var data = requestBody.data;
    
    // Verify webhook authenticity
    var expectedToken = gs.getProperty('google.chat.verification.token');
    if (data.token !== expectedToken) {
        response.setStatus(401);
        response.setBody(JSON.stringify({error: 'Unauthorized'}));
        return;
    }
    
    // Handle different event types
    if (data.type === 'MESSAGE') {
        var message = data.message;
        var space = data.space.name;
        
        // Process message and create ServiceNow record
        var gr = new GlideRecord('incident');
        gr.initialize();
        gr.short_description = 'Chat request: ' + message.text;
        gr.description = 'Created from Google Chat space: ' + space;
        gr.caller_id = getUserFromEmail(message.sender.email);
        var sysId = gr.insert();
        
        response.setStatus(200);
        response.setBody(JSON.stringify({
            text: 'Incident ' + gr.number + ' created successfully'
        }));
    }
    
    function getUserFromEmail(email) {
        var user = new GlideRecord('sys_user');
        user.addQuery('email', email);
        user.query();
        return user.next() ? user.getUniqueValue() : '';
    }
})(request, response);

(function executeRule(current, previous) {
    try {
        var chatSpoke = new sn_ih.IntegrationHub();
        var action = chatSpoke.getAction('Google Chat', 'Send Message');
        
        action.setParameter('space_name', 'spaces/AAAA_your_space_id');
        action.setParameter('message_text', 
            'Incident ' + current.number + ' has been updated\n' +
            'Priority: ' + current.priority.getDisplayValue() + '\n' +
            'State: ' + current.state.getDisplayValue() + '\n' +
            'Assigned to: ' + current.assigned_to.getDisplayValue() + '\n' +
            'Link: ' + gs.getProperty('glide.servlet.uri') + current.getLink()
        );
        
        var result = action.execute();
        if (result.getStatus() === 'success') {
            gs.info('Google Chat notification sent for incident ' + current.number);
        } else {
            gs.error('Failed to send Google Chat notification: ' + result.getErrorMessage());
        }
    } catch (e) {
        gs.error('Google Chat integration error: ' + e.message);
    }
})(current, previous);

// Test script for System Logs > Scripts - Background
var testIncident = new GlideRecord('incident');
testIncident.initialize();
testIncident.short_description = 'Google Chat Integration Test';
testIncident.urgency = 2;
testIncident.impact = 2;
var incidentId = testIncident.insert();

gs.info('Test incident created: ' + testIncident.number + ' with sys_id: ' + incidentId);

// Verify Google Chat spoke availability
var hub = new sn_ih.IntegrationHub();
var actions = hub.getAvailableActions('Google Chat');
gs.info('Available Google Chat actions: ' + JSON.stringify(actions));

// Health check script for scheduled job
var healthCheck = function() {
    try {
        var hub = new sn_ih.IntegrationHub();
        var testAction = hub.getAction('Google Chat', 'Send Message');
        
        // Test connection without sending actual message
        var connectionTest = testAction.testConnection();
        
        if (connectionTest.isSuccessful()) {
            gs.eventQueue('google.chat.health.success', null, 'Google Chat integration healthy');
            return 'SUCCESS';
        } else {
            gs.eventQueue('google.chat.health.failure', null, connectionTest.getErrorMessage());
            return 'FAILURE: ' + connectionTest.getErrorMessage();
        }
    } catch (e) {
        gs.eventQueue('google.chat.health.error', null, e.message);
        return 'ERROR: ' + e.message;
    }
};

gs.info('Google Chat health check result: ' + healthCheck());

Common Use Cases

Troubleshooting

Pro Tips

• →Configure Integration Hub connection pooling and timeout settings optimally by setting connection timeout to 30 seconds and read timeout to 60 seconds for Google Chat spoke connections to handle varying API response times during peak usage periods. Monitor connection pool utilization in Integration Hub statistics and increase pool size if you observe connection queueing during high-volume notification periods.
• →Implement message templating using ServiceNow's Template Engine (sys_template) to standardize Google Chat message formatting across different notification types and ensure consistent branding and information presentation. Create reusable templates for common notification patterns like incident alerts, change approvals, and service request updates to maintain consistency and simplify maintenance.
• →Leverage Google Chat's thread and card features by implementing advanced message formatting in your ServiceNow integration code to create rich, interactive messages with buttons, images, and structured data that improve user engagement and provide contextual actions. Use cards for complex notifications and threads for follow-up messages to maintain conversation context.
• →Set up comprehensive monitoring and alerting for the integration by creating custom ServiceNow Event Management rules that trigger when Google Chat API calls consistently fail or when webhook processing errors exceed defined thresholds. Implement health check flows that periodically test the integration and automatically alert administrators to connectivity issues before they impact business operations.
• →Optimize performance for high-volume environments by implementing asynchronous message processing using ServiceNow's Scheduled Job framework to queue and batch Google Chat notifications rather than sending them synchronously in Business Rules, which can impact database transaction performance during peak system usage.
• →Enhance security by implementing IP address allowlisting for Google Chat webhook endpoints using ServiceNow's network access controls and by validating webhook signatures using Google's verification mechanisms to prevent unauthorized access to your Scripted REST APIs from external sources attempting to inject malicious data.

Known Limitations

• —Google Chat API enforces rate limits of 10,000 requests per minute per project, which may require message batching or queuing mechanisms for ServiceNow instances generating high notification volumes during incident storms or mass updates. Integration Hub license allocation also limits the number of spoke actions that can be executed per month, potentially impacting organizations with extensive notification requirements.
• —The Google Chat spoke does not support all advanced Chat API features like custom bot avatars, rich card interactions with complex layouts, or direct message capabilities outside of spaces, limiting the sophistication of user interactions compared to native Google Chat applications. Interactive features are limited to basic buttons and simple form inputs.
• —ServiceNow's Scripted REST APIs processing inbound Google Chat webhooks operate with limited execution time and memory constraints that may impact complex workflow processing or bulk data operations triggered by chat interactions. Long-running operations may timeout, requiring asynchronous processing patterns and additional complexity in implementation.
• —Message formatting and link rendering in Google Chat may not preserve all ServiceNow UI formatting or custom styling, and embedded links to ServiceNow records require users to have appropriate ServiceNow access permissions, potentially limiting the effectiveness of notifications for external stakeholders or users without ServiceNow licenses.
• —The integration requires ongoing maintenance of Google Cloud Project configurations, service account credentials, and API enablement status, creating additional administrative overhead and potential points of failure outside of ServiceNow's direct control that could impact integration reliability during Google platform changes or policy updates.

Frequently Asked Questions