Inbound Integrations
Connect your observability stack to our platform
Integrations are dynamic and flexible. The integration process is simple and involves two steps:
- Receiving a payload
- Mapping payload attributes to incidents
How Integrations Work
To create a new integration, simply navigate to the Integrations
tab and click on the `Create New Integration button.
From there, give your integration a name, such as “AWS Amazon CloudWatch” if you’re connecting to this tool. You’ll also need to choose which team the integration should belong to, as this can’t be changed later. Finally, select the type of integration, such as “AWS Amazon CloudWatch”. Keep in mind that the integration type can’t be changed later.
Configuring Integrations
Again, integrations work by a two-step process:
- Receiving a payload
- Mapping payload attributes to incidents
Step 2 is identical for each integration type, while step 1 (receiving the payload) differs for each integration type.
We’ll walk you through these steps by the example of a Webhook
Integration.
Receiving Payloads
Once you’ve created an integration of type Webhook
, you can send HTTP requests to the integration’s URL.
Every request sent to this address will show up as a new payload from which we’ll extract attributes and map these to incidents.
You can see payloads that were received by All Quiet in the right pane and select them as a template / example for your attribute mapping.
The payload will always be in JSON format and wrap other formats like HTML or XML depending on your payload.
Issue the following cURL
command to send a form post to a webhook integration. The payload will show up under the field formBody.
curl -X POST https://allquiet.app/api/webhook/8fa1637f-cafa-4a5d-8bb8-af1dd5caaf2f
-H "Content-Type: application/x-www-form-urlencoded"
-d "alertName=My+Monitor&alertStatus=Failed&description=From+cURL"
Learn more about generic webhooks here: Connect Generic Webhooks.
Triggering Dummy Incidents
To get a practical understanding of All Quiet’s incident handling, you have the option to initiate a dummy incident. This feature allows you to simulate a real incident by using the current request payload example alongside your established mapping configurations.
When you trigger a dummy incident, the system will execute all the usual processing steps. This includes sending out notifications to your teams and managing any outgoing integrations. This simulation is an effective way to experience firsthand how All Quiet will respond in an actual operational scenario. It’s an invaluable tool for verifying that your configurations and mappings will behave as expected during a live incident.
Here’s how to trigger a dummy incident:
- Navigate to the Payload section, where you’ll see your saved request payload for testing.
- Review your Mapping settings to ensure they’re correctly configured to simulate the desired incident conditions.
- Click on Trigger Dummy Incident to start the simulation. You’ll observe the full cycle of incident processing as if it were a genuine alert.
Mapping Payloads
To map a payload’s JSON to an actual incident you need to define a set of mapping rules. Those rules are also defined in JSON. To allow you to conveniently configure your mapping your changes to the JSON are automatically applied to a preview of an incident.
Teams are a means of organizing collaborators (team members) and integrations.
- Each user can be a member of multiple teams.
- Each integration belongs to exactly one team.
- Each incident triggered by an integration is thus available for collaboration only to the members of the integration’s team.
How does attribute mapping work?
With attribute mapping you can map the payload of your integration to the defined data structure of All Quiet’s incidents.
For each attribute
in attributes
we will evaluate all mappings from the first to the last element. The result of a mapping will be passed on to the next mapping element as an input. The last result will be the attribute’s value. In the following example the attribute Status is first mapped by a jsonPath and then by a map evaluation.
Let’s assume, we’ve created an integration of type Webhook. We can use the following CURL command below as an example to trigger the webhook:
curl -X POST 'https://allquiet.app/api/webhook/8fa1637f-cafa-4a5d-8bb8-af1dd5caaf2f' \
-H 'Content-Type: application/json' \
-d '{"alertName": "My Monitor", "alertStatus": "Failed", "description": "From cURL"}'
Then, we can map the payload to an incident with this attribute mapping:
{
"attributes": [
{
"name": "Status",
"mappings": [
{
"jsonPath": "$.jsonBody.alertStatus"
},
{
"map": "Failed->Open,->Resolved"
}
]
},
{
"name": "Title",
"mappings": [
{
"jsonPath": "$.jsonBody.alertName"
}
]
},
{
"name": "Severity",
"mappings": [
{
"static": "Critical"
}
]
},
{
"name": "Description",
"mappings": [
{
"jsonPath": "$.jsonBody.description"
}
]
}
]
}
Reserved and required attributes
You can map as many attributes with any name you like. There are a few reserved and required attributes though:
Property | Description | Allowed Values |
---|---|---|
CorrelationId | Optional | Use this attribute to uniquely identify and correlate your incidents. If ommitted, a hash of all attributes is used to uniquely identify the incident. |
Status | Required | Open , Resolved |
Severity | Required | Minor , Warning , Critical |
Title | Optional | Defaults to your integration’s name |
Evaluation Types
Each attribute must hold exactly one of the following evaluation types:
Type | Description |
---|---|
jsonPath | A JSONPath expression to map JSON (goessner.net/articles/JsonPath) |
xPath | A XPath expression to map HTML or XML. ( w3schools) |
regex | A regular expression to extract parts of text. The regex is evaluated with the .NET/C# flavor. If groups are matched, the named group “result” is returned. If no group is named “result” the last group is returned. If no groups are found the whole match is returned. ( regex101.com) |
map | A simple map expression mapping values from A to B. The expression A->1,B->2,->3 will map the value “A” to “1” and “B” to “2” and fallback to “3” if no match is found. You can also omit the fallback. The result will then evaluate to the original value. |
static | A static string. The result will always be this string. |
JSONPath examples
Extract elements by property To get the value of the “Return-Path” field of the “headers” array, use ```$.headers[?(@.field==‘Return-Path’)].value“ for the following JSON:
{ "headers": [{ "field": "Return-Path", "value": "" }] }
XPath examples
Extract elements by preceding tag value
To get the value of the “Server” field, i.e. the value of the td that follows a td with value “Server” use //table/tr[td='Server']/td[2]
for the following HTML:
<body>
<table>
<tr>
<td>Severity</td>
<td>Critical</td>
</tr>
<tr>
<td>Server</td>
<td>prod1</td>
</tr>
</table>
</body>
Regex examples
To get the value “my-server” after a colon followed by space use [: ](?[^: ]*)$
for the following text:
Any label here: my-server
Note the use of the named group “result”. Since it’s the only group, the naming of the group could also be ommitted.
Built-in Integrations
Receive alerts from your observability tools. We offer generic email and webhook as well as a growing number of pre-built integrations:
Webhook
AWS Cloudwatch
Google Cloud Monitoring
Azure Monitor
Datadog
New Relic
Grafana
Prometheus
UptimeRobot
Propose a new integration
Didn’t find your tool here? Upvote or add your preferred integration to our roadmap, and we’re happy to ship it. 🚢
Was this page helpful?