fix(alerting): Resolve issue with blank GoogleChat messages (#364)

* debug: Print GoogleChat request body

* chore: Update TwiN/whois to v1.1.0

* fix: Add missing client changes

* test: Improve DNS tests

* chore: Remove accidental change

* docs: Add note for future change to default behavior

* fix(alerting): Don't include URL in Google Chat alert if endpoint type isn't HTTP

Fixes #362

.examples/docker-compose-grafana-prometheus/README.md

@@ -0,0 +1,41 @@
+## Usage
+Gatus exposes Prometheus metrics at `/metrics` if the `metrics` configuration option is set to `true`.
+
+To run this example, all you need to do is execute the following command:
+```console
+docker-compose up
+```
+Once you've done the above, you should be able to access the Grafana dashboard at `http://localhost:3000`.
+
+![Gatus Grafana dashboard](../../.github/assets/grafana-dashboard.png)
+
+
+## Queries
+By default, this example has a Grafana dashboard with some panels, but for the sake of verbosity, you'll find
+a list of simple queries below. Those make use of the `key` parameter, which is a concatenation of the endpoint's
+group and name.
+
+### Success rate
+```
+sum(rate(gatus_results_total{success="true"}[30s])) by (key) / sum(rate(gatus_results_total[30s])) by (key)
+```
+
+### Response time
+```
+gatus_results_duration_seconds
+```
+
+### Total results per minute
+```
+sum(rate(gatus_results_total[5m])*60) by (key)
+```
+
+### Total successful results per minute
+```
+sum(rate(gatus_results_total{success="true"}[5m])*60) by (key)
+```
+
+### Total unsuccessful results per minute
+```
+sum(rate(gatus_results_total{success="false"}[5m])*60) by (key)
+```

.examples/docker-compose-grafana-prometheus/config/config.yaml

@@ -2,15 +2,18 @@ metrics: true
 endpoints:
   - name: website
     url: https://twin.sh/health
-    interval: 30s
+    interval: 5m
     conditions:
       - "[STATUS] == 200"
+
+  - name: example
+    url: https://example.com/
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+
   - name: github
     url: https://api.github.com/healthz
     interval: 5m
-    conditions:
-      - "[STATUS] == 200"
-  - name: example
-    url: https://example.com/
     conditions:
       - "[STATUS] == 200"

.examples/docker-compose-grafana-prometheus/docker-compose.yml

@@ -7,7 +7,7 @@ services:
     ports:
       - "8080:8080"
     volumes:
-      - ./config.yaml:/config/config.yaml
+      - ./config:/config
     networks:
       - metrics
 

.examples/docker-compose-grafana-prometheus/grafana/provisioning/dashboards/gatus.json

@@ -0,0 +1,582 @@
+{
+  "annotations": {
+    "list": [
+      {
+        "builtIn": 1,
+        "datasource": "-- Grafana --",
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "name": "Annotations & Alerts",
+        "type": "dashboard"
+      }
+    ]
+  },
+  "editable": true,
+  "gnetId": null,
+  "graphTooltip": 0,
+  "id": 3,
+  "links": [],
+  "panels": [
+    {
+      "cacheTimeout": null,
+      "datasource": null,
+      "description": "Number of successful results compared to the total number of results during the current interval",
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 0
+      },
+      "id": 9,
+      "links": [],
+      "options": {
+        "fieldOptions": {
+          "calcs": [
+            "mean"
+          ],
+          "defaults": {
+            "mappings": [
+              {
+                "id": 0,
+                "op": "=",
+                "text": "N/A",
+                "type": 1,
+                "value": "null"
+              }
+            ],
+            "max": 1,
+            "min": 0,
+            "nullValueMode": "connected",
+            "thresholds": [
+              {
+                "color": "red",
+                "value": null
+              },
+              {
+                "color": "semi-dark-orange",
+                "value": 0.6
+              },
+              {
+                "color": "yellow",
+                "value": 0.8
+              },
+              {
+                "color": "dark-green",
+                "value": 0.95
+              }
+            ],
+            "unit": "percentunit"
+          },
+          "override": {},
+          "values": false
+        },
+        "orientation": "horizontal",
+        "showThresholdLabels": false,
+        "showThresholdMarkers": false
+      },
+      "pluginVersion": "6.4.4",
+      "targets": [
+        {
+          "expr": "sum(rate(gatus_results_total{success=\"true\"}[30s])) by (key) / sum(rate(gatus_results_total[30s])) by (key)",
+          "hide": false,
+          "legendFormat": "{{key}}",
+          "refId": "B"
+        }
+      ],
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "Success rate",
+      "type": "gauge"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "cacheTimeout": null,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 0
+      },
+      "id": 11,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null as zero",
+      "options": {
+        "dataLinks": []
+      },
+      "percentage": false,
+      "pluginVersion": "6.4.4",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "gatus_results_duration_seconds",
+          "format": "time_series",
+          "instant": false,
+          "interval": "",
+          "intervalFactor": 1,
+          "legendFormat": "{{key}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Response time",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "cacheTimeout": null,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 8
+      },
+      "id": 10,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "connected",
+      "options": {
+        "dataLinks": []
+      },
+      "percentage": false,
+      "pluginVersion": "6.4.4",
+      "pointradius": 2,
+      "points": true,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(rate(gatus_results_total{success=\"true\"}[30s])) by (key) / sum(rate(gatus_results_total[30s])) by (key)",
+          "format": "time_series",
+          "instant": false,
+          "interval": "",
+          "intervalFactor": 1,
+          "legendFormat": "{{key}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Success rate",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "description": "Number of results per minute",
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 8
+      },
+      "id": 2,
+      "interval": "",
+      "legend": {
+        "alignAsTable": false,
+        "avg": false,
+        "current": false,
+        "hideEmpty": false,
+        "hideZero": false,
+        "max": false,
+        "min": false,
+        "rightSide": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null",
+      "options": {
+        "dataLinks": []
+      },
+      "percentage": false,
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(rate(gatus_results_total[5m])*60) by (key)",
+          "format": "time_series",
+          "hide": false,
+          "instant": false,
+          "interval": "30s",
+          "intervalFactor": 1,
+          "legendFormat": "{{key}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Total results per minute",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "decimals": null,
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 7,
+        "w": 12,
+        "x": 0,
+        "y": 16
+      },
+      "id": 5,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null",
+      "options": {
+        "dataLinks": []
+      },
+      "percentage": false,
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(rate(gatus_results_total{success=\"true\"}[5m])*60) by (key)",
+          "instant": false,
+          "interval": "30s",
+          "legendFormat": "{{key}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Successful results per minute",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "decimals": null,
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 7,
+        "w": 12,
+        "x": 12,
+        "y": 16
+      },
+      "id": 3,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null",
+      "options": {
+        "dataLinks": []
+      },
+      "percentage": false,
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(rate(gatus_results_total{success=\"false\"}[5m])*60) by (key)",
+          "interval": "30s",
+          "legendFormat": "{{key}} ",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Unsuccessful results per minute",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    }
+  ],
+  "refresh": "1m",
+  "schemaVersion": 20,
+  "style": "dark",
+  "tags": [],
+  "templating": {
+    "list": []
+  },
+  "time": {
+    "from": "now-1h",
+    "to": "now"
+  },
+  "timepicker": {
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ]
+  },
+  "timezone": "",
+  "title": "Gatus",
+  "uid": "KPI7Qj1Wk",
+  "version": 2
+}

.examples/docker-compose-grafana-prometheus/grafana/provisioning/dashboards/main.json

@@ -1,300 +0,0 @@
-{
-  "annotations": {
-    "list": [
-      {
-        "builtIn": 1,
-        "datasource": "-- Grafana --",
-        "enable": true,
-        "hide": true,
-        "iconColor": "rgba(0, 211, 255, 1)",
-        "name": "Annotations & Alerts",
-        "type": "dashboard"
-      }
-    ]
-  },
-  "editable": true,
-  "gnetId": null,
-  "graphTooltip": 0,
-  "id": 2,
-  "links": [],
-  "panels": [
-    {
-      "aliasColors": {},
-      "bars": false,
-      "dashLength": 10,
-      "dashes": false,
-      "datasource": null,
-      "fill": 1,
-      "fillGradient": 0,
-      "gridPos": {
-        "h": 14,
-        "w": 12,
-        "x": 0,
-        "y": 0
-      },
-      "id": 2,
-      "legend": {
-        "avg": false,
-        "current": false,
-        "max": false,
-        "min": false,
-        "show": true,
-        "total": false,
-        "values": false
-      },
-      "lines": true,
-      "linewidth": 1,
-      "nullPointMode": "null",
-      "options": {
-        "dataLinks": []
-      },
-      "percentage": false,
-      "pointradius": 2,
-      "points": false,
-      "renderer": "flot",
-      "seriesOverrides": [],
-      "spaceLength": 10,
-      "stack": false,
-      "steppedLine": false,
-      "targets": [
-        {
-          "expr": "sum(rate(gatus_tasks[30s])) by (endpoint)",
-          "interval": "30s",
-          "legendFormat": "{{endpoint}}",
-          "refId": "A"
-        }
-      ],
-      "thresholds": [],
-      "timeFrom": null,
-      "timeRegions": [],
-      "timeShift": null,
-      "title": "All tasks executed over time",
-      "tooltip": {
-        "shared": true,
-        "sort": 0,
-        "value_type": "individual"
-      },
-      "type": "graph",
-      "xaxis": {
-        "buckets": null,
-        "mode": "time",
-        "name": null,
-        "show": true,
-        "values": []
-      },
-      "yaxes": [
-        {
-          "format": "short",
-          "label": null,
-          "logBase": 1,
-          "max": null,
-          "min": null,
-          "show": true
-        },
-        {
-          "format": "short",
-          "label": null,
-          "logBase": 1,
-          "max": null,
-          "min": null,
-          "show": true
-        }
-      ],
-      "yaxis": {
-        "align": false,
-        "alignLevel": null
-      }
-    },
-    {
-      "aliasColors": {},
-      "bars": false,
-      "dashLength": 10,
-      "dashes": false,
-      "datasource": null,
-      "fill": 1,
-      "fillGradient": 0,
-      "gridPos": {
-        "h": 7,
-        "w": 12,
-        "x": 12,
-        "y": 0
-      },
-      "id": 3,
-      "legend": {
-        "avg": false,
-        "current": false,
-        "max": false,
-        "min": false,
-        "show": true,
-        "total": false,
-        "values": false
-      },
-      "lines": true,
-      "linewidth": 1,
-      "nullPointMode": "null",
-      "options": {
-        "dataLinks": []
-      },
-      "percentage": false,
-      "pointradius": 2,
-      "points": false,
-      "renderer": "flot",
-      "seriesOverrides": [],
-      "spaceLength": 10,
-      "stack": false,
-      "steppedLine": false,
-      "targets": [
-        {
-          "expr": "sum(rate(gatus_tasks{success=\"false\"}[30s])) by (endpoint)",
-          "interval": "30s",
-          "legendFormat": "{{endpoint}}",
-          "refId": "A"
-        }
-      ],
-      "thresholds": [],
-      "timeFrom": null,
-      "timeRegions": [],
-      "timeShift": null,
-      "title": "Unsuccessful tasks",
-      "tooltip": {
-        "shared": true,
-        "sort": 0,
-        "value_type": "individual"
-      },
-      "type": "graph",
-      "xaxis": {
-        "buckets": null,
-        "mode": "time",
-        "name": null,
-        "show": true,
-        "values": []
-      },
-      "yaxes": [
-        {
-          "format": "short",
-          "label": null,
-          "logBase": 1,
-          "max": null,
-          "min": null,
-          "show": true
-        },
-        {
-          "format": "short",
-          "label": null,
-          "logBase": 1,
-          "max": null,
-          "min": null,
-          "show": true
-        }
-      ],
-      "yaxis": {
-        "align": false,
-        "alignLevel": null
-      }
-    },
-    {
-      "aliasColors": {},
-      "bars": false,
-      "dashLength": 10,
-      "dashes": false,
-      "datasource": null,
-      "fill": 1,
-      "fillGradient": 0,
-      "gridPos": {
-        "h": 7,
-        "w": 12,
-        "x": 12,
-        "y": 7
-      },
-      "id": 5,
-      "legend": {
-        "avg": false,
-        "current": false,
-        "max": false,
-        "min": false,
-        "show": true,
-        "total": false,
-        "values": false
-      },
-      "lines": true,
-      "linewidth": 1,
-      "nullPointMode": "null",
-      "options": {
-        "dataLinks": []
-      },
-      "percentage": false,
-      "pointradius": 2,
-      "points": false,
-      "renderer": "flot",
-      "seriesOverrides": [],
-      "spaceLength": 10,
-      "stack": false,
-      "steppedLine": false,
-      "targets": [
-        {
-          "expr": "sum(rate(gatus_tasks{success=\"true\"}[30s])) by (endpoint)",
-          "instant": false,
-          "interval": "30s",
-          "legendFormat": "{{endpoint}}",
-          "refId": "A"
-        }
-      ],
-      "thresholds": [],
-      "timeFrom": null,
-      "timeRegions": [],
-      "timeShift": null,
-      "title": "Successful tasks",
-      "tooltip": {
-        "shared": true,
-        "sort": 0,
-        "value_type": "individual"
-      },
-      "type": "graph",
-      "xaxis": {
-        "buckets": null,
-        "mode": "time",
-        "name": null,
-        "show": true,
-        "values": []
-      },
-      "yaxes": [
-        {
-          "format": "short",
-          "label": null,
-          "logBase": 1,
-          "max": null,
-          "min": null,
-          "show": true
-        },
-        {
-          "format": "short",
-          "label": null,
-          "logBase": 1,
-          "max": null,
-          "min": null,
-          "show": true
-        }
-      ],
-      "yaxis": {
-        "align": false,
-        "alignLevel": null
-      }
-    }
-  ],
-  "refresh": "10s",
-  "schemaVersion": 20,
-  "style": "dark",
-  "tags": [],
-  "templating": {
-    "list": []
-  },
-  "time": {
-    "from": "now-30m",
-    "to": "now"
-  },
-  "timepicker": {},
-  "timezone": "",
-  "title": "Gatus",
-  "uid": "KPI7Qj1Wk",
-  "version": 3
-}

.examples/docker-compose-mattermost/docker-compose.yml

@@ -6,7 +6,7 @@ services:
     ports:
       - "8080:8080"
     volumes:
-      - ./config.yaml:/config/config.yaml
+      - ./config:/config
     networks:
       - default
 

.examples/docker-compose-postgres-storage/docker-compose.yml

@@ -19,11 +19,11 @@ services:
     ports:
       - "8080:8080"
     volumes:
-      - ./config.yaml:/config/config.yaml
+      - ./config:/config
     networks:
       - web
     depends_on:
       - postgres
 
 networks:
-  web:
+  web:

.examples/docker-compose-sqlite-storage/docker-compose.yml

@@ -5,5 +5,5 @@ services:
     ports:
       - "8080:8080"
     volumes:
-      - ./config.yaml:/config/config.yaml
-      - ./data:/data/
+      - ./config:/config
+      - ./data:/data/

.examples/docker-compose/docker-compose.yml

@@ -5,4 +5,4 @@ services:
     ports:
       - 8080:8080
     volumes:
-      - ./config.yaml:/config/config.yaml
+      - ./config:/config

.examples/kubernetes/gatus.yaml

@@ -54,10 +54,10 @@ spec:
       app: gatus
   template:
     metadata:
-      labels:
-        app: gatus
       name: gatus
       namespace: kube-system
+      labels:
+        app: gatus
     spec:
       serviceAccountName: gatus
       terminationGracePeriodSeconds: 5
@@ -76,6 +76,22 @@ spec:
             requests:
               cpu: 50m
               memory: 30M
+          readinessProbe:
+            httpGet:
+              path: /health
+              port: 8080
+            initialDelaySeconds: 5
+            periodSeconds: 10
+            successThreshold: 1
+            failureThreshold: 3
+          livenessProbe:
+            httpGet:
+              path: /health
+              port: 8080
+            initialDelaySeconds: 10
+            periodSeconds: 10
+            successThreshold: 1
+            failureThreshold: 5
           volumeMounts:
             - mountPath: /config
               name: gatus-config

.github/codecov.yml

@@ -5,3 +5,8 @@ ignore:
 coverage:
   status:
     patch: off
+    project:
+      default:
+        target: 75%
+        threshold: null
+

.github/dependabot.yml

@@ -0,0 +1,15 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    labels: ["dependencies"]
+    schedule:
+      interval: "weekly"
+      day: "wednesday"
+  - package-ecosystem: "gomod"
+    directory: "/"
+    open-pull-requests-limit: 1
+    labels: ["dependencies"]
+    schedule:
+      interval: "weekly"
+      day: "wednesday"

.github/workflows/benchmark.yml

@@ -0,0 +1,26 @@
+name: benchmark
+on:
+  workflow_dispatch:
+    inputs:
+      repository:
+        description: "Repository to checkout. Useful for benchmarking a fork. Format should be <owner>/<repository>."
+        required: true
+        default: "TwiN/gatus"
+      ref:
+        description: "Branch, tag or SHA to checkout"
+        required: true
+        default: "master"
+jobs:
+  build:
+    name: benchmark
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/setup-go@v3
+        with:
+          go-version: 1.19
+          repository: "${{ github.event.inputs.repository }}"
+          ref: "${{ github.event.inputs.ref }}"
+      - uses: actions/checkout@v3
+      - name: Benchmark
+        run: go test -bench=. ./storage/store

.github/workflows/publish-experimental.yml

@@ -0,0 +1,27 @@
+name: publish-experimental
+on: [workflow_dispatch]
+jobs:
+  publish-experimental:
+    name: publish-experimental
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v3
+      - name: Get image repository
+        run: echo IMAGE_REPOSITORY=$(echo ${{ secrets.DOCKER_USERNAME }}/${{ github.event.repository.name }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Login to Docker Registry
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Build and push docker image
+        uses: docker/build-push-action@v3
+        with:
+          platforms: linux/amd64
+          pull: true
+          push: true
+          tags: ${{ env.IMAGE_REPOSITORY }}:experimental

.github/workflows/publish-latest.yml

@@ -4,31 +4,32 @@ on:
     workflows: ["build"]
     branches: [master]
     types: [completed]
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: true
 jobs:
   publish-latest:
-    name: Publish latest
+    name: publish-latest
     runs-on: ubuntu-latest
     if: ${{ github.event.workflow_run.conclusion == 'success' }}
-    timeout-minutes: 30
+    timeout-minutes: 60
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Get image repository
         run: echo IMAGE_REPOSITORY=$(echo ${{ secrets.DOCKER_USERNAME }}/${{ github.event.repository.name }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@v2
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v2
       - name: Login to Docker Registry
-        uses: docker/login-action@v1
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Build and push docker image
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v3
         with:
-          platforms: linux/amd64
+          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
           pull: true
           push: true
-          tags: |
-            ${{ env.IMAGE_REPOSITORY }}:latest
+          tags: ${{ env.IMAGE_REPOSITORY }}:latest

.github/workflows/publish-release.yml

@@ -4,30 +4,28 @@ on:
     types: [published]
 jobs:
   publish-release:
-    name: Publish release
+    name: publish-release
     runs-on: ubuntu-latest
-    timeout-minutes: 30
+    timeout-minutes: 60
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Get image repository
         run: echo IMAGE_REPOSITORY=$(echo ${{ secrets.DOCKER_USERNAME }}/${{ github.event.repository.name }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
       - name: Get the release
         run: echo RELEASE=${GITHUB_REF/refs\/tags\//} >> $GITHUB_ENV
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@v2
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v2
       - name: Login to Docker Registry
-        uses: docker/login-action@v1
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Build and push docker image
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v3
         with:
           platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
           pull: true
           push: true
-          tags: |
-            ${{ env.IMAGE_REPOSITORY }}:${{ env.RELEASE }}
+          tags: ${{ env.IMAGE_REPOSITORY }}:${{ env.RELEASE }},${{ env.IMAGE_REPOSITORY }}:stable

.github/workflows/test.yml

@@ -1,4 +1,4 @@
-name: build
+name: test
 on:
   pull_request:
     paths-ignore:
@@ -9,25 +9,22 @@ on:
     paths-ignore:
       - '*.md'
 jobs:
-  build:
-    name: Build
+  test:
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
-      - name: Set up Go
-        uses: actions/setup-go@v2
+      - uses: actions/setup-go@v3
         with:
-          go-version: 1.17
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
+          go-version: 1.19
+      - uses: actions/checkout@v3
       - name: Build binary to make sure it works
-        run: go build -mod vendor
+        run: go build
       - name: Test
         # We're using "sudo" because one of the tests leverages ping, which requires super-user privileges.
         # As for the 'env "PATH=$PATH" "GOROOT=$GOROOT"', we need it to use the same "go" executable that
         # was configured by the "Set up Go" step (otherwise, it'd use sudo's "go" executable)
-        run: sudo env "PATH=$PATH" "GOROOT=$GOROOT" go test -mod vendor ./... -race -coverprofile=coverage.txt -covermode=atomic
+        run: sudo env "PATH=$PATH" "GOROOT=$GOROOT" go test ./... -race -coverprofile=coverage.txt -covermode=atomic
       - name: Codecov
-        uses: codecov/codecov-action@v2.1.0
+        uses: codecov/codecov-action@v3.1.1
         with:
           files: ./coverage.txt

.gitignore

@@ -1,8 +1,7 @@
 .idea
 .vscode
+*.db
+*.db-shm
+*.db-wal
 gatus
-db.db
-config/config.yml
-db.db-shm
-db.db-wal
-memory.db
+config/config.yml

Dockerfile

@@ -3,7 +3,7 @@ FROM golang:alpine as builder
 RUN apk --update add ca-certificates
 WORKDIR /app
 COPY . ./
-RUN CGO_ENABLED=0 GOOS=linux go build -mod vendor -a -installsuffix cgo -o gatus .
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o gatus .
 
 # Run Tests inside docker image if you don't have a configured go environment
 #RUN apk update && apk add --virtual build-dependencies build-base gcc
@@ -13,7 +13,6 @@ RUN CGO_ENABLED=0 GOOS=linux go build -mod vendor -a -installsuffix cgo -o gatus
 FROM scratch
 COPY --from=builder /app/gatus .
 COPY --from=builder /app/config.yaml ./config/config.yaml
-COPY --from=builder /app/web/static ./web/static
 COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
 ENV PORT=8080
 EXPOSE ${PORT}

LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

Makefile

@@ -1,5 +1,8 @@
 BINARY=gatus
 
+# Because there's a folder called "test", we need to make the target "test" phony
+.PHONY: test
+
 install:
 	go build -mod vendor -o $(BINARY) .
 
@@ -10,7 +13,7 @@ clean:
 	rm $(BINARY)
 
 test:
-	sudo go test ./alerting/... ./client/... ./config/... ./controller/... ./core/... ./jsonpath/... ./pattern/... ./security/... ./storage/... ./util/... ./watchdog/... -cover
+	go test ./... -cover
 
 
 ##########

alerting/alert/alert.go

@@ -1,5 +1,15 @@
 package alert
 
+import (
+	"errors"
+	"strings"
+)
+
+var (
+	// ErrAlertWithInvalidDescription is the error with which Gatus will panic if an alert has an invalid character
+	ErrAlertWithInvalidDescription = errors.New("alert description must not have \" or \\")
+)
+
 // Alert is a core.Endpoint's alert configuration
 type Alert struct {
 	// Type of alert (required)
@@ -9,7 +19,7 @@ type Alert struct {
 	//
 	// This is a pointer, because it is populated by YAML and we need to know whether it was explicitly set to a value
 	// or not for provider.ParseWithDefaultAlert to work.
-	Enabled *bool `yaml:"enabled"`
+	Enabled *bool `yaml:"enabled,omitempty"`
 
 	// FailureThreshold is the number of failures in a row needed before triggering the alert
 	FailureThreshold int `yaml:"failure-threshold"`
@@ -31,7 +41,7 @@ type Alert struct {
 
 	// ResolveKey is an optional field that is used by some providers (i.e. PagerDuty's dedup_key) to resolve
 	// ongoing/triggered incidents
-	ResolveKey string
+	ResolveKey string `yaml:"-"`
 
 	// Triggered is used to determine whether an alert has been triggered. When an alert is resolved, this value
 	// should be set back to false. It is used to prevent the same alert from going out twice.
@@ -41,7 +51,21 @@ type Alert struct {
 	// applied for alerts that are already triggered and has become "healthy" again is to prevent a case where, for
 	// some reason, the alert provider always returns errors when trying to send the resolved notification
 	// (SendOnResolved).
-	Triggered bool
+	Triggered bool `yaml:"-"`
+}
+
+// ValidateAndSetDefaults validates the alert's configuration and sets the default value of fields that have one
+func (alert *Alert) ValidateAndSetDefaults() error {
+	if alert.FailureThreshold <= 0 {
+		alert.FailureThreshold = 3
+	}
+	if alert.SuccessThreshold <= 0 {
+		alert.SuccessThreshold = 2
+	}
+	if strings.ContainsAny(alert.GetDescription(), "\"\\") {
+		return ErrAlertWithInvalidDescription
+	}
+	return nil
 }
 
 // GetDescription retrieves the description of the alert
@@ -55,6 +79,7 @@ func (alert Alert) GetDescription() string {
 // IsEnabled returns whether an alert is enabled or not
 func (alert Alert) IsEnabled() bool {
 	if alert.Enabled == nil {
+		// TODO: Default to true in v5.0.0 (unless default-alert.enabled is set to false)
 		return false
 	}
 	return *alert.Enabled

alerting/alert/alert_test.go

@@ -1,6 +1,55 @@
 package alert
 
-import "testing"
+import (
+	"testing"
+)
+
+func TestAlert_ValidateAndSetDefaults(t *testing.T) {
+	invalidDescription := "\""
+	scenarios := []struct {
+		name                     string
+		alert                    Alert
+		expectedError            error
+		expectedSuccessThreshold int
+		expectedFailureThreshold int
+	}{
+		{
+			name: "valid-empty",
+			alert: Alert{
+				Description:      nil,
+				FailureThreshold: 0,
+				SuccessThreshold: 0,
+			},
+			expectedError:            nil,
+			expectedFailureThreshold: 3,
+			expectedSuccessThreshold: 2,
+		},
+		{
+			name: "invalid-description",
+			alert: Alert{
+				Description:      &invalidDescription,
+				FailureThreshold: 10,
+				SuccessThreshold: 5,
+			},
+			expectedError:            ErrAlertWithInvalidDescription,
+			expectedFailureThreshold: 10,
+			expectedSuccessThreshold: 5,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			if err := scenario.alert.ValidateAndSetDefaults(); err != scenario.expectedError {
+				t.Errorf("expected error %v, got %v", scenario.expectedError, err)
+			}
+			if scenario.alert.SuccessThreshold != scenario.expectedSuccessThreshold {
+				t.Errorf("expected success threshold %v, got %v", scenario.expectedSuccessThreshold, scenario.alert.SuccessThreshold)
+			}
+			if scenario.alert.FailureThreshold != scenario.expectedFailureThreshold {
+				t.Errorf("expected failure threshold %v, got %v", scenario.expectedFailureThreshold, scenario.alert.FailureThreshold)
+			}
+		})
+	}
+}
 
 func TestAlert_IsEnabled(t *testing.T) {
 	if (Alert{Enabled: nil}).IsEnabled() {

alerting/alert/type.go

@@ -11,12 +11,27 @@ const (
 	// TypeDiscord is the Type for the discord alerting provider
 	TypeDiscord Type = "discord"
 
+	// TypeEmail is the Type for the email alerting provider
+	TypeEmail Type = "email"
+
+	// TypeGoogleChat is the Type for the googlechat alerting provider
+	TypeGoogleChat Type = "googlechat"
+
+	// TypeMatrix is the Type for the matrix alerting provider
+	TypeMatrix Type = "matrix"
+
 	// TypeMattermost is the Type for the mattermost alerting provider
 	TypeMattermost Type = "mattermost"
 
 	// TypeMessagebird is the Type for the messagebird alerting provider
 	TypeMessagebird Type = "messagebird"
 
+	// TypeNtfy is the Type for the ntfy alerting provider
+	TypeNtfy Type = "ntfy"
+
+	// TypeOpsgenie is the Type for the opsgenie alerting provider
+	TypeOpsgenie Type = "opsgenie"
+
 	// TypePagerDuty is the Type for the pagerduty alerting provider
 	TypePagerDuty Type = "pagerduty"
 

alerting/config.go

@@ -1,47 +1,67 @@
 package alerting
 
 import (
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/alerting/provider/discord"
-	"github.com/TwiN/gatus/v3/alerting/provider/mattermost"
-	"github.com/TwiN/gatus/v3/alerting/provider/messagebird"
-	"github.com/TwiN/gatus/v3/alerting/provider/pagerduty"
-	"github.com/TwiN/gatus/v3/alerting/provider/slack"
-	"github.com/TwiN/gatus/v3/alerting/provider/teams"
-	"github.com/TwiN/gatus/v3/alerting/provider/telegram"
-	"github.com/TwiN/gatus/v3/alerting/provider/twilio"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/alerting/provider"
+	"github.com/TwiN/gatus/v4/alerting/provider/custom"
+	"github.com/TwiN/gatus/v4/alerting/provider/discord"
+	"github.com/TwiN/gatus/v4/alerting/provider/email"
+	"github.com/TwiN/gatus/v4/alerting/provider/googlechat"
+	"github.com/TwiN/gatus/v4/alerting/provider/matrix"
+	"github.com/TwiN/gatus/v4/alerting/provider/mattermost"
+	"github.com/TwiN/gatus/v4/alerting/provider/messagebird"
+	"github.com/TwiN/gatus/v4/alerting/provider/ntfy"
+	"github.com/TwiN/gatus/v4/alerting/provider/opsgenie"
+	"github.com/TwiN/gatus/v4/alerting/provider/pagerduty"
+	"github.com/TwiN/gatus/v4/alerting/provider/slack"
+	"github.com/TwiN/gatus/v4/alerting/provider/teams"
+	"github.com/TwiN/gatus/v4/alerting/provider/telegram"
+	"github.com/TwiN/gatus/v4/alerting/provider/twilio"
 )
 
 // Config is the configuration for alerting providers
 type Config struct {
 	// Custom is the configuration for the custom alerting provider
-	Custom *custom.AlertProvider `yaml:"custom"`
+	Custom *custom.AlertProvider `yaml:"custom,omitempty"`
+
+	// GoogleChat is the configuration for the Google chat alerting provider
+	GoogleChat *googlechat.AlertProvider `yaml:"googlechat,omitempty"`
 
 	// Discord is the configuration for the discord alerting provider
-	Discord *discord.AlertProvider `yaml:"discord"`
+	Discord *discord.AlertProvider `yaml:"discord,omitempty"`
+
+	// Email is the configuration for the email alerting provider
+	Email *email.AlertProvider `yaml:"email,omitempty"`
+
+	// Matrix is the configuration for the matrix alerting provider
+	Matrix *matrix.AlertProvider `yaml:"matrix,omitempty"`
 
 	// Mattermost is the configuration for the mattermost alerting provider
-	Mattermost *mattermost.AlertProvider `yaml:"mattermost"`
+	Mattermost *mattermost.AlertProvider `yaml:"mattermost,omitempty"`
 
 	// Messagebird is the configuration for the messagebird alerting provider
-	Messagebird *messagebird.AlertProvider `yaml:"messagebird"`
+	Messagebird *messagebird.AlertProvider `yaml:"messagebird,omitempty"`
+
+	// Ntfy is the configuration for the ntfy alerting provider
+	Ntfy *ntfy.AlertProvider `yaml:"ntfy,omitempty"`
+
+	// Opsgenie is the configuration for the opsgenie alerting provider
+	Opsgenie *opsgenie.AlertProvider `yaml:"opsgenie,omitempty"`
 
 	// PagerDuty is the configuration for the pagerduty alerting provider
-	PagerDuty *pagerduty.AlertProvider `yaml:"pagerduty"`
+	PagerDuty *pagerduty.AlertProvider `yaml:"pagerduty,omitempty"`
 
 	// Slack is the configuration for the slack alerting provider
-	Slack *slack.AlertProvider `yaml:"slack"`
+	Slack *slack.AlertProvider `yaml:"slack,omitempty"`
 
 	// Teams is the configuration for the teams alerting provider
-	Teams *teams.AlertProvider `yaml:"teams"`
+	Teams *teams.AlertProvider `yaml:"teams,omitempty"`
 
 	// Telegram is the configuration for the telegram alerting provider
-	Telegram *telegram.AlertProvider `yaml:"telegram"`
+	Telegram *telegram.AlertProvider `yaml:"telegram,omitempty"`
 
 	// Twilio is the configuration for the twilio alerting provider
-	Twilio *twilio.AlertProvider `yaml:"twilio"`
+	Twilio *twilio.AlertProvider `yaml:"twilio,omitempty"`
 }
 
 // GetAlertingProviderByAlertType returns an provider.AlertProvider by its corresponding alert.Type
@@ -59,6 +79,24 @@ func (config Config) GetAlertingProviderByAlertType(alertType alert.Type) provid
 			return nil
 		}
 		return config.Discord
+	case alert.TypeEmail:
+		if config.Email == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Email
+	case alert.TypeGoogleChat:
+		if config.GoogleChat == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.GoogleChat
+	case alert.TypeMatrix:
+		if config.Matrix == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Matrix
 	case alert.TypeMattermost:
 		if config.Mattermost == nil {
 			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
@@ -71,6 +109,18 @@ func (config Config) GetAlertingProviderByAlertType(alertType alert.Type) provid
 			return nil
 		}
 		return config.Messagebird
+	case alert.TypeNtfy:
+		if config.Ntfy == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Ntfy
+	case alert.TypeOpsgenie:
+		if config.Opsgenie == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Opsgenie
 	case alert.TypePagerDuty:
 		if config.PagerDuty == nil {
 			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil

alerting/provider/custom/custom.go

@@ -2,16 +2,14 @@ package custom
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
-	"os"
 	"strings"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using a custom HTTP request
@@ -24,10 +22,10 @@ type AlertProvider struct {
 	Placeholders map[string]map[string]string `yaml:"placeholders,omitempty"`
 
 	// ClientConfig is the configuration of the client used to communicate with the provider's target
-	ClientConfig *client.Config `yaml:"client"`
+	ClientConfig *client.Config `yaml:"client,omitempty"`
 
 	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
-	DefaultAlert *alert.Alert `yaml:"default-alert"`
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
 }
 
 // IsValid returns whether the provider's configuration is valid
@@ -38,11 +36,6 @@ func (provider *AlertProvider) IsValid() bool {
 	return len(provider.URL) > 0 && provider.ClientConfig != nil
 }
 
-// ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) *AlertProvider {
-	return provider
-}
-
 // GetAlertStatePlaceholderValue returns the Placeholder value for ALERT_TRIGGERED_OR_RESOLVED if configured
 func (provider *AlertProvider) GetAlertStatePlaceholderValue(resolved bool) string {
 	status := "TRIGGERED"
@@ -57,75 +50,46 @@ func (provider *AlertProvider) GetAlertStatePlaceholderValue(resolved bool) stri
 	return status
 }
 
-func (provider *AlertProvider) buildHTTPRequest(endpointName, alertDescription string, resolved bool) *http.Request {
-	body := provider.Body
-	providerURL := provider.URL
-	method := provider.Method
-
-	if strings.Contains(body, "[ALERT_DESCRIPTION]") {
-		body = strings.ReplaceAll(body, "[ALERT_DESCRIPTION]", alertDescription)
-	}
-	if strings.Contains(body, "[SERVICE_NAME]") { // XXX: Remove this in v4.0.0
-		body = strings.ReplaceAll(body, "[SERVICE_NAME]", endpointName)
-	}
-	if strings.Contains(body, "[ENDPOINT_NAME]") {
-		body = strings.ReplaceAll(body, "[ENDPOINT_NAME]", endpointName)
-	}
-	if strings.Contains(body, "[ALERT_TRIGGERED_OR_RESOLVED]") {
-		if resolved {
-			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(true))
-		} else {
-			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(false))
-		}
-	}
-	if strings.Contains(providerURL, "[ALERT_DESCRIPTION]") {
-		providerURL = strings.ReplaceAll(providerURL, "[ALERT_DESCRIPTION]", alertDescription)
-	}
-	if strings.Contains(providerURL, "[SERVICE_NAME]") { // XXX: Remove this in v4.0.0
-		providerURL = strings.ReplaceAll(providerURL, "[SERVICE_NAME]", endpointName)
-	}
-	if strings.Contains(providerURL, "[ENDPOINT_NAME]") {
-		providerURL = strings.ReplaceAll(providerURL, "[ENDPOINT_NAME]", endpointName)
-	}
-	if strings.Contains(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]") {
-		if resolved {
-			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(true))
-		} else {
-			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(false))
-		}
+func (provider *AlertProvider) buildHTTPRequest(endpoint *core.Endpoint, alert *alert.Alert, resolved bool) *http.Request {
+	body, url, method := provider.Body, provider.URL, provider.Method
+	body = strings.ReplaceAll(body, "[ALERT_DESCRIPTION]", alert.GetDescription())
+	url = strings.ReplaceAll(url, "[ALERT_DESCRIPTION]", alert.GetDescription())
+	body = strings.ReplaceAll(body, "[ENDPOINT_NAME]", endpoint.Name)
+	url = strings.ReplaceAll(url, "[ENDPOINT_NAME]", endpoint.Name)
+	body = strings.ReplaceAll(body, "[ENDPOINT_GROUP]", endpoint.Group)
+	url = strings.ReplaceAll(url, "[ENDPOINT_GROUP]", endpoint.Group)
+	body = strings.ReplaceAll(body, "[ENDPOINT_URL]", endpoint.URL)
+	url = strings.ReplaceAll(url, "[ENDPOINT_URL]", endpoint.URL)
+	if resolved {
+		body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(true))
+		url = strings.ReplaceAll(url, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(true))
+	} else {
+		body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(false))
+		url = strings.ReplaceAll(url, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(false))
 	}
 	if len(method) == 0 {
 		method = http.MethodGet
 	}
 	bodyBuffer := bytes.NewBuffer([]byte(body))
-	request, _ := http.NewRequest(method, providerURL, bodyBuffer)
+	request, _ := http.NewRequest(method, url, bodyBuffer)
 	for k, v := range provider.Headers {
 		request.Header.Set(k, v)
 	}
 	return request
 }
 
-// Send a request to the alert provider and return the body
-func (provider *AlertProvider) Send(endpointName, alertDescription string, resolved bool) ([]byte, error) {
-	if os.Getenv("MOCK_ALERT_PROVIDER") == "true" {
-		if os.Getenv("MOCK_ALERT_PROVIDER_ERROR") == "true" {
-			return nil, errors.New("error")
-		}
-		return []byte("{}"), nil
-	}
-	request := provider.buildHTTPRequest(endpointName, alertDescription, resolved)
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	request := provider.buildHTTPRequest(endpoint, alert, resolved)
 	response, err := client.GetHTTPClient(provider.ClientConfig).Do(request)
 	if err != nil {
-		return nil, err
+		return err
 	}
+	defer response.Body.Close()
 	if response.StatusCode > 399 {
-		body, err := ioutil.ReadAll(response.Body)
-		if err != nil {
-			return nil, fmt.Errorf("call to provider alert returned status code %d", response.StatusCode)
-		}
-		return nil, fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
 	}
-	return ioutil.ReadAll(response.Body)
+	return err
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/custom/custom_test.go

@@ -1,106 +1,212 @@
 package custom
 
 import (
-	"io/ioutil"
+	"fmt"
+	"io"
+	"net/http"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
-	invalidProvider := AlertProvider{URL: ""}
-	if invalidProvider.IsValid() {
-		t.Error("provider shouldn't have been valid")
+	t.Run("invalid-provider", func(t *testing.T) {
+		invalidProvider := AlertProvider{URL: ""}
+		if invalidProvider.IsValid() {
+			t.Error("provider shouldn't have been valid")
+		}
+	})
+	t.Run("valid-provider", func(t *testing.T) {
+		validProvider := AlertProvider{URL: "https://example.com"}
+		if validProvider.ClientConfig != nil {
+			t.Error("provider client config should have been nil prior to IsValid() being executed")
+		}
+		if !validProvider.IsValid() {
+			t.Error("provider should've been valid")
+		}
+		if validProvider.ClientConfig == nil {
+			t.Error("provider client config should have been set after IsValid() was executed")
+		}
+	})
+}
+
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
 	}
-	validProvider := AlertProvider{URL: "https://example.com"}
-	if !validProvider.IsValid() {
-		t.Error("provider should've been valid")
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
 	}
 }
 
-func TestAlertProvider_buildHTTPRequestWhenResolved(t *testing.T) {
-	const (
-		ExpectedURL  = "https://example.com/endpoint-name?event=RESOLVED&description=alert-description"
-		ExpectedBody = "endpoint-name,alert-description,RESOLVED"
-	)
+func TestAlertProvider_buildHTTPRequest(t *testing.T) {
 	customAlertProvider := &AlertProvider{
-		URL:     "https://example.com/[ENDPOINT_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
-		Body:    "[ENDPOINT_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
-		Headers: nil,
+		URL:  "https://example.com/[ENDPOINT_GROUP]/[ENDPOINT_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]&url=[ENDPOINT_URL]",
+		Body: "[ENDPOINT_NAME],[ENDPOINT_GROUP],[ALERT_DESCRIPTION],[ENDPOINT_URL],[ALERT_TRIGGERED_OR_RESOLVED]",
 	}
-	request := customAlertProvider.buildHTTPRequest("endpoint-name", "alert-description", true)
-	if request.URL.String() != ExpectedURL {
-		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
+	alertDescription := "alert-description"
+	scenarios := []struct {
+		AlertProvider *AlertProvider
+		Resolved      bool
+		ExpectedURL   string
+		ExpectedBody  string
+	}{
+		{
+			AlertProvider: customAlertProvider,
+			Resolved:      true,
+			ExpectedURL:   "https://example.com/endpoint-group/endpoint-name?event=RESOLVED&description=alert-description&url=https://example.com",
+			ExpectedBody:  "endpoint-name,endpoint-group,alert-description,https://example.com,RESOLVED",
+		},
+		{
+			AlertProvider: customAlertProvider,
+			Resolved:      false,
+			ExpectedURL:   "https://example.com/endpoint-group/endpoint-name?event=TRIGGERED&description=alert-description&url=https://example.com",
+			ExpectedBody:  "endpoint-name,endpoint-group,alert-description,https://example.com,TRIGGERED",
+		},
 	}
-	body, _ := ioutil.ReadAll(request.Body)
-	if string(body) != ExpectedBody {
-		t.Error("expected body to be", ExpectedBody, "was", string(body))
-	}
-}
-
-func TestAlertProvider_buildHTTPRequestWhenTriggered(t *testing.T) {
-	const (
-		ExpectedURL  = "https://example.com/endpoint-name?event=TRIGGERED&description=alert-description"
-		ExpectedBody = "endpoint-name,alert-description,TRIGGERED"
-	)
-	customAlertProvider := &AlertProvider{
-		URL:     "https://example.com/[ENDPOINT_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
-		Body:    "[ENDPOINT_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
-		Headers: map[string]string{"Authorization": "Basic hunter2"},
-	}
-	request := customAlertProvider.buildHTTPRequest("endpoint-name", "alert-description", false)
-	if request.URL.String() != ExpectedURL {
-		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
-	}
-	body, _ := ioutil.ReadAll(request.Body)
-	if string(body) != ExpectedBody {
-		t.Error("expected body to be", ExpectedBody, "was", string(body))
-	}
-}
-
-func TestAlertProvider_ToCustomAlertProvider(t *testing.T) {
-	provider := AlertProvider{URL: "https://example.com"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{}, true)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
-	}
-	if customAlertProvider.URL != "https://example.com" {
-		t.Error("expected URL to be https://example.com, got", customAlertProvider.URL)
+	for _, scenario := range scenarios {
+		t.Run(fmt.Sprintf("resolved-%v-with-default-placeholders", scenario.Resolved), func(t *testing.T) {
+			request := customAlertProvider.buildHTTPRequest(
+				&core.Endpoint{Name: "endpoint-name", Group: "endpoint-group", URL: "https://example.com"},
+				&alert.Alert{Description: &alertDescription},
+				scenario.Resolved,
+			)
+			if request.URL.String() != scenario.ExpectedURL {
+				t.Error("expected URL to be", scenario.ExpectedURL, "got", request.URL.String())
+			}
+			body, _ := io.ReadAll(request.Body)
+			if string(body) != scenario.ExpectedBody {
+				t.Error("expected body to be", scenario.ExpectedBody, "got", string(body))
+			}
+		})
 	}
 }
 
 func TestAlertProvider_buildHTTPRequestWithCustomPlaceholder(t *testing.T) {
-	const (
-		ExpectedURL  = "https://example.com/endpoint-name?event=test&description=alert-description"
-		ExpectedBody = "endpoint-name,alert-description,test"
-	)
 	customAlertProvider := &AlertProvider{
-		URL:     "https://example.com/[ENDPOINT_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
-		Body:    "[ENDPOINT_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
+		URL:     "https://example.com/[ENDPOINT_GROUP]/[ENDPOINT_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
+		Body:    "[ENDPOINT_NAME],[ENDPOINT_GROUP],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
 		Headers: nil,
 		Placeholders: map[string]map[string]string{
 			"ALERT_TRIGGERED_OR_RESOLVED": {
-				"RESOLVED": "test",
+				"RESOLVED":  "fixed",
+				"TRIGGERED": "boom",
 			},
 		},
 	}
-	request := customAlertProvider.buildHTTPRequest("endpoint-name", "alert-description", true)
-	if request.URL.String() != ExpectedURL {
-		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
+	alertDescription := "alert-description"
+	scenarios := []struct {
+		AlertProvider *AlertProvider
+		Resolved      bool
+		ExpectedURL   string
+		ExpectedBody  string
+	}{
+		{
+			AlertProvider: customAlertProvider,
+			Resolved:      true,
+			ExpectedURL:   "https://example.com/endpoint-group/endpoint-name?event=fixed&description=alert-description",
+			ExpectedBody:  "endpoint-name,endpoint-group,alert-description,fixed",
+		},
+		{
+			AlertProvider: customAlertProvider,
+			Resolved:      false,
+			ExpectedURL:   "https://example.com/endpoint-group/endpoint-name?event=boom&description=alert-description",
+			ExpectedBody:  "endpoint-name,endpoint-group,alert-description,boom",
+		},
 	}
-	body, _ := ioutil.ReadAll(request.Body)
-	if string(body) != ExpectedBody {
-		t.Error("expected body to be", ExpectedBody, "was", string(body))
+	for _, scenario := range scenarios {
+		t.Run(fmt.Sprintf("resolved-%v-with-custom-placeholders", scenario.Resolved), func(t *testing.T) {
+			request := customAlertProvider.buildHTTPRequest(
+				&core.Endpoint{Name: "endpoint-name", Group: "endpoint-group"},
+				&alert.Alert{Description: &alertDescription},
+				scenario.Resolved,
+			)
+			if request.URL.String() != scenario.ExpectedURL {
+				t.Error("expected URL to be", scenario.ExpectedURL, "got", request.URL.String())
+			}
+			body, _ := io.ReadAll(request.Body)
+			if string(body) != scenario.ExpectedBody {
+				t.Error("expected body to be", scenario.ExpectedBody, "got", string(body))
+			}
+		})
 	}
 }
 
 func TestAlertProvider_GetAlertStatePlaceholderValueDefaults(t *testing.T) {
 	customAlertProvider := &AlertProvider{
-		URL:          "https://example.com/[ENDPOINT_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
-		Body:         "[ENDPOINT_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
-		Headers:      nil,
-		Placeholders: nil,
+		URL:  "https://example.com/[ENDPOINT_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
+		Body: "[ENDPOINT_NAME],[ENDPOINT_GROUP],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
 	}
 	if customAlertProvider.GetAlertStatePlaceholderValue(true) != "RESOLVED" {
 		t.Error("expected RESOLVED, got", customAlertProvider.GetAlertStatePlaceholderValue(true))
@@ -110,25 +216,11 @@ func TestAlertProvider_GetAlertStatePlaceholderValueDefaults(t *testing.T) {
 	}
 }
 
-// TestAlertProvider_isBackwardCompatibleWithServiceRename checks if the custom alerting provider still supports
-// service placeholders after the migration from "service" to "endpoint"
-//
-// XXX: Remove this in v4.0.0
-func TestAlertProvider_isBackwardCompatibleWithServiceRename(t *testing.T) {
-	const (
-		ExpectedURL  = "https://example.com/endpoint-name?event=TRIGGERED&description=alert-description"
-		ExpectedBody = "endpoint-name,alert-description,TRIGGERED"
-	)
-	customAlertProvider := &AlertProvider{
-		URL:  "https://example.com/[SERVICE_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
-		Body: "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
 	}
-	request := customAlertProvider.buildHTTPRequest("endpoint-name", "alert-description", false)
-	if request.URL.String() != ExpectedURL {
-		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
-	}
-	body, _ := ioutil.ReadAll(request.Body)
-	if string(body) != ExpectedBody {
-		t.Error("expected body to be", ExpectedBody, "was", string(body))
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
 	}
 }

alerting/provider/discord/discord.go

@@ -1,12 +1,15 @@
 package discord
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Discord
@@ -14,23 +17,79 @@ type AlertProvider struct {
 	WebhookURL string `yaml:"webhook-url"`
 
 	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
-	DefaultAlert *alert.Alert `yaml:"default-alert"`
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+
+	// Overrides is a list of Override that may be prioritized over the default configuration
+	Overrides []Override `yaml:"overrides,omitempty"`
+}
+
+// Override is a case under which the default integration is overridden
+type Override struct {
+	Group      string `yaml:"group"`
+	WebhookURL string `yaml:"webhook-url"`
 }
 
 // IsValid returns whether the provider's configuration is valid
 func (provider *AlertProvider) IsValid() bool {
+	registeredGroups := make(map[string]bool)
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" || len(override.WebhookURL) == 0 {
+				return false
+			}
+			registeredGroups[override.Group] = true
+		}
+	}
 	return len(provider.WebhookURL) > 0
 }
 
-// ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+// Send an alert using the provider
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, provider.getWebhookURLForGroup(endpoint.Group), buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type Body struct {
+	Content string  `json:"content"`
+	Embeds  []Embed `json:"embeds"`
+}
+
+type Embed struct {
+	Title       string  `json:"title"`
+	Description string  `json:"description"`
+	Color       int     `json:"color"`
+	Fields      []Field `json:"fields"`
+}
+
+type Field struct {
+	Name   string `json:"name"`
+	Value  string `json:"value"`
+	Inline bool   `json:"inline"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
 	var message, results string
 	var colorCode int
 	if resolved {
-		message = fmt.Sprintf("An alert for **%s** has been resolved after passing successfully %d time(s) in a row", endpoint.Name, alert.SuccessThreshold)
+		message = fmt.Sprintf("An alert for **%s** has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
 		colorCode = 3066993
 	} else {
-		message = fmt.Sprintf("An alert for **%s** has been triggered due to having failed %d time(s) in a row", endpoint.Name, alert.FailureThreshold)
+		message = fmt.Sprintf("An alert for **%s** has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
 		colorCode = 15158332
 	}
 	for _, conditionResult := range result.ConditionResults {
@@ -40,34 +99,42 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
 		} else {
 			prefix = ":x:"
 		}
-		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
+		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
 	}
 	var description string
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
-		description = ":\\n> " + alertDescription
+		description = ":\n> " + alertDescription
 	}
-	return &custom.AlertProvider{
-		URL:    provider.WebhookURL,
-		Method: http.MethodPost,
-		Body: fmt.Sprintf(`{
-  "content": "",
-  "embeds": [
-    {
-      "title": ":helmet_with_white_cross: Gatus",
-      "description": "%s%s",
-      "color": %d,
-      "fields": [
-        {
-          "name": "Condition results",
-          "value": "%s",
-          "inline": false
-        }
-      ]
-    }
-  ]
-}`, message, description, colorCode, results),
-		Headers: map[string]string{"Content-Type": "application/json"},
+	body, _ := json.Marshal(Body{
+		Content: "",
+		Embeds: []Embed{
+			{
+				Title:       ":helmet_with_white_cross: Gatus",
+				Description: message + description,
+				Color:       colorCode,
+				Fields: []Field{
+					{
+						Name:   "Condition results",
+						Value:  results,
+						Inline: false,
+					},
+				},
+			},
+		},
+	})
+	return body
+}
+
+// getWebhookURLForGroup returns the appropriate Webhook URL integration to for a given group
+func (provider *AlertProvider) getWebhookURLForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.WebhookURL
+			}
+		}
 	}
+	return provider.WebhookURL
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/discord/discord_test.go

@@ -3,11 +3,12 @@ package discord
 import (
 	"encoding/json"
 	"net/http"
-	"strings"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
@@ -21,50 +22,238 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.com"}
-	alertDescription := "test"
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
+func TestAlertProvider_IsValidWithOverride(t *testing.T) {
+	providerWithInvalidOverrideGroup := AlertProvider{
+		Overrides: []Override{
+			{
+				WebhookURL: "http://example.com",
+				Group:      "",
+			},
+		},
 	}
-	if !strings.Contains(customAlertProvider.Body, "resolved") {
-		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	if providerWithInvalidOverrideGroup.IsValid() {
+		t.Error("provider Group shouldn't have been valid")
 	}
-	if customAlertProvider.URL != "http://example.com" {
-		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	providerWithInvalidOverrideTo := AlertProvider{
+		Overrides: []Override{
+			{
+				WebhookURL: "",
+				Group:      "group",
+			},
+		},
 	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	if providerWithInvalidOverrideTo.IsValid() {
+		t.Error("provider integration key shouldn't have been valid")
 	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	providerWithValidOverride := AlertProvider{
+		WebhookURL: "http://example.com",
+		Overrides: []Override{
+			{
+				WebhookURL: "http://example.com",
+				Group:      "group",
+			},
+		},
 	}
-	if expected := "An alert for **svc** has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["embeds"].([]interface{})[0].(map[string]interface{})["description"] {
-		t.Errorf("expected $.embeds[0].description to be %s, got %s", expected, body["embeds"].([]interface{})[0].(map[string]interface{})["description"])
+	if !providerWithValidOverride.IsValid() {
+		t.Error("provider should've been valid")
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.com"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
 	}
-	if !strings.Contains(customAlertProvider.Body, "triggered") {
-		t.Error("customAlertProvider.Body should've contained the substring triggered")
-	}
-	if customAlertProvider.URL != "http://example.com" {
-		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\"content\":\"\",\"embeds\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"description\":\"An alert for **endpoint-name** has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"color\":15158332,\"fields\":[{\"name\":\"Condition results\",\"value\":\":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n:x: - `[BODY] != \\\"\\\"`\\n\",\"inline\":false}]}]}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"content\":\"\",\"embeds\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"description\":\"An alert for **endpoint-name** has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"color\":3066993,\"fields\":[{\"name\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n:white_check_mark: - `[BODY] != \\\"\\\"`\\n\",\"inline\":false}]}]}",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+						{Condition: "[BODY] != \"\"", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal(body, &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}
+
+func TestAlertProvider_getWebhookURLForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example01.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getWebhookURLForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getWebhookURLForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
 	}
 }

alerting/provider/email/email.go

@@ -0,0 +1,109 @@
+package email
+
+import (
+	"fmt"
+	"math"
+	"strings"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/core"
+	gomail "gopkg.in/mail.v2"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using SMTP
+type AlertProvider struct {
+	From     string `yaml:"from"`
+	Username string `yaml:"username"`
+	Password string `yaml:"password"`
+	Host     string `yaml:"host"`
+	Port     int    `yaml:"port"`
+	To       string `yaml:"to"`
+
+	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+
+	// Overrides is a list of Override that may be prioritized over the default configuration
+	Overrides []Override `yaml:"overrides,omitempty"`
+}
+
+// Override is a case under which the default integration is overridden
+type Override struct {
+	Group string `yaml:"group"`
+	To    string `yaml:"to"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	registeredGroups := make(map[string]bool)
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" || len(override.To) == 0 {
+				return false
+			}
+			registeredGroups[override.Group] = true
+		}
+	}
+
+	return len(provider.From) > 0 && len(provider.Password) > 0 && len(provider.Host) > 0 && len(provider.To) > 0 && provider.Port > 0 && provider.Port < math.MaxUint16
+}
+
+// Send an alert using the provider
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	var username string
+	if len(provider.Username) > 0 {
+		username = provider.Username
+	} else {
+		username = provider.From
+	}
+	subject, body := provider.buildMessageSubjectAndBody(endpoint, alert, result, resolved)
+	m := gomail.NewMessage()
+	m.SetHeader("From", provider.From)
+	m.SetHeader("To", strings.Split(provider.getToForGroup(endpoint.Group), ",")...)
+	m.SetHeader("Subject", subject)
+	m.SetBody("text/plain", body)
+	d := gomail.NewDialer(provider.Host, provider.Port, username, provider.Password)
+	return d.DialAndSend(m)
+}
+
+// buildMessageSubjectAndBody builds the message subject and body
+func (provider *AlertProvider) buildMessageSubjectAndBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) (string, string) {
+	var subject, message, results string
+	if resolved {
+		subject = fmt.Sprintf("[%s] Alert resolved", endpoint.DisplayName())
+		message = fmt.Sprintf("An alert for %s has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
+	} else {
+		subject = fmt.Sprintf("[%s] Alert triggered", endpoint.DisplayName())
+		message = fmt.Sprintf("An alert for %s has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
+	}
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = "✅"
+		} else {
+			prefix = "❌"
+		}
+		results += fmt.Sprintf("%s %s\n", prefix, conditionResult.Condition)
+	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = "\n\nAlert description: " + alertDescription
+	}
+	return subject, message + description + "\n\nCondition results:\n" + results
+}
+
+// getToForGroup returns the appropriate email integration to for a given group
+func (provider *AlertProvider) getToForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.To
+			}
+		}
+	}
+	return provider.To
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/email/email_test.go

@@ -0,0 +1,183 @@
+package email
+
+import (
+	"testing"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/core"
+)
+
+func TestAlertDefaultProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{From: "from@example.com", Password: "password", Host: "smtp.gmail.com", Port: 587, To: "to@example.com"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_IsValidWithOverride(t *testing.T) {
+	providerWithInvalidOverrideGroup := AlertProvider{
+		Overrides: []Override{
+			{
+				To:    "to@example.com",
+				Group: "",
+			},
+		},
+	}
+	if providerWithInvalidOverrideGroup.IsValid() {
+		t.Error("provider Group shouldn't have been valid")
+	}
+	providerWithInvalidOverrideTo := AlertProvider{
+		Overrides: []Override{
+			{
+				To:    "",
+				Group: "group",
+			},
+		},
+	}
+	if providerWithInvalidOverrideTo.IsValid() {
+		t.Error("provider integration key shouldn't have been valid")
+	}
+	providerWithValidOverride := AlertProvider{
+		From:     "from@example.com",
+		Password: "password",
+		Host:     "smtp.gmail.com",
+		Port:     587,
+		To:       "to@example.com",
+		Overrides: []Override{
+			{
+				To:    "to@example.com",
+				Group: "group",
+			},
+		},
+	}
+	if !providerWithValidOverride.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name            string
+		Provider        AlertProvider
+		Alert           alert.Alert
+		Resolved        bool
+		ExpectedSubject string
+		ExpectedBody    string
+	}{
+		{
+			Name:            "triggered",
+			Provider:        AlertProvider{},
+			Alert:           alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:        false,
+			ExpectedSubject: "[endpoint-name] Alert triggered",
+			ExpectedBody:    "An alert for endpoint-name has been triggered due to having failed 3 time(s) in a row\n\nAlert description: description-1\n\nCondition results:\n❌ [CONNECTED] == true\n❌ [STATUS] == 200\n",
+		},
+		{
+			Name:            "resolved",
+			Provider:        AlertProvider{},
+			Alert:           alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:        true,
+			ExpectedSubject: "[endpoint-name] Alert resolved",
+			ExpectedBody:    "An alert for endpoint-name has been resolved after passing successfully 5 time(s) in a row\n\nAlert description: description-2\n\nCondition results:\n✅ [CONNECTED] == true\n✅ [STATUS] == 200\n",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			subject, body := scenario.Provider.buildMessageSubjectAndBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if subject != scenario.ExpectedSubject {
+				t.Errorf("expected subject to be %s, got %s", scenario.ExpectedSubject, subject)
+			}
+			if body != scenario.ExpectedBody {
+				t.Errorf("expected body to be %s, got %s", scenario.ExpectedBody, body)
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}
+
+func TestAlertProvider_getToForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				To:        "to@example.com",
+				Overrides: nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "to@example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				To:        "to@example.com",
+				Overrides: nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "to@example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				To: "to@example.com",
+				Overrides: []Override{
+					{
+						Group: "group",
+						To:    "to01@example.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "to@example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				To: "to@example.com",
+				Overrides: []Override{
+					{
+						Group: "group",
+						To:    "to01@example.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "to01@example.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getToForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getToForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
+	}
+}

alerting/provider/googlechat/googlechat.go

@@ -0,0 +1,201 @@
+package googlechat
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Google chat
+type AlertProvider struct {
+	WebhookURL string `yaml:"webhook-url"`
+
+	// ClientConfig is the configuration of the client used to communicate with the provider's target
+	ClientConfig *client.Config `yaml:"client,omitempty"`
+
+	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+
+	// Overrides is a list of Override that may be prioritized over the default configuration
+	Overrides []Override `yaml:"overrides,omitempty"`
+}
+
+// Override is a case under which the default integration is overridden
+type Override struct {
+	Group      string `yaml:"group"`
+	WebhookURL string `yaml:"webhook-url"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	if provider.ClientConfig == nil {
+		provider.ClientConfig = client.GetDefaultConfig()
+	}
+	registeredGroups := make(map[string]bool)
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" || len(override.WebhookURL) == 0 {
+				return false
+			}
+			registeredGroups[override.Group] = true
+		}
+	}
+	return len(provider.WebhookURL) > 0
+}
+
+// Send an alert using the provider
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, provider.getWebhookURLForGroup(endpoint.Group), buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(provider.ClientConfig).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type Body struct {
+	Cards []Cards `json:"cards"`
+}
+
+type Cards struct {
+	Sections []Sections `json:"sections"`
+}
+
+type Sections struct {
+	Widgets []Widgets `json:"widgets"`
+}
+
+type Widgets struct {
+	KeyValue *KeyValue `json:"keyValue,omitempty"`
+	Buttons  []Buttons `json:"buttons,omitempty"`
+}
+
+type KeyValue struct {
+	TopLabel         string `json:"topLabel,omitempty"`
+	Content          string `json:"content,omitempty"`
+	ContentMultiline string `json:"contentMultiline,omitempty"`
+	BottomLabel      string `json:"bottomLabel,omitempty"`
+	Icon             string `json:"icon,omitempty"`
+}
+
+type Buttons struct {
+	TextButton TextButton `json:"textButton"`
+}
+
+type TextButton struct {
+	Text    string  `json:"text"`
+	OnClick OnClick `json:"onClick"`
+}
+
+type OnClick struct {
+	OpenLink OpenLink `json:"openLink"`
+}
+
+type OpenLink struct {
+	URL string `json:"url"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
+	var message, color string
+	if resolved {
+		color = "#36A64F"
+		message = fmt.Sprintf("<font color='%s'>An alert has been resolved after passing successfully %d time(s) in a row</font>", color, alert.SuccessThreshold)
+	} else {
+		color = "#DD0000"
+		message = fmt.Sprintf("<font color='%s'>An alert has been triggered due to having failed %d time(s) in a row</font>", color, alert.FailureThreshold)
+	}
+	var results string
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = "✅"
+		} else {
+			prefix = "❌"
+		}
+		results += fmt.Sprintf("%s   %s<br>", prefix, conditionResult.Condition)
+	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = ":: " + alertDescription
+	}
+	payload := Body{
+		Cards: []Cards{
+			{
+				Sections: []Sections{
+					{
+						Widgets: []Widgets{
+							{
+								KeyValue: &KeyValue{
+									TopLabel:         endpoint.DisplayName(),
+									Content:          message,
+									ContentMultiline: "true",
+									BottomLabel:      description,
+									Icon:             "BOOKMARK",
+								},
+							},
+							{
+								KeyValue: &KeyValue{
+									TopLabel:         "Condition results",
+									Content:          results,
+									ContentMultiline: "true",
+									Icon:             "DESCRIPTION",
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+	if endpoint.Type() == core.EndpointTypeHTTP {
+		// We only include a button targeting the URL if the endpoint is an HTTP endpoint
+		// If the URL isn't prefixed with https://, Google Chat will just display a blank message aynways.
+		// See https://github.com/TwiN/gatus/issues/362
+		payload.Cards[0].Sections[0].Widgets = append(payload.Cards[0].Sections[0].Widgets, Widgets{
+			Buttons: []Buttons{
+				{
+					TextButton: TextButton{
+						Text:    "URL",
+						OnClick: OnClick{OpenLink: OpenLink{URL: endpoint.URL}},
+					},
+				},
+			},
+		})
+	}
+	body, _ := json.Marshal(payload)
+	return body
+}
+
+// getWebhookURLForGroup returns the appropriate Webhook URL integration to for a given group
+func (provider *AlertProvider) getWebhookURLForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.WebhookURL
+			}
+		}
+	}
+	return provider.WebhookURL
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/googlechat/googlechat_test.go

@@ -0,0 +1,277 @@
+package googlechat
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
+)
+
+func TestAlertDefaultProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{WebhookURL: ""}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{WebhookURL: "http://example.com"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_IsValidWithOverride(t *testing.T) {
+	providerWithInvalidOverrideGroup := AlertProvider{
+		Overrides: []Override{
+			{
+				WebhookURL: "http://example.com",
+				Group:      "",
+			},
+		},
+	}
+	if providerWithInvalidOverrideGroup.IsValid() {
+		t.Error("provider Group shouldn't have been valid")
+	}
+	providerWithInvalidOverrideTo := AlertProvider{
+		Overrides: []Override{
+			{
+				WebhookURL: "",
+				Group:      "group",
+			},
+		},
+	}
+	if providerWithInvalidOverrideTo.IsValid() {
+		t.Error("provider integration key shouldn't have been valid")
+	}
+	providerWithValidOverride := AlertProvider{
+		WebhookURL: "http://example.com",
+		Overrides: []Override{
+			{
+				WebhookURL: "http://example.com",
+				Group:      "group",
+			},
+		},
+	}
+	if !providerWithValidOverride.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name", Group: "endpoint-group"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Endpoint     core.Endpoint
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "https://example.org"},
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#DD0000'\u003eAn alert has been triggered due to having failed 3 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-1","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"❌   [CONNECTED] == true\u003cbr\u003e❌   [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}},{"buttons":[{"textButton":{"text":"URL","onClick":{"openLink":{"url":"https://example.org"}}}}]}]}]}]}`,
+		},
+		{
+			Name:         "resolved",
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "https://example.org"},
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#36A64F'\u003eAn alert has been resolved after passing successfully 5 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-2","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"✅   [CONNECTED] == true\u003cbr\u003e✅   [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}},{"buttons":[{"textButton":{"text":"URL","onClick":{"openLink":{"url":"https://example.org"}}}}]}]}]}]}`,
+		},
+		{
+			Name:         "icmp-should-not-include-url", // See https://github.com/TwiN/gatus/issues/362
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "icmp://example.org"},
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#DD0000'\u003eAn alert has been triggered due to having failed 3 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-1","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"❌   [CONNECTED] == true\u003cbr\u003e❌   [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}}]}]}]}`,
+		},
+		{
+			Name:         "tcp-should-not-include-url", // See https://github.com/TwiN/gatus/issues/362
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "tcp://example.org"},
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#DD0000'\u003eAn alert has been triggered due to having failed 3 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-1","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"❌   [CONNECTED] == true\u003cbr\u003e❌   [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}}]}]}]}`,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&scenario.Endpoint,
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal(body, &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}
+
+func TestAlertProvider_getWebhookURLForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example01.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getWebhookURLForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getToForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
+	}
+}

alerting/provider/matrix/matrix.go

@@ -0,0 +1,190 @@
+package matrix
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math/rand"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Matrix
+type AlertProvider struct {
+	MatrixProviderConfig `yaml:",inline"`
+
+	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+
+	// Overrides is a list of Override that may be prioritized over the default configuration
+	Overrides []Override `yaml:"overrides,omitempty"`
+}
+
+// Override is a case under which the default integration is overridden
+type Override struct {
+	Group string `yaml:"group"`
+
+	MatrixProviderConfig `yaml:",inline"`
+}
+
+const defaultHomeserverURL = "https://matrix-client.matrix.org"
+
+type MatrixProviderConfig struct {
+	// ServerURL is the custom homeserver to use (optional)
+	ServerURL string `yaml:"server-url"`
+
+	// AccessToken is the bot user's access token to send messages
+	AccessToken string `yaml:"access-token"`
+
+	// InternalRoomID is the room that the bot user has permissions to send messages to
+	InternalRoomID string `yaml:"internal-room-id"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	registeredGroups := make(map[string]bool)
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" || len(override.AccessToken) == 0 || len(override.InternalRoomID) == 0 {
+				return false
+			}
+			registeredGroups[override.Group] = true
+		}
+	}
+	return len(provider.AccessToken) > 0 && len(provider.InternalRoomID) > 0
+}
+
+// Send an alert using the provider
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	config := provider.getConfigForGroup(endpoint.Group)
+	if config.ServerURL == "" {
+		config.ServerURL = defaultHomeserverURL
+	}
+	// The Matrix endpoint requires a unique transaction ID for each event sent
+	txnId := randStringBytes(24)
+	request, err := http.NewRequest(
+		http.MethodPut,
+		fmt.Sprintf("%s/_matrix/client/v3/rooms/%s/send/m.room.message/%s?access_token=%s",
+			config.ServerURL,
+			url.PathEscape(config.InternalRoomID),
+			txnId,
+			url.QueryEscape(config.AccessToken),
+		),
+		buffer,
+	)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type Body struct {
+	MsgType       string `json:"msgtype"`
+	Format        string `json:"format"`
+	Body          string `json:"body"`
+	FormattedBody string `json:"formatted_body"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
+	body, _ := json.Marshal(Body{
+		MsgType:       "m.text",
+		Format:        "org.matrix.custom.html",
+		Body:          buildPlaintextMessageBody(endpoint, alert, result, resolved),
+		FormattedBody: buildHTMLMessageBody(endpoint, alert, result, resolved),
+	})
+	return body
+}
+
+// buildPlaintextMessageBody builds the message body in plaintext to include in request
+func buildPlaintextMessageBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
+	var message, results string
+	if resolved {
+		message = fmt.Sprintf("An alert for `%s` has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
+	} else {
+		message = fmt.Sprintf("An alert for `%s` has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
+	}
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = "✓"
+		} else {
+			prefix = "✕"
+		}
+		results += fmt.Sprintf("\n%s - %s", prefix, conditionResult.Condition)
+	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = "\n" + alertDescription
+	}
+	return fmt.Sprintf("%s%s\n%s", message, description, results)
+}
+
+// buildHTMLMessageBody builds the message body in HTML to include in request
+func buildHTMLMessageBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
+	var message, results string
+	if resolved {
+		message = fmt.Sprintf("An alert for <code>%s</code> has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
+	} else {
+		message = fmt.Sprintf("An alert for <code>%s</code> has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
+	}
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = "✅"
+		} else {
+			prefix = "❌"
+		}
+		results += fmt.Sprintf("<li>%s - <code>%s</code></li>", prefix, conditionResult.Condition)
+	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = fmt.Sprintf("\n<blockquote>%s</blockquote>", alertDescription)
+	}
+	return fmt.Sprintf("<h3>%s</h3>%s\n<h5>Condition results</h5><ul>%s</ul>", message, description, results)
+}
+
+// getConfigForGroup returns the appropriate configuration for a given group
+func (provider *AlertProvider) getConfigForGroup(group string) MatrixProviderConfig {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.MatrixProviderConfig
+			}
+		}
+	}
+	return provider.MatrixProviderConfig
+}
+
+func randStringBytes(n int) string {
+	// All the compatible characters to use in a transaction ID
+	const availableCharacterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+	b := make([]byte, n)
+	rand.Seed(time.Now().UnixNano())
+	for i := range b {
+		b[i] = availableCharacterBytes[rand.Intn(len(availableCharacterBytes))]
+	}
+	return string(b)
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/matrix/matrix_test.go

@@ -0,0 +1,331 @@
+package matrix
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{
+		MatrixProviderConfig: MatrixProviderConfig{
+			AccessToken:    "",
+			InternalRoomID: "",
+		},
+	}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{
+		MatrixProviderConfig: MatrixProviderConfig{
+			AccessToken:    "1",
+			InternalRoomID: "!a:example.com",
+		},
+	}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+	validProviderWithHomeserver := AlertProvider{
+		MatrixProviderConfig: MatrixProviderConfig{
+			ServerURL:      "https://example.com",
+			AccessToken:    "1",
+			InternalRoomID: "!a:example.com",
+		},
+	}
+	if !validProviderWithHomeserver.IsValid() {
+		t.Error("provider with homeserver should've been valid")
+	}
+}
+
+func TestAlertProvider_IsValidWithOverride(t *testing.T) {
+	providerWithInvalidOverrideGroup := AlertProvider{
+		Overrides: []Override{
+			{
+				Group: "",
+				MatrixProviderConfig: MatrixProviderConfig{
+					AccessToken:    "",
+					InternalRoomID: "",
+				},
+			},
+		},
+	}
+	if providerWithInvalidOverrideGroup.IsValid() {
+		t.Error("provider Group shouldn't have been valid")
+	}
+	providerWithInvalidOverrideTo := AlertProvider{
+		Overrides: []Override{
+			{
+				Group: "group",
+				MatrixProviderConfig: MatrixProviderConfig{
+					AccessToken:    "",
+					InternalRoomID: "",
+				},
+			},
+		},
+	}
+	if providerWithInvalidOverrideTo.IsValid() {
+		t.Error("provider integration key shouldn't have been valid")
+	}
+	providerWithValidOverride := AlertProvider{
+		MatrixProviderConfig: MatrixProviderConfig{
+			AccessToken:    "1",
+			InternalRoomID: "!a:example.com",
+		},
+		Overrides: []Override{
+			{
+				Group: "group",
+				MatrixProviderConfig: MatrixProviderConfig{
+					ServerURL:      "https://example.com",
+					AccessToken:    "1",
+					InternalRoomID: "!a:example.com",
+				},
+			},
+		},
+	}
+	if !providerWithValidOverride.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\"msgtype\":\"m.text\",\"format\":\"org.matrix.custom.html\",\"body\":\"An alert for `endpoint-name` has been triggered due to having failed 3 time(s) in a row\\ndescription-1\\n\\n✕ - [CONNECTED] == true\\n✕ - [STATUS] == 200\",\"formatted_body\":\"\\u003ch3\\u003eAn alert for \\u003ccode\\u003eendpoint-name\\u003c/code\\u003e has been triggered due to having failed 3 time(s) in a row\\u003c/h3\\u003e\\n\\u003cblockquote\\u003edescription-1\\u003c/blockquote\\u003e\\n\\u003ch5\\u003eCondition results\\u003c/h5\\u003e\\u003cul\\u003e\\u003cli\\u003e❌ - \\u003ccode\\u003e[CONNECTED] == true\\u003c/code\\u003e\\u003c/li\\u003e\\u003cli\\u003e❌ - \\u003ccode\\u003e[STATUS] == 200\\u003c/code\\u003e\\u003c/li\\u003e\\u003c/ul\\u003e\"}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"msgtype\":\"m.text\",\"format\":\"org.matrix.custom.html\",\"body\":\"An alert for `endpoint-name` has been resolved after passing successfully 5 time(s) in a row\\ndescription-2\\n\\n✓ - [CONNECTED] == true\\n✓ - [STATUS] == 200\",\"formatted_body\":\"\\u003ch3\\u003eAn alert for \\u003ccode\\u003eendpoint-name\\u003c/code\\u003e has been resolved after passing successfully 5 time(s) in a row\\u003c/h3\\u003e\\n\\u003cblockquote\\u003edescription-2\\u003c/blockquote\\u003e\\n\\u003ch5\\u003eCondition results\\u003c/h5\\u003e\\u003cul\\u003e\\u003cli\\u003e✅ - \\u003ccode\\u003e[CONNECTED] == true\\u003c/code\\u003e\\u003c/li\\u003e\\u003cli\\u003e✅ - \\u003ccode\\u003e[STATUS] == 200\\u003c/code\\u003e\\u003c/li\\u003e\\u003c/ul\\u003e\"}",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal(body, &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}
+
+func TestAlertProvider_getConfigForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput MatrixProviderConfig
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				MatrixProviderConfig: MatrixProviderConfig{
+					ServerURL:      "https://example.com",
+					AccessToken:    "1",
+					InternalRoomID: "!a:example.com",
+				},
+				Overrides: nil,
+			},
+			InputGroup: "",
+			ExpectedOutput: MatrixProviderConfig{
+				ServerURL:      "https://example.com",
+				AccessToken:    "1",
+				InternalRoomID: "!a:example.com",
+			},
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				MatrixProviderConfig: MatrixProviderConfig{
+					ServerURL:      "https://example.com",
+					AccessToken:    "1",
+					InternalRoomID: "!a:example.com",
+				},
+				Overrides: nil,
+			},
+			InputGroup: "group",
+			ExpectedOutput: MatrixProviderConfig{
+				ServerURL:      "https://example.com",
+				AccessToken:    "1",
+				InternalRoomID: "!a:example.com",
+			},
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				MatrixProviderConfig: MatrixProviderConfig{
+					ServerURL:      "https://example.com",
+					AccessToken:    "1",
+					InternalRoomID: "!a:example.com",
+				},
+				Overrides: []Override{
+					{
+						Group: "group",
+						MatrixProviderConfig: MatrixProviderConfig{
+							ServerURL:      "https://example01.com",
+							AccessToken:    "12",
+							InternalRoomID: "!a:example01.com",
+						},
+					},
+				},
+			},
+			InputGroup: "",
+			ExpectedOutput: MatrixProviderConfig{
+				ServerURL:      "https://example.com",
+				AccessToken:    "1",
+				InternalRoomID: "!a:example.com",
+			},
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				MatrixProviderConfig: MatrixProviderConfig{
+					ServerURL:      "https://example.com",
+					AccessToken:    "1",
+					InternalRoomID: "!a:example.com",
+				},
+				Overrides: []Override{
+					{
+						Group: "group",
+						MatrixProviderConfig: MatrixProviderConfig{
+							ServerURL:      "https://example01.com",
+							AccessToken:    "12",
+							InternalRoomID: "!a:example01.com",
+						},
+					},
+				},
+			},
+			InputGroup: "group",
+			ExpectedOutput: MatrixProviderConfig{
+				ServerURL:      "https://example01.com",
+				AccessToken:    "12",
+				InternalRoomID: "!a:example01.com",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getConfigForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getConfigForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
+	}
+}

alerting/provider/mattermost/mattermost.go

@@ -1,13 +1,15 @@
 package mattermost
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Mattermost
@@ -15,10 +17,19 @@ type AlertProvider struct {
 	WebhookURL string `yaml:"webhook-url"`
 
 	// ClientConfig is the configuration of the client used to communicate with the provider's target
-	ClientConfig *client.Config `yaml:"client"`
+	ClientConfig *client.Config `yaml:"client,omitempty"`
 
 	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
-	DefaultAlert *alert.Alert `yaml:"default-alert"`
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+
+	// Overrides is a list of Override that may be prioritized over the default configuration
+	Overrides []Override `yaml:"overrides,omitempty"`
+}
+
+// Override is a case under which the default integration is overridden
+type Override struct {
+	Group      string `yaml:"group"`
+	WebhookURL string `yaml:"webhook-url"`
 }
 
 // IsValid returns whether the provider's configuration is valid
@@ -26,21 +37,70 @@ func (provider *AlertProvider) IsValid() bool {
 	if provider.ClientConfig == nil {
 		provider.ClientConfig = client.GetDefaultConfig()
 	}
+	if provider.Overrides != nil {
+		registeredGroups := make(map[string]bool)
+		for _, override := range provider.Overrides {
+			if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" || len(override.WebhookURL) == 0 {
+				return false
+			}
+			registeredGroups[override.Group] = true
+		}
+	}
 	return len(provider.WebhookURL) > 0
 }
 
-// ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
-	var message string
-	var color string
+// Send an alert using the provider
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer([]byte(provider.buildRequestBody(endpoint, alert, result, resolved)))
+	request, err := http.NewRequest(http.MethodPost, provider.getWebhookURLForGroup(endpoint.Group), buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(provider.ClientConfig).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type Body struct {
+	Text        string       `json:"text"`
+	Username    string       `json:"username"`
+	IconURL     string       `json:"icon_url"`
+	Attachments []Attachment `json:"attachments"`
+}
+
+type Attachment struct {
+	Title    string  `json:"title"`
+	Fallback string  `json:"fallback"`
+	Text     string  `json:"text"`
+	Short    bool    `json:"short"`
+	Color    string  `json:"color"`
+	Fields   []Field `json:"fields"`
+}
+
+type Field struct {
+	Title string `json:"title"`
+	Value string `json:"value"`
+	Short bool   `json:"short"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
+	var message, color, results string
 	if resolved {
-		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", endpoint.Name, alert.SuccessThreshold)
+		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
 		color = "#36A64F"
 	} else {
-		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", endpoint.Name, alert.FailureThreshold)
+		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
 		color = "#DD0000"
 	}
-	var results string
 	for _, conditionResult := range result.ConditionResults {
 		var prefix string
 		if conditionResult.Success {
@@ -48,44 +108,46 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
 		} else {
 			prefix = ":x:"
 		}
-		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
+		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
 	}
 	var description string
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
-		description = ":\\n> " + alertDescription
+		description = ":\n> " + alertDescription
 	}
-	return &custom.AlertProvider{
-		URL:          provider.WebhookURL,
-		Method:       http.MethodPost,
-		ClientConfig: provider.ClientConfig,
-		Body: fmt.Sprintf(`{
-  "text": "",
-  "username": "gatus",
-  "icon_url": "https://raw.githubusercontent.com/TwiN/gatus/master/static/logo.png",
-  "attachments": [
-    {
-      "title": ":rescue_worker_helmet: Gatus",
-      "fallback": "Gatus - %s",
-      "text": "%s%s",
-      "short": false,
-      "color": "%s",
-      "fields": [
-        {
-          "title": "URL",
-          "value": "%s",
-          "short": false
-        },
-        {
-          "title": "Condition results",
-          "value": "%s",
-          "short": false
-        }
-      ]
-    }
-  ]
-}`, message, message, description, color, endpoint.URL, results),
-		Headers: map[string]string{"Content-Type": "application/json"},
+	body, _ := json.Marshal(Body{
+		Text:     "",
+		Username: "gatus",
+		IconURL:  "https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png",
+		Attachments: []Attachment{
+			{
+				Title:    ":helmet_with_white_cross: Gatus",
+				Fallback: "Gatus - " + message,
+				Text:     message + description,
+				Short:    false,
+				Color:    color,
+				Fields: []Field{
+					{
+						Title: "Condition results",
+						Value: results,
+						Short: false,
+					},
+				},
+			},
+		},
+	})
+	return body
+}
+
+// getWebhookURLForGroup returns the appropriate Webhook URL integration to for a given group
+func (provider *AlertProvider) getWebhookURLForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.WebhookURL
+			}
+		}
 	}
+	return provider.WebhookURL
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/mattermost/mattermost_test.go

@@ -3,11 +3,12 @@ package mattermost
 import (
 	"encoding/json"
 	"net/http"
-	"strings"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
@@ -21,50 +22,241 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.org"}
-	alertDescription := "test"
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
+func TestAlertProvider_IsValidWithOverride(t *testing.T) {
+	providerWithInvalidOverrideGroup := AlertProvider{
+		Overrides: []Override{
+			{
+				WebhookURL: "http://example.com",
+				Group:      "",
+			},
+		},
 	}
-	if !strings.Contains(customAlertProvider.Body, "resolved") {
-		t.Error("customAlertProvider.Body should've contained the substring resolved")
+
+	if providerWithInvalidOverrideGroup.IsValid() {
+		t.Error("provider Group shouldn't have been valid")
 	}
-	if customAlertProvider.URL != "http://example.org" {
-		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
+
+	providerWithInvalidOverrideWebHookUrl := AlertProvider{
+		Overrides: []Override{
+			{
+
+				WebhookURL: "",
+				Group:      "group",
+			},
+		},
 	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	if providerWithInvalidOverrideWebHookUrl.IsValid() {
+		t.Error("provider WebHookURL shoudn't have been valid")
 	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+
+	providerWithValidOverride := AlertProvider{
+		WebhookURL: "http://example.com",
+		Overrides: []Override{
+			{
+				WebhookURL: "http://example.com",
+				Group:      "group",
+			},
+		},
 	}
-	if expected := "An alert for *svc* has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["attachments"].([]interface{})[0].(map[string]interface{})["text"] {
-		t.Errorf("expected $.attachments[0].description to be %s, got %s", expected, body["attachments"].([]interface{})[0].(map[string]interface{})["text"])
+	if !providerWithValidOverride.IsValid() {
+		t.Error("provider should've been valid")
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.org"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
 	}
-	if !strings.Contains(customAlertProvider.Body, "triggered") {
-		t.Error("customAlertProvider.Body should've contained the substring triggered")
-	}
-	if customAlertProvider.URL != "http://example.org" {
-		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\"text\":\"\",\"username\":\"gatus\",\"icon_url\":\"https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"fallback\":\"Gatus - An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row\",\"text\":\"An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"short\":false,\"color\":\"#DD0000\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"text\":\"\",\"username\":\"gatus\",\"icon_url\":\"https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"fallback\":\"Gatus - An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row\",\"text\":\"An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"short\":false,\"color\":\"#36A64F\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal(body, &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}
+
+func TestAlertProvider_getWebhookURLForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example01.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getWebhookURLForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getToForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
 	}
 }

alerting/provider/messagebird/messagebird.go

@@ -1,12 +1,15 @@
 package messagebird
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
 )
 
 const (
@@ -20,7 +23,7 @@ type AlertProvider struct {
 	Recipients string `yaml:"recipients"`
 
 	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
-	DefaultAlert *alert.Alert `yaml:"default-alert"`
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
 }
 
 // IsValid returns whether the provider's configuration is valid
@@ -28,28 +31,48 @@ func (provider *AlertProvider) IsValid() bool {
 	return len(provider.AccessKey) > 0 && len(provider.Originator) > 0 && len(provider.Recipients) > 0
 }
 
-// ToCustomAlertProvider converts the provider into a custom.AlertProvider
-// Reference doc for messagebird https://developers.messagebird.com/api/sms-messaging/#send-outbound-sms
-func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, alert *alert.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
+// Send an alert using the provider
+// Reference doc for messagebird: https://developers.messagebird.com/api/sms-messaging/#send-outbound-sms
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, restAPIURL, buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	request.Header.Set("Authorization", fmt.Sprintf("AccessKey %s", provider.AccessKey))
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type Body struct {
+	Originator string `json:"originator"`
+	Recipients string `json:"recipients"`
+	Body       string `json:"body"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
 	var message string
 	if resolved {
-		message = fmt.Sprintf("RESOLVED: %s - %s", endpoint.Name, alert.GetDescription())
+		message = fmt.Sprintf("RESOLVED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
 	} else {
-		message = fmt.Sprintf("TRIGGERED: %s - %s", endpoint.Name, alert.GetDescription())
-	}
-	return &custom.AlertProvider{
-		URL:    restAPIURL,
-		Method: http.MethodPost,
-		Body: fmt.Sprintf(`{
-  "originator": "%s",
-  "recipients": "%s",
-  "body": "%s"
-}`, provider.Originator, provider.Recipients, message),
-		Headers: map[string]string{
-			"Content-Type":  "application/json",
-			"Authorization": fmt.Sprintf("AccessKey %s", provider.AccessKey),
-		},
+		message = fmt.Sprintf("TRIGGERED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
 	}
+	body, _ := json.Marshal(Body{
+		Originator: provider.Originator,
+		Recipients: provider.Recipients,
+		Body:       message,
+	})
+	return body
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/messagebird/messagebird_test.go

@@ -3,11 +3,12 @@ package messagebird
 import (
 	"encoding/json"
 	"net/http"
-	"strings"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
 )
 
 func TestMessagebirdAlertProvider_IsValid(t *testing.T) {
@@ -25,54 +26,137 @@ func TestMessagebirdAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
-	provider := AlertProvider{
-		AccessKey:  "1",
-		Originator: "1",
-		Recipients: "1",
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
 	}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{}, true)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
-	}
-	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
-		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
-	}
-	if customAlertProvider.URL != "https://rest.messagebird.com/messages" {
-		t.Errorf("expected URL to be %s, got %s", "https://rest.messagebird.com/messages", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
-	provider := AlertProvider{
-		AccessKey:  "1",
-		Originator: "1",
-		Recipients: "1",
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{AccessKey: "1", Originator: "2", Recipients: "3"},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\"originator\":\"2\",\"recipients\":\"3\",\"body\":\"TRIGGERED: endpoint-name - description-1\"}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{AccessKey: "4", Originator: "5", Recipients: "6"},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"originator\":\"5\",\"recipients\":\"6\",\"body\":\"RESOLVED: endpoint-name - description-2\"}",
+		},
 	}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{}, false)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
-	}
-	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
-		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
-	}
-	if customAlertProvider.URL != "https://rest.messagebird.com/messages" {
-		t.Errorf("expected URL to be %s, got %s", "https://rest.messagebird.com/messages", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal([]byte(body), &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
 	}
 }

alerting/provider/ntfy/ntfy.go

@@ -0,0 +1,95 @@
+package ntfy
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+)
+
+const (
+	DefaultURL      = "https://ntfy.sh"
+	DefaultPriority = 3
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Slack
+type AlertProvider struct {
+	Topic    string `yaml:"topic"`
+	URL      string `yaml:"url,omitempty"`      // Defaults to DefaultURL
+	Priority int    `yaml:"priority,omitempty"` // Defaults to DefaultPriority
+
+	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	if len(provider.URL) == 0 {
+		provider.URL = DefaultURL
+	}
+	if provider.Priority == 0 {
+		provider.Priority = DefaultPriority
+	}
+	return len(provider.URL) > 0 && len(provider.Topic) > 0 && provider.Priority > 0 && provider.Priority < 6
+}
+
+// Send an alert using the provider
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, provider.URL, buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type Body struct {
+	Topic    string   `json:"topic"`
+	Title    string   `json:"title"`
+	Message  string   `json:"message"`
+	Tags     []string `json:"tags"`
+	Priority int      `json:"priority"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
+	var message, tag string
+	if len(alert.GetDescription()) > 0 {
+		message = endpoint.DisplayName() + " - " + alert.GetDescription()
+	} else {
+		message = endpoint.DisplayName()
+	}
+	if resolved {
+		tag = "white_check_mark"
+	} else {
+		tag = "x"
+	}
+	body, _ := json.Marshal(Body{
+		Topic:    provider.Topic,
+		Title:    "Gatus",
+		Message:  message,
+		Tags:     []string{tag},
+		Priority: provider.Priority,
+	})
+	return body
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/ntfy/ntfy_test.go

@@ -0,0 +1,104 @@
+package ntfy
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/core"
+)
+
+func TestAlertDefaultProvider_IsValid(t *testing.T) {
+	scenarios := []struct {
+		name     string
+		provider AlertProvider
+		expected bool
+	}{
+		{
+			name:     "valid",
+			provider: AlertProvider{URL: "https://ntfy.sh", Topic: "example", Priority: 1},
+			expected: true,
+		},
+		{
+			name:     "no-url-should-use-default-value",
+			provider: AlertProvider{Topic: "example", Priority: 1},
+			expected: true,
+		},
+		{
+			name:     "invalid-topic",
+			provider: AlertProvider{URL: "https://ntfy.sh", Topic: "", Priority: 1},
+			expected: false,
+		},
+		{
+			name:     "invalid-priority-too-high",
+			provider: AlertProvider{URL: "https://ntfy.sh", Topic: "example", Priority: 6},
+			expected: false,
+		},
+		{
+			name:     "invalid-priority-too-low",
+			provider: AlertProvider{URL: "https://ntfy.sh", Topic: "example", Priority: -1},
+			expected: false,
+		},
+		{
+			name:     "no-priority-should-use-default-value",
+			provider: AlertProvider{URL: "https://ntfy.sh", Topic: "example"},
+			expected: true,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			if scenario.provider.IsValid() != scenario.expected {
+				t.Errorf("expected %t, got %t", scenario.expected, scenario.provider.IsValid())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{URL: "https://ntfy.sh", Topic: "example", Priority: 1},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\"topic\":\"example\",\"title\":\"Gatus\",\"message\":\"endpoint-name - description-1\",\"tags\":[\"x\"],\"priority\":1}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{URL: "https://ntfy.sh", Topic: "example", Priority: 2},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"topic\":\"example\",\"title\":\"Gatus\",\"message\":\"endpoint-name - description-2\",\"tags\":[\"white_check_mark\"],\"priority\":2}",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal(body, &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
+	}
+}

alerting/provider/opsgenie/opsgenie.go

@@ -0,0 +1,239 @@
+package opsgenie
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+)
+
+const (
+	restAPI = "https://api.opsgenie.com/v2/alerts"
+)
+
+type AlertProvider struct {
+	// APIKey to use for
+	APIKey string `yaml:"api-key"`
+
+	// Priority to be used in Opsgenie alert payload
+	//
+	// default: P1
+	Priority string `yaml:"priority"`
+
+	// Source define source to be used in Opsgenie alert payload
+	//
+	// default: gatus
+	Source string `yaml:"source"`
+
+	// EntityPrefix is a prefix to be used in entity argument in Opsgenie alert payload
+	//
+	// default: gatus-
+	EntityPrefix string `yaml:"entity-prefix"`
+
+	//AliasPrefix is a prefix to be used in alias argument in Opsgenie alert payload
+	//
+	// default: gatus-healthcheck-
+	AliasPrefix string `yaml:"alias-prefix"`
+
+	// Tags to be used in Opsgenie alert payload
+	//
+	// default: []
+	Tags []string `yaml:"tags"`
+
+	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.APIKey) > 0
+}
+
+// Send an alert using the provider
+//
+// Relevant: https://docs.opsgenie.com/docs/alert-api
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	err := provider.createAlert(endpoint, alert, result, resolved)
+	if err != nil {
+		return err
+	}
+	if resolved {
+		err = provider.closeAlert(endpoint, alert)
+		if err != nil {
+			return err
+		}
+	}
+	if alert.IsSendingOnResolved() {
+		if resolved {
+			// The alert has been resolved and there's no error, so we can clear the alert's ResolveKey
+			alert.ResolveKey = ""
+		} else {
+			alert.ResolveKey = provider.alias(buildKey(endpoint))
+		}
+	}
+	return nil
+}
+
+func (provider *AlertProvider) createAlert(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	payload := provider.buildCreateRequestBody(endpoint, alert, result, resolved)
+	return provider.sendRequest(restAPI, http.MethodPost, payload)
+}
+
+func (provider *AlertProvider) closeAlert(endpoint *core.Endpoint, alert *alert.Alert) error {
+	payload := provider.buildCloseRequestBody(endpoint, alert)
+	url := restAPI + "/" + provider.alias(buildKey(endpoint)) + "/close?identifierType=alias"
+	return provider.sendRequest(url, http.MethodPost, payload)
+}
+
+func (provider *AlertProvider) sendRequest(url, method string, payload interface{}) error {
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("error build alert with payload %v: %w", payload, err)
+	}
+	request, err := http.NewRequest(method, url, bytes.NewBuffer(body))
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	request.Header.Set("Authorization", "GenieKey "+provider.APIKey)
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		rBody, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(rBody))
+	}
+	return nil
+}
+
+func (provider *AlertProvider) buildCreateRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) alertCreateRequest {
+	var message, description, results string
+	if resolved {
+		message = fmt.Sprintf("RESOLVED: %s - %s", endpoint.Name, alert.GetDescription())
+		description = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
+	} else {
+		message = fmt.Sprintf("%s - %s", endpoint.Name, alert.GetDescription())
+		description = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
+	}
+	if endpoint.Group != "" {
+		message = fmt.Sprintf("[%s] %s", endpoint.Group, message)
+	}
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = "▣"
+		} else {
+			prefix = "▢"
+		}
+		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
+	}
+	description = description + "\n" + results
+	key := buildKey(endpoint)
+	details := map[string]string{
+		"endpoint:url":    endpoint.URL,
+		"endpoint:group":  endpoint.Group,
+		"result:hostname": result.Hostname,
+		"result:ip":       result.IP,
+		"result:dns_code": result.DNSRCode,
+		"result:errors":   strings.Join(result.Errors, ","),
+	}
+	for k, v := range details {
+		if v == "" {
+			delete(details, k)
+		}
+	}
+	if result.HTTPStatus > 0 {
+		details["result:http_status"] = strconv.Itoa(result.HTTPStatus)
+	}
+	return alertCreateRequest{
+		Message:     message,
+		Description: description,
+		Source:      provider.source(),
+		Priority:    provider.priority(),
+		Alias:       provider.alias(key),
+		Entity:      provider.entity(key),
+		Tags:        provider.Tags,
+		Details:     details,
+	}
+}
+
+func (provider *AlertProvider) buildCloseRequestBody(endpoint *core.Endpoint, alert *alert.Alert) alertCloseRequest {
+	return alertCloseRequest{
+		Source: buildKey(endpoint),
+		Note:   fmt.Sprintf("RESOLVED: %s - %s", endpoint.Name, alert.GetDescription()),
+	}
+}
+
+func (provider *AlertProvider) source() string {
+	source := provider.Source
+	if source == "" {
+		return "gatus"
+	}
+	return source
+}
+
+func (provider *AlertProvider) alias(key string) string {
+	alias := provider.AliasPrefix
+	if alias == "" {
+		alias = "gatus-healthcheck-"
+	}
+	return alias + key
+}
+
+func (provider *AlertProvider) entity(key string) string {
+	alias := provider.EntityPrefix
+	if alias == "" {
+		alias = "gatus-"
+	}
+	return alias + key
+}
+
+func (provider *AlertProvider) priority() string {
+	priority := provider.Priority
+	if priority == "" {
+		return "P1"
+	}
+	return priority
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}
+
+func buildKey(endpoint *core.Endpoint) string {
+	name := toKebabCase(endpoint.Name)
+	if endpoint.Group == "" {
+		return name
+	}
+	return toKebabCase(endpoint.Group) + "-" + name
+}
+
+func toKebabCase(val string) string {
+	return strings.ToLower(strings.ReplaceAll(val, " ", "-"))
+}
+
+type alertCreateRequest struct {
+	Message     string            `json:"message"`
+	Priority    string            `json:"priority"`
+	Source      string            `json:"source"`
+	Entity      string            `json:"entity"`
+	Alias       string            `json:"alias"`
+	Description string            `json:"description"`
+	Tags        []string          `json:"tags,omitempty"`
+	Details     map[string]string `json:"details"`
+}
+
+type alertCloseRequest struct {
+	Source string `json:"source"`
+	Note   string `json:"note"`
+}

alerting/provider/opsgenie/opsgenie_test.go

@@ -0,0 +1,319 @@
+package opsgenie
+
+import (
+	"net/http"
+	"reflect"
+	"testing"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{APIKey: ""}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{APIKey: "00000000-0000-0000-0000-000000000000"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	description := "my bad alert description"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:          "triggered",
+			Provider:      AlertProvider{},
+			Alert:         alert.Alert{Description: &description, SuccessThreshold: 1, FailureThreshold: 1},
+			Resolved:      false,
+			ExpectedError: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+		},
+		{
+			Name:          "triggered-error",
+			Provider:      AlertProvider{},
+			Alert:         alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:      false,
+			ExpectedError: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+		},
+		{
+			Name:          "resolved",
+			Provider:      AlertProvider{},
+			Alert:         alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:      true,
+			ExpectedError: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+		},
+		{
+			Name:          "resolved-error",
+			Provider:      AlertProvider{},
+			Alert:         alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:      true,
+			ExpectedError: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+		},
+	}
+
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildCreateRequestBody(t *testing.T) {
+	t.Parallel()
+	description := "alert description"
+	scenarios := []struct {
+		Name     string
+		Provider *AlertProvider
+		Alert    *alert.Alert
+		Endpoint *core.Endpoint
+		Result   *core.Result
+		Resolved bool
+		want     alertCreateRequest
+	}{
+		{
+			Name:     "missing all params (unresolved)",
+			Provider: &AlertProvider{},
+			Alert:    &alert.Alert{},
+			Endpoint: &core.Endpoint{},
+			Result:   &core.Result{},
+			Resolved: false,
+			want: alertCreateRequest{
+				Message:     " - ",
+				Priority:    "P1",
+				Source:      "gatus",
+				Entity:      "gatus-",
+				Alias:       "gatus-healthcheck-",
+				Description: "An alert for ** has been triggered due to having failed 0 time(s) in a row\n",
+				Tags:        nil,
+				Details:     map[string]string{},
+			},
+		},
+		{
+			Name:     "missing all params (resolved)",
+			Provider: &AlertProvider{},
+			Alert:    &alert.Alert{},
+			Endpoint: &core.Endpoint{},
+			Result:   &core.Result{},
+			Resolved: true,
+			want: alertCreateRequest{
+				Message:     "RESOLVED:  - ",
+				Priority:    "P1",
+				Source:      "gatus",
+				Entity:      "gatus-",
+				Alias:       "gatus-healthcheck-",
+				Description: "An alert for ** has been resolved after passing successfully 0 time(s) in a row\n",
+				Tags:        nil,
+				Details:     map[string]string{},
+			},
+		},
+		{
+			Name:     "with default options (unresolved)",
+			Provider: &AlertProvider{},
+			Alert: &alert.Alert{
+				Description:      &description,
+				FailureThreshold: 3,
+			},
+			Endpoint: &core.Endpoint{
+				Name: "my super app",
+			},
+			Result: &core.Result{
+				ConditionResults: []*core.ConditionResult{
+					{
+						Condition: "[STATUS] == 200",
+						Success:   true,
+					},
+					{
+						Condition: "[BODY] == OK",
+						Success:   false,
+					},
+				},
+			},
+			Resolved: false,
+			want: alertCreateRequest{
+				Message:     "my super app - " + description,
+				Priority:    "P1",
+				Source:      "gatus",
+				Entity:      "gatus-my-super-app",
+				Alias:       "gatus-healthcheck-my-super-app",
+				Description: "An alert for *my super app* has been triggered due to having failed 3 time(s) in a row\n▣ - `[STATUS] == 200`\n▢ - `[BODY] == OK`\n",
+				Tags:        nil,
+				Details:     map[string]string{},
+			},
+		},
+		{
+			Name: "with custom options (resolved)",
+			Provider: &AlertProvider{
+				Priority:     "P5",
+				EntityPrefix: "oompa-",
+				AliasPrefix:  "loompa-",
+				Source:       "gatus-hc",
+				Tags:         []string{"do-ba-dee-doo"},
+			},
+			Alert: &alert.Alert{
+				Description:      &description,
+				SuccessThreshold: 4,
+			},
+			Endpoint: &core.Endpoint{
+				Name: "my mega app",
+			},
+			Result: &core.Result{
+				ConditionResults: []*core.ConditionResult{
+					{
+						Condition: "[STATUS] == 200",
+						Success:   true,
+					},
+				},
+			},
+			Resolved: true,
+			want: alertCreateRequest{
+				Message:     "RESOLVED: my mega app - " + description,
+				Priority:    "P5",
+				Source:      "gatus-hc",
+				Entity:      "oompa-my-mega-app",
+				Alias:       "loompa-my-mega-app",
+				Description: "An alert for *my mega app* has been resolved after passing successfully 4 time(s) in a row\n▣ - `[STATUS] == 200`\n",
+				Tags:        []string{"do-ba-dee-doo"},
+				Details:     map[string]string{},
+			},
+		},
+		{
+			Name: "with default options and details (unresolved)",
+			Provider: &AlertProvider{
+				Tags: []string{"foo"},
+			},
+			Alert: &alert.Alert{
+				Description:      &description,
+				FailureThreshold: 6,
+			},
+			Endpoint: &core.Endpoint{
+				Name:  "my app",
+				Group: "end game",
+				URL:   "https://my.go/app",
+			},
+			Result: &core.Result{
+				HTTPStatus: 400,
+				Hostname:   "my.go",
+				Errors:     []string{"error 01", "error 02"},
+				Success:    false,
+				ConditionResults: []*core.ConditionResult{
+					{
+						Condition: "[STATUS] == 200",
+						Success:   false,
+					},
+				},
+			},
+			Resolved: false,
+			want: alertCreateRequest{
+				Message:     "[end game] my app - " + description,
+				Priority:    "P1",
+				Source:      "gatus",
+				Entity:      "gatus-end-game-my-app",
+				Alias:       "gatus-healthcheck-end-game-my-app",
+				Description: "An alert for *end game/my app* has been triggered due to having failed 6 time(s) in a row\n▢ - `[STATUS] == 200`\n",
+				Tags:        []string{"foo"},
+				Details: map[string]string{
+					"endpoint:url":       "https://my.go/app",
+					"endpoint:group":     "end game",
+					"result:hostname":    "my.go",
+					"result:errors":      "error 01,error 02",
+					"result:http_status": "400",
+				},
+			},
+		},
+	}
+	for _, scenario := range scenarios {
+		actual := scenario
+		t.Run(actual.Name, func(t *testing.T) {
+			if got := actual.Provider.buildCreateRequestBody(actual.Endpoint, actual.Alert, actual.Result, actual.Resolved); !reflect.DeepEqual(got, actual.want) {
+				t.Errorf("buildCreateRequestBody() = %v, want %v", got, actual.want)
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildCloseRequestBody(t *testing.T) {
+	t.Parallel()
+	description := "alert description"
+	scenarios := []struct {
+		Name     string
+		Provider *AlertProvider
+		Alert    *alert.Alert
+		Endpoint *core.Endpoint
+		want     alertCloseRequest
+	}{
+		{
+			Name:     "Missing all values",
+			Provider: &AlertProvider{},
+			Alert:    &alert.Alert{},
+			Endpoint: &core.Endpoint{},
+			want: alertCloseRequest{
+				Source: "",
+				Note:   "RESOLVED:  - ",
+			},
+		},
+		{
+			Name:     "Basic values",
+			Provider: &AlertProvider{},
+			Alert: &alert.Alert{
+				Description: &description,
+			},
+			Endpoint: &core.Endpoint{
+				Name: "endpoint name",
+			},
+			want: alertCloseRequest{
+				Source: "endpoint-name",
+				Note:   "RESOLVED: endpoint name - alert description",
+			},
+		},
+	}
+
+	for _, scenario := range scenarios {
+		actual := scenario
+		t.Run(actual.Name, func(t *testing.T) {
+			if got := actual.Provider.buildCloseRequestBody(actual.Endpoint, actual.Alert); !reflect.DeepEqual(got, actual.want) {
+				t.Errorf("buildCloseRequestBody() = %v, want %v", got, actual.want)
+			}
+		})
+	}
+}

alerting/provider/pagerduty/pagerduty.go

@@ -1,12 +1,16 @@
 package pagerduty
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
+	"io"
+	"log"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
 )
 
 const (
@@ -18,10 +22,10 @@ type AlertProvider struct {
 	IntegrationKey string `yaml:"integration-key"`
 
 	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
-	DefaultAlert *alert.Alert `yaml:"default-alert"`
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
 
 	// Overrides is a list of Override that may be prioritized over the default configuration
-	Overrides []Override `yaml:"overrides"`
+	Overrides []Override `yaml:"overrides,omitempty"`
 }
 
 // Override is a case under which the default integration is overridden
@@ -45,37 +49,80 @@ func (provider *AlertProvider) IsValid() bool {
 	return len(provider.IntegrationKey) == 32 || len(provider.Overrides) != 0
 }
 
-// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+// Send an alert using the provider
 //
-// relevant: https://developer.pagerduty.com/docs/events-api-v2/trigger-events/
-func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, alert *alert.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
+// Relevant: https://developer.pagerduty.com/docs/events-api-v2/trigger-events/
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, restAPIURL, buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	if alert.IsSendingOnResolved() {
+		if resolved {
+			// The alert has been resolved and there's no error, so we can clear the alert's ResolveKey
+			alert.ResolveKey = ""
+		} else {
+			// We need to retrieve the resolve key from the response
+			body, err := io.ReadAll(response.Body)
+			var payload pagerDutyResponsePayload
+			if err = json.Unmarshal(body, &payload); err != nil {
+				// Silently fail. We don't want to create tons of alerts just because we failed to parse the body.
+				log.Printf("[pagerduty][Send] Ran into error unmarshaling pagerduty response: %s", err.Error())
+			} else {
+				alert.ResolveKey = payload.DedupKey
+			}
+		}
+	}
+	return nil
+}
+
+type Body struct {
+	RoutingKey  string  `json:"routing_key"`
+	DedupKey    string  `json:"dedup_key"`
+	EventAction string  `json:"event_action"`
+	Payload     Payload `json:"payload"`
+}
+
+type Payload struct {
+	Summary  string `json:"summary"`
+	Source   string `json:"source"`
+	Severity string `json:"severity"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
 	var message, eventAction, resolveKey string
 	if resolved {
-		message = fmt.Sprintf("RESOLVED: %s - %s", endpoint.Name, alert.GetDescription())
+		message = fmt.Sprintf("RESOLVED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
 		eventAction = "resolve"
 		resolveKey = alert.ResolveKey
 	} else {
-		message = fmt.Sprintf("TRIGGERED: %s - %s", endpoint.Name, alert.GetDescription())
+		message = fmt.Sprintf("TRIGGERED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
 		eventAction = "trigger"
 		resolveKey = ""
 	}
-	return &custom.AlertProvider{
-		URL:    restAPIURL,
-		Method: http.MethodPost,
-		Body: fmt.Sprintf(`{
-  "routing_key": "%s",
-  "dedup_key": "%s",
-  "event_action": "%s",
-  "payload": {
-    "summary": "%s",
-    "source": "%s",
-    "severity": "critical"
-  }
-}`, provider.getIntegrationKeyForGroup(endpoint.Group), resolveKey, eventAction, message, endpoint.Name),
-		Headers: map[string]string{
-			"Content-Type": "application/json",
+	body, _ := json.Marshal(Body{
+		RoutingKey:  provider.getIntegrationKeyForGroup(endpoint.Group),
+		DedupKey:    resolveKey,
+		EventAction: eventAction,
+		Payload: Payload{
+			Summary:  message,
+			Source:   "Gatus",
+			Severity: "critical",
 		},
-	}
+	})
+	return body
 }
 
 // getIntegrationKeyForGroup returns the appropriate pagerduty integration key for a given group
@@ -94,3 +141,9 @@ func (provider *AlertProvider) getIntegrationKeyForGroup(group string) string {
 func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
 	return provider.DefaultAlert
 }
+
+type pagerDutyResponsePayload struct {
+	Status   string `json:"status"`
+	Message  string `json:"message"`
+	DedupKey string `json:"dedup_key"`
+}

alerting/provider/pagerduty/pagerduty_test.go

@@ -3,11 +3,12 @@ package pagerduty
 import (
 	"encoding/json"
 	"net/http"
-	"strings"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
@@ -57,107 +58,118 @@ func TestAlertProvider_IsValidWithOverride(t *testing.T) {
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
-	provider := AlertProvider{IntegrationKey: "00000000000000000000000000000000"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{}, true)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
-	}
-	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
-		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
-	}
-	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
-		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
-	}
-}
-
-func TestAlertProvider_ToCustomAlertProviderWithResolvedAlertAndOverride(t *testing.T) {
-	provider := AlertProvider{
-		IntegrationKey: "",
-		Overrides: []Override{
-			{
-				IntegrationKey: "00000000000000000000000000000000",
-				Group:          "group",
-			},
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
 		},
 	}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{}, true)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
-	}
-	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
-		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
-	}
-	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
-		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
-	provider := AlertProvider{IntegrationKey: "00000000000000000000000000000000"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{}, false)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
-	}
-	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
-		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
-	}
-	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
-		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
-	}
-}
-
-func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlertAndOverride(t *testing.T) {
-	provider := AlertProvider{
-		IntegrationKey: "",
-		Overrides: []Override{
-			{
-				IntegrationKey: "00000000000000000000000000000000",
-				Group:          "group",
-			},
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	description := "test"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{IntegrationKey: "00000000000000000000000000000000"},
+			Alert:        alert.Alert{Description: &description},
+			Resolved:     false,
+			ExpectedBody: "{\"routing_key\":\"00000000000000000000000000000000\",\"dedup_key\":\"\",\"event_action\":\"trigger\",\"payload\":{\"summary\":\"TRIGGERED: endpoint-name - test\",\"source\":\"Gatus\",\"severity\":\"critical\"}}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{IntegrationKey: "00000000000000000000000000000000"},
+			Alert:        alert.Alert{Description: &description, ResolveKey: "key"},
+			Resolved:     true,
+			ExpectedBody: "{\"routing_key\":\"00000000000000000000000000000000\",\"dedup_key\":\"key\",\"event_action\":\"resolve\",\"payload\":{\"summary\":\"RESOLVED: endpoint-name - test\",\"source\":\"Gatus\",\"severity\":\"critical\"}}",
 		},
 	}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{}, false)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
-	}
-	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
-		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
-	}
-	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
-		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(&core.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &core.Result{}, scenario.Resolved)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal(body, &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
 	}
 }
 
@@ -223,3 +235,12 @@ func TestAlertProvider_getIntegrationKeyForGroup(t *testing.T) {
 		})
 	}
 }
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}

alerting/provider/provider.go

@@ -1,17 +1,22 @@
 package provider
 
 import (
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/alerting/provider/discord"
-	"github.com/TwiN/gatus/v3/alerting/provider/mattermost"
-	"github.com/TwiN/gatus/v3/alerting/provider/messagebird"
-	"github.com/TwiN/gatus/v3/alerting/provider/pagerduty"
-	"github.com/TwiN/gatus/v3/alerting/provider/slack"
-	"github.com/TwiN/gatus/v3/alerting/provider/teams"
-	"github.com/TwiN/gatus/v3/alerting/provider/telegram"
-	"github.com/TwiN/gatus/v3/alerting/provider/twilio"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/alerting/provider/custom"
+	"github.com/TwiN/gatus/v4/alerting/provider/discord"
+	"github.com/TwiN/gatus/v4/alerting/provider/email"
+	"github.com/TwiN/gatus/v4/alerting/provider/googlechat"
+	"github.com/TwiN/gatus/v4/alerting/provider/matrix"
+	"github.com/TwiN/gatus/v4/alerting/provider/mattermost"
+	"github.com/TwiN/gatus/v4/alerting/provider/messagebird"
+	"github.com/TwiN/gatus/v4/alerting/provider/ntfy"
+	"github.com/TwiN/gatus/v4/alerting/provider/opsgenie"
+	"github.com/TwiN/gatus/v4/alerting/provider/pagerduty"
+	"github.com/TwiN/gatus/v4/alerting/provider/slack"
+	"github.com/TwiN/gatus/v4/alerting/provider/teams"
+	"github.com/TwiN/gatus/v4/alerting/provider/telegram"
+	"github.com/TwiN/gatus/v4/alerting/provider/twilio"
+	"github.com/TwiN/gatus/v4/core"
 )
 
 // AlertProvider is the interface that each providers should implement
@@ -19,11 +24,11 @@ type AlertProvider interface {
 	// IsValid returns whether the provider's configuration is valid
 	IsValid() bool
 
-	// ToCustomAlertProvider converts the provider into a custom.AlertProvider
-	ToCustomAlertProvider(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider
-
 	// GetDefaultAlert returns the provider's default alert configuration
 	GetDefaultAlert() *alert.Alert
+
+	// Send an alert using the provider
+	Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error
 }
 
 // ParseWithDefaultAlert parses an Endpoint alert by using the provider's default alert as a baseline
@@ -52,8 +57,13 @@ var (
 	// Validate interface implementation on compile
 	_ AlertProvider = (*custom.AlertProvider)(nil)
 	_ AlertProvider = (*discord.AlertProvider)(nil)
+	_ AlertProvider = (*email.AlertProvider)(nil)
+	_ AlertProvider = (*googlechat.AlertProvider)(nil)
+	_ AlertProvider = (*matrix.AlertProvider)(nil)
 	_ AlertProvider = (*mattermost.AlertProvider)(nil)
 	_ AlertProvider = (*messagebird.AlertProvider)(nil)
+	_ AlertProvider = (*ntfy.AlertProvider)(nil)
+	_ AlertProvider = (*opsgenie.AlertProvider)(nil)
 	_ AlertProvider = (*pagerduty.AlertProvider)(nil)
 	_ AlertProvider = (*slack.AlertProvider)(nil)
 	_ AlertProvider = (*teams.AlertProvider)(nil)

alerting/provider/provider_test.go

@@ -3,7 +3,7 @@ package provider
 import (
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v4/alerting/alert"
 )
 
 func TestParseWithDefaultAlert(t *testing.T) {

alerting/provider/slack/slack.go

@@ -1,35 +1,93 @@
 package slack
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Slack
 type AlertProvider struct {
 	WebhookURL string `yaml:"webhook-url"` // Slack webhook URL
-
 	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
-	DefaultAlert *alert.Alert `yaml:"default-alert"`
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+	// Overrides is a list of Override that may be prioritized over the default configuration
+	Overrides []Override `yaml:"overrides,omitempty"`
+}
+
+// Override is a case under which the default integration is overridden
+type Override struct {
+	Group      string `yaml:"group"`
+	WebhookURL string `yaml:"webhook-url"`
 }
 
 // IsValid returns whether the provider's configuration is valid
 func (provider *AlertProvider) IsValid() bool {
+	registeredGroups := make(map[string]bool)
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" || len(override.WebhookURL) == 0 {
+				return false
+			}
+			registeredGroups[override.Group] = true
+		}
+	}
 	return len(provider.WebhookURL) > 0
 }
 
-// ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+// Send an alert using the provider
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, provider.getWebhookURLForGroup(endpoint.Group), buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type Body struct {
+	Text        string       `json:"text"`
+	Attachments []Attachment `json:"attachments"`
+}
+
+type Attachment struct {
+	Title  string  `json:"title"`
+	Text   string  `json:"text"`
+	Short  bool    `json:"short"`
+	Color  string  `json:"color"`
+	Fields []Field `json:"fields"`
+}
+
+type Field struct {
+	Title string `json:"title"`
+	Value string `json:"value"`
+	Short bool   `json:"short"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
 	var message, color, results string
 	if resolved {
-		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", endpoint.Name, alert.SuccessThreshold)
+		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
 		color = "#36A64F"
 	} else {
-		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", endpoint.Name, alert.FailureThreshold)
+		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
 		color = "#DD0000"
 	}
 	for _, conditionResult := range result.ConditionResults {
@@ -39,35 +97,43 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
 		} else {
 			prefix = ":x:"
 		}
-		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
+		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
 	}
 	var description string
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
-		description = ":\\n> " + alertDescription
+		description = ":\n> " + alertDescription
 	}
-	return &custom.AlertProvider{
-		URL:    provider.WebhookURL,
-		Method: http.MethodPost,
-		Body: fmt.Sprintf(`{
-  "text": "",
-  "attachments": [
-    {
-      "title": ":helmet_with_white_cross: Gatus",
-      "text": "%s%s",
-      "short": false,
-      "color": "%s",
-      "fields": [
-        {
-          "title": "Condition results",
-          "value": "%s",
-          "short": false
-        }
-      ]
-    }
-  ]
-}`, message, description, color, results),
-		Headers: map[string]string{"Content-Type": "application/json"},
+	body, _ := json.Marshal(Body{
+		Text: "",
+		Attachments: []Attachment{
+			{
+				Title: ":helmet_with_white_cross: Gatus",
+				Text:  message + description,
+				Short: false,
+				Color: color,
+				Fields: []Field{
+					{
+						Title: "Condition results",
+						Value: results,
+						Short: false,
+					},
+				},
+			},
+		},
+	})
+	return body
+}
+
+// getWebhookURLForGroup returns the appropriate Webhook URL integration to for a given group
+func (provider *AlertProvider) getWebhookURLForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.WebhookURL
+			}
+		}
 	}
+	return provider.WebhookURL
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/slack/slack_test.go

@@ -3,68 +3,275 @@ package slack
 import (
 	"encoding/json"
 	"net/http"
-	"strings"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
 )
 
-func TestAlertProvider_IsValid(t *testing.T) {
+func TestAlertDefaultProvider_IsValid(t *testing.T) {
 	invalidProvider := AlertProvider{WebhookURL: ""}
 	if invalidProvider.IsValid() {
 		t.Error("provider shouldn't have been valid")
 	}
-	validProvider := AlertProvider{WebhookURL: "http://example.com"}
+	validProvider := AlertProvider{WebhookURL: "https://example.com"}
 	if !validProvider.IsValid() {
 		t.Error("provider should've been valid")
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.com"}
-	alertDescription := "test"
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
+func TestAlertProvider_IsValidWithOverride(t *testing.T) {
+	providerWithInvalidOverrideGroup := AlertProvider{
+		Overrides: []Override{
+			{
+				WebhookURL: "http://example.com",
+				Group:      "",
+			},
+		},
 	}
-	if !strings.Contains(customAlertProvider.Body, "resolved") {
-		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	if providerWithInvalidOverrideGroup.IsValid() {
+		t.Error("provider Group shouldn't have been valid")
 	}
-	if customAlertProvider.URL != "http://example.com" {
-		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	providerWithInvalidOverrideTo := AlertProvider{
+		Overrides: []Override{
+			{
+				WebhookURL: "",
+				Group:      "group",
+			},
+		},
 	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	if providerWithInvalidOverrideTo.IsValid() {
+		t.Error("provider integration key shouldn't have been valid")
 	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	providerWithValidOverride := AlertProvider{
+		WebhookURL: "http://example.com",
+		Overrides: []Override{
+			{
+				WebhookURL: "http://example.com",
+				Group:      "group",
+			},
+		},
 	}
-	if expected := "An alert for *svc* has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["attachments"].([]interface{})[0].(map[string]interface{})["text"] {
-		t.Errorf("expected $.attachments[0].description to be %s, got %s", expected, body["attachments"].([]interface{})[0].(map[string]interface{})["text"])
+	if !providerWithValidOverride.IsValid() {
+		t.Error("provider should've been valid")
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.com"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
 	}
-	if !strings.Contains(customAlertProvider.Body, "triggered") {
-		t.Error("customAlertProvider.Body should've contained the substring triggered")
-	}
-	if customAlertProvider.URL != "http://example.com" {
-		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Endpoint     core.Endpoint
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{},
+			Endpoint:     core.Endpoint{Name: "name"},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *name* has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"short\":false,\"color\":\"#DD0000\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
+		},
+		{
+			Name:         "triggered-with-group",
+			Provider:     AlertProvider{},
+			Endpoint:     core.Endpoint{Name: "name", Group: "group"},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *group/name* has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"short\":false,\"color\":\"#DD0000\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{},
+			Endpoint:     core.Endpoint{Name: "name"},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *name* has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"short\":false,\"color\":\"#36A64F\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
+		},
+		{
+			Name:         "resolved-with-group",
+			Provider:     AlertProvider{},
+			Endpoint:     core.Endpoint{Name: "name", Group: "group"},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *group/name* has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"short\":false,\"color\":\"#36A64F\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&scenario.Endpoint,
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal(body, &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}
+
+func TestAlertProvider_getWebhookURLForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example01.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getWebhookURLForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getWebhookURLForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
 	}
 }

alerting/provider/teams/teams.go

@@ -1,12 +1,15 @@
 package teams
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Teams
@@ -14,23 +17,74 @@ type AlertProvider struct {
 	WebhookURL string `yaml:"webhook-url"`
 
 	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
-	DefaultAlert *alert.Alert `yaml:"default-alert"`
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+
+	// Overrides is a list of Override that may be prioritized over the default configuration
+	Overrides []Override `yaml:"overrides,omitempty"`
+}
+
+// Override is a case under which the default integration is overridden
+type Override struct {
+	Group      string `yaml:"group"`
+	WebhookURL string `yaml:"webhook-url"`
 }
 
 // IsValid returns whether the provider's configuration is valid
 func (provider *AlertProvider) IsValid() bool {
+	registeredGroups := make(map[string]bool)
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" || len(override.WebhookURL) == 0 {
+				return false
+			}
+			registeredGroups[override.Group] = true
+		}
+	}
 	return len(provider.WebhookURL) > 0
 }
 
-// ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
-	var message string
-	var color string
+// Send an alert using the provider
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, provider.getWebhookURLForGroup(endpoint.Group), buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type Body struct {
+	Type       string    `json:"@type"`
+	Context    string    `json:"@context"`
+	ThemeColor string    `json:"themeColor"`
+	Title      string    `json:"title"`
+	Text       string    `json:"text"`
+	Sections   []Section `json:"sections"`
+}
+
+type Section struct {
+	ActivityTitle string `json:"activityTitle"`
+	Text          string `json:"text"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
+	var message, color string
 	if resolved {
-		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", endpoint.Name, alert.SuccessThreshold)
+		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
 		color = "#36A64F"
 	} else {
-		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", endpoint.Name, alert.FailureThreshold)
+		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
 		color = "#DD0000"
 	}
 	var results string
@@ -45,30 +99,34 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
 	}
 	var description string
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
-		description = ":\\n> " + alertDescription
+		description = ": " + alertDescription
 	}
-	return &custom.AlertProvider{
-		URL:    provider.WebhookURL,
-		Method: http.MethodPost,
-		Body: fmt.Sprintf(`{
-  "@type": "MessageCard",
-  "@context": "http://schema.org/extensions",
-  "themeColor": "%s",
-  "title": "🚨 Gatus",
-  "text": "%s%s",
-  "sections": [
-    {
-      "activityTitle": "URL",
-      "text": "%s"
-    },
-    {
-      "activityTitle": "Condition results",
-      "text": "%s"
-    }
-  ]
-}`, color, message, description, endpoint.URL, results),
-		Headers: map[string]string{"Content-Type": "application/json"},
+	body, _ := json.Marshal(Body{
+		Type:       "MessageCard",
+		Context:    "http://schema.org/extensions",
+		ThemeColor: color,
+		Title:      "🚨 Gatus",
+		Text:       message + description,
+		Sections: []Section{
+			{
+				ActivityTitle: "Condition results",
+				Text:          results,
+			},
+		},
+	})
+	return body
+}
+
+// getWebhookURLForGroup returns the appropriate Webhook URL integration to for a given group
+func (provider *AlertProvider) getWebhookURLForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.WebhookURL
+			}
+		}
 	}
+	return provider.WebhookURL
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/teams/teams_test.go

@@ -3,14 +3,15 @@ package teams
 import (
 	"encoding/json"
 	"net/http"
-	"strings"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
 )
 
-func TestAlertProvider_IsValid(t *testing.T) {
+func TestAlertDefaultProvider_IsValid(t *testing.T) {
 	invalidProvider := AlertProvider{WebhookURL: ""}
 	if invalidProvider.IsValid() {
 		t.Error("provider shouldn't have been valid")
@@ -21,50 +22,237 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.org"}
-	alertDescription := "test"
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
+func TestAlertProvider_IsValidWithOverride(t *testing.T) {
+	providerWithInvalidOverrideGroup := AlertProvider{
+		Overrides: []Override{
+			{
+				WebhookURL: "http://example.com",
+				Group:      "",
+			},
+		},
 	}
-	if !strings.Contains(customAlertProvider.Body, "resolved") {
-		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	if providerWithInvalidOverrideGroup.IsValid() {
+		t.Error("provider Group shouldn't have been valid")
 	}
-	if customAlertProvider.URL != "http://example.org" {
-		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
+	providerWithInvalidOverrideTo := AlertProvider{
+		Overrides: []Override{
+			{
+				WebhookURL: "",
+				Group:      "group",
+			},
+		},
 	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	if providerWithInvalidOverrideTo.IsValid() {
+		t.Error("provider integration key shouldn't have been valid")
 	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	providerWithValidOverride := AlertProvider{
+		WebhookURL: "http://example.com",
+		Overrides: []Override{
+			{
+				WebhookURL: "http://example.com",
+				Group:      "group",
+			},
+		},
 	}
-	if expected := "An alert for *svc* has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["text"] {
-		t.Errorf("expected $.text to be %s, got %s", expected, body["text"])
+	if !providerWithValidOverride.IsValid() {
+		t.Error("provider should've been valid")
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.org"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
 	}
-	if !strings.Contains(customAlertProvider.Body, "triggered") {
-		t.Error("customAlertProvider.Body should've contained the substring triggered")
-	}
-	if customAlertProvider.URL != "http://example.org" {
-		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\"@type\":\"MessageCard\",\"@context\":\"http://schema.org/extensions\",\"themeColor\":\"#DD0000\",\"title\":\"\\u0026#x1F6A8; Gatus\",\"text\":\"An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row: description-1\",\"sections\":[{\"activityTitle\":\"Condition results\",\"text\":\"\\u0026#x274C; - `[CONNECTED] == true`\\u003cbr/\\u003e\\u0026#x274C; - `[STATUS] == 200`\\u003cbr/\\u003e\"}]}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"@type\":\"MessageCard\",\"@context\":\"http://schema.org/extensions\",\"themeColor\":\"#36A64F\",\"title\":\"\\u0026#x1F6A8; Gatus\",\"text\":\"An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row: description-2\",\"sections\":[{\"activityTitle\":\"Condition results\",\"text\":\"\\u0026#x2705; - `[CONNECTED] == true`\\u003cbr/\\u003e\\u0026#x2705; - `[STATUS] == 200`\\u003cbr/\\u003e\"}]}",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal(body, &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}
+
+func TestAlertProvider_getWebhookURLForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example01.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getWebhookURLForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getToForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
 	}
 }

alerting/provider/telegram/telegram.go

@@ -1,35 +1,77 @@
 package telegram
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
 )
 
+const defaultAPIURL = "https://api.telegram.org"
+
 // AlertProvider is the configuration necessary for sending an alert using Telegram
 type AlertProvider struct {
-	Token string `yaml:"token"`
-	ID    string `yaml:"id"`
+	Token  string `yaml:"token"`
+	ID     string `yaml:"id"`
+	APIURL string `yaml:"api-url"`
+
+	// ClientConfig is the configuration of the client used to communicate with the provider's target
+	ClientConfig *client.Config `yaml:"client,omitempty"`
 
 	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
-	DefaultAlert *alert.Alert `yaml:"default-alert"`
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
 }
 
 // IsValid returns whether the provider's configuration is valid
 func (provider *AlertProvider) IsValid() bool {
+	if provider.ClientConfig == nil {
+		provider.ClientConfig = client.GetDefaultConfig()
+	}
 	return len(provider.Token) > 0 && len(provider.ID) > 0
 }
 
-// ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+// Send an alert using the provider
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	apiURL := provider.APIURL
+	if apiURL == "" {
+		apiURL = defaultAPIURL
+	}
+	request, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/bot%s/sendMessage", apiURL, provider.Token), buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(provider.ClientConfig).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type Body struct {
+	ChatID    string `json:"chat_id"`
+	Text      string `json:"text"`
+	ParseMode string `json:"parse_mode"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
 	var message, results string
 	if resolved {
-		message = fmt.Sprintf("An alert for *%s* has been resolved:\\n—\\n    _healthcheck passing successfully %d time(s) in a row_\\n—  ", endpoint.Name, alert.FailureThreshold)
+		message = fmt.Sprintf("An alert for *%s* has been resolved:\n—\n    _healthcheck passing successfully %d time(s) in a row_\n—  ", endpoint.DisplayName(), alert.FailureThreshold)
 	} else {
-		message = fmt.Sprintf("An alert for *%s* has been triggered:\\n—\\n    _healthcheck failed %d time(s) in a row_\\n—  ", endpoint.Name, alert.FailureThreshold)
+		message = fmt.Sprintf("An alert for *%s* has been triggered:\n—\n    _healthcheck failed %d time(s) in a row_\n—  ", endpoint.DisplayName(), alert.FailureThreshold)
 	}
 	for _, conditionResult := range result.ConditionResults {
 		var prefix string
@@ -38,20 +80,20 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
 		} else {
 			prefix = "❌"
 		}
-		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
+		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
 	}
 	var text string
 	if len(alert.GetDescription()) > 0 {
-		text = fmt.Sprintf("⛑ *Gatus* \\n%s \\n*Description* \\n_%s_  \\n\\n*Condition results*\\n%s", message, alert.GetDescription(), results)
+		text = fmt.Sprintf("⛑ *Gatus* \n%s \n*Description* \n_%s_  \n\n*Condition results*\n%s", message, alert.GetDescription(), results)
 	} else {
-		text = fmt.Sprintf("⛑ *Gatus* \\n%s \\n*Condition results*\\n%s", message, results)
-	}
-	return &custom.AlertProvider{
-		URL:     fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token),
-		Method:  http.MethodPost,
-		Body:    fmt.Sprintf(`{"chat_id": "%s", "text": "%s", "parse_mode": "MARKDOWN"}`, provider.ID, text),
-		Headers: map[string]string{"Content-Type": "application/json"},
+		text = fmt.Sprintf("⛑ *Gatus* \n%s \n*Condition results*\n%s", message, results)
 	}
+	body, _ := json.Marshal(Body{
+		ChatID:    provider.ID,
+		Text:      text,
+		ParseMode: "MARKDOWN",
+	})
+	return body
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/telegram/telegram_test.go

@@ -2,90 +2,167 @@ package telegram
 
 import (
 	"encoding/json"
-	"fmt"
 	"net/http"
-	"strings"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
-	invalidProvider := AlertProvider{Token: "", ID: ""}
-	if invalidProvider.IsValid() {
-		t.Error("provider shouldn't have been valid")
+	t.Run("invalid-provider", func(t *testing.T) {
+		invalidProvider := AlertProvider{Token: "", ID: ""}
+		if invalidProvider.IsValid() {
+			t.Error("provider shouldn't have been valid")
+		}
+	})
+	t.Run("valid-provider", func(t *testing.T) {
+		validProvider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}
+		if validProvider.ClientConfig != nil {
+			t.Error("provider client config should have been nil prior to IsValid() being executed")
+		}
+		if !validProvider.IsValid() {
+			t.Error("provider should've been valid")
+		}
+		if validProvider.ClientConfig == nil {
+			t.Error("provider client config should have been set after IsValid() was executed")
+		}
+	})
+}
+
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
 	}
-	validProvider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}
-	if !validProvider.IsValid() {
-		t.Error("provider should've been valid")
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
-	provider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{ID: "123"},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\"chat_id\":\"123\",\"text\":\"⛑ *Gatus* \\nAn alert for *endpoint-name* has been triggered:\\n—\\n    _healthcheck failed 3 time(s) in a row_\\n—   \\n*Description* \\n_description-1_  \\n\\n*Condition results*\\n❌ - `[CONNECTED] == true`\\n❌ - `[STATUS] == 200`\\n\",\"parse_mode\":\"MARKDOWN\"}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{ID: "123"},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"chat_id\":\"123\",\"text\":\"⛑ *Gatus* \\nAn alert for *endpoint-name* has been resolved:\\n—\\n    _healthcheck passing successfully 3 time(s) in a row_\\n—   \\n*Description* \\n_description-2_  \\n\\n*Condition results*\\n✅ - `[CONNECTED] == true`\\n✅ - `[STATUS] == 200`\\n\",\"parse_mode\":\"MARKDOWN\"}",
+		},
 	}
-	if !strings.Contains(customAlertProvider.Body, "resolved") {
-		t.Error("customAlertProvider.Body should've contained the substring resolved")
-	}
-	if customAlertProvider.URL != fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token) {
-		t.Errorf("expected URL to be %s, got %s", fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token), customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	//_, err := json.Marshal(customAlertProvider.Body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal(body, &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
-	provider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "0123456789"}
-	description := "Healthcheck Successful"
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{Description: &description}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
 	}
-	if !strings.Contains(customAlertProvider.Body, "triggered") {
-		t.Error("customAlertProvider.Body should've contained the substring triggered")
-	}
-	if customAlertProvider.URL != fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token) {
-		t.Errorf("expected URL to be %s, got %s", fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token), customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
-	}
-}
-
-func TestAlertProvider_ToCustomAlertProviderWithDescription(t *testing.T) {
-	provider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "0123456789"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
-	}
-	if !strings.Contains(customAlertProvider.Body, "triggered") {
-		t.Error("customAlertProvider.Body should've contained the substring triggered")
-	}
-	if customAlertProvider.URL != fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token) {
-		t.Errorf("expected URL to be %s, got %s", fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token), customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	body := make(map[string]interface{})
-	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
-	if err != nil {
-		t.Error("expected body to be valid JSON, got error:", err.Error())
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
 	}
 }

alerting/provider/twilio/twilio.go

@@ -1,14 +1,16 @@
 package twilio
 
 import (
+	"bytes"
 	"encoding/base64"
 	"fmt"
+	"io"
 	"net/http"
 	"net/url"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Twilio
@@ -19,7 +21,7 @@ type AlertProvider struct {
 	To    string `yaml:"to"`
 
 	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
-	DefaultAlert *alert.Alert `yaml:"default-alert"`
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
 }
 
 // IsValid returns whether the provider's configuration is valid
@@ -27,27 +29,40 @@ func (provider *AlertProvider) IsValid() bool {
 	return len(provider.Token) > 0 && len(provider.SID) > 0 && len(provider.From) > 0 && len(provider.To) > 0
 }
 
-// ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, alert *alert.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
+// Send an alert using the provider
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer([]byte(provider.buildRequestBody(endpoint, alert, result, resolved)))
+	request, err := http.NewRequest(http.MethodPost, fmt.Sprintf("https://api.twilio.com/2010-04-01/Accounts/%s/Messages.json", provider.SID), buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	request.Header.Set("Authorization", fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString([]byte(provider.SID+":"+provider.Token))))
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
 	var message string
 	if resolved {
-		message = fmt.Sprintf("RESOLVED: %s - %s", endpoint.Name, alert.GetDescription())
+		message = fmt.Sprintf("RESOLVED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
 	} else {
-		message = fmt.Sprintf("TRIGGERED: %s - %s", endpoint.Name, alert.GetDescription())
-	}
-	return &custom.AlertProvider{
-		URL:    fmt.Sprintf("https://api.twilio.com/2010-04-01/Accounts/%s/Messages.json", provider.SID),
-		Method: http.MethodPost,
-		Body: url.Values{
-			"To":   {provider.To},
-			"From": {provider.From},
-			"Body": {message},
-		}.Encode(),
-		Headers: map[string]string{
-			"Content-Type":  "application/x-www-form-urlencoded",
-			"Authorization": fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", provider.SID, provider.Token)))),
-		},
+		message = fmt.Sprintf("TRIGGERED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
 	}
+	return url.Values{
+		"To":   {provider.To},
+		"From": {provider.From},
+		"Body": {message},
+	}.Encode()
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/twilio/twilio_test.go

@@ -1,12 +1,10 @@
 package twilio
 
 import (
-	"net/http"
-	"strings"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/core"
 )
 
 func TestTwilioAlertProvider_IsValid(t *testing.T) {
@@ -25,54 +23,56 @@ func TestTwilioAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
-	provider := AlertProvider{
-		SID:   "1",
-		Token: "2",
-		From:  "3",
-		To:    "4",
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{SID: "1", Token: "2", From: "3", To: "4"},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "Body=TRIGGERED%3A+endpoint-name+-+description-1&From=3&To=4",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{SID: "1", Token: "2", From: "3", To: "4"},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "Body=RESOLVED%3A+endpoint-name+-+description-2&From=3&To=4",
+		},
 	}
-	description := "alert-description"
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{Name: "endpoint-name"}, &alert.Alert{Description: &description}, &core.Result{}, true)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
-	}
-	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
-		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
-	}
-	if customAlertProvider.URL != "https://api.twilio.com/2010-04-01/Accounts/1/Messages.json" {
-		t.Errorf("expected URL to be %s, got %s", "https://api.twilio.com/2010-04-01/Accounts/1/Messages.json", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	if customAlertProvider.Body != "Body=RESOLVED%3A+endpoint-name+-+alert-description&From=3&To=4" {
-		t.Errorf("expected body to be %s, got %s", "Body=RESOLVED%3A+endpoint-name+-+alert-description&From=3&To=4", customAlertProvider.Body)
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if body != scenario.ExpectedBody {
+				t.Errorf("expected %s, got %s", scenario.ExpectedBody, body)
+			}
+		})
 	}
 }
 
-func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
-	provider := AlertProvider{
-		SID:   "4",
-		Token: "3",
-		From:  "2",
-		To:    "1",
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
 	}
-	description := "alert-description"
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Endpoint{Name: "endpoint-name"}, &alert.Alert{Description: &description}, &core.Result{}, false)
-	if customAlertProvider == nil {
-		t.Fatal("customAlertProvider shouldn't have been nil")
-	}
-	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
-		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
-	}
-	if customAlertProvider.URL != "https://api.twilio.com/2010-04-01/Accounts/4/Messages.json" {
-		t.Errorf("expected URL to be %s, got %s", "https://api.twilio.com/2010-04-01/Accounts/4/Messages.json", customAlertProvider.URL)
-	}
-	if customAlertProvider.Method != http.MethodPost {
-		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
-	}
-	if customAlertProvider.Body != "Body=TRIGGERED%3A+endpoint-name+-+alert-description&From=2&To=1" {
-		t.Errorf("expected body to be %s, got %s", "Body=TRIGGERED%3A+endpoint-name+-+alert-description&From=2&To=1", customAlertProvider.Body)
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
 	}
 }

client/client.go

@@ -4,6 +4,7 @@ import (
 	"crypto/tls"
 	"crypto/x509"
 	"errors"
+	"fmt"
 	"net"
 	"net/http"
 	"net/smtp"
@@ -11,17 +12,60 @@ import (
 	"strings"
 	"time"
 
+	"github.com/TwiN/gocache/v2"
+	"github.com/TwiN/whois"
 	"github.com/go-ping/ping"
+	"github.com/ishidawataru/sctp"
 )
 
-// GetHTTPClient returns the shared HTTP client
+var (
+	// injectedHTTPClient is used for testing purposes
+	injectedHTTPClient *http.Client
+
+	whoisClient              = whois.NewClient().WithReferralCache(true)
+	whoisExpirationDateCache = gocache.NewCache().WithMaxSize(10000).WithDefaultTTL(24 * time.Hour)
+)
+
+// GetHTTPClient returns the shared HTTP client, or the client from the configuration passed
 func GetHTTPClient(config *Config) *http.Client {
+	if injectedHTTPClient != nil {
+		return injectedHTTPClient
+	}
 	if config == nil {
 		return defaultConfig.getHTTPClient()
 	}
 	return config.getHTTPClient()
 }
 
+// GetDomainExpiration retrieves the duration until the domain provided expires
+func GetDomainExpiration(hostname string) (domainExpiration time.Duration, err error) {
+	var retrievedCachedValue bool
+	if v, exists := whoisExpirationDateCache.Get(hostname); exists {
+		domainExpiration = time.Until(v.(time.Time))
+		retrievedCachedValue = true
+		// If the domain OR the TTL is not going to expire in less than 24 hours
+		// we don't have to refresh the cache. Otherwise, we'll refresh it.
+		cacheEntryTTL, _ := whoisExpirationDateCache.TTL(hostname)
+		if cacheEntryTTL > 24*time.Hour && domainExpiration > 24*time.Hour {
+			// No need to refresh, so we'll just return the cached values
+			return domainExpiration, nil
+		}
+	}
+	if whoisResponse, err := whoisClient.QueryAndParse(hostname); err != nil {
+		if !retrievedCachedValue { // Add an error unless we already retrieved a cached value
+			return 0, fmt.Errorf("error querying and parsing hostname using whois client: %w", err)
+		}
+	} else {
+		domainExpiration = time.Until(whoisResponse.ExpirationDate)
+		if domainExpiration > 720*time.Hour {
+			whoisExpirationDateCache.SetWithTTL(hostname, whoisResponse.ExpirationDate, 240*time.Hour)
+		} else {
+			whoisExpirationDateCache.SetWithTTL(hostname, whoisResponse.ExpirationDate, 72*time.Hour)
+		}
+	}
+	return domainExpiration, nil
+}
+
 // CanCreateTCPConnection checks whether a connection can be established with a TCP endpoint
 func CanCreateTCPConnection(address string, config *Config) bool {
 	conn, err := net.DialTimeout("tcp", address, config.Timeout)
@@ -32,6 +76,41 @@ func CanCreateTCPConnection(address string, config *Config) bool {
 	return true
 }
 
+// CanCreateUDPConnection checks whether a connection can be established with a UDP endpoint
+func CanCreateUDPConnection(address string, config *Config) bool {
+	conn, err := net.DialTimeout("udp", address, config.Timeout)
+	if err != nil {
+		return false
+	}
+	_ = conn.Close()
+	return true
+}
+
+// CanCreateSCTPConnection checks whether a connection can be established with a SCTP endpoint
+func CanCreateSCTPConnection(address string, config *Config) bool {
+	ch := make(chan bool)
+	go (func(res chan bool) {
+		addr, err := sctp.ResolveSCTPAddr("sctp", address)
+		if err != nil {
+			res <- false
+		}
+
+		conn, err := sctp.DialSCTP("sctp", nil, addr)
+		if err != nil {
+			res <- false
+		}
+		_ = conn.Close()
+		res <- true
+	})(ch)
+
+	select {
+	case result := <-ch:
+		return result
+	case <-time.After(config.Timeout):
+		return false
+	}
+}
+
 // CanPerformStartTLS checks whether a connection can be established to an address using the STARTTLS protocol
 func CanPerformStartTLS(address string, config *Config) (connected bool, certificate *x509.Certificate, err error) {
 	hostAndPort := strings.Split(address, ":")
@@ -104,3 +183,8 @@ func Ping(address string, config *Config) (bool, time.Duration) {
 	}
 	return true, 0
 }
+
+// InjectHTTPClient is used to inject a custom HTTP client for testing purposes
+func InjectHTTPClient(httpClient *http.Client) {
+	injectedHTTPClient = httpClient
+}

client/client_test.go

@@ -1,8 +1,13 @@
 package client
 
 import (
+	"bytes"
+	"io"
+	"net/http"
 	"testing"
 	"time"
+
+	"github.com/TwiN/gatus/v4/test"
 )
 
 func TestGetHTTPClient(t *testing.T) {
@@ -10,8 +15,18 @@ func TestGetHTTPClient(t *testing.T) {
 		Insecure:       false,
 		IgnoreRedirect: false,
 		Timeout:        0,
+		DNSResolver:    "tcp://1.1.1.1:53",
+		OAuth2Config: &OAuth2Config{
+			ClientID:     "00000000-0000-0000-0000-000000000000",
+			ClientSecret: "secretsauce",
+			TokenURL:     "https://token-server.local/token",
+			Scopes:       []string{"https://application.local/.default"},
+		},
+	}
+	err := cfg.ValidateAndSetDefaults()
+	if err != nil {
+		t.Errorf("expected error to be nil, but got: `%s`", err)
 	}
-	cfg.ValidateAndSetDefaults()
 	if GetHTTPClient(cfg) == nil {
 		t.Error("expected client to not be nil")
 	}
@@ -20,6 +35,33 @@ func TestGetHTTPClient(t *testing.T) {
 	}
 }
 
+func TestGetDomainExpiration(t *testing.T) {
+	if domainExpiration, err := GetDomainExpiration("example.com"); err != nil {
+		t.Fatalf("expected error to be nil, but got: `%s`", err)
+	} else if domainExpiration <= 0 {
+		t.Error("expected domain expiration to be higher than 0")
+	}
+	if domainExpiration, err := GetDomainExpiration("example.com"); err != nil {
+		t.Errorf("expected error to be nil, but got: `%s`", err)
+	} else if domainExpiration <= 0 {
+		t.Error("expected domain expiration to be higher than 0")
+	}
+	// Hack to pretend like the domain is expiring in 1 hour, which should trigger a refresh
+	whoisExpirationDateCache.SetWithTTL("example.com", time.Now().Add(time.Hour), 25*time.Hour)
+	if domainExpiration, err := GetDomainExpiration("example.com"); err != nil {
+		t.Errorf("expected error to be nil, but got: `%s`", err)
+	} else if domainExpiration <= 0 {
+		t.Error("expected domain expiration to be higher than 0")
+	}
+	// Make sure the refresh works when the ttl is <24 hours
+	whoisExpirationDateCache.SetWithTTL("example.com", time.Now().Add(35*time.Hour), 23*time.Hour)
+	if domainExpiration, err := GetDomainExpiration("example.com"); err != nil {
+		t.Errorf("expected error to be nil, but got: `%s`", err)
+	} else if domainExpiration <= 0 {
+		t.Error("expected domain expiration to be higher than 0")
+	}
+}
+
 func TestPing(t *testing.T) {
 	if success, rtt := Ping("127.0.0.1", &Config{Timeout: 500 * time.Millisecond}); !success {
 		t.Error("expected true")
@@ -146,3 +188,61 @@ func TestCanCreateTCPConnection(t *testing.T) {
 		t.Error("should've failed, because there's no port in the address")
 	}
 }
+
+// This test checks if a HTTP client configured with `configureOAuth2()` automatically
+// performs a Client Credentials OAuth2 flow and adds the obtained token as a `Authorization`
+// header to all outgoing HTTP calls.
+func TestHttpClientProvidesOAuth2BearerToken(t *testing.T) {
+	defer InjectHTTPClient(nil)
+	oAuth2Config := &OAuth2Config{
+		ClientID:     "00000000-0000-0000-0000-000000000000",
+		ClientSecret: "secretsauce",
+		TokenURL:     "https://token-server.local/token",
+		Scopes:       []string{"https://application.local/.default"},
+	}
+	mockHttpClient := &http.Client{
+		Transport: test.MockRoundTripper(func(r *http.Request) *http.Response {
+			// if the mock HTTP client tries to get a token from the `token-server`
+			// we provide the expected token response
+			if r.Host == "token-server.local" {
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body: io.NopCloser(bytes.NewReader(
+						[]byte(
+							`{"token_type":"Bearer","expires_in":3599,"ext_expires_in":3599,"access_token":"secret-token"}`,
+						),
+					)),
+				}
+			}
+			// to verify the headers were sent as expected, we echo them back in the
+			// `X-Org-Authorization` header and check if the token value matches our
+			// mocked `token-server` response
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header: map[string][]string{
+					"X-Org-Authorization": {r.Header.Get("Authorization")},
+				},
+				Body: http.NoBody,
+			}
+		}),
+	}
+	mockHttpClientWithOAuth := configureOAuth2(mockHttpClient, *oAuth2Config)
+	InjectHTTPClient(mockHttpClientWithOAuth)
+	request, err := http.NewRequest(http.MethodPost, "http://127.0.0.1:8282", http.NoBody)
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	response, err := mockHttpClientWithOAuth.Do(request)
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if response.Header == nil {
+		t.Error("expected response headers, but got nil")
+	}
+	// the mock response echos the Authorization header used in the request back
+	// to us as `X-Org-Authorization` header, we check here if the value matches
+	// our expected token `secret-token`
+	if response.Header.Get("X-Org-Authorization") != "Bearer secret-token" {
+		t.Error("exptected `secret-token` as Bearer token in the mocked response header `X-Org-Authorization`, but got", response.Header.Get("X-Org-Authorization"))
+	}
+}

client/config.go

@@ -1,9 +1,18 @@
 package client
 
 import (
+	"context"
 	"crypto/tls"
+	"errors"
+	"log"
+	"net"
 	"net/http"
+	"regexp"
+	"strconv"
 	"time"
+
+	"golang.org/x/oauth2"
+	"golang.org/x/oauth2/clientcredentials"
 )
 
 const (
@@ -11,7 +20,10 @@ const (
 )
 
 var (
-	// DefaultConfig is the default client configuration
+	ErrInvalidDNSResolver        = errors.New("invalid DNS resolver specified. Required format is {proto}://{ip}:{port}")
+	ErrInvalidDNSResolverPort    = errors.New("invalid DNS resolver port")
+	ErrInvalidClientOAuth2Config = errors.New("invalid OAuth2 configuration, all fields are required")
+
 	defaultConfig = Config{
 		Insecure:       false,
 		IgnoreRedirect: false,
@@ -28,22 +40,99 @@ func GetDefaultConfig() *Config {
 // Config is the configuration for clients
 type Config struct {
 	// Insecure determines whether to skip verifying the server's certificate chain and host name
-	Insecure bool `yaml:"insecure"`
+	Insecure bool `yaml:"insecure,omitempty"`
 
 	// IgnoreRedirect determines whether to ignore redirects (true) or follow them (false, default)
-	IgnoreRedirect bool `yaml:"ignore-redirect"`
+	IgnoreRedirect bool `yaml:"ignore-redirect,omitempty"`
 
 	// Timeout for the client
 	Timeout time.Duration `yaml:"timeout"`
 
+	// DNSResolver override for the HTTP client
+	// Expected format is {protocol}://{host}:{port}, e.g. tcp://8.8.8.8:53
+	DNSResolver string `yaml:"dns-resolver,omitempty"`
+
+	// OAuth2Config is the OAuth2 configuration used for the client.
+	//
+	// If non-nil, the http.Client returned by getHTTPClient will automatically retrieve a token if necessary.
+	// See configureOAuth2 for more details.
+	OAuth2Config *OAuth2Config `yaml:"oauth2,omitempty"`
+
 	httpClient *http.Client
 }
 
+// DNSResolverConfig is the parsed configuration from the DNSResolver config string.
+type DNSResolverConfig struct {
+	Protocol string
+	Host     string
+	Port     string
+}
+
+// OAuth2Config is the configuration for the OAuth2 client credentials flow
+type OAuth2Config struct {
+	TokenURL     string   `yaml:"token-url"` // e.g. https://dev-12345678.okta.com/token
+	ClientID     string   `yaml:"client-id"`
+	ClientSecret string   `yaml:"client-secret"`
+	Scopes       []string `yaml:"scopes"` // e.g. ["openid"]
+}
+
 // ValidateAndSetDefaults validates the client configuration and sets the default values if necessary
-func (c *Config) ValidateAndSetDefaults() {
+func (c *Config) ValidateAndSetDefaults() error {
 	if c.Timeout < time.Millisecond {
 		c.Timeout = 10 * time.Second
 	}
+	if c.HasCustomDNSResolver() {
+		// Validate the DNS resolver now to make sure it will not return an error later.
+		if _, err := c.parseDNSResolver(); err != nil {
+			return err
+		}
+	}
+	if c.HasOAuth2Config() && !c.OAuth2Config.isValid() {
+		return ErrInvalidClientOAuth2Config
+	}
+	return nil
+}
+
+// HasCustomDNSResolver returns whether a custom DNSResolver is configured
+func (c *Config) HasCustomDNSResolver() bool {
+	return len(c.DNSResolver) > 0
+}
+
+// parseDNSResolver parses the DNS resolver into the DNSResolverConfig struct
+func (c *Config) parseDNSResolver() (*DNSResolverConfig, error) {
+	re := regexp.MustCompile(`^(?P<proto>(.*))://(?P<host>[A-Za-z0-9\-\.]+):(?P<port>[0-9]+)?(.*)$`)
+	matches := re.FindStringSubmatch(c.DNSResolver)
+	if len(matches) == 0 {
+		return nil, ErrInvalidDNSResolver
+	}
+	r := make(map[string]string)
+	for i, k := range re.SubexpNames() {
+		if i != 0 && k != "" {
+			r[k] = matches[i]
+		}
+	}
+	port, err := strconv.Atoi(r["port"])
+	if err != nil {
+		return nil, err
+	}
+	if port < 1 || port > 65535 {
+		return nil, ErrInvalidDNSResolverPort
+	}
+	return &DNSResolverConfig{
+		Protocol: r["proto"],
+		Host:     r["host"],
+		Port:     r["port"],
+	}, nil
+}
+
+// HasOAuth2Config returns true if the client has OAuth2 configuration parameters
+func (c *Config) HasOAuth2Config() bool {
+	return c.OAuth2Config != nil
+}
+
+// isValid() returns true if the OAuth2 configuration is valid
+func (c *OAuth2Config) isValid() bool {
+	return len(c.TokenURL) > 0 && len(c.ClientID) > 0 && len(c.ClientSecret) > 0 && len(c.Scopes) > 0
 }
 
 // GetHTTPClient return an HTTP client matching the Config's parameters.
@@ -68,6 +157,43 @@ func (c *Config) getHTTPClient() *http.Client {
 				return nil
 			},
 		}
+		if c.HasCustomDNSResolver() {
+			dnsResolver, err := c.parseDNSResolver()
+			if err != nil {
+				// We're ignoring the error, because it should have been validated on startup ValidateAndSetDefaults.
+				// It shouldn't happen, but if it does, we'll log it... Better safe than sorry ;)
+				log.Println("[client][getHTTPClient] THIS SHOULD NOT HAPPEN. Silently ignoring invalid DNS resolver due to error:", err.Error())
+			} else {
+				dialer := &net.Dialer{
+					Resolver: &net.Resolver{
+						PreferGo: true,
+						Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
+							d := net.Dialer{}
+							return d.DialContext(ctx, dnsResolver.Protocol, dnsResolver.Host+":"+dnsResolver.Port)
+						},
+					},
+				}
+				c.httpClient.Transport.(*http.Transport).DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
+					return dialer.DialContext(ctx, network, addr)
+				}
+			}
+		}
+		if c.HasOAuth2Config() {
+			c.httpClient = configureOAuth2(c.httpClient, *c.OAuth2Config)
+		}
 	}
 	return c.httpClient
 }
+
+// configureOAuth2 returns an HTTP client that will obtain and refresh tokens as necessary.
+// The returned Client and its Transport should not be modified.
+func configureOAuth2(httpClient *http.Client, c OAuth2Config) *http.Client {
+	oauth2cfg := clientcredentials.Config{
+		ClientID:     c.ClientID,
+		ClientSecret: c.ClientSecret,
+		Scopes:       c.Scopes,
+		TokenURL:     c.TokenURL,
+	}
+	ctx := context.WithValue(context.Background(), oauth2.HTTPClient, httpClient)
+	return oauth2cfg.Client(ctx)
+}

client/config_test.go

@@ -35,3 +35,47 @@ func TestConfig_getHTTPClient(t *testing.T) {
 		t.Error("expected Config.IgnoreRedirect set to true to cause the HTTP client's CheckRedirect to return http.ErrUseLastResponse")
 	}
 }
+
+func TestConfig_ValidateAndSetDefaults_withCustomDNSResolver(t *testing.T) {
+	type args struct {
+		dnsResolver string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "with-valid-resolver",
+			args: args{
+				dnsResolver: "tcp://1.1.1.1:53",
+			},
+			wantErr: false,
+		},
+		{
+			name: "with-invalid-resolver-port",
+			args: args{
+				dnsResolver: "tcp://127.0.0.1:99999",
+			},
+			wantErr: true,
+		},
+		{
+			name: "with-invalid-resolver-format",
+			args: args{
+				dnsResolver: "foobar",
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cfg := &Config{
+				DNSResolver: tt.args.dnsResolver,
+			}
+			err := cfg.ValidateAndSetDefaults()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ValidateAndSetDefaults() error=%v, wantErr=%v", err, tt.wantErr)
+			}
+		})
+	}
+}

config.yaml

@@ -45,3 +45,9 @@ endpoints:
     interval: 1m
     conditions:
       - "[CONNECTED] == true"
+
+  - name: check-domain-expiration
+    url: "https://example.org/"
+    interval: 1h
+    conditions:
+      - "[DOMAIN_EXPIRATION] > 720h"

config/config.go

@@ -2,20 +2,22 @@ package config
 
 import (
 	"errors"
-	"io/ioutil"
+	"fmt"
 	"log"
 	"os"
 	"time"
 
-	"github.com/TwiN/gatus/v3/alerting"
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider"
-	"github.com/TwiN/gatus/v3/config/maintenance"
-	"github.com/TwiN/gatus/v3/config/ui"
-	"github.com/TwiN/gatus/v3/config/web"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/security"
-	"github.com/TwiN/gatus/v3/storage"
+	"github.com/TwiN/gatus/v4/alerting"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/alerting/provider"
+	"github.com/TwiN/gatus/v4/config/maintenance"
+	"github.com/TwiN/gatus/v4/config/remote"
+	"github.com/TwiN/gatus/v4/config/ui"
+	"github.com/TwiN/gatus/v4/config/web"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/security"
+	"github.com/TwiN/gatus/v4/storage"
+	"github.com/TwiN/gatus/v4/util"
 	"gopkg.in/yaml.v2"
 )
 
@@ -86,10 +88,24 @@ type Config struct {
 	// Maintenance is the configuration for creating a maintenance window in which no alerts are sent
 	Maintenance *maintenance.Config `yaml:"maintenance,omitempty"`
 
+	// Remote is the configuration for remote Gatus instances
+	// WARNING: This is in ALPHA and may change or be completely removed in the future
+	Remote *remote.Config `yaml:"remote,omitempty"`
+
 	filePath        string    // path to the file from which config was loaded from
 	lastFileModTime time.Time // last modification time
 }
 
+func (config *Config) GetEndpointByKey(key string) *core.Endpoint {
+	for i := 0; i < len(config.Endpoints); i++ {
+		ep := config.Endpoints[i]
+		if util.ConvertGroupAndEndpointNameToKey(ep.Group, ep.Name) == key {
+			return ep
+		}
+	}
+	return nil
+}
+
 // HasLoadedConfigurationFileBeenModified returns whether the file that the
 // configuration has been loaded from has been modified since it was last read
 func (config Config) HasLoadedConfigurationFileBeenModified() bool {
@@ -142,7 +158,7 @@ func LoadDefaultConfiguration() (*Config, error) {
 
 func readConfigurationFile(fileName string) (config *Config, err error) {
 	var bytes []byte
-	if bytes, err = ioutil.ReadFile(fileName); err == nil {
+	if bytes, err = os.ReadFile(fileName); err == nil {
 		// file exists, so we'll parse it and return it
 		return parseAndValidateConfigBytes(bytes)
 	}
@@ -186,10 +202,22 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 		if err := validateStorageConfig(config); err != nil {
 			return nil, err
 		}
+		if err := validateRemoteConfig(config); err != nil {
+			return nil, err
+		}
 	}
 	return
 }
 
+func validateRemoteConfig(config *Config) error {
+	if config.Remote != nil {
+		if err := config.Remote.ValidateAndSetDefaults(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func validateStorageConfig(config *Config) error {
 	if config.Storage == nil {
 		config.Storage = &storage.Config{
@@ -240,7 +268,7 @@ func validateEndpointsConfig(config *Config) error {
 			log.Printf("[config][validateEndpointsConfig] Validating endpoint '%s'", endpoint.Name)
 		}
 		if err := endpoint.ValidateAndSetDefaults(); err != nil {
-			return err
+			return fmt.Errorf("invalid endpoint %s: %w", endpoint.DisplayName(), err)
 		}
 	}
 	log.Printf("[config][validateEndpointsConfig] Validated %d endpoints", len(config.Endpoints))
@@ -274,8 +302,13 @@ func validateAlertingConfig(alertingConfig *alerting.Config, endpoints []*core.E
 	alertTypes := []alert.Type{
 		alert.TypeCustom,
 		alert.TypeDiscord,
+		alert.TypeGoogleChat,
+		alert.TypeEmail,
+		alert.TypeMatrix,
 		alert.TypeMattermost,
 		alert.TypeMessagebird,
+		alert.TypeNtfy,
+		alert.TypeOpsgenie,
 		alert.TypePagerDuty,
 		alert.TypeSlack,
 		alert.TypeTeams,

config/config_test.go

@@ -5,22 +5,21 @@ import (
 	"testing"
 	"time"
 
-	"github.com/TwiN/gatus/v3/alerting"
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/alerting/provider/discord"
-	"github.com/TwiN/gatus/v3/alerting/provider/mattermost"
-	"github.com/TwiN/gatus/v3/alerting/provider/messagebird"
-	"github.com/TwiN/gatus/v3/alerting/provider/pagerduty"
-	"github.com/TwiN/gatus/v3/alerting/provider/slack"
-	"github.com/TwiN/gatus/v3/alerting/provider/teams"
-	"github.com/TwiN/gatus/v3/alerting/provider/telegram"
-	"github.com/TwiN/gatus/v3/alerting/provider/twilio"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/config/ui"
-	"github.com/TwiN/gatus/v3/config/web"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/storage"
+	"github.com/TwiN/gatus/v4/alerting"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/alerting/provider/custom"
+	"github.com/TwiN/gatus/v4/alerting/provider/discord"
+	"github.com/TwiN/gatus/v4/alerting/provider/mattermost"
+	"github.com/TwiN/gatus/v4/alerting/provider/messagebird"
+	"github.com/TwiN/gatus/v4/alerting/provider/pagerduty"
+	"github.com/TwiN/gatus/v4/alerting/provider/slack"
+	"github.com/TwiN/gatus/v4/alerting/provider/teams"
+	"github.com/TwiN/gatus/v4/alerting/provider/telegram"
+	"github.com/TwiN/gatus/v4/alerting/provider/twilio"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/config/web"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/storage"
 )
 
 func TestLoadFileThatDoesNotExist(t *testing.T) {
@@ -39,10 +38,6 @@ func TestLoadDefaultConfigurationFile(t *testing.T) {
 
 func TestParseAndValidateConfigBytes(t *testing.T) {
 	file := t.TempDir() + "/test.db"
-	ui.StaticFolder = "../web/static"
-	defer func() {
-		ui.StaticFolder = "./web/static"
-	}()
 	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
 storage:
   type: sqlite
@@ -53,7 +48,14 @@ maintenance:
   duration: 4h
   every: [Monday, Thursday]
 ui:
-  title: Test
+  title: T
+  header: H
+  link: https://example.org
+  buttons:
+    - name: "Home"
+      link: "https://example.org"
+    - name: "Status page"
+      link: "https://status.example.org"
 endpoints:
   - name: website
     url: https://twin.sh/health
@@ -88,8 +90,8 @@ endpoints:
 	if config.Storage == nil || config.Storage.Path != file || config.Storage.Type != storage.TypeSQLite {
 		t.Error("expected storage to be set to sqlite, got", config.Storage)
 	}
-	if config.UI == nil || config.UI.Title != "Test" {
-		t.Error("Expected Config.UI.Title to be Test")
+	if config.UI == nil || config.UI.Title != "T" || config.UI.Header != "H" || config.UI.Link != "https://example.org" || len(config.UI.Buttons) != 2 || config.UI.Buttons[0].Name != "Home" || config.UI.Buttons[0].Link != "https://example.org" || config.UI.Buttons[1].Name != "Status page" || config.UI.Buttons[1].Link != "https://status.example.org" {
+		t.Error("expected ui to be set to T, H, https://example.org, 2 buttons, Home and Status page, got", config.UI)
 	}
 	if mc := config.Maintenance; mc == nil || mc.Start != "00:00" || !mc.IsEnabled() || mc.Duration != 4*time.Hour || len(mc.Every) != 2 {
 		t.Error("Expected Config.Maintenance to be configured properly")
@@ -1118,7 +1120,7 @@ endpoints:
     conditions:
       - "[STATUS] == 200"
 `))
-	if err != core.ErrEndpointWithNoName {
+	if err == nil {
 		t.Error("should've returned an error")
 	}
 }
@@ -1172,12 +1174,12 @@ endpoints:
 
 func TestParseAndValidateConfigBytesWithValidSecurityConfig(t *testing.T) {
 	const expectedUsername = "admin"
-	const expectedPasswordHash = "6b97ed68d14eb3f1aa959ce5d49c7dc612e1eb1dafd73b1e705847483fd6a6c809f2ceb4e8df6ff9984c6298ff0285cace6614bf8daa9f0070101b6c89899e22"
+	const expectedPasswordHash = "JDJhJDEwJHRiMnRFakxWazZLdXBzRERQazB1TE8vckRLY05Yb1hSdnoxWU0yQ1FaYXZRSW1McmladDYu"
 	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`debug: true
 security:
   basic:
     username: "%s"
-    password-sha512: "%s"
+    password-bcrypt-base64: "%s"
 endpoints:
   - name: website
     url: https://twin.sh/health
@@ -1202,8 +1204,8 @@ endpoints:
 	if config.Security.Basic.Username != expectedUsername {
 		t.Errorf("config.Security.Basic.Username should've been %s, but was %s", expectedUsername, config.Security.Basic.Username)
 	}
-	if config.Security.Basic.PasswordSha512Hash != expectedPasswordHash {
-		t.Errorf("config.Security.Basic.PasswordSha512Hash should've been %s, but was %s", expectedPasswordHash, config.Security.Basic.PasswordSha512Hash)
+	if config.Security.Basic.PasswordBcryptHashBase64Encoded != expectedPasswordHash {
+		t.Errorf("config.Security.Basic.PasswordBcryptHashBase64Encoded should've been %s, but was %s", expectedPasswordHash, config.Security.Basic.PasswordBcryptHashBase64Encoded)
 	}
 }
 
@@ -1302,53 +1304,3 @@ endpoints:
 		t.Error("services should've been merged in endpoints")
 	}
 }
-
-// XXX: Remove this in v4.0.0
-func TestParseAndValidateConfigBytes_backwardCompatibleWithStorageFile(t *testing.T) {
-	file := t.TempDir() + "/test.db"
-	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
-storage:
-  type: sqlite
-  file: %s
-
-endpoints:
-  - name: website
-    url: https://twin.sh/actuator/health
-    conditions:
-      - "[STATUS] == 200"
-`, file)))
-	if err != nil {
-		t.Error("expected no error, got", err.Error())
-	}
-	if config == nil {
-		t.Fatal("Config shouldn't have been nil")
-	}
-	if config.Storage == nil || config.Storage.Path != file || config.Storage.Type != storage.TypeSQLite {
-		t.Error("expected storage to be set to sqlite, got", config.Storage)
-	}
-}
-
-// XXX: Remove this in v4.0.0
-func TestParseAndValidateConfigBytes_backwardCompatibleWithStorageTypeMemoryAndFile(t *testing.T) {
-	file := t.TempDir() + "/test.db"
-	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
-storage:
-  type: memory
-  file: %s
-
-endpoints:
-  - name: website
-    url: https://twin.sh/actuator/health
-    conditions:
-      - "[STATUS] == 200"
-`, file)))
-	if err != nil {
-		t.Error("expected no error, got", err.Error())
-	}
-	if config == nil {
-		t.Fatal("Config shouldn't have been nil")
-	}
-	if config.Storage == nil || config.Storage.Path != file || config.Storage.Type != storage.TypeMemory {
-		t.Error("expected storage to be set to memory, got", config.Storage)
-	}
-}

config/maintenance/maintenance.go

@@ -39,7 +39,6 @@ type Config struct {
 	Every []string `yaml:"every"`
 
 	durationToStartFromMidnight time.Duration
-	timeLocation                *time.Location
 }
 
 func GetDefaultConfig() *Config {

config/maintenance/maintenance_test.go

@@ -98,6 +98,15 @@ func TestConfig_ValidateAndSetDefaults(t *testing.T) {
 			},
 			expectedError: nil,
 		},
+		{
+			name: "every-day-explicitly-at-2300",
+			cfg: &Config{
+				Start:    "23:00",
+				Duration: time.Hour,
+				Every:    []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"},
+			},
+			expectedError: nil,
+		},
 		{
 			name: "every-monday-at-0000",
 			cfg: &Config{
@@ -168,6 +177,24 @@ func TestConfig_IsUnderMaintenance(t *testing.T) {
 			},
 			expected: true,
 		},
+		{
+			name: "under-maintenance-starting-now-for-8h-explicit-days",
+			cfg: &Config{
+				Start:    fmt.Sprintf("%02d:00", now.Hour()),
+				Duration: 8 * time.Hour,
+				Every:    []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"},
+			},
+			expected: true,
+		},
+		{
+			name: "under-maintenance-starting-now-for-23h-explicit-days",
+			cfg: &Config{
+				Start:    fmt.Sprintf("%02d:00", now.Hour()),
+				Duration: 23 * time.Hour,
+				Every:    []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"},
+			},
+			expected: true,
+		},
 		{
 			name: "under-maintenance-starting-4h-ago-for-8h",
 			cfg: &Config{
@@ -176,6 +203,14 @@ func TestConfig_IsUnderMaintenance(t *testing.T) {
 			},
 			expected: true,
 		},
+		{
+			name: "under-maintenance-starting-22h-ago-for-23h",
+			cfg: &Config{
+				Start:    fmt.Sprintf("%02d:00", normalizeHour(now.Hour()-22)),
+				Duration: 23 * time.Hour,
+			},
+			expected: true,
+		},
 		{
 			name: "under-maintenance-starting-4h-ago-for-3h",
 			cfg: &Config{

config/remote/remote.go

@@ -0,0 +1,39 @@
+package remote
+
+import (
+	"log"
+
+	"github.com/TwiN/gatus/v4/client"
+)
+
+// NOTICE: This is an experimental alpha feature and may be updated/removed in future versions.
+// For more information, see https://github.com/TwiN/gatus/issues/64
+
+type Config struct {
+	// Instances is a list of remote instances to retrieve endpoint statuses from.
+	Instances []Instance `yaml:"instances,omitempty"`
+
+	// ClientConfig is the configuration of the client used to communicate with the provider's target
+	ClientConfig *client.Config `yaml:"client,omitempty"`
+}
+
+type Instance struct {
+	EndpointPrefix string `yaml:"endpoint-prefix"`
+	URL            string `yaml:"url"`
+}
+
+func (c *Config) ValidateAndSetDefaults() error {
+	if c.ClientConfig == nil {
+		c.ClientConfig = client.GetDefaultConfig()
+	} else {
+		if err := c.ClientConfig.ValidateAndSetDefaults(); err != nil {
+			return err
+		}
+	}
+	if len(c.Instances) > 0 {
+		log.Println("WARNING: Your configuration is using 'remote', which is in alpha and may be updated/removed in future versions.")
+		log.Println("WARNING: See https://github.com/TwiN/gatus/issues/64 for more information")
+		log.Println("WARNING: This feature is a candidate for removal in future versions. Please comment on the issue above if you need this feature.")
+	}
+	return nil
+}

config/ui/ui.go

@@ -2,31 +2,56 @@ package ui
 
 import (
 	"bytes"
+	"errors"
 	"html/template"
+
+	"github.com/TwiN/gatus/v4/web"
 )
 
 const (
-	defaultTitle = "Health Dashboard | Gatus"
-	defaultLogo  = ""
+	defaultTitle       = "Health Dashboard | Gatus"
+	defaultDescription = "Gatus is an advanced automated status page that lets you monitor your applications and configure alerts to notify you if there's an issue"
+	defaultHeader      = "Health Status"
+	defaultLogo        = ""
+	defaultLink        = ""
 )
 
 var (
-	// StaticFolder is the path to the location of the static folder from the root path of the project
-	// The only reason this is exposed is to allow running tests from a different path than the root path of the project
-	StaticFolder = "./web/static"
+	ErrButtonValidationFailed = errors.New("invalid button configuration: missing required name or link")
 )
 
 // Config is the configuration for the UI of Gatus
 type Config struct {
-	Title string `yaml:"title"` // Title of the page
-	Logo  string `yaml:"logo"`  // Logo to display on the page
+	Title       string   `yaml:"title,omitempty"`       // Title of the page
+	Description string   `yaml:"description,omitempty"` // Meta description of the page
+	Header      string   `yaml:"header,omitempty"`      // Header is the text at the top of the page
+	Logo        string   `yaml:"logo,omitempty"`        // Logo to display on the page
+	Link        string   `yaml:"link,omitempty"`        // Link to open when clicking on the logo
+	Buttons     []Button `yaml:"buttons,omitempty"`     // Buttons to display below the header
+}
+
+// Button is the configuration for a button on the UI
+type Button struct {
+	Name string `yaml:"name,omitempty"` // Name is the text to display on the button
+	Link string `yaml:"link,omitempty"` // Link to open when the button is clicked.
+}
+
+// Validate validates the button configuration
+func (btn *Button) Validate() error {
+	if len(btn.Name) == 0 || len(btn.Link) == 0 {
+		return ErrButtonValidationFailed
+	}
+	return nil
 }
 
 // GetDefaultConfig returns a Config struct with the default values
 func GetDefaultConfig() *Config {
 	return &Config{
-		Title: defaultTitle,
-		Logo:  defaultLogo,
+		Title:       defaultTitle,
+		Description: defaultDescription,
+		Header:      defaultHeader,
+		Logo:        defaultLogo,
+		Link:        defaultLink,
 	}
 }
 
@@ -35,7 +60,22 @@ func (cfg *Config) ValidateAndSetDefaults() error {
 	if len(cfg.Title) == 0 {
 		cfg.Title = defaultTitle
 	}
-	t, err := template.ParseFiles(StaticFolder + "/index.html")
+	if len(cfg.Description) == 0 {
+		cfg.Description = defaultDescription
+	}
+	if len(cfg.Header) == 0 {
+		cfg.Header = defaultHeader
+	}
+	if len(cfg.Header) == 0 {
+		cfg.Header = defaultLink
+	}
+	for _, btn := range cfg.Buttons {
+		if err := btn.Validate(); err != nil {
+			return err
+		}
+	}
+	// Validate that the template works
+	t, err := template.ParseFS(static.FileSystem, static.IndexPath)
 	if err != nil {
 		return err
 	}

config/ui/ui_test.go

@@ -1,18 +1,69 @@
 package ui
 
 import (
+	"strconv"
 	"testing"
 )
 
 func TestConfig_ValidateAndSetDefaults(t *testing.T) {
-	StaticFolder = "../../web/static"
-	defer func() {
-		StaticFolder = "./web/static"
-	}()
-	cfg := &Config{Title: ""}
+	cfg := &Config{
+		Title:       "",
+		Description: "",
+		Header:      "",
+		Logo:        "",
+		Link:        "",
+	}
 	if err := cfg.ValidateAndSetDefaults(); err != nil {
 		t.Error("expected no error, got", err.Error())
 	}
+	if cfg.Title != defaultTitle {
+		t.Errorf("expected title to be %s, got %s", defaultTitle, cfg.Title)
+	}
+	if cfg.Description != defaultDescription {
+		t.Errorf("expected description to be %s, got %s", defaultDescription, cfg.Description)
+	}
+	if cfg.Header != defaultHeader {
+		t.Errorf("expected header to be %s, got %s", defaultHeader, cfg.Header)
+	}
+}
+
+func TestButton_Validate(t *testing.T) {
+	scenarios := []struct {
+		Name, Link    string
+		ExpectedError error
+	}{
+		{
+			Name:          "",
+			Link:          "",
+			ExpectedError: ErrButtonValidationFailed,
+		},
+		{
+			Name:          "",
+			Link:          "link",
+			ExpectedError: ErrButtonValidationFailed,
+		},
+		{
+			Name:          "name",
+			Link:          "",
+			ExpectedError: ErrButtonValidationFailed,
+		},
+		{
+			Name:          "name",
+			Link:          "link",
+			ExpectedError: nil,
+		},
+	}
+	for i, scenario := range scenarios {
+		t.Run(strconv.Itoa(i)+"_"+scenario.Name+"_"+scenario.Link, func(t *testing.T) {
+			button := &Button{
+				Name: scenario.Name,
+				Link: scenario.Link,
+			}
+			if err := button.Validate(); err != scenario.ExpectedError {
+				t.Errorf("expected error %v, got %v", scenario.ExpectedError, err)
+			}
+		})
+	}
 }
 
 func TestGetDefaultConfig(t *testing.T) {

controller/controller.go

@@ -8,10 +8,8 @@ import (
 	"os"
 	"time"
 
-	"github.com/TwiN/gatus/v3/config/ui"
-	"github.com/TwiN/gatus/v3/config/web"
-	"github.com/TwiN/gatus/v3/controller/handler"
-	"github.com/TwiN/gatus/v3/security"
+	"github.com/TwiN/gatus/v4/config"
+	"github.com/TwiN/gatus/v4/controller/handler"
 )
 
 var (
@@ -21,19 +19,19 @@ var (
 )
 
 // Handle creates the router and starts the server
-func Handle(securityConfig *security.Config, webConfig *web.Config, uiConfig *ui.Config, enableMetrics bool) {
-	var router http.Handler = handler.CreateRouter(ui.StaticFolder, securityConfig, uiConfig, enableMetrics)
+func Handle(cfg *config.Config) {
+	var router http.Handler = handler.CreateRouter(cfg)
 	if os.Getenv("ENVIRONMENT") == "dev" {
 		router = handler.DevelopmentCORS(router)
 	}
 	server = &http.Server{
-		Addr:         fmt.Sprintf("%s:%d", webConfig.Address, webConfig.Port),
+		Addr:         fmt.Sprintf("%s:%d", cfg.Web.Address, cfg.Web.Port),
 		Handler:      router,
 		ReadTimeout:  15 * time.Second,
 		WriteTimeout: 15 * time.Second,
 		IdleTimeout:  15 * time.Second,
 	}
-	log.Println("[controller][Handle] Listening on " + webConfig.SocketAddress())
+	log.Println("[controller][Handle] Listening on " + cfg.Web.SocketAddress())
 	if os.Getenv("ROUTER_TEST") == "true" {
 		return
 	}

controller/controller_test.go

@@ -7,9 +7,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/config"
-	"github.com/TwiN/gatus/v3/config/web"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v4/config"
+	"github.com/TwiN/gatus/v4/config/web"
+	"github.com/TwiN/gatus/v4/core"
 )
 
 func TestHandle(t *testing.T) {
@@ -32,9 +32,9 @@ func TestHandle(t *testing.T) {
 	_ = os.Setenv("ROUTER_TEST", "true")
 	_ = os.Setenv("ENVIRONMENT", "dev")
 	defer os.Clearenv()
-	Handle(cfg.Security, cfg.Web, cfg.UI, cfg.Metrics)
+	Handle(cfg)
 	defer Shutdown()
-	request, _ := http.NewRequest("GET", "/health", nil)
+	request, _ := http.NewRequest("GET", "/health", http.NoBody)
 	responseRecorder := httptest.NewRecorder()
 	server.Handler.ServeHTTP(responseRecorder, request)
 	if responseRecorder.Code != http.StatusOK {

controller/handler/badge.go

@@ -7,8 +7,10 @@ import (
 	"strings"
 	"time"
 
-	"github.com/TwiN/gatus/v3/storage/store"
-	"github.com/TwiN/gatus/v3/storage/store/common"
+	"github.com/TwiN/gatus/v4/config"
+	"github.com/TwiN/gatus/v4/storage/store"
+	"github.com/TwiN/gatus/v4/storage/store/common"
+	"github.com/TwiN/gatus/v4/storage/store/common/paging"
 	"github.com/gorilla/mux"
 )
 
@@ -21,6 +23,16 @@ const (
 	badgeColorHexVeryBad  = "#c7130a"
 )
 
+const (
+	HealthStatusUp      = "up"
+	HealthStatusDown    = "down"
+	HealthStatusUnknown = "?"
+)
+
+var (
+	badgeColors = []string{badgeColorHexAwesome, badgeColorHexGreat, badgeColorHexGood, badgeColorHexPassable, badgeColorHexBad}
+)
+
 // UptimeBadge handles the automatic generation of badge based on the group name and endpoint name passed.
 //
 // Valid values for {duration}: 7d, 24h, 1h
@@ -43,60 +55,89 @@ func UptimeBadge(writer http.ResponseWriter, request *http.Request) {
 	uptime, err := store.Get().GetUptimeByKey(key, from, time.Now())
 	if err != nil {
 		if err == common.ErrEndpointNotFound {
-			writer.WriteHeader(http.StatusNotFound)
+			http.Error(writer, err.Error(), http.StatusNotFound)
 		} else if err == common.ErrInvalidTimeRange {
-			writer.WriteHeader(http.StatusBadRequest)
+			http.Error(writer, err.Error(), http.StatusBadRequest)
 		} else {
-			writer.WriteHeader(http.StatusInternalServerError)
+			http.Error(writer, err.Error(), http.StatusInternalServerError)
 		}
-		_, _ = writer.Write([]byte(err.Error()))
 		return
 	}
-	formattedDate := time.Now().Format(http.TimeFormat)
-	writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
-	writer.Header().Set("Date", formattedDate)
-	writer.Header().Set("Expires", formattedDate)
 	writer.Header().Set("Content-Type", "image/svg+xml")
+	writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	writer.Header().Set("Expires", "0")
+	writer.WriteHeader(http.StatusOK)
 	_, _ = writer.Write(generateUptimeBadgeSVG(duration, uptime))
 }
 
 // ResponseTimeBadge handles the automatic generation of badge based on the group name and endpoint name passed.
 //
 // Valid values for {duration}: 7d, 24h, 1h
-func ResponseTimeBadge(writer http.ResponseWriter, request *http.Request) {
-	variables := mux.Vars(request)
-	duration := variables["duration"]
-	var from time.Time
-	switch duration {
-	case "7d":
-		from = time.Now().Add(-7 * 24 * time.Hour)
-	case "24h":
-		from = time.Now().Add(-24 * time.Hour)
-	case "1h":
-		from = time.Now().Add(-2 * time.Hour) // Because response time metrics are stored by hour, we have to cheat a little
-	default:
-		http.Error(writer, "Durations supported: 7d, 24h, 1h", http.StatusBadRequest)
-		return
+func ResponseTimeBadge(config *config.Config) http.HandlerFunc {
+	return func(writer http.ResponseWriter, request *http.Request) {
+		variables := mux.Vars(request)
+		duration := variables["duration"]
+		var from time.Time
+		switch duration {
+		case "7d":
+			from = time.Now().Add(-7 * 24 * time.Hour)
+		case "24h":
+			from = time.Now().Add(-24 * time.Hour)
+		case "1h":
+			from = time.Now().Add(-2 * time.Hour) // Because response time metrics are stored by hour, we have to cheat a little
+		default:
+			http.Error(writer, "Durations supported: 7d, 24h, 1h", http.StatusBadRequest)
+			return
+		}
+		key := variables["key"]
+		averageResponseTime, err := store.Get().GetAverageResponseTimeByKey(key, from, time.Now())
+		if err != nil {
+			if err == common.ErrEndpointNotFound {
+				http.Error(writer, err.Error(), http.StatusNotFound)
+			} else if err == common.ErrInvalidTimeRange {
+				http.Error(writer, err.Error(), http.StatusBadRequest)
+			} else {
+				http.Error(writer, err.Error(), http.StatusInternalServerError)
+			}
+			return
+		}
+		writer.Header().Set("Content-Type", "image/svg+xml")
+		writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+		writer.Header().Set("Expires", "0")
+		writer.WriteHeader(http.StatusOK)
+		_, _ = writer.Write(generateResponseTimeBadgeSVG(duration, averageResponseTime, key, config))
 	}
+}
+
+// HealthBadge handles the automatic generation of badge based on the group name and endpoint name passed.
+func HealthBadge(writer http.ResponseWriter, request *http.Request) {
+	variables := mux.Vars(request)
 	key := variables["key"]
-	averageResponseTime, err := store.Get().GetAverageResponseTimeByKey(key, from, time.Now())
+	pagingConfig := paging.NewEndpointStatusParams()
+	status, err := store.Get().GetEndpointStatusByKey(key, pagingConfig.WithResults(1, 1))
 	if err != nil {
 		if err == common.ErrEndpointNotFound {
-			writer.WriteHeader(http.StatusNotFound)
+			http.Error(writer, err.Error(), http.StatusNotFound)
 		} else if err == common.ErrInvalidTimeRange {
-			writer.WriteHeader(http.StatusBadRequest)
+			http.Error(writer, err.Error(), http.StatusBadRequest)
 		} else {
-			writer.WriteHeader(http.StatusInternalServerError)
+			http.Error(writer, err.Error(), http.StatusInternalServerError)
 		}
-		_, _ = writer.Write([]byte(err.Error()))
 		return
 	}
-	formattedDate := time.Now().Format(http.TimeFormat)
-	writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
-	writer.Header().Set("Date", formattedDate)
-	writer.Header().Set("Expires", formattedDate)
+	healthStatus := HealthStatusUnknown
+	if len(status.Results) > 0 {
+		if status.Results[0].Success {
+			healthStatus = HealthStatusUp
+		} else {
+			healthStatus = HealthStatusDown
+		}
+	}
 	writer.Header().Set("Content-Type", "image/svg+xml")
-	_, _ = writer.Write(generateResponseTimeBadgeSVG(duration, averageResponseTime))
+	writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	writer.Header().Set("Expires", "0")
+	writer.WriteHeader(http.StatusOK)
+	_, _ = writer.Write(generateHealthBadgeSVG(healthStatus))
 }
 
 func generateUptimeBadgeSVG(duration string, uptime float64) []byte {
@@ -165,7 +206,7 @@ func getBadgeColorFromUptime(uptime float64) string {
 	return badgeColorHexVeryBad
 }
 
-func generateResponseTimeBadgeSVG(duration string, averageResponseTime int) []byte {
+func generateResponseTimeBadgeSVG(duration string, averageResponseTime int, key string, cfg *config.Config) []byte {
 	var labelWidth, valueWidth int
 	switch duration {
 	case "7d":
@@ -176,7 +217,7 @@ func generateResponseTimeBadgeSVG(duration string, averageResponseTime int) []by
 		labelWidth = 105
 	default:
 	}
-	color := getBadgeColorFromResponseTime(averageResponseTime)
+	color := getBadgeColorFromResponseTime(averageResponseTime, key, cfg)
 	sanitizedValue := strconv.Itoa(averageResponseTime) + "ms"
 	valueWidth = len(sanitizedValue) * 11
 	width := labelWidth + valueWidth
@@ -213,17 +254,71 @@ func generateResponseTimeBadgeSVG(duration string, averageResponseTime int) []by
 	return svg
 }
 
-func getBadgeColorFromResponseTime(responseTime int) string {
-	if responseTime <= 50 {
-		return badgeColorHexAwesome
-	} else if responseTime <= 200 {
-		return badgeColorHexGreat
-	} else if responseTime <= 300 {
-		return badgeColorHexGood
-	} else if responseTime <= 500 {
-		return badgeColorHexPassable
-	} else if responseTime <= 750 {
-		return badgeColorHexBad
+func getBadgeColorFromResponseTime(responseTime int, key string, cfg *config.Config) string {
+	endpoint := cfg.GetEndpointByKey(key)
+	// the threshold config requires 5 values, so we can be sure it's set here
+	for i := 0; i < 5; i++ {
+		if responseTime <= endpoint.UIConfig.Badge.ResponseTime.Thresholds[i] {
+			return badgeColors[i]
+		}
 	}
 	return badgeColorHexVeryBad
 }
+
+func generateHealthBadgeSVG(healthStatus string) []byte {
+	var labelWidth, valueWidth int
+	switch healthStatus {
+	case HealthStatusUp:
+		valueWidth = 28
+	case HealthStatusDown:
+		valueWidth = 44
+	case HealthStatusUnknown:
+		valueWidth = 10
+	default:
+	}
+	color := getBadgeColorFromHealth(healthStatus)
+	labelWidth = 48
+
+	width := labelWidth + valueWidth
+	labelX := labelWidth / 2
+	valueX := labelWidth + (valueWidth / 2)
+	svg := []byte(fmt.Sprintf(`<svg xmlns="http://www.w3.org/2000/svg" width="%d" height="20">
+  <linearGradient id="b" x2="0" y2="100%%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <mask id="a">
+    <rect width="%d" height="20" rx="3" fill="#fff"/>
+  </mask>
+  <g mask="url(#a)">
+    <path fill="#555" d="M0 0h%dv20H0z"/>
+    <path fill="%s" d="M%d 0h%dv20H%dz"/>
+    <path fill="url(#b)" d="M0 0h%dv20H0z"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
+    <text x="%d" y="15" fill="#010101" fill-opacity=".3">
+      health
+    </text>
+    <text x="%d" y="14">
+      health
+    </text>
+    <text x="%d" y="15" fill="#010101" fill-opacity=".3">
+      %s
+    </text>
+    <text x="%d" y="14">
+      %s
+    </text>
+  </g>
+</svg>`, width, width, labelWidth, color, labelWidth, valueWidth, labelWidth, width, labelX, labelX, valueX, healthStatus, valueX, healthStatus))
+
+	return svg
+}
+
+func getBadgeColorFromHealth(healthStatus string) string {
+	if healthStatus == HealthStatusUp {
+		return badgeColorHexAwesome
+	} else if healthStatus == HealthStatusDown {
+		return badgeColorHexVeryBad
+	}
+	return badgeColorHexPassable
+}

controller/handler/badge_test.go

@@ -7,13 +7,14 @@ import (
 	"testing"
 	"time"
 
-	"github.com/TwiN/gatus/v3/config"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/storage/store"
-	"github.com/TwiN/gatus/v3/watchdog"
+	"github.com/TwiN/gatus/v4/config"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/core/ui"
+	"github.com/TwiN/gatus/v4/storage/store"
+	"github.com/TwiN/gatus/v4/watchdog"
 )
 
-func TestUptimeBadge(t *testing.T) {
+func TestBadge(t *testing.T) {
 	defer store.Get().Clear()
 	defer cache.Clear()
 	cfg := &config.Config{
@@ -29,9 +30,39 @@ func TestUptimeBadge(t *testing.T) {
 			},
 		},
 	}
-	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
-	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+
+	testSuccessfulResult = core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Errors:                nil,
+		Connected:             true,
+		Success:               true,
+		Timestamp:             timestamp,
+		Duration:              150 * time.Millisecond,
+		CertificateExpiration: 10 * time.Hour,
+		ConditionResults: []*core.ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   true,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   true,
+			},
+		},
+	}
+
+	cfg.Endpoints[0].UIConfig = ui.GetDefaultConfig()
+	cfg.Endpoints[1].UIConfig = ui.GetDefaultConfig()
+
+	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Connected: true, Duration: time.Millisecond, Timestamp: time.Now()})
+	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Connected: false, Duration: time.Second, Timestamp: time.Now()})
+	router := CreateRouter(cfg)
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -89,25 +120,40 @@ func TestUptimeBadge(t *testing.T) {
 			Path:         "/api/v1/endpoints/invalid_key/response-times/7d/badge.svg",
 			ExpectedCode: http.StatusNotFound,
 		},
+		{
+			Name:         "badge-health-up",
+			Path:         "/api/v1/endpoints/core_frontend/health/badge.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badge-health-down",
+			Path:         "/api/v1/endpoints/core_backend/health/badge.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badge-health-for-invalid-key",
+			Path:         "/api/v1/endpoints/invalid_key/health/badge.svg",
+			ExpectedCode: http.StatusNotFound,
+		},
 		{
 			Name:         "chart-response-time-24h",
 			Path:         "/api/v1/endpoints/core_backend/response-times/24h/chart.svg",
 			ExpectedCode: http.StatusOK,
 		},
-		{ // XXX: Remove this in v4.0.0
-			Name:         "backward-compatible-services-badge-uptime-1h",
-			Path:         "/api/v1/services/core_frontend/uptimes/1h/badge.svg",
+		{
+			Name:         "chart-response-time-7d",
+			Path:         "/api/v1/endpoints/core_frontend/response-times/7d/chart.svg",
 			ExpectedCode: http.StatusOK,
 		},
-		{ // XXX: Remove this in v4.0.0
-			Name:         "backward-compatible-services-chart-response-time-24h",
-			Path:         "/api/v1/services/core_backend/response-times/24h/chart.svg",
-			ExpectedCode: http.StatusOK,
+		{
+			Name:         "chart-response-time-with-invalid-duration",
+			Path:         "/api/v1/endpoints/core_backend/response-times/3d/chart.svg",
+			ExpectedCode: http.StatusBadRequest,
 		},
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
 			if scenario.Gzip {
 				request.Header.Set("Accept-Encoding", "gzip")
 			}
@@ -176,55 +222,155 @@ func TestGetBadgeColorFromUptime(t *testing.T) {
 }
 
 func TestGetBadgeColorFromResponseTime(t *testing.T) {
+	defer store.Get().Clear()
+	defer cache.Clear()
+
+	var (
+		firstCondition  = core.Condition("[STATUS] == 200")
+		secondCondition = core.Condition("[RESPONSE_TIME] < 500")
+		thirdCondition  = core.Condition("[CERTIFICATE_EXPIRATION] < 72h")
+	)
+
+	firstTestEndpoint := core.Endpoint{
+		Name:                    "a",
+		URL:                     "https://example.org/what/ever",
+		Method:                  "GET",
+		Body:                    "body",
+		Interval:                30 * time.Second,
+		Conditions:              []core.Condition{firstCondition, secondCondition, thirdCondition},
+		Alerts:                  nil,
+		NumberOfFailuresInARow:  0,
+		NumberOfSuccessesInARow: 0,
+		UIConfig:                ui.GetDefaultConfig(),
+	}
+	secondTestEndpoint := core.Endpoint{
+		Name:                    "b",
+		URL:                     "https://example.org/what/ever",
+		Method:                  "GET",
+		Body:                    "body",
+		Interval:                30 * time.Second,
+		Conditions:              []core.Condition{firstCondition, secondCondition, thirdCondition},
+		Alerts:                  nil,
+		NumberOfFailuresInARow:  0,
+		NumberOfSuccessesInARow: 0,
+		UIConfig: &ui.Config{
+			Badge: &ui.Badge{
+				ResponseTime: &ui.ResponseTime{
+					Thresholds: []int{100, 500, 1000, 2000, 3000},
+				},
+			},
+		},
+	}
+	cfg := &config.Config{
+		Metrics:   true,
+		Endpoints: []*core.Endpoint{&firstTestEndpoint, &secondTestEndpoint},
+	}
+
+	store.Get().Insert(&firstTestEndpoint, &testSuccessfulResult)
+	store.Get().Insert(&secondTestEndpoint, &testSuccessfulResult)
+
 	scenarios := []struct {
+		Key           string
 		ResponseTime  int
 		ExpectedColor string
 	}{
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  10,
 			ExpectedColor: badgeColorHexAwesome,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  50,
 			ExpectedColor: badgeColorHexAwesome,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  75,
 			ExpectedColor: badgeColorHexGreat,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  150,
 			ExpectedColor: badgeColorHexGreat,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  201,
 			ExpectedColor: badgeColorHexGood,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  300,
 			ExpectedColor: badgeColorHexGood,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  301,
 			ExpectedColor: badgeColorHexPassable,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  450,
 			ExpectedColor: badgeColorHexPassable,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  700,
 			ExpectedColor: badgeColorHexBad,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  1500,
 			ExpectedColor: badgeColorHexVeryBad,
 		},
+		{
+			Key:           secondTestEndpoint.Key(),
+			ResponseTime:  50,
+			ExpectedColor: badgeColorHexAwesome,
+		},
+		{
+			Key:           secondTestEndpoint.Key(),
+			ResponseTime:  1500,
+			ExpectedColor: badgeColorHexPassable,
+		},
+		{
+			Key:           secondTestEndpoint.Key(),
+			ResponseTime:  2222,
+			ExpectedColor: badgeColorHexBad,
+		},
 	}
 	for _, scenario := range scenarios {
-		t.Run("response-time-"+strconv.Itoa(scenario.ResponseTime), func(t *testing.T) {
-			if getBadgeColorFromResponseTime(scenario.ResponseTime) != scenario.ExpectedColor {
-				t.Errorf("expected %s from %d, got %v", scenario.ExpectedColor, scenario.ResponseTime, getBadgeColorFromResponseTime(scenario.ResponseTime))
+		t.Run(scenario.Key+"-response-time-"+strconv.Itoa(scenario.ResponseTime), func(t *testing.T) {
+			if getBadgeColorFromResponseTime(scenario.ResponseTime, scenario.Key, cfg) != scenario.ExpectedColor {
+				t.Errorf("expected %s from %d, got %v", scenario.ExpectedColor, scenario.ResponseTime, getBadgeColorFromResponseTime(scenario.ResponseTime, scenario.Key, cfg))
+			}
+		})
+	}
+}
+
+func TestGetBadgeColorFromHealth(t *testing.T) {
+	scenarios := []struct {
+		HealthStatus  string
+		ExpectedColor string
+	}{
+		{
+			HealthStatus:  HealthStatusUp,
+			ExpectedColor: badgeColorHexAwesome,
+		},
+		{
+			HealthStatus:  HealthStatusDown,
+			ExpectedColor: badgeColorHexVeryBad,
+		},
+		{
+			HealthStatus:  HealthStatusUnknown,
+			ExpectedColor: badgeColorHexPassable,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run("health-"+scenario.HealthStatus, func(t *testing.T) {
+			if getBadgeColorFromHealth(scenario.HealthStatus) != scenario.ExpectedColor {
+				t.Errorf("expected %s from %s, got %v", scenario.ExpectedColor, scenario.HealthStatus, getBadgeColorFromHealth(scenario.HealthStatus))
 			}
 		})
 	}

controller/handler/chart.go

@@ -7,8 +7,8 @@ import (
 	"sort"
 	"time"
 
-	"github.com/TwiN/gatus/v3/storage/store"
-	"github.com/TwiN/gatus/v3/storage/store/common"
+	"github.com/TwiN/gatus/v4/storage/store"
+	"github.com/TwiN/gatus/v4/storage/store/common"
 	"github.com/gorilla/mux"
 	"github.com/wcharczuk/go-chart/v2"
 	"github.com/wcharczuk/go-chart/v2/drawing"
@@ -45,18 +45,16 @@ func ResponseTimeChart(writer http.ResponseWriter, r *http.Request) {
 	hourlyAverageResponseTime, err := store.Get().GetHourlyAverageResponseTimeByKey(vars["key"], from, time.Now())
 	if err != nil {
 		if err == common.ErrEndpointNotFound {
-			writer.WriteHeader(http.StatusNotFound)
+			http.Error(writer, err.Error(), http.StatusNotFound)
 		} else if err == common.ErrInvalidTimeRange {
-			writer.WriteHeader(http.StatusBadRequest)
+			http.Error(writer, err.Error(), http.StatusBadRequest)
 		} else {
-			writer.WriteHeader(http.StatusInternalServerError)
+			http.Error(writer, err.Error(), http.StatusInternalServerError)
 		}
-		_, _ = writer.Write([]byte(err.Error()))
 		return
 	}
 	if len(hourlyAverageResponseTime) == 0 {
-		writer.WriteHeader(http.StatusNoContent)
-		_, _ = writer.Write(nil)
+		http.Error(writer, "", http.StatusNoContent)
 		return
 	}
 	series := chart.TimeSeries{
@@ -114,6 +112,9 @@ func ResponseTimeChart(writer http.ResponseWriter, r *http.Request) {
 		Series: []chart.Series{series},
 	}
 	writer.Header().Set("Content-Type", "image/svg+xml")
+	writer.Header().Set("Cache-Control", "no-cache, no-store")
+	writer.Header().Set("Expires", "0")
+	writer.WriteHeader(http.StatusOK)
 	if err := graph.Render(chart.SVG, writer); err != nil {
 		log.Println("[handler][ResponseTimeChart] Failed to render response time chart:", err.Error())
 		return

controller/handler/chart_test.go

@@ -6,10 +6,10 @@ import (
 	"testing"
 	"time"
 
-	"github.com/TwiN/gatus/v3/config"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/storage/store"
-	"github.com/TwiN/gatus/v3/watchdog"
+	"github.com/TwiN/gatus/v4/config"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/storage/store"
+	"github.com/TwiN/gatus/v4/watchdog"
 )
 
 func TestResponseTimeChart(t *testing.T) {
@@ -30,7 +30,7 @@ func TestResponseTimeChart(t *testing.T) {
 	}
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+	router := CreateRouter(cfg)
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -58,15 +58,10 @@ func TestResponseTimeChart(t *testing.T) {
 			Path:         "/api/v1/endpoints/invalid_key/response-times/7d/chart.svg",
 			ExpectedCode: http.StatusNotFound,
 		},
-		{ // XXX: Remove this in v4.0.0
-			Name:         "backward-compatible-services-chart-response-time-24h",
-			Path:         "/api/v1/services/core_backend/response-times/24h/chart.svg",
-			ExpectedCode: http.StatusOK,
-		},
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
 			if scenario.Gzip {
 				request.Header.Set("Accept-Encoding", "gzip")
 			}

controller/handler/config.go

@@ -0,0 +1,26 @@
+package handler
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwiN/gatus/v4/security"
+)
+
+// ConfigHandler is a handler that returns information for the front end of the application.
+type ConfigHandler struct {
+	securityConfig *security.Config
+}
+
+func (handler ConfigHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	hasOIDC := false
+	isAuthenticated := true // Default to true if no security config is set
+	if handler.securityConfig != nil {
+		hasOIDC = handler.securityConfig.OIDC != nil
+		isAuthenticated = handler.securityConfig.IsAuthenticated(r)
+	}
+	// Return the config
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write([]byte(fmt.Sprintf(`{"oidc":%v,"authenticated":%v}`, hasOIDC, isAuthenticated)))
+}

controller/handler/config_test.go

@@ -0,0 +1,34 @@
+package handler
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/TwiN/gatus/v4/security"
+	"github.com/gorilla/mux"
+)
+
+func TestConfigHandler_ServeHTTP(t *testing.T) {
+	securityConfig := &security.Config{
+		OIDC: &security.OIDCConfig{
+			IssuerURL:       "https://sso.gatus.io/",
+			RedirectURL:     "http://localhost:80/authorization-code/callback",
+			Scopes:          []string{"openid"},
+			AllowedSubjects: []string{"user1@example.com"},
+		},
+	}
+	handler := ConfigHandler{securityConfig: securityConfig}
+	// Create a fake router. We're doing this because I need the gate to be initialized.
+	securityConfig.ApplySecurityMiddleware(mux.NewRouter())
+	// Test the config handler
+	request, _ := http.NewRequest("GET", "/api/v1/config", http.NoBody)
+	responseRecorder := httptest.NewRecorder()
+	handler.ServeHTTP(responseRecorder, request)
+	if responseRecorder.Code != http.StatusOK {
+		t.Error("expected code to be 200, but was", responseRecorder.Code)
+	}
+	if responseRecorder.Body.String() != `{"oidc":true,"authenticated":false}` {
+		t.Error("expected body to be `{\"oidc\":true,\"authenticated\":false}`, but was", responseRecorder.Body.String())
+	}
+}

controller/handler/cors.go

@@ -4,7 +4,11 @@ import "net/http"
 
 func DevelopmentCORS(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Credentials", "true")
 		w.Header().Set("Access-Control-Allow-Origin", "http://localhost:8081")
+		if r.Method == "OPTIONS" {
+			return
+		}
 		next.ServeHTTP(w, r)
 	})
 }

controller/handler/endpoint_status.go

@@ -5,15 +5,20 @@ import (
 	"compress/gzip"
 	"encoding/json"
 	"fmt"
+	"io"
 	"log"
 	"net/http"
 	"strings"
 	"time"
 
-	"github.com/TwiN/gatus/v3/storage/store"
-	"github.com/TwiN/gatus/v3/storage/store/common"
-	"github.com/TwiN/gatus/v3/storage/store/common/paging"
-	"github.com/TwiN/gocache"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/config"
+	"github.com/TwiN/gatus/v4/config/remote"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/storage/store"
+	"github.com/TwiN/gatus/v4/storage/store/common"
+	"github.com/TwiN/gatus/v4/storage/store/common/paging"
+	"github.com/TwiN/gocache/v2"
 	"github.com/gorilla/mux"
 )
 
@@ -28,48 +33,89 @@ var (
 // EndpointStatuses handles requests to retrieve all EndpointStatus
 // Due to the size of the response, this function leverages a cache.
 // Must not be wrapped by GzipHandler
-func EndpointStatuses(writer http.ResponseWriter, r *http.Request) {
-	page, pageSize := extractPageAndPageSizeFromRequest(r)
-	gzipped := strings.Contains(r.Header.Get("Accept-Encoding"), "gzip")
-	var exists bool
-	var value interface{}
-	if gzipped {
-		writer.Header().Set("Content-Encoding", "gzip")
-		value, exists = cache.Get(fmt.Sprintf("endpoint-status-%d-%d-gzipped", page, pageSize))
-	} else {
-		value, exists = cache.Get(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize))
-	}
-	var data []byte
-	if !exists {
-		var err error
-		buffer := &bytes.Buffer{}
-		gzipWriter := gzip.NewWriter(buffer)
-		endpointStatuses, err := store.Get().GetAllEndpointStatuses(paging.NewEndpointStatusParams().WithResults(page, pageSize))
-		if err != nil {
-			log.Printf("[handler][EndpointStatuses] Failed to retrieve endpoint statuses: %s", err.Error())
-			http.Error(writer, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		data, err = json.Marshal(endpointStatuses)
-		if err != nil {
-			log.Printf("[handler][EndpointStatuses] Unable to marshal object to JSON: %s", err.Error())
-			http.Error(writer, "unable to marshal object to JSON", http.StatusInternalServerError)
-			return
-		}
-		_, _ = gzipWriter.Write(data)
-		_ = gzipWriter.Close()
-		gzippedData := buffer.Bytes()
-		cache.SetWithTTL(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize), data, cacheTTL)
-		cache.SetWithTTL(fmt.Sprintf("endpoint-status-%d-%d-gzipped", page, pageSize), gzippedData, cacheTTL)
+func EndpointStatuses(cfg *config.Config) http.HandlerFunc {
+	return func(writer http.ResponseWriter, r *http.Request) {
+		page, pageSize := extractPageAndPageSizeFromRequest(r)
+		gzipped := strings.Contains(r.Header.Get("Accept-Encoding"), "gzip")
+		var exists bool
+		var value interface{}
 		if gzipped {
-			data = gzippedData
+			writer.Header().Set("Content-Encoding", "gzip")
+			value, exists = cache.Get(fmt.Sprintf("endpoint-status-%d-%d-gzipped", page, pageSize))
+		} else {
+			value, exists = cache.Get(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize))
 		}
-	} else {
-		data = value.([]byte)
+		var data []byte
+		if !exists {
+			var err error
+			buffer := &bytes.Buffer{}
+			gzipWriter := gzip.NewWriter(buffer)
+			endpointStatuses, err := store.Get().GetAllEndpointStatuses(paging.NewEndpointStatusParams().WithResults(page, pageSize))
+			if err != nil {
+				log.Printf("[handler][EndpointStatuses] Failed to retrieve endpoint statuses: %s", err.Error())
+				http.Error(writer, err.Error(), http.StatusInternalServerError)
+				return
+			}
+			// ALPHA: Retrieve endpoint statuses from remote instances
+			if endpointStatusesFromRemote, err := getEndpointStatusesFromRemoteInstances(cfg.Remote); err != nil {
+				log.Printf("[handler][EndpointStatuses] Silently failed to retrieve endpoint statuses from remote: %s", err.Error())
+			} else if endpointStatusesFromRemote != nil {
+				endpointStatuses = append(endpointStatuses, endpointStatusesFromRemote...)
+			}
+			// Marshal endpoint statuses to JSON
+			data, err = json.Marshal(endpointStatuses)
+			if err != nil {
+				log.Printf("[handler][EndpointStatuses] Unable to marshal object to JSON: %s", err.Error())
+				http.Error(writer, "unable to marshal object to JSON", http.StatusInternalServerError)
+				return
+			}
+			_, _ = gzipWriter.Write(data)
+			_ = gzipWriter.Close()
+			gzippedData := buffer.Bytes()
+			cache.SetWithTTL(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize), data, cacheTTL)
+			cache.SetWithTTL(fmt.Sprintf("endpoint-status-%d-%d-gzipped", page, pageSize), gzippedData, cacheTTL)
+			if gzipped {
+				data = gzippedData
+			}
+		} else {
+			data = value.([]byte)
+		}
+		writer.Header().Add("Content-Type", "application/json")
+		writer.WriteHeader(http.StatusOK)
+		_, _ = writer.Write(data)
 	}
-	writer.Header().Add("Content-Type", "application/json")
-	writer.WriteHeader(http.StatusOK)
-	_, _ = writer.Write(data)
+}
+
+func getEndpointStatusesFromRemoteInstances(remoteConfig *remote.Config) ([]*core.EndpointStatus, error) {
+	if remoteConfig == nil || len(remoteConfig.Instances) == 0 {
+		return nil, nil
+	}
+	var endpointStatusesFromAllRemotes []*core.EndpointStatus
+	httpClient := client.GetHTTPClient(remoteConfig.ClientConfig)
+	for _, instance := range remoteConfig.Instances {
+		response, err := httpClient.Get(instance.URL)
+		if err != nil {
+			return nil, err
+		}
+		body, err := io.ReadAll(response.Body)
+		if err != nil {
+			_ = response.Body.Close()
+			log.Printf("[handler][getEndpointStatusesFromRemoteInstances] Silently failed to retrieve endpoint statuses from %s: %s", instance.URL, err.Error())
+			continue
+		}
+		var endpointStatuses []*core.EndpointStatus
+		if err = json.Unmarshal(body, &endpointStatuses); err != nil {
+			_ = response.Body.Close()
+			log.Printf("[handler][getEndpointStatusesFromRemoteInstances] Silently failed to retrieve endpoint statuses from %s: %s", instance.URL, err.Error())
+			continue
+		}
+		_ = response.Body.Close()
+		for _, endpointStatus := range endpointStatuses {
+			endpointStatus.Name = instance.EndpointPrefix + endpointStatus.Name
+		}
+		endpointStatusesFromAllRemotes = append(endpointStatusesFromAllRemotes, endpointStatuses...)
+	}
+	return endpointStatusesFromAllRemotes, nil
 }
 
 // EndpointStatus retrieves a single core.EndpointStatus by group and endpoint name

controller/handler/endpoint_status_test.go

@@ -6,17 +6,13 @@ import (
 	"testing"
 	"time"
 
-	"github.com/TwiN/gatus/v3/config"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/storage/store"
-	"github.com/TwiN/gatus/v3/watchdog"
+	"github.com/TwiN/gatus/v4/config"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/storage/store"
+	"github.com/TwiN/gatus/v4/watchdog"
 )
 
 var (
-	firstCondition  = core.Condition("[STATUS] == 200")
-	secondCondition = core.Condition("[RESPONSE_TIME] < 500")
-	thirdCondition  = core.Condition("[CERTIFICATE_EXPIRATION] < 72h")
-
 	timestamp = time.Now()
 
 	testEndpoint = core.Endpoint{
@@ -26,7 +22,7 @@ var (
 		Method:                  "GET",
 		Body:                    "body",
 		Interval:                30 * time.Second,
-		Conditions:              []*core.Condition{&firstCondition, &secondCondition, &thirdCondition},
+		Conditions:              []core.Condition{core.Condition("[STATUS] == 200"), core.Condition("[RESPONSE_TIME] < 500"), core.Condition("[CERTIFICATE_EXPIRATION] < 72h")},
 		Alerts:                  nil,
 		NumberOfFailuresInARow:  0,
 		NumberOfSuccessesInARow: 0,
@@ -101,7 +97,7 @@ func TestEndpointStatus(t *testing.T) {
 	}
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+	router := CreateRouter(cfg)
 
 	type Scenario struct {
 		Name         string
@@ -131,15 +127,10 @@ func TestEndpointStatus(t *testing.T) {
 			Path:         "/api/v1/endpoints/invalid_key/statuses",
 			ExpectedCode: http.StatusNotFound,
 		},
-		{ // XXX: Remove this in v4.0.0
-			Name:         "backward-compatible-service-status",
-			Path:         "/api/v1/services/core_frontend/statuses",
-			ExpectedCode: http.StatusOK,
-		},
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
 			if scenario.Gzip {
 				request.Header.Set("Accept-Encoding", "gzip")
 			}
@@ -162,7 +153,7 @@ func TestEndpointStatuses(t *testing.T) {
 	// Can't be bothered dealing with timezone issues on the worker that runs the automated tests
 	firstResult.Timestamp = time.Time{}
 	secondResult.Timestamp = time.Time{}
-	router := CreateRouter("../../web/static", nil, nil, false)
+	router := CreateRouter(&config.Config{Metrics: true})
 
 	type Scenario struct {
 		Name         string
@@ -201,17 +192,11 @@ func TestEndpointStatuses(t *testing.T) {
 			ExpectedCode: http.StatusOK,
 			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}]}]`,
 		},
-		{ // XXX: Remove this in v4.0.0
-			Name:         "backward-compatible-service-status",
-			Path:         "/api/v1/services/statuses",
-			ExpectedCode: http.StatusOK,
-			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}]}]`,
-		},
 	}
 
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
 			responseRecorder := httptest.NewRecorder()
 			router.ServeHTTP(responseRecorder, request)
 			if responseRecorder.Code != scenario.ExpectedCode {

controller/handler/favicon.go

@@ -1,12 +0,0 @@
-package handler
-
-import (
-	"net/http"
-)
-
-// FavIcon handles requests for /favicon.ico
-func FavIcon(staticFolder string) http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		http.ServeFile(writer, request, staticFolder+"/favicon.ico")
-	}
-}

controller/handler/favicon_test.go

@@ -1,33 +0,0 @@
-package handler
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-func TestFavIcon(t *testing.T) {
-	router := CreateRouter("../../web/static", nil, nil, false)
-	type Scenario struct {
-		Name         string
-		Path         string
-		ExpectedCode int
-	}
-	scenarios := []Scenario{
-		{
-			Name:         "favicon",
-			Path:         "/favicon.ico",
-			ExpectedCode: http.StatusOK,
-		},
-	}
-	for _, scenario := range scenarios {
-		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, nil)
-			responseRecorder := httptest.NewRecorder()
-			router.ServeHTTP(responseRecorder, request)
-			if responseRecorder.Code != scenario.ExpectedCode {
-				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
-			}
-		})
-	}
-}

controller/handler/gzip.go

@@ -3,7 +3,6 @@ package handler
 import (
 	"compress/gzip"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"strings"
 	"sync"
@@ -11,7 +10,7 @@ import (
 
 var gzPool = sync.Pool{
 	New: func() interface{} {
-		return gzip.NewWriter(ioutil.Discard)
+		return gzip.NewWriter(io.Discard)
 	},
 }
 

controller/handler/handler.go

@@ -1,47 +1,50 @@
 package handler
 
 import (
+	"io/fs"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/config/ui"
-	"github.com/TwiN/gatus/v3/security"
+	"github.com/TwiN/gatus/v4/config"
+	"github.com/TwiN/gatus/v4/web"
 	"github.com/TwiN/health"
 	"github.com/gorilla/mux"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
-func CreateRouter(staticFolder string, securityConfig *security.Config, uiConfig *ui.Config, enabledMetrics bool) *mux.Router {
+func CreateRouter(cfg *config.Config) *mux.Router {
 	router := mux.NewRouter()
-	if enabledMetrics {
+	if cfg.Metrics {
 		router.Handle("/metrics", promhttp.Handler()).Methods("GET")
 	}
-	router.Handle("/health", health.Handler().WithJSON(true)).Methods("GET")
-	router.HandleFunc("/favicon.ico", FavIcon(staticFolder)).Methods("GET")
+	api := router.PathPrefix("/api").Subrouter()
+	protected := api.PathPrefix("/").Subrouter()
+	unprotected := api.PathPrefix("/").Subrouter()
+	if cfg.Security != nil {
+		if err := cfg.Security.RegisterHandlers(router); err != nil {
+			panic(err)
+		}
+		if err := cfg.Security.ApplySecurityMiddleware(protected); err != nil {
+			panic(err)
+		}
+	}
 	// Endpoints
-	router.HandleFunc("/api/v1/endpoints/statuses", secureIfNecessary(securityConfig, EndpointStatuses)).Methods("GET") // No GzipHandler for this one, because we cache the content as Gzipped already
-	router.HandleFunc("/api/v1/endpoints/{key}/statuses", secureIfNecessary(securityConfig, GzipHandlerFunc(EndpointStatus))).Methods("GET")
-	router.HandleFunc("/api/v1/endpoints/{key}/uptimes/{duration}/badge.svg", UptimeBadge).Methods("GET")
-	router.HandleFunc("/api/v1/endpoints/{key}/response-times/{duration}/badge.svg", ResponseTimeBadge).Methods("GET")
-	router.HandleFunc("/api/v1/endpoints/{key}/response-times/{duration}/chart.svg", ResponseTimeChart).Methods("GET")
-	// XXX: Remove the lines between this and the next XXX comment in v4.0.0
-	router.HandleFunc("/api/v1/services/statuses", secureIfNecessary(securityConfig, EndpointStatuses)).Methods("GET") // No GzipHandler for this one, because we cache the content as Gzipped already
-	router.HandleFunc("/api/v1/services/{key}/statuses", secureIfNecessary(securityConfig, GzipHandlerFunc(EndpointStatus))).Methods("GET")
-	router.HandleFunc("/api/v1/services/{key}/uptimes/{duration}/badge.svg", UptimeBadge).Methods("GET")
-	router.HandleFunc("/api/v1/services/{key}/response-times/{duration}/badge.svg", ResponseTimeBadge).Methods("GET")
-	router.HandleFunc("/api/v1/services/{key}/response-times/{duration}/chart.svg", ResponseTimeChart).Methods("GET")
-	// XXX: Remove the lines between this and the previous XXX comment in v4.0.0
+	unprotected.Handle("/v1/config", ConfigHandler{securityConfig: cfg.Security}).Methods("GET")
+	protected.HandleFunc("/v1/endpoints/statuses", EndpointStatuses(cfg)).Methods("GET") // No GzipHandler for this one, because we cache the content as Gzipped already
+	protected.HandleFunc("/v1/endpoints/{key}/statuses", GzipHandlerFunc(EndpointStatus)).Methods("GET")
+	unprotected.HandleFunc("/v1/endpoints/{key}/health/badge.svg", HealthBadge).Methods("GET")
+	unprotected.HandleFunc("/v1/endpoints/{key}/uptimes/{duration}/badge.svg", UptimeBadge).Methods("GET")
+	unprotected.HandleFunc("/v1/endpoints/{key}/response-times/{duration}/badge.svg", ResponseTimeBadge(cfg)).Methods("GET")
+	unprotected.HandleFunc("/v1/endpoints/{key}/response-times/{duration}/chart.svg", ResponseTimeChart).Methods("GET")
+	// Misc
+	router.Handle("/health", health.Handler().WithJSON(true)).Methods("GET")
 	// SPA
-	router.HandleFunc("/services/{name}", SinglePageApplication(staticFolder, uiConfig)).Methods("GET") // XXX: Remove this in v4.0.0
-	router.HandleFunc("/endpoints/{name}", SinglePageApplication(staticFolder, uiConfig)).Methods("GET")
-	router.HandleFunc("/", SinglePageApplication(staticFolder, uiConfig)).Methods("GET")
+	router.HandleFunc("/endpoints/{name}", SinglePageApplication(cfg.UI)).Methods("GET")
+	router.HandleFunc("/", SinglePageApplication(cfg.UI)).Methods("GET")
 	// Everything else falls back on static content
-	router.PathPrefix("/").Handler(GzipHandler(http.FileServer(http.Dir(staticFolder))))
+	staticFileSystem, err := fs.Sub(static.FileSystem, static.RootPath)
+	if err != nil {
+		panic(err)
+	}
+	router.PathPrefix("/").Handler(GzipHandler(http.FileServer(http.FS(staticFileSystem))))
 	return router
 }
-
-func secureIfNecessary(securityConfig *security.Config, handler http.HandlerFunc) http.HandlerFunc {
-	if securityConfig != nil && securityConfig.IsValid() {
-		return security.Handler(handler, securityConfig)
-	}
-	return handler
-}

controller/handler/handler_test.go

@@ -4,10 +4,12 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"testing"
+
+	"github.com/TwiN/gatus/v4/config"
 )
 
 func TestCreateRouter(t *testing.T) {
-	router := CreateRouter("../../web/static", nil, nil, true)
+	router := CreateRouter(&config.Config{Metrics: true})
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -26,16 +28,32 @@ func TestCreateRouter(t *testing.T) {
 			ExpectedCode: http.StatusOK,
 		},
 		{
-			Name:         "scripts",
+			Name:         "favicon.ico",
+			Path:         "/favicon.ico",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "app.js",
 			Path:         "/js/app.js",
 			ExpectedCode: http.StatusOK,
 		},
 		{
-			Name:         "scripts-gzipped",
+			Name:         "app.js-gzipped",
 			Path:         "/js/app.js",
 			ExpectedCode: http.StatusOK,
 			Gzip:         true,
 		},
+		{
+			Name:         "chunk-vendors.js",
+			Path:         "/js/chunk-vendors.js",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "chunk-vendors.js-gzipped",
+			Path:         "/js/chunk-vendors.js",
+			ExpectedCode: http.StatusOK,
+			Gzip:         true,
+		},
 		{
 			Name:         "index-redirect",
 			Path:         "/index.html",
@@ -44,7 +62,7 @@ func TestCreateRouter(t *testing.T) {
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
 			if scenario.Gzip {
 				request.Header.Set("Accept-Encoding", "gzip")
 			}

controller/handler/spa.go

@@ -1,26 +1,30 @@
 package handler
 
 import (
+	_ "embed"
 	"html/template"
 	"log"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/config/ui"
+	"github.com/TwiN/gatus/v4/config/ui"
+	"github.com/TwiN/gatus/v4/web"
 )
 
-func SinglePageApplication(staticFolder string, ui *ui.Config) http.HandlerFunc {
+func SinglePageApplication(ui *ui.Config) http.HandlerFunc {
 	return func(writer http.ResponseWriter, request *http.Request) {
-		t, err := template.ParseFiles(staticFolder + "/index.html")
+		t, err := template.ParseFS(static.FileSystem, static.IndexPath)
 		if err != nil {
-			log.Println("[handler][SinglePageApplication] Failed to parse template:", err.Error())
-			http.ServeFile(writer, request, staticFolder+"/index.html")
+			// This should never happen, because ui.ValidateAndSetDefaults validates that the template works.
+			log.Println("[handler][SinglePageApplication] Failed to parse template. This should never happen, because the template is validated on start. Error:", err.Error())
+			http.Error(writer, "Failed to parse template. This should never happen, because the template is validated on start.", http.StatusInternalServerError)
 			return
 		}
 		writer.Header().Set("Content-Type", "text/html")
 		err = t.Execute(writer, ui)
 		if err != nil {
-			log.Println("[handler][SinglePageApplication] Failed to parse template:", err.Error())
-			http.ServeFile(writer, request, staticFolder+"/index.html")
+			// This should never happen, because ui.ValidateAndSetDefaults validates that the template works.
+			log.Println("[handler][SinglePageApplication] Failed to execute template. This should never happen, because the template is validated on start. Error:", err.Error())
+			http.Error(writer, "Failed to execute template. This should never happen, because the template is validated on start.", http.StatusInternalServerError)
 			return
 		}
 	}

controller/handler/spa_test.go

@@ -6,10 +6,10 @@ import (
 	"testing"
 	"time"
 
-	"github.com/TwiN/gatus/v3/config"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/storage/store"
-	"github.com/TwiN/gatus/v3/watchdog"
+	"github.com/TwiN/gatus/v4/config"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/storage/store"
+	"github.com/TwiN/gatus/v4/watchdog"
 )
 
 func TestSinglePageApplication(t *testing.T) {
@@ -30,7 +30,7 @@ func TestSinglePageApplication(t *testing.T) {
 	}
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+	router := CreateRouter(cfg)
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -48,15 +48,10 @@ func TestSinglePageApplication(t *testing.T) {
 			Path:         "/endpoints/core_frontend",
 			ExpectedCode: http.StatusOK,
 		},
-		{ // XXX: Remove this in v4.0.0
-			Name:         "frontend-service",
-			Path:         "/services/core_frontend",
-			ExpectedCode: http.StatusOK,
-		},
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			request, _ := http.NewRequest("GET", scenario.Path, http.NoBody)
 			if scenario.Gzip {
 				request.Header.Set("Accept-Encoding", "gzip")
 			}

controller/handler/util.go

@@ -4,7 +4,7 @@ import (
 	"net/http"
 	"strconv"
 
-	"github.com/TwiN/gatus/v3/storage/store/common"
+	"github.com/TwiN/gatus/v4/storage/store/common"
 )
 
 const (