SnappyFlow

Overview

This document provides a detailed guide to integrating SnappyFlow's Alerting Engine with Callgoose SQIBS for real-time Incident Management, log/metric/trace-based alerting, and automated incident resolution. The integration uses SnappyFlow's generic Webhook Notification Channel to send alert event payloads directly to Callgoose, where API Filters convert them into incidents that are automatically created and resolved.

Prerequisites

Before beginning, ensure you have the following:

• A Callgoose SQIBS account with permissions to create API Filters and access the integration endpoint.
• A SnappyFlow account with admin-level access to Notifications and an existing Project with active Alert Rules.
• A valid Callgoose API token and Api endpoint URL.
• A test SnappyFlow alert rule (recommended) for validating webhook delivery and payloads.

1. Prepare Callgoose: Obtain Endpoint and Token

1.1 Retrieve Callgoose API Endpoint

Generate or locate your Callgoose process endpoint:

https://****.callgoose.com/v1/process?from=snappyflow&token=xxxx

Store the API token securely and never commit it to source control.

2. Configure SnappyFlow Webhook

2.1 Choose the Webhook Scope

In SnappyFlow, the webhook is configured at the Global Notification Channel level and then mapped to specific Projects and Alerts.

Global Notification Channel level:

• Navigate to Manage →Profile → Notifications →Add new → Webhook.

Alert Rule level (Mapping the Channel):

• Alerts→ Select Alert →Edit→ Notification → Select the created Webhook Channel.

SnappyFlow allows sending events for metrics, logs, traces, and anomaly-based alerts.

2.2 Configure Webhook Fields

Set the following options in the SnappyFlow Notification Channel configuration:

• Webhook URL: Callgoose endpoint from Step 1 (The full Callgoose URL including the token.)
• HTTP Method: POST (SnappyFlow's webhooks default to POST for sending the JSON payload.)
• Content Type: application/json (This is the standard format for the SnappyFlow payload.)
• Template: Standard (Use the default template for the standard JSON payload.)
• Status: Must be Enabled to ensure the channel is active.

Save and then map the new channel to your desired SnappyFlow Project and specific Alert Rules.

2.3 Verification Headers

SnappyFlow typically does not include specific signature headers by default in its standard webhook template, relying on the API token in the URL for authentication. If using an intermediary, you should rely on secure transmission (HTTPS) and the unique token for validation.

3. Example SnappyFlow Payloads

A simplified SnappyFlow alert event body using the Standard template:

JSON

{
  "alertName": "High CPU Utilization",
  "appName": "auth-service",
  "status": "firing",
  "severity": "critical",
  "triggeredTime": "2025-12-11T10:30:00Z",
  "alertMessage": "Metric alert triggered: CPU usage > 90%.",
  "correlationId": "High-CPU-auth-service-001", 
  "tags": {
    "host": "node-1",
    "region": "eu-central"
  }
}

Resolved state example (key fields change):

JSON

{
  "alertName": "High CPU Utilization",
  "appName": "auth-service",
  "status": "resolved",
  "severity": "critical",
  "resolvedTime": "2025-12-11T10:45:00Z",
  "alertMessage": "Metric alert resolved: CPU usage back to normal.",
  "correlationId": "High-CPU-auth-service-001",
  // ... other fields remain consistent for correlation
}

Inspect your actual payloads inside Callgoose API Log and use those fields in your API Filter mappings.

4. Create API Filters in Callgoose SQIBS

Callgoose API Filters convert incoming SnappyFlow webhooks into incidents. Use two filters:

• Trigger Filter (create incident)
• Resolve Filter (auto-resolve)

4.1 Trigger Filter — Create Incident

This filter creates an incident whenever SnappyFlow fires a new alert.

Use the following settings:

• Payload JSON Key: "status"
• Key Value Contains: firing
• Map Incident With: "correlationId" (Recommended unique identifier for linking events.)
• Incident Title: "alertName"
• Incident Description: "alertMessage"

4.2 Resolve Filter — Auto-Resolve Incident

This ensures the incident is resolved when the corresponding SnappyFlow alert clears.

Use the following settings:

• Payload JSON Key: "status"
• Key Value Contains: resolved
• Incident Mapped With: "correlationId" (Must match the key used in the Trigger Filter.)

5. Verify and Test the Integration

5.1 Test Initial Delivery

Create a broad test filter in Callgoose (optional, for initial reception testing).

Trigger a test Alert in SnappyFlow (or wait for a live alert).

Confirm Callgoose receives the payload in API Logs.

5.2 View Exact Payload

Use Callgoose’s API request logs to inspect the exact JSON payload received from SnappyFlow.

Copy field names directly from these logs (e.g., alertName, correlationId) for accurate filter configuration.

5.3 Final Verification

1. Trigger an alert in SnappyFlow $\rightarrow$ Incident should be created
2. Clear the alert condition $\rightarrow$ Incident should be auto-resolved
3. Confirm mapping consistency using the correlationId field

6. Troubleshooting

Incoming Payload Not Received

• Check: SnappyFlow webhook logs or delivery status.
• Resolution:
• Verify the endpoint URL and token in SnappyFlow.
• Confirm HTTPS connectivity from SnappyFlow's environment to the Callgoose endpoint.
• Ensure the Webhook Notification Channel is properly mapped and enabled for the specific Alert Rule in SnappyFlow.

Incidents Not Auto-Resolving

• Check: Verify that SnappyFlow is actually sending a payload with status="resolved".
• Resolution:
• Ensure the same field (e.g., correlationId) is used for Map Incident With in the Trigger Filter and Incident Mapped With in the Resolve Filter.
• Confirm the Key Value Contains field in the Resolve Filter is correctly set to resolved.

Wrong or Missing Payload Fields

• Check: Inspect live payloads in Callgoose API Logs.
• Resolution:
• Update API Filters to match the exact JSON field structure and names received from SnappyFlow. Do not guess field names; copy them directly from the Callgoose API Log.

7. Conclusion

Integrating SnappyFlow with Callgoose SQIBS enables fully automated incident creation and resolution based on metric, log, and trace alerts. By configuring SnappyFlow webhooks and mapping them through Callgoose API Filters, teams gain real-time visibility into system errors and performance anomalies.

With clean Trigger and Resolve filters, this integration ensures that observability alert spikes instantly become actionable incidents—and clearing the alert automatically closes the loop, improving operational reliability.

For further customization or advanced use cases, refer to:

• SnappyFlow Documentation
• Callgoose SQIBS API Token Documentation
• Callgoose SQIBS API Endpoint Documentation
• API Filter Instructions and FAQ
• How to Send API