chore!: Update module from v3 to v4

fix(badge): Regenerate assets and tweak health badge width
feat(badge): Implement UP/DOWN status badge (#291 )
2022-06-20 21:25:14 -04:00 · 2022-06-20 14:27:05 -04:00 · 2022-06-20 13:59:45 -04:00 · 2022-06-19 22:37:19 -04:00 · 2022-06-18 14:09:24 -04:00 · 2022-06-18 14:04:11 -04:00
360 changed files with 41342 additions and 15341 deletions
--- a/.examples/docker-compose-grafana-prometheus/README.md
+++ b/.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)
+```
--- a/.examples/docker-compose-grafana-prometheus/config/config.yaml
+++ b/.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"
--- a/.examples/docker-compose-grafana-prometheus/docker-compose.yml
+++ b/.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

--- a/.examples/docker-compose-grafana-prometheus/grafana/provisioning/dashboards/gatus.json
+++ b/.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
+}
--- a/.examples/docker-compose-grafana-prometheus/grafana/provisioning/dashboards/main.json
+++ b/.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
-}
--- a/.examples/docker-compose-mattermost/config/config.yaml
+++ b/.examples/docker-compose-mattermost/config/config.yaml
--- a/.examples/docker-compose-mattermost/docker-compose.yml
+++ b/.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

--- a/.examples/docker-compose-postgres-storage/config/config.yaml
+++ b/.examples/docker-compose-postgres-storage/config/config.yaml
@@ -1,6 +1,6 @@
 storage:
  type: postgres
-  file: "postgres://username:password@postgres:5432/gatus?sslmode=disable"
+  path: "postgres://username:password@postgres:5432/gatus?sslmode=disable"

 endpoints:
  - name: back-end
@@ -26,7 +26,7 @@ endpoints:
      - "[STATUS] == 200"

  - name: example-dns-query
-    url: "8.8.8.8" # Address of the DNS server to use
+    url: "1.1.1.1" # Address of the DNS server to use
    interval: 5m
    dns:
      query-name: "example.com"
--- a/.examples/docker-compose-postgres-storage/docker-compose.yml
+++ b/.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:
--- a/.examples/docker-compose-sqlite-storage/config/config.yaml
+++ b/.examples/docker-compose-sqlite-storage/config/config.yaml
@@ -1,6 +1,6 @@
 storage:
  type: sqlite
-  file: /data/data.db
+  path: /data/data.db

 endpoints:
  - name: back-end
@@ -26,7 +26,7 @@ endpoints:
      - "[STATUS] == 200"

  - name: example-dns-query
-    url: "8.8.8.8" # Address of the DNS server to use
+    url: "1.1.1.1" # Address of the DNS server to use
    interval: 5m
    dns:
      query-name: "example.com"
--- a/.examples/docker-compose-sqlite-storage/docker-compose.yml
+++ b/.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/
--- a/.examples/docker-compose/config/config.yaml
+++ b/.examples/docker-compose/config/config.yaml
--- a/.examples/docker-compose/docker-compose.yml
+++ b/.examples/docker-compose/docker-compose.yml
@@ -5,4 +5,4 @@ services:
    ports:
      - 8080:8080
    volumes:
-      - ./config.yaml:/config/config.yaml
+      - ./config:/config
--- a/.examples/kubernetes/gatus.yaml
+++ b/.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
--- a/.github/assets/dark-mode.png
+++ b/.github/assets/dark-mode.png
--- a/.github/assets/dashboard-conditions.png
+++ b/.github/assets/dashboard-conditions.png
--- a/.github/assets/dashboard-dark.png
+++ b/.github/assets/dashboard-dark.png
--- a/.github/assets/example.png
+++ b/.github/assets/example.png
--- a/.github/assets/grafana-dashboard.png
+++ b/.github/assets/grafana-dashboard.png
--- a/.github/assets/logo-with-dark-text.png
+++ b/.github/assets/logo-with-dark-text.png
--- a/.github/assets/logo-with-name.png
+++ b/.github/assets/logo-with-name.png
--- a/.github/assets/logo.png
+++ b/.github/assets/logo.png
--- a/.github/codecov.yml
+++ b/.github/codecov.yml
@@ -5,3 +5,8 @@ ignore:
 coverage:
  status:
    patch: off
+    project:
+      default:
+        target: 75%
+        threshold: null
+
--- a/.github/workflows/benchmark.yml
+++ b/.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.18
+          repository: "${{ github.event.inputs.repository }}"
+          ref: "${{ github.event.inputs.ref }}"
+      - uses: actions/checkout@v3
+      - name: Benchmark
+        run: go test -bench=. ./storage/store
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -10,24 +10,22 @@ on:
      - '*.md'
 jobs:
  build:
-    name: Build
+    name: build
    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.16
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
+          go-version: 1.18
+      - uses: actions/checkout@v3
      - name: Build binary to make sure it works
        run: go build -mod vendor
      - 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 1.15" step (otherwise, it'd use sudo's "go" executable)
+        # 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
      - name: Codecov
-        uses: codecov/codecov-action@v1.5.2
+        uses: codecov/codecov-action@v2.1.0
        with:
-          file: ./coverage.txt
+          files: ./coverage.txt
--- a/.github/workflows/publish-latest.yml
+++ b/.github/workflows/publish-latest.yml
@@ -6,13 +6,12 @@ on:
    types: [completed]
 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: 45
    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
@@ -27,7 +26,7 @@ jobs:
      - name: Build and push docker image
        uses: docker/build-push-action@v2
        with:
-          platforms: linux/amd64
+          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
          pull: true
          push: true
          tags: |
--- a/.github/workflows/publish-release.yml
+++ b/.github/workflows/publish-release.yml
@@ -4,12 +4,11 @@ on:
    types: [published]
 jobs:
  publish-release:
-    name: Publish release
+    name: publish-release
    runs-on: ubuntu-latest
-    timeout-minutes: 30
+    timeout-minutes: 45
    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
--- a/.gitignore
+++ b/.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
--- a/202
+++ b/202
@@ -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 2021 TwiN
+
+   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.
+
--- a/5
+++ b/5
@@ -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


 ##########
--- a/README.md
+++ b/README.md
--- a/alerting/alert/alert.go
+++ b/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
--- a/alerting/alert/alert_test.go
+++ b/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() {
--- a/alerting/alert/type.go
+++ b/alerting/alert/type.go
@@ -11,6 +11,12 @@ 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"
+
 	// TypeMattermost is the Type for the mattermost alerting provider
 	TypeMattermost Type = "mattermost"

@@ -31,4 +37,7 @@ const (

 	// TypeTwilio is the Type for the twilio alerting provider
 	TypeTwilio Type = "twilio"
+
+	// TypeOpsgenie is the Type for the opsgenie alerting provider
+	TypeOpsgenie Type = "opsgenie"
 )
--- a/alerting/config.go
+++ b/alerting/config.go
@@ -1,47 +1,59 @@
 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/mattermost"
+	"github.com/TwiN/gatus/v4/alerting/provider/messagebird"
+	"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"`

 	// 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"`

 	// 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"`
+
+	// Opsgenie is the configuration for the opsgenie alerting provider
+	Opsgenie *opsgenie.AlertProvider `yaml:"opsgenie,omitempty"`
 }

 // GetAlertingProviderByAlertType returns an provider.AlertProvider by its corresponding alert.Type
@@ -59,6 +71,18 @@ 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.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 +95,12 @@ func (config Config) GetAlertingProviderByAlertType(alertType alert.Type) provid
 			return nil
 		}
 		return config.Messagebird
+	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
--- a/alerting/provider/custom/custom.go
+++ b/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,45 @@ 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
 	}
 	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
--- a/alerting/provider/custom/custom_test.go
+++ b/alerting/provider/custom/custom_test.go
@@ -1,11 +1,15 @@
 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) {
@@ -19,88 +23,180 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }

-func TestAlertProvider_buildHTTPRequestWhenResolved(t *testing.T) {
-	const (
-		ExpectedURL  = "https://example.com/endpoint-name?event=RESOLVED&description=alert-description"
-		ExpectedBody = "endpoint-name,alert-description,RESOLVED"
-	)
-	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,
+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,
+		},
 	}
-	request := customAlertProvider.buildHTTPRequest("endpoint-name", "alert-description", true)
-	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))
+	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_buildHTTPRequestWhenTriggered(t *testing.T) {
-	const (
-		ExpectedURL  = "https://example.com/endpoint-name?event=TRIGGERED&description=alert-description"
-		ExpectedBody = "endpoint-name,alert-description,TRIGGERED"
-	)
+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: map[string]string{"Authorization": "Basic hunter2"},
+		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", false)
-	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_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 +206,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")
 	}
 }
--- a/alerting/provider/discord/discord.go
+++ b/alerting/provider/discord/discord.go
@@ -1,12 +1,14 @@
 package discord

 import (
+	"bytes"
 	"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 +16,60 @@ 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([]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(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	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, 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 {
@@ -46,10 +85,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
 		description = ":\\n> " + alertDescription
 	}
-	return &custom.AlertProvider{
-		URL:    provider.WebhookURL,
-		Method: http.MethodPost,
-		Body: fmt.Sprintf(`{
+	return fmt.Sprintf(`{
  "content": "",
  "embeds": [
    {
@@ -65,9 +101,19 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
      ]
    }
  ]
-}`, message, description, colorCode, results),
-		Headers: map[string]string{"Content-Type": "application/json"},
+}`, message, description, colorCode, results)
+}
+
+// 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
--- a/alerting/provider/discord/discord_test.go
+++ b/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,237 @@ 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: "{\n  \"content\": \"\",\n  \"embeds\": [\n    {\n      \"title\": \":helmet_with_white_cross: Gatus\",\n      \"description\": \"An alert for **endpoint-name** has been triggered due to having failed 3 time(s) in a row:\\n> description-1\",\n      \"color\": 15158332,\n      \"fields\": [\n        {\n          \"name\": \"Condition results\",\n          \"value\": \":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\n          \"inline\": false\n        }\n      ]\n    }\n  ]\n}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\n  \"content\": \"\",\n  \"embeds\": [\n    {\n      \"title\": \":helmet_with_white_cross: Gatus\",\n      \"description\": \"An alert for **endpoint-name** has been resolved after passing successfully 5 time(s) in a row:\\n> description-2\",\n      \"color\": 3066993,\n      \"fields\": [\n        {\n          \"name\": \"Condition results\",\n          \"value\": \":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\n          \"inline\": false\n        }\n      ]\n    }\n  ]\n}",
+		},
+	}
+	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)
+			}
+			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")
+	}
+}
+
+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)
+			}
+		})
 	}
 }
--- a/alerting/provider/email/email.go
+++ b/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
+}
--- a/alerting/provider/email/email_test.go
+++ b/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)
+			}
+		})
+	}
+}
--- a/alerting/provider/googlechat/googlechat.go
+++ b/alerting/provider/googlechat/googlechat.go
@@ -0,0 +1,156 @@
+package googlechat
+
+import (
+	"bytes"
+	"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([]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
+	}
+	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, 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
+	}
+	return fmt.Sprintf(`{
+    "cards": [
+  {
+    "sections": [
+      {
+        "widgets": [
+          {
+            "keyValue": {
+              "topLabel": "%s [%s]",
+              "content": "%s",
+              "contentMultiline": "true",
+              "bottomLabel": "%s",
+              "icon": "BOOKMARK"
+            }
+          },
+          {
+            "keyValue": {
+              "topLabel": "Condition results",
+              "content": "%s",
+              "contentMultiline": "true",
+              "icon": "DESCRIPTION"
+            }
+          },
+          {
+            "buttons": [
+              {
+                "textButton": {
+                  "text": "URL",
+                  "onClick": {
+                    "openLink": {
+                      "url": "%s"
+                    }
+                  }
+                }
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+]
+}`, endpoint.Name, endpoint.Group, message, description, results, endpoint.URL)
+}
+
+// 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
+}
--- a/alerting/provider/googlechat/googlechat_test.go
+++ b/alerting/provider/googlechat/googlechat_test.go
@@ -0,0 +1,260 @@
+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
+		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: "{\n    \"cards\": [\n  {\n    \"sections\": [\n      {\n        \"widgets\": [\n          {\n            \"keyValue\": {\n              \"topLabel\": \"endpoint-name []\",\n              \"content\": \"\u003cfont color='#DD0000'\u003eAn alert has been triggered due to having failed 3 time(s) in a row\u003c/font\u003e\",\n              \"contentMultiline\": \"true\",\n              \"bottomLabel\": \":: description-1\",\n              \"icon\": \"BOOKMARK\"\n            }\n          },\n          {\n            \"keyValue\": {\n              \"topLabel\": \"Condition results\",\n              \"content\": \"❌   [CONNECTED] == true\u003cbr\u003e❌   [STATUS] == 200\u003cbr\u003e\",\n              \"contentMultiline\": \"true\",\n              \"icon\": \"DESCRIPTION\"\n            }\n          },\n          {\n            \"buttons\": [\n              {\n                \"textButton\": {\n                  \"text\": \"URL\",\n                  \"onClick\": {\n                    \"openLink\": {\n                      \"url\": \"\"\n                    }\n                  }\n                }\n              }\n            ]\n          }\n        ]\n      }\n    ]\n  }\n]\n}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\n    \"cards\": [\n  {\n    \"sections\": [\n      {\n        \"widgets\": [\n          {\n            \"keyValue\": {\n              \"topLabel\": \"endpoint-name []\",\n              \"content\": \"\u003cfont color='#36A64F'\u003eAn alert has been resolved after passing successfully 5 time(s) in a row\u003c/font\u003e\",\n              \"contentMultiline\": \"true\",\n              \"bottomLabel\": \":: description-2\",\n              \"icon\": \"BOOKMARK\"\n            }\n          },\n          {\n            \"keyValue\": {\n              \"topLabel\": \"Condition results\",\n              \"content\": \"✅   [CONNECTED] == true\u003cbr\u003e✅   [STATUS] == 200\u003cbr\u003e\",\n              \"contentMultiline\": \"true\",\n              \"icon\": \"DESCRIPTION\"\n            }\n          },\n          {\n            \"buttons\": [\n              {\n                \"textButton\": {\n                  \"text\": \"URL\",\n                  \"onClick\": {\n                    \"openLink\": {\n                      \"url\": \"\"\n                    }\n                  }\n                }\n              }\n            ]\n          }\n        ]\n      }\n    ]\n  }\n]\n}",
+		},
+	}
+	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,
+			)
+			b, _ := json.Marshal(body)
+			e, _ := json.Marshal(scenario.ExpectedBody)
+			if body != scenario.ExpectedBody {
+				t.Errorf("expected %s, got %s", e, b)
+			}
+			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")
+	}
+}
+
+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)
+			}
+		})
+	}
+}
--- a/alerting/provider/mattermost/mattermost.go
+++ b/alerting/provider/mattermost/mattermost.go
@@ -1,13 +1,14 @@
 package mattermost

 import (
+	"bytes"
 	"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 +16,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,18 +36,45 @@ 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
+	}
+	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, 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
@@ -54,14 +91,10 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
 		description = ":\\n> " + alertDescription
 	}
-	return &custom.AlertProvider{
-		URL:          provider.WebhookURL,
-		Method:       http.MethodPost,
-		ClientConfig: provider.ClientConfig,
-		Body: fmt.Sprintf(`{
+	return fmt.Sprintf(`{
  "text": "",
  "username": "gatus",
-  "icon_url": "https://raw.githubusercontent.com/TwiN/gatus/master/static/logo.png",
+  "icon_url": "https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png",
  "attachments": [
    {
      "title": ":rescue_worker_helmet: Gatus",
@@ -83,9 +116,19 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
      ]
    }
  ]
-}`, message, message, description, color, endpoint.URL, results),
-		Headers: map[string]string{"Content-Type": "application/json"},
+}`, message, message, description, color, endpoint.URL, results)
+}
+
+// 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
--- a/alerting/provider/mattermost/mattermost_test.go
+++ b/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: "{\n  \"text\": \"\",\n  \"username\": \"gatus\",\n  \"icon_url\": \"https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png\",\n  \"attachments\": [\n    {\n      \"title\": \":rescue_worker_helmet: Gatus\",\n      \"fallback\": \"Gatus - An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row\",\n      \"text\": \"An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row:\\n> description-1\",\n      \"short\": false,\n      \"color\": \"#DD0000\",\n      \"fields\": [\n        {\n          \"title\": \"URL\",\n          \"value\": \"\",\n          \"short\": false\n        },\n        {\n          \"title\": \"Condition results\",\n          \"value\": \":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\n          \"short\": false\n        }\n      ]\n    }\n  ]\n}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\n  \"text\": \"\",\n  \"username\": \"gatus\",\n  \"icon_url\": \"https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png\",\n  \"attachments\": [\n    {\n      \"title\": \":rescue_worker_helmet: Gatus\",\n      \"fallback\": \"Gatus - An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row\",\n      \"text\": \"An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row:\\n> description-2\",\n      \"short\": false,\n      \"color\": \"#36A64F\",\n      \"fields\": [\n        {\n          \"title\": \"URL\",\n          \"value\": \"\",\n          \"short\": false\n        },\n        {\n          \"title\": \"Condition results\",\n          \"value\": \":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\n          \"short\": false\n        }\n      ]\n    }\n  ]\n}",
+		},
+	}
+	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)
+			}
+			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")
+	}
+}
+
+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)
+			}
+		})
 	}
 }
--- a/alerting/provider/messagebird/messagebird.go
+++ b/alerting/provider/messagebird/messagebird.go
@@ -1,12 +1,14 @@
 package messagebird

 import (
+	"bytes"
 	"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 +22,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 +30,40 @@ 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([]byte(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
+	}
+	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())
+		message = fmt.Sprintf("TRIGGERED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
 	}
-	return &custom.AlertProvider{
-		URL:    restAPIURL,
-		Method: http.MethodPost,
-		Body: fmt.Sprintf(`{
+	return 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),
-		},
-	}
+}`, provider.Originator, provider.Recipients, message)
 }

 // GetDefaultAlert returns the provider's default alert configuration
--- a/alerting/provider/messagebird/messagebird_test.go
+++ b/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: "{\n  \"originator\": \"2\",\n  \"recipients\": \"3\",\n  \"body\": \"TRIGGERED: endpoint-name - description-1\"\n}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{AccessKey: "4", Originator: "5", Recipients: "6"},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\n  \"originator\": \"5\",\n  \"recipients\": \"6\",\n  \"body\": \"RESOLVED: endpoint-name - description-2\"\n}",
+		},
 	}
-	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 body != scenario.ExpectedBody {
+				t.Errorf("expected %s, got %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")
 	}
 }
--- a/alerting/provider/opsgenie/opsgenie.go
+++ b/alerting/provider/opsgenie/opsgenie.go
@@ -0,0 +1,240 @@
+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)
+	_, err := provider.sendRequest(restAPI, http.MethodPost, payload)
+	return err
+}
+
+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"
+	_, err := provider.sendRequest(url, http.MethodPost, payload)
+	return err
+}
+
+func (provider *AlertProvider) sendRequest(url, method string, payload interface{}) (*http.Response, error) {
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return nil, fmt.Errorf("fail to build alert payload: %v", payload)
+	}
+	request, err := http.NewRequest(method, url, bytes.NewBuffer(body))
+	if err != nil {
+		return nil, err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	request.Header.Set("Authorization", "GenieKey "+provider.APIKey)
+	res, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return nil, err
+	}
+	if res.StatusCode > 399 {
+		rBody, _ := io.ReadAll(res.Body)
+		return nil, fmt.Errorf("call to provider alert returned status code %d: %s", res.StatusCode, string(rBody))
+	}
+	return res, 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"`
+}
--- a/alerting/provider/opsgenie/opsgenie_test.go
+++ b/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)
+			}
+		})
+	}
+}
--- a/alerting/provider/pagerduty/pagerduty.go
+++ b/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,24 +49,56 @@ 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([]byte(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
+	}
+	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
+}
+
+// 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, 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(`{
+	return fmt.Sprintf(`{
  "routing_key": "%s",
  "dedup_key": "%s",
  "event_action": "%s",
@@ -71,11 +107,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
    "source": "%s",
    "severity": "critical"
  }
-}`, provider.getIntegrationKeyForGroup(endpoint.Group), resolveKey, eventAction, message, endpoint.Name),
-		Headers: map[string]string{
-			"Content-Type": "application/json",
-		},
-	}
+}`, provider.getIntegrationKeyForGroup(endpoint.Group), resolveKey, eventAction, message, endpoint.Name)
 }

 // getIntegrationKeyForGroup returns the appropriate pagerduty integration key for a given group
@@ -94,3 +126,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"`
+}
--- a/alerting/provider/pagerduty/pagerduty_test.go
+++ b/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: "{\n  \"routing_key\": \"00000000000000000000000000000000\",\n  \"dedup_key\": \"\",\n  \"event_action\": \"trigger\",\n  \"payload\": {\n    \"summary\": \"TRIGGERED:  - test\",\n    \"source\": \"\",\n    \"severity\": \"critical\"\n  }\n}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{IntegrationKey: "00000000000000000000000000000000"},
+			Alert:        alert.Alert{Description: &description, ResolveKey: "key"},
+			Resolved:     true,
+			ExpectedBody: "{\n  \"routing_key\": \"00000000000000000000000000000000\",\n  \"dedup_key\": \"key\",\n  \"event_action\": \"resolve\",\n  \"payload\": {\n    \"summary\": \"RESOLVED:  - test\",\n    \"source\": \"\",\n    \"severity\": \"critical\"\n  }\n}",
 		},
 	}
-	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{}, &scenario.Alert, &core.Result{}, scenario.Resolved)
+			if body != scenario.ExpectedBody {
+				t.Errorf("expected %s, got %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())
+			}
+		})
 	}
 }

@@ -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")
+	}
+}
--- a/alerting/provider/provider.go
+++ b/alerting/provider/provider.go
@@ -1,17 +1,20 @@
 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/mattermost"
+	"github.com/TwiN/gatus/v4/alerting/provider/messagebird"
+	"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 +22,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 +55,11 @@ var (
 	// Validate interface implementation on compile
 	_ AlertProvider = (*custom.AlertProvider)(nil)
 	_ AlertProvider = (*discord.AlertProvider)(nil)
+	_ AlertProvider = (*email.AlertProvider)(nil)
+	_ AlertProvider = (*googlechat.AlertProvider)(nil)
 	_ AlertProvider = (*mattermost.AlertProvider)(nil)
 	_ AlertProvider = (*messagebird.AlertProvider)(nil)
+	_ AlertProvider = (*opsgenie.AlertProvider)(nil)
 	_ AlertProvider = (*pagerduty.AlertProvider)(nil)
 	_ AlertProvider = (*slack.AlertProvider)(nil)
 	_ AlertProvider = (*teams.AlertProvider)(nil)
--- a/alerting/provider/provider_test.go
+++ b/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) {
--- a/alerting/provider/slack/slack.go
+++ b/alerting/provider/slack/slack.go
@@ -1,35 +1,72 @@
 package slack

 import (
+	"bytes"
 	"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([]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(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	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, 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 {
@@ -45,10 +82,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
 		description = ":\\n> " + alertDescription
 	}
-	return &custom.AlertProvider{
-		URL:    provider.WebhookURL,
-		Method: http.MethodPost,
-		Body: fmt.Sprintf(`{
+	return fmt.Sprintf(`{
  "text": "",
  "attachments": [
    {
@@ -65,9 +99,19 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
      ]
    }
  ]
-}`, message, description, color, results),
-		Headers: map[string]string{"Content-Type": "application/json"},
+}`, message, description, color, results)
+}
+
+// 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
--- a/alerting/provider/slack/slack_test.go
+++ b/alerting/provider/slack/slack_test.go
@@ -3,68 +3,274 @@ 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_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_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_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: "{\n  \"text\": \"\",\n  \"attachments\": [\n    {\n      \"title\": \":helmet_with_white_cross: Gatus\",\n      \"text\": \"An alert for *name* has been triggered due to having failed 3 time(s) in a row:\\n> description-1\",\n      \"short\": false,\n      \"color\": \"#DD0000\",\n      \"fields\": [\n        {\n          \"title\": \"Condition results\",\n          \"value\": \":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\n          \"short\": false\n        }\n      ]\n    }\n  ]\n}",
+		},
+		{
+			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: "{\n  \"text\": \"\",\n  \"attachments\": [\n    {\n      \"title\": \":helmet_with_white_cross: Gatus\",\n      \"text\": \"An alert for *group/name* has been triggered due to having failed 3 time(s) in a row:\\n> description-1\",\n      \"short\": false,\n      \"color\": \"#DD0000\",\n      \"fields\": [\n        {\n          \"title\": \"Condition results\",\n          \"value\": \":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\n          \"short\": false\n        }\n      ]\n    }\n  ]\n}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{},
+			Endpoint:     core.Endpoint{Name: "name"},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\n  \"text\": \"\",\n  \"attachments\": [\n    {\n      \"title\": \":helmet_with_white_cross: Gatus\",\n      \"text\": \"An alert for *name* has been resolved after passing successfully 5 time(s) in a row:\\n> description-2\",\n      \"short\": false,\n      \"color\": \"#36A64F\",\n      \"fields\": [\n        {\n          \"title\": \"Condition results\",\n          \"value\": \":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\n          \"short\": false\n        }\n      ]\n    }\n  ]\n}",
+		},
+		{
+			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: "{\n  \"text\": \"\",\n  \"attachments\": [\n    {\n      \"title\": \":helmet_with_white_cross: Gatus\",\n      \"text\": \"An alert for *group/name* has been resolved after passing successfully 5 time(s) in a row:\\n> description-2\",\n      \"short\": false,\n      \"color\": \"#36A64F\",\n      \"fields\": [\n        {\n          \"title\": \"Condition results\",\n          \"value\": \":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\n          \"short\": false\n        }\n      ]\n    }\n  ]\n}",
+		},
 	}
-	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) {
+			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 body != scenario.ExpectedBody {
+				t.Errorf("expected %s, got %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")
+	}
+}
+
+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)
+			}
+		})
 	}
 }
--- a/alerting/provider/teams/teams.go
+++ b/alerting/provider/teams/teams.go
@@ -1,12 +1,14 @@
 package teams

 import (
+	"bytes"
 	"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 +16,59 @@ 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([]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(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	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, 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
@@ -47,10 +85,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
 		description = ":\\n> " + alertDescription
 	}
-	return &custom.AlertProvider{
-		URL:    provider.WebhookURL,
-		Method: http.MethodPost,
-		Body: fmt.Sprintf(`{
+	return fmt.Sprintf(`{
  "@type": "MessageCard",
  "@context": "http://schema.org/extensions",
  "themeColor": "%s",
@@ -66,9 +101,19 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
      "text": "%s"
    }
  ]
-}`, color, message, description, endpoint.URL, results),
-		Headers: map[string]string{"Content-Type": "application/json"},
+}`, color, message, description, endpoint.URL, results)
+}
+
+// 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
--- a/alerting/provider/teams/teams_test.go
+++ b/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: "{\n  \"@type\": \"MessageCard\",\n  \"@context\": \"http://schema.org/extensions\",\n  \"themeColor\": \"#DD0000\",\n  \"title\": \"&#x1F6A8; Gatus\",\n  \"text\": \"An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row:\\n> description-1\",\n  \"sections\": [\n    {\n      \"activityTitle\": \"URL\",\n      \"text\": \"\"\n    },\n    {\n      \"activityTitle\": \"Condition results\",\n      \"text\": \"&#x274C; - `[CONNECTED] == true`<br/>&#x274C; - `[STATUS] == 200`<br/>\"\n    }\n  ]\n}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\n  \"@type\": \"MessageCard\",\n  \"@context\": \"http://schema.org/extensions\",\n  \"themeColor\": \"#36A64F\",\n  \"title\": \"&#x1F6A8; Gatus\",\n  \"text\": \"An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row:\\n> description-2\",\n  \"sections\": [\n    {\n      \"activityTitle\": \"URL\",\n      \"text\": \"\"\n    },\n    {\n      \"activityTitle\": \"Condition results\",\n      \"text\": \"&#x2705; - `[CONNECTED] == true`<br/>&#x2705; - `[STATUS] == 200`<br/>\"\n    }\n  ]\n}",
+		},
+	}
+	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)
+			}
+			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")
+	}
+}
+
+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)
+			}
+		})
 	}
 }
--- a/alerting/provider/telegram/telegram.go
+++ b/alerting/provider/telegram/telegram.go
@@ -1,21 +1,26 @@
 package telegram

 import (
+	"bytes"
 	"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"`

 	// 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
@@ -23,13 +28,36 @@ func (provider *AlertProvider) IsValid() bool {
 	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([]byte(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(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	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, 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
@@ -46,12 +74,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(endpoint *core.Endpoint, al
 	} 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"},
-	}
+	return fmt.Sprintf(`{"chat_id": "%s", "text": "%s", "parse_mode": "MARKDOWN"}`, provider.ID, text)
 }

 // GetDefaultAlert returns the provider's default alert configuration
--- a/alerting/provider/telegram/telegram_test.go
+++ b/alerting/provider/telegram/telegram_test.go
@@ -2,13 +2,13 @@ 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) {
@@ -22,70 +22,137 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }

-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_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, "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) {
+			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{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_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, "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())
+	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)
+			}
+			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_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")
+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())
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
 	}
 }
--- a/alerting/provider/twilio/twilio.go
+++ b/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,39 @@ 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
+	}
+	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
--- a/alerting/provider/twilio/twilio_test.go
+++ b/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")
 	}
 }
--- a/client/client.go
+++ b/client/client.go
@@ -14,8 +14,14 @@ import (
 	"github.com/go-ping/ping"
 )

+// injectedHTTPClient is used for testing purposes
+var injectedHTTPClient *http.Client
+
 // GetHTTPClient returns the shared HTTP client
 func GetHTTPClient(config *Config) *http.Client {
+	if injectedHTTPClient != nil {
+		return injectedHTTPClient
+	}
 	if config == nil {
 		return defaultConfig.getHTTPClient()
 	}
@@ -104,3 +110,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
+}
--- a/client/client_test.go
+++ b/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")
 	}
@@ -146,3 +161,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"))
+	}
+}
--- a/client/config.go
+++ b/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://1.1.1.1: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)
+}
--- a/client/config_test.go
+++ b/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)
+			}
+		})
+	}
+}
--- a/config.yaml
+++ b/config.yaml
@@ -31,7 +31,7 @@ endpoints:
      - "[STATUS] == 200"

  - name: example-dns-query
-    url: "8.8.8.8" # Address of the DNS server to use
+    url: "1.1.1.1" # Address of the DNS server to use
    interval: 5m
    dns:
      query-name: "example.com"
--- a/config/config.go
+++ b/config/config.go
@@ -2,20 +2,19 @@ package config

 import (
 	"errors"
-	"io/ioutil"
 	"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/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"
 	"gopkg.in/yaml.v2"
 )

@@ -142,7 +141,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)
 	}
@@ -274,8 +273,10 @@ func validateAlertingConfig(alertingConfig *alerting.Config, endpoints []*core.E
 	alertTypes := []alert.Type{
 		alert.TypeCustom,
 		alert.TypeDiscord,
+		alert.TypeEmail,
 		alert.TypeMattermost,
 		alert.TypeMessagebird,
+		alert.TypeOpsgenie,
 		alert.TypePagerDuty,
 		alert.TypeSlack,
 		alert.TypeTeams,
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -5,21 +5,22 @@ 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/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/ui"
+	"github.com/TwiN/gatus/v4/config/web"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/storage"
 )

 func TestLoadFileThatDoesNotExist(t *testing.T) {
@@ -44,14 +45,22 @@ func TestParseAndValidateConfigBytes(t *testing.T) {
 	}()
 	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
 storage:
-  file: %s
+  type: sqlite
+  path: %s
 maintenance:
  enabled: true
  start: 00:00
  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
@@ -83,8 +92,11 @@ endpoints:
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
 	}
-	if config.UI == nil || config.UI.Title != "Test" {
-		t.Error("Expected Config.UI.Title to be Test")
+	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 != "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")
@@ -1167,12 +1179,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
@@ -1197,8 +1209,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)
 	}
 }

--- a/config/maintenance/maintenance.go
+++ b/config/maintenance/maintenance.go
@@ -39,7 +39,6 @@ type Config struct {
 	Every []string `yaml:"every"`

 	durationToStartFromMidnight time.Duration
-	timeLocation                *time.Location
 }

 func GetDefaultConfig() *Config {
--- a/config/maintenance/maintenance_test.go
+++ b/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{
--- a/config/ui/ui.go
+++ b/config/ui/ui.go
@@ -2,31 +2,55 @@ package ui

 import (
 	"bytes"
+	"errors"
 	"html/template"
 )

 const (
-	defaultTitle = "Health Dashboard | Gatus"
-	defaultLogo  = ""
+	defaultTitle  = "Health Dashboard | Gatus"
+	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
+	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,
+		Header: defaultHeader,
+		Logo:   defaultLogo,
+		Link:   defaultLink,
 	}
 }

@@ -35,6 +59,18 @@ func (cfg *Config) ValidateAndSetDefaults() error {
 	if len(cfg.Title) == 0 {
 		cfg.Title = defaultTitle
 	}
+	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.ParseFiles(StaticFolder + "/index.html")
 	if err != nil {
 		return err
--- a/config/ui/ui_test.go
+++ b/config/ui/ui_test.go
@@ -1,6 +1,7 @@
 package ui

 import (
+	"strconv"
 	"testing"
 )

@@ -9,10 +10,60 @@ func TestConfig_ValidateAndSetDefaults(t *testing.T) {
 	defer func() {
 		StaticFolder = "./web/static"
 	}()
-	cfg := &Config{Title: ""}
+	cfg := &Config{
+		Title:  "",
+		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.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) {
--- a/controller/controller.go
+++ b/controller/controller.go
@@ -8,10 +8,10 @@ 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/ui"
+	"github.com/TwiN/gatus/v4/config/web"
+	"github.com/TwiN/gatus/v4/controller/handler"
+	"github.com/TwiN/gatus/v4/security"
 )

 var (
--- a/controller/controller_test.go
+++ b/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) {
@@ -34,7 +34,7 @@ func TestHandle(t *testing.T) {
 	defer os.Clearenv()
 	Handle(cfg.Security, cfg.Web, cfg.UI, cfg.Metrics)
 	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 {
--- a/controller/handler/badge.go
+++ b/controller/handler/badge.go
@@ -7,8 +7,9 @@ import (
 	"strings"
 	"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/TwiN/gatus/v4/storage/store/common/paging"
 	"github.com/gorilla/mux"
 )

@@ -21,6 +22,12 @@ const (
 	badgeColorHexVeryBad  = "#c7130a"
 )

+const (
+	HealthStatusUp      = "up"
+	HealthStatusDown    = "down"
+	HealthStatusUnknown = "?"
+)
+
 // UptimeBadge handles the automatic generation of badge based on the group name and endpoint name passed.
 //
 // Valid values for {duration}: 7d, 24h, 1h
@@ -43,20 +50,18 @@ 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))
 }

@@ -82,23 +87,52 @@ func ResponseTimeBadge(writer http.ResponseWriter, request *http.Request) {
 	averageResponseTime, err := store.Get().GetAverageResponseTimeByKey(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(generateResponseTimeBadgeSVG(duration, averageResponseTime))
 }

+// 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"]
+	pagingConfig := paging.NewEndpointStatusParams()
+	status, err := store.Get().GetEndpointStatusByKey(key, pagingConfig.WithResults(1, 1))
+	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
+	}
+	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.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 {
 	var labelWidth, valueWidth, valueWidthAdjustment int
 	switch duration {
@@ -227,3 +261,61 @@ func getBadgeColorFromResponseTime(responseTime int) string {
 	}
 	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
+}
--- a/controller/handler/badge_test.go
+++ b/controller/handler/badge_test.go
@@ -7,13 +7,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"
 )

-func TestUptimeBadge(t *testing.T) {
+func TestBadge(t *testing.T) {
 	defer store.Get().Clear()
 	defer cache.Clear()
 	cfg := &config.Config{
@@ -29,8 +29,8 @@ 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()})
+	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("../../web/static", cfg.Security, nil, cfg.Metrics)
 	type Scenario struct {
 		Name         string
@@ -89,25 +89,30 @@ 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",
-			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,
-		},
 	}
 	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")
 			}
@@ -229,3 +234,30 @@ func TestGetBadgeColorFromResponseTime(t *testing.T) {
 		})
 	}
 }
+
+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))
+			}
+		})
+	}
+}
--- a/controller/handler/chart.go
+++ b/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
--- a/controller/handler/chart_test.go
+++ b/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) {
@@ -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")
 			}
--- a/controller/handler/config.go
+++ b/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)))
+}
--- a/controller/handler/config_test.go
+++ b/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())
+	}
+}
--- a/controller/handler/cors.go
+++ b/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)
 	})
 }
--- a/controller/handler/endpoint_status.go
+++ b/controller/handler/endpoint_status.go
@@ -10,10 +10,10 @@ import (
 	"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/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"
 )

--- a/controller/handler/endpoint_status_test.go
+++ b/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,
@@ -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")
 			}
@@ -175,43 +166,37 @@ func TestEndpointStatuses(t *testing.T) {
 			Name:         "no-pagination",
 			Path:         "/api/v1/endpoints/statuses",
 			ExpectedCode: http.StatusOK,
-			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"errors":null,"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"}],"events":[]}]`,
+			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"}]}]`,
 		},
 		{
 			Name:         "pagination-first-result",
 			Path:         "/api/v1/endpoints/statuses?page=1&pageSize=1",
 			ExpectedCode: http.StatusOK,
-			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"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"}],"events":[]}]`,
+			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"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"}]}]`,
 		},
 		{
 			Name:         "pagination-second-result",
 			Path:         "/api/v1/endpoints/statuses?page=2&pageSize=1",
 			ExpectedCode: http.StatusOK,
-			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"errors":null,"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"}],"events":[]}]`,
+			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"}]}]`,
 		},
 		{
 			Name:         "pagination-no-results",
 			Path:         "/api/v1/endpoints/statuses?page=5&pageSize=20",
 			ExpectedCode: http.StatusOK,
-			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[],"events":[]}]`,
+			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[]}]`,
 		},
 		{
 			Name:         "invalid-pagination-should-fall-back-to-default",
 			Path:         "/api/v1/endpoints/statuses?page=INVALID&pageSize=INVALID",
 			ExpectedCode: http.StatusOK,
-			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"errors":null,"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"}],"events":[]}]`,
-		},
-		{ // 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,"errors":null,"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"}],"events":[]}]`,
+			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 {
--- a/controller/handler/favicon_test.go
+++ b/controller/handler/favicon_test.go
@@ -22,7 +22,7 @@ func TestFavIcon(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)
 			responseRecorder := httptest.NewRecorder()
 			router.ServeHTTP(responseRecorder, request)
 			if responseRecorder.Code != scenario.ExpectedCode {
--- a/controller/handler/gzip.go
+++ b/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)
 	},
 }

--- a/controller/handler/handler.go
+++ b/controller/handler/handler.go
@@ -3,8 +3,8 @@ package handler
 import (
 	"net/http"

-	"github.com/TwiN/gatus/v3/config/ui"
-	"github.com/TwiN/gatus/v3/security"
+	"github.com/TwiN/gatus/v4/config/ui"
+	"github.com/TwiN/gatus/v4/security"
 	"github.com/TwiN/health"
 	"github.com/gorilla/mux"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
@@ -15,33 +15,32 @@ func CreateRouter(staticFolder string, securityConfig *security.Config, uiConfig
 	if enabledMetrics {
 		router.Handle("/metrics", promhttp.Handler()).Methods("GET")
 	}
+	api := router.PathPrefix("/api").Subrouter()
+	protected := api.PathPrefix("/").Subrouter()
+	unprotected := api.PathPrefix("/").Subrouter()
+	if securityConfig != nil {
+		if err := securityConfig.RegisterHandlers(router); err != nil {
+			panic(err)
+		}
+		if err := securityConfig.ApplySecurityMiddleware(protected); err != nil {
+			panic(err)
+		}
+	}
+	// Endpoints
+	unprotected.Handle("/v1/config", ConfigHandler{securityConfig: securityConfig}).Methods("GET")
+	protected.HandleFunc("/v1/endpoints/statuses", EndpointStatuses).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).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")
 	router.HandleFunc("/favicon.ico", FavIcon(staticFolder)).Methods("GET")
-	// 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
 	// 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")
 	// Everything else falls back on static content
 	router.PathPrefix("/").Handler(GzipHandler(http.FileServer(http.Dir(staticFolder))))
 	return router
 }
-
-func secureIfNecessary(securityConfig *security.Config, handler http.HandlerFunc) http.HandlerFunc {
-	if securityConfig != nil && securityConfig.IsValid() {
-		return security.Handler(handler, securityConfig)
-	}
-	return handler
-}
--- a/controller/handler/handler_test.go
+++ b/controller/handler/handler_test.go
@@ -44,7 +44,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")
 			}
--- a/controller/handler/spa.go
+++ b/controller/handler/spa.go
@@ -5,7 +5,7 @@ import (
 	"log"
 	"net/http"

-	"github.com/TwiN/gatus/v3/config/ui"
+	"github.com/TwiN/gatus/v4/config/ui"
 )

 func SinglePageApplication(staticFolder string, ui *ui.Config) http.HandlerFunc {
--- a/controller/handler/spa_test.go
+++ b/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) {
@@ -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")
 			}
--- a/controller/handler/util.go
+++ b/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 (
--- a/controller/handler/util_test.go
+++ b/controller/handler/util_test.go
@@ -54,7 +54,7 @@ func TestExtractPageAndPageSizeFromRequest(t *testing.T) {
 	}
 	for _, scenario := range scenarios {
 		t.Run("page-"+scenario.Page+"-pageSize-"+scenario.PageSize, func(t *testing.T) {
-			request, _ := http.NewRequest("GET", fmt.Sprintf("/api/v1/statuses?page=%s&pageSize=%s", scenario.Page, scenario.PageSize), nil)
+			request, _ := http.NewRequest("GET", fmt.Sprintf("/api/v1/statuses?page=%s&pageSize=%s", scenario.Page, scenario.PageSize), http.NoBody)
 			actualPage, actualPageSize := extractPageAndPageSizeFromRequest(request)
 			if actualPage != scenario.ExpectedPage {
 				t.Errorf("expected %d, got %d", scenario.ExpectedPage, actualPage)
--- a/core/condition.go
+++ b/core/condition.go
@@ -6,8 +6,8 @@ import (
 	"strings"
 	"time"

-	"github.com/TwiN/gatus/v3/jsonpath"
-	"github.com/TwiN/gatus/v3/pattern"
+	"github.com/TwiN/gatus/v4/jsonpath"
+	"github.com/TwiN/gatus/v4/pattern"
 )

 const (
@@ -80,7 +80,7 @@ const (
 	maximumLengthBeforeTruncatingWhenComparedWithPattern = 25
 )

-// Condition is a condition that needs to be met in order for a Endpoint to be considered healthy.
+// Condition is a condition that needs to be met in order for an Endpoint to be considered healthy.
 type Condition string

 // evaluate the Condition with the Result of the health check
@@ -283,7 +283,7 @@ func prettifyNumericalParameters(parameters []string, resolvedParameters []int64
 	return prettify(parameters, []string{strconv.Itoa(int(resolvedParameters[0])), strconv.Itoa(int(resolvedParameters[1]))}, operator)
 }

-// XXX: make this configurable? i.e. show-resolved-conditions-on-failure
+// prettify returns a string representation of a condition with its parameters resolved between parentheses
 func prettify(parameters []string, resolvedParameters []string, operator string) string {
 	// Since, in the event of an invalid path, the resolvedParameters also contain the condition itself,
 	// we'll return the resolvedParameters as-is.
--- a/core/dns_test.go
+++ b/core/dns_test.go
@@ -2,8 +2,9 @@ package core

 import (
 	"testing"
+	"time"

-	"github.com/TwiN/gatus/v3/pattern"
+	"github.com/TwiN/gatus/v4/pattern"
 )

 func TestIntegrationQuery(t *testing.T) {
@@ -21,7 +22,7 @@ func TestIntegrationQuery(t *testing.T) {
 				QueryType: "A",
 				QueryName: "example.com.",
 			},
-			inputURL:        "8.8.8.8",
+			inputURL:        "1.1.1.1",
 			expectedDNSCode: "NOERROR",
 			expectedBody:    "93.184.216.34",
 		},
@@ -31,7 +32,7 @@ func TestIntegrationQuery(t *testing.T) {
 				QueryType: "AAAA",
 				QueryName: "example.com.",
 			},
-			inputURL:        "8.8.8.8",
+			inputURL:        "1.1.1.1",
 			expectedDNSCode: "NOERROR",
 			expectedBody:    "2606:2800:220:1:248:1893:25c8:1946",
 		},
@@ -39,11 +40,11 @@ func TestIntegrationQuery(t *testing.T) {
 			name: "test DNS with type CNAME",
 			inputDNS: DNS{
 				QueryType: "CNAME",
-				QueryName: "doc.google.com.",
+				QueryName: "en.wikipedia.org.",
 			},
-			inputURL:        "8.8.8.8",
+			inputURL:        "1.1.1.1",
 			expectedDNSCode: "NOERROR",
-			expectedBody:    "writely.l.google.com.",
+			expectedBody:    "dyna.wikimedia.org.",
 		},
 		{
 			name: "test DNS with type MX",
@@ -51,7 +52,7 @@ func TestIntegrationQuery(t *testing.T) {
 				QueryType: "MX",
 				QueryName: "example.com.",
 			},
-			inputURL:        "8.8.8.8",
+			inputURL:        "1.1.1.1",
 			expectedDNSCode: "NOERROR",
 			expectedBody:    ".",
 		},
@@ -61,7 +62,7 @@ func TestIntegrationQuery(t *testing.T) {
 				QueryType: "NS",
 				QueryName: "example.com.",
 			},
-			inputURL:        "8.8.8.8",
+			inputURL:        "1.1.1.1",
 			expectedDNSCode: "NOERROR",
 			expectedBody:    "*.iana-servers.net.",
 		},
@@ -69,15 +70,14 @@ func TestIntegrationQuery(t *testing.T) {
 			name: "test DNS with fake type and retrieve error",
 			inputDNS: DNS{
 				QueryType: "B",
-				QueryName: "google",
+				QueryName: "example",
 			},
-			inputURL:      "8.8.8.8",
+			inputURL:      "1.1.1.1",
 			isErrExpected: true,
 		},
 	}

 	for _, test := range tests {
-		test := test
 		t.Run(test.name, func(t *testing.T) {
 			dns := test.inputDNS
 			result := &Result{}
@@ -86,9 +86,8 @@ func TestIntegrationQuery(t *testing.T) {
 				t.Errorf("there should be errors")
 			}
 			if result.DNSRCode != test.expectedDNSCode {
-				t.Errorf("DNSRCodePlaceholder '%s' should have been %s", result.DNSRCode, test.expectedDNSCode)
+				t.Errorf("expected DNSRCode to be %s, got %s", test.expectedDNSCode, result.DNSRCode)
 			}
-
 			if test.inputDNS.QueryType == "NS" {
 				// Because there are often multiple nameservers backing a single domain, we'll only look at the suffix
 				if !pattern.Match(test.expectedBody, string(result.body)) {
@@ -100,6 +99,7 @@ func TestIntegrationQuery(t *testing.T) {
 				}
 			}
 		})
+		time.Sleep(5 * time.Millisecond)
 	}
 }

--- a/core/endpoint.go
+++ b/core/endpoint.go
@@ -5,19 +5,21 @@ import (
 	"crypto/x509"
 	"encoding/json"
 	"errors"
-	"io/ioutil"
+	"io"
 	"net"
 	"net/http"
 	"net/url"
 	"strings"
 	"time"

-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core/ui"
-	"github.com/TwiN/gatus/v3/util"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core/ui"
+	"github.com/TwiN/gatus/v4/util"
 )

+type EndpointType string
+
 const (
 	// HostHeader is the name of the header used to specify the host
 	HostHeader = "Host"
@@ -30,6 +32,14 @@ const (

 	// GatusUserAgent is the default user agent that Gatus uses to send requests.
 	GatusUserAgent = "Gatus/1.0"
+
+	// EndpointType enum for the endpoint type.
+	EndpointTypeDNS      EndpointType = "DNS"
+	EndpointTypeTCP      EndpointType = "TCP"
+	EndpointTypeICMP     EndpointType = "ICMP"
+	EndpointTypeSTARTTLS EndpointType = "STARTTLS"
+	EndpointTypeTLS      EndpointType = "TLS"
+	EndpointTypeHTTP     EndpointType = "HTTP"
 )

 var (
@@ -41,6 +51,9 @@ var (

 	// ErrEndpointWithNoName is the error with which Gatus will panic if an endpoint is configured with no name
 	ErrEndpointWithNoName = errors.New("you must specify a name for each endpoint")
+
+	// ErrEndpointWithInvalidNameOrGroup is the error with which Gatus will panic if an endpoint has an invalid character where it shouldn't
+	ErrEndpointWithInvalidNameOrGroup = errors.New("endpoint name and group must not have \" or \\")
 )

 // Endpoint is the configuration of a monitored
@@ -76,7 +89,7 @@ type Endpoint struct {
 	Interval time.Duration `yaml:"interval,omitempty"`

 	// Conditions used to determine the health of the endpoint
-	Conditions []*Condition `yaml:"conditions"`
+	Conditions []Condition `yaml:"conditions"`

 	// Alerts is the alerting configuration for the endpoint in case of failure
 	Alerts []*alert.Alert `yaml:"alerts,omitempty"`
@@ -102,13 +115,33 @@ func (endpoint Endpoint) IsEnabled() bool {
 	return *endpoint.Enabled
 }

+// Type returns the endpoint type
+func (endpoint Endpoint) Type() EndpointType {
+	switch {
+	case endpoint.DNS != nil:
+		return EndpointTypeDNS
+	case strings.HasPrefix(endpoint.URL, "tcp://"):
+		return EndpointTypeTCP
+	case strings.HasPrefix(endpoint.URL, "icmp://"):
+		return EndpointTypeICMP
+	case strings.HasPrefix(endpoint.URL, "starttls://"):
+		return EndpointTypeSTARTTLS
+	case strings.HasPrefix(endpoint.URL, "tls://"):
+		return EndpointTypeTLS
+	default:
+		return EndpointTypeHTTP
+	}
+}
+
 // ValidateAndSetDefaults validates the endpoint's configuration and sets the default value of fields that have one
 func (endpoint *Endpoint) ValidateAndSetDefaults() error {
 	// Set default values
 	if endpoint.ClientConfig == nil {
 		endpoint.ClientConfig = client.GetDefaultConfig()
 	} else {
-		endpoint.ClientConfig.ValidateAndSetDefaults()
+		if err := endpoint.ClientConfig.ValidateAndSetDefaults(); err != nil {
+			return err
+		}
 	}
 	if endpoint.UIConfig == nil {
 		endpoint.UIConfig = ui.GetDefaultConfig()
@@ -132,16 +165,16 @@ func (endpoint *Endpoint) ValidateAndSetDefaults() error {
 		endpoint.Headers[ContentTypeHeader] = "application/json"
 	}
 	for _, endpointAlert := range endpoint.Alerts {
-		if endpointAlert.FailureThreshold <= 0 {
-			endpointAlert.FailureThreshold = 3
-		}
-		if endpointAlert.SuccessThreshold <= 0 {
-			endpointAlert.SuccessThreshold = 2
+		if err := endpointAlert.ValidateAndSetDefaults(); err != nil {
+			return err
 		}
 	}
 	if len(endpoint.Name) == 0 {
 		return ErrEndpointWithNoName
 	}
+	if strings.ContainsAny(endpoint.Name, "\"\\") || strings.ContainsAny(endpoint.Group, "\"\\") {
+		return ErrEndpointWithInvalidNameOrGroup
+	}
 	if len(endpoint.URL) == 0 {
 		return ErrEndpointWithNoURL
 	}
@@ -159,6 +192,14 @@ func (endpoint *Endpoint) ValidateAndSetDefaults() error {
 	return nil
 }

+// DisplayName returns an identifier made up of the Name and, if not empty, the Group.
+func (endpoint Endpoint) DisplayName() string {
+	if len(endpoint.Group) > 0 {
+		return endpoint.Group + "/" + endpoint.Name
+	}
+	return endpoint.Name
+}
+
 // Key returns the unique key for the Endpoint
 func (endpoint Endpoint) Key() string {
 	return util.ConvertGroupAndEndpointNameToKey(endpoint.Group, endpoint.Name)
@@ -183,7 +224,15 @@ func (endpoint *Endpoint) EvaluateHealth() *Result {
 	// No need to keep the body after the endpoint has been evaluated
 	result.body = nil
 	// Clean up parameters that we don't need to keep in the results
+	if endpoint.UIConfig.HideURL {
+		for errIdx, errorString := range result.Errors {
+			result.Errors[errIdx] = strings.ReplaceAll(errorString, endpoint.URL, "<redacted>")
+		}
+	}
 	if endpoint.UIConfig.HideHostname {
+		for errIdx, errorString := range result.Errors {
+			result.Errors[errIdx] = strings.ReplaceAll(errorString, result.Hostname, "<redacted>")
+		}
 		result.Hostname = ""
 	}
 	return result
@@ -213,21 +262,16 @@ func (endpoint *Endpoint) call(result *Result) {
 	var response *http.Response
 	var err error
 	var certificate *x509.Certificate
-	isTypeDNS := endpoint.DNS != nil
-	isTypeTCP := strings.HasPrefix(endpoint.URL, "tcp://")
-	isTypeICMP := strings.HasPrefix(endpoint.URL, "icmp://")
-	isTypeSTARTTLS := strings.HasPrefix(endpoint.URL, "starttls://")
-	isTypeTLS := strings.HasPrefix(endpoint.URL, "tls://")
-	isTypeHTTP := !isTypeDNS && !isTypeTCP && !isTypeICMP && !isTypeSTARTTLS && !isTypeTLS
-	if isTypeHTTP {
+	endpointType := endpoint.Type()
+	if endpointType == EndpointTypeHTTP {
 		request = endpoint.buildHTTPRequest()
 	}
 	startTime := time.Now()
-	if isTypeDNS {
+	if endpointType == EndpointTypeDNS {
 		endpoint.DNS.query(endpoint.URL, result)
 		result.Duration = time.Since(startTime)
-	} else if isTypeSTARTTLS || isTypeTLS {
-		if isTypeSTARTTLS {
+	} else if endpointType == EndpointTypeSTARTTLS || endpointType == EndpointTypeTLS {
+		if endpointType == EndpointTypeSTARTTLS {
 			result.Connected, certificate, err = client.CanPerformStartTLS(strings.TrimPrefix(endpoint.URL, "starttls://"), endpoint.ClientConfig)
 		} else {
 			result.Connected, certificate, err = client.CanPerformTLS(strings.TrimPrefix(endpoint.URL, "tls://"), endpoint.ClientConfig)
@@ -238,10 +282,10 @@ func (endpoint *Endpoint) call(result *Result) {
 		}
 		result.Duration = time.Since(startTime)
 		result.CertificateExpiration = time.Until(certificate.NotAfter)
-	} else if isTypeTCP {
+	} else if endpointType == EndpointTypeTCP {
 		result.Connected = client.CanCreateTCPConnection(strings.TrimPrefix(endpoint.URL, "tcp://"), endpoint.ClientConfig)
 		result.Duration = time.Since(startTime)
-	} else if isTypeICMP {
+	} else if endpointType == EndpointTypeICMP {
 		result.Connected, result.Duration = client.Ping(strings.TrimPrefix(endpoint.URL, "icmp://"), endpoint.ClientConfig)
 	} else {
 		response, err = client.GetHTTPClient(endpoint.ClientConfig).Do(request)
@@ -259,7 +303,7 @@ func (endpoint *Endpoint) call(result *Result) {
 		result.Connected = response.StatusCode > 0
 		// Only read the body if there's a condition that uses the BodyPlaceholder
 		if endpoint.needsToReadBody() {
-			result.body, err = ioutil.ReadAll(response.Body)
+			result.body, err = io.ReadAll(response.Body)
 			if err != nil {
 				result.AddError(err.Error())
 			}
--- a/core/endpoint_status.go
+++ b/core/endpoint_status.go
@@ -1,6 +1,6 @@
 package core

-import "github.com/TwiN/gatus/v3/util"
+import "github.com/TwiN/gatus/v4/util"

 // EndpointStatus contains the evaluation Results of an Endpoint
 type EndpointStatus struct {
@@ -17,7 +17,7 @@ type EndpointStatus struct {
 	Results []*Result `json:"results"`

 	// Events is a list of events
-	Events []*Event `json:"events"`
+	Events []*Event `json:"events,omitempty"`

 	// Uptime information on the endpoint's uptime
 	//
--- a/core/endpoint_test.go
+++ b/core/endpoint_test.go
@@ -1,13 +1,14 @@
 package core

 import (
-	"io/ioutil"
+	"io"
 	"strings"
 	"testing"
 	"time"

-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core/ui"
 )

 func TestEndpoint_IsEnabled(t *testing.T) {
@@ -22,12 +23,67 @@ func TestEndpoint_IsEnabled(t *testing.T) {
 	}
 }

+func TestEndpoint_Type(t *testing.T) {
+	type fields struct {
+		URL string
+		DNS *DNS
+	}
+	tests := []struct {
+		fields fields
+		want   EndpointType
+	}{{
+		fields: fields{
+			URL: "1.1.1.1",
+			DNS: &DNS{
+				QueryType: "A",
+				QueryName: "example.com",
+			},
+		},
+		want: EndpointTypeDNS,
+	}, {
+		fields: fields{
+			URL: "tcp://127.0.0.1:6379",
+		},
+		want: EndpointTypeTCP,
+	}, {
+		fields: fields{
+			URL: "icmp://example.com",
+		},
+		want: EndpointTypeICMP,
+	}, {
+		fields: fields{
+			URL: "starttls://smtp.gmail.com:587",
+		},
+		want: EndpointTypeSTARTTLS,
+	}, {
+		fields: fields{
+			URL: "tls://example.com:443",
+		},
+		want: EndpointTypeTLS,
+	}, {
+		fields: fields{
+			URL: "https://twin.sh/health",
+		},
+		want: EndpointTypeHTTP,
+	}}
+	for _, tt := range tests {
+		t.Run(string(tt.want), func(t *testing.T) {
+			endpoint := Endpoint{
+				URL: tt.fields.URL,
+				DNS: tt.fields.DNS,
+			}
+			if got := endpoint.Type(); got != tt.want {
+				t.Errorf("Endpoint.Type() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
 func TestEndpoint_ValidateAndSetDefaults(t *testing.T) {
-	condition := Condition("[STATUS] == 200")
 	endpoint := Endpoint{
 		Name:       "website-health",
 		URL:        "https://twin.sh/health",
-		Conditions: []*Condition{&condition},
+		Conditions: []Condition{Condition("[STATUS] == 200")},
 		Alerts:     []*alert.Alert{{Type: alert.TypePagerDuty}},
 	}
 	endpoint.ValidateAndSetDefaults()
@@ -72,7 +128,7 @@ func TestEndpoint_ValidateAndSetDefaultsWithClientConfig(t *testing.T) {
 	endpoint := Endpoint{
 		Name:       "website-health",
 		URL:        "https://twin.sh/health",
-		Conditions: []*Condition{&condition},
+		Conditions: []Condition{condition},
 		ClientConfig: &client.Config{
 			Insecure:       true,
 			IgnoreRedirect: true,
@@ -101,7 +157,7 @@ func TestEndpoint_ValidateAndSetDefaultsWithNoName(t *testing.T) {
 	endpoint := &Endpoint{
 		Name:       "",
 		URL:        "http://example.com",
-		Conditions: []*Condition{&condition},
+		Conditions: []Condition{condition},
 	}
 	err := endpoint.ValidateAndSetDefaults()
 	if err == nil {
@@ -115,7 +171,7 @@ func TestEndpoint_ValidateAndSetDefaultsWithNoUrl(t *testing.T) {
 	endpoint := &Endpoint{
 		Name:       "example",
 		URL:        "",
-		Conditions: []*Condition{&condition},
+		Conditions: []Condition{condition},
 	}
 	err := endpoint.ValidateAndSetDefaults()
 	if err == nil {
@@ -137,7 +193,6 @@ func TestEndpoint_ValidateAndSetDefaultsWithNoConditions(t *testing.T) {
 }

 func TestEndpoint_ValidateAndSetDefaultsWithDNS(t *testing.T) {
-	conditionSuccess := Condition("[DNS_RCODE] == NOERROR")
 	endpoint := &Endpoint{
 		Name: "dns-test",
 		URL:  "http://example.com",
@@ -145,7 +200,7 @@ func TestEndpoint_ValidateAndSetDefaultsWithDNS(t *testing.T) {
 			QueryType: "A",
 			QueryName: "example.com",
 		},
-		Conditions: []*Condition{&conditionSuccess},
+		Conditions: []Condition{Condition("[DNS_RCODE] == NOERROR")},
 	}
 	err := endpoint.ValidateAndSetDefaults()
 	if err != nil {
@@ -161,7 +216,7 @@ func TestEndpoint_buildHTTPRequest(t *testing.T) {
 	endpoint := Endpoint{
 		Name:       "website-health",
 		URL:        "https://twin.sh/health",
-		Conditions: []*Condition{&condition},
+		Conditions: []Condition{condition},
 	}
 	endpoint.ValidateAndSetDefaults()
 	request := endpoint.buildHTTPRequest()
@@ -181,7 +236,7 @@ func TestEndpoint_buildHTTPRequestWithCustomUserAgent(t *testing.T) {
 	endpoint := Endpoint{
 		Name:       "website-health",
 		URL:        "https://twin.sh/health",
-		Conditions: []*Condition{&condition},
+		Conditions: []Condition{condition},
 		Headers: map[string]string{
 			"User-Agent": "Test/2.0",
 		},
@@ -205,7 +260,7 @@ func TestEndpoint_buildHTTPRequestWithHostHeader(t *testing.T) {
 		Name:       "website-health",
 		URL:        "https://twin.sh/health",
 		Method:     "POST",
-		Conditions: []*Condition{&condition},
+		Conditions: []Condition{condition},
 		Headers: map[string]string{
 			"Host": "example.com",
 		},
@@ -226,7 +281,7 @@ func TestEndpoint_buildHTTPRequestWithGraphQLEnabled(t *testing.T) {
 		Name:       "website-graphql",
 		URL:        "https://twin.sh/graphql",
 		Method:     "POST",
-		Conditions: []*Condition{&condition},
+		Conditions: []Condition{condition},
 		GraphQL:    true,
 		Body: `{
  users(gender: "female") {
@@ -245,7 +300,7 @@ func TestEndpoint_buildHTTPRequestWithGraphQLEnabled(t *testing.T) {
 	if contentType := request.Header.Get(ContentTypeHeader); contentType != "application/json" {
 		t.Error("request.Header.Content-Type should've been application/json, but was", contentType)
 	}
-	body, _ := ioutil.ReadAll(request.Body)
+	body, _ := io.ReadAll(request.Body)
 	if !strings.HasPrefix(string(body), "{\"query\":") {
 		t.Error("request.body should've started with '{\"query\":', but it didn't:", string(body))
 	}
@@ -257,7 +312,7 @@ func TestIntegrationEvaluateHealth(t *testing.T) {
 	endpoint := Endpoint{
 		Name:       "website-health",
 		URL:        "https://twin.sh/health",
-		Conditions: []*Condition{&condition, &bodyCondition},
+		Conditions: []Condition{condition, bodyCondition},
 	}
 	endpoint.ValidateAndSetDefaults()
 	result := endpoint.EvaluateHealth()
@@ -270,6 +325,9 @@ func TestIntegrationEvaluateHealth(t *testing.T) {
 	if !result.Success {
 		t.Error("Because all conditions passed, this should have been a success")
 	}
+	if result.Hostname != "twin.sh" {
+		t.Error("result.Hostname should've been twin.sh, but was", result.Hostname)
+	}
 }

 func TestIntegrationEvaluateHealthWithFailure(t *testing.T) {
@@ -277,7 +335,7 @@ func TestIntegrationEvaluateHealthWithFailure(t *testing.T) {
 	endpoint := Endpoint{
 		Name:       "website-health",
 		URL:        "https://twin.sh/health",
-		Conditions: []*Condition{&condition},
+		Conditions: []Condition{condition},
 	}
 	endpoint.ValidateAndSetDefaults()
 	result := endpoint.EvaluateHealth()
@@ -288,7 +346,78 @@ func TestIntegrationEvaluateHealthWithFailure(t *testing.T) {
 		t.Error("Because the connection has been established, result.Connected should've been true")
 	}
 	if result.Success {
-		t.Error("Because one of the conditions failed, success should have been false")
+		t.Error("Because one of the conditions failed, result.Success should have been false")
+	}
+}
+
+func TestIntegrationEvaluateHealthWithInvalidCondition(t *testing.T) {
+	condition := Condition("[STATUS] invalid 200")
+	endpoint := Endpoint{
+		Name:       "invalid-condition",
+		URL:        "https://twin.sh/health",
+		Conditions: []Condition{condition},
+	}
+	if err := endpoint.ValidateAndSetDefaults(); err != nil {
+		// XXX: Should this really not return an error? After all, the condition is not valid and conditions are part of the endpoint...
+		t.Error("endpoint validation should've been successful, but wasn't")
+	}
+	result := endpoint.EvaluateHealth()
+	if result.Success {
+		t.Error("Because one of the conditions was invalid, result.Success should have been false")
+	}
+	if len(result.Errors) == 0 {
+		t.Error("There should've been an error")
+	}
+}
+
+func TestIntegrationEvaluateHealthWithError(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	endpoint := Endpoint{
+		Name:       "invalid-host",
+		URL:        "http://invalid/health",
+		Conditions: []Condition{condition},
+		UIConfig: &ui.Config{
+			HideHostname: true,
+		},
+	}
+	endpoint.ValidateAndSetDefaults()
+	result := endpoint.EvaluateHealth()
+	if result.Success {
+		t.Error("Because one of the conditions was invalid, result.Success should have been false")
+	}
+	if len(result.Errors) == 0 {
+		t.Error("There should've been an error")
+	}
+	if !strings.Contains(result.Errors[0], "<redacted>") {
+		t.Error("result.Errors[0] should've had the hostname redacted because ui.hide-hostname is set to true")
+	}
+	if result.Hostname != "" {
+		t.Error("result.Hostname should've been empty because ui.hide-hostname is set to true")
+	}
+}
+
+func TestIntegrationEvaluateHealthWithErrorAndHideURL(t *testing.T) {
+	endpoint := Endpoint{
+		Name:       "invalid-url",
+		URL:        "https://httpstat.us/200?sleep=100",
+		Conditions: []Condition{Condition("[STATUS] == 200")},
+		ClientConfig: &client.Config{
+			Timeout: 1 * time.Millisecond,
+		},
+		UIConfig: &ui.Config{
+			HideURL: true,
+		},
+	}
+	endpoint.ValidateAndSetDefaults()
+	result := endpoint.EvaluateHealth()
+	if result.Success {
+		t.Error("Because one of the conditions was invalid, result.Success should have been false")
+	}
+	if len(result.Errors) == 0 {
+		t.Error("There should've been an error")
+	}
+	if !strings.Contains(result.Errors[0], "<redacted>") || strings.Contains(result.Errors[0], endpoint.URL) {
+		t.Error("result.Errors[0] should've had the URL redacted because ui.hide-url is set to true")
 	}
 }

@@ -297,12 +426,12 @@ func TestIntegrationEvaluateHealthForDNS(t *testing.T) {
 	conditionBody := Condition("[BODY] == 93.184.216.34")
 	endpoint := Endpoint{
 		Name: "example",
-		URL:  "8.8.8.8",
+		URL:  "1.1.1.1",
 		DNS: &DNS{
 			QueryType: "A",
 			QueryName: "example.com.",
 		},
-		Conditions: []*Condition{&conditionSuccess, &conditionBody},
+		Conditions: []Condition{conditionSuccess, conditionBody},
 	}
 	endpoint.ValidateAndSetDefaults()
 	result := endpoint.EvaluateHealth()
@@ -322,7 +451,7 @@ func TestIntegrationEvaluateHealthForICMP(t *testing.T) {
 	endpoint := Endpoint{
 		Name:       "icmp-test",
 		URL:        "icmp://127.0.0.1",
-		Conditions: []*Condition{&conditionSuccess},
+		Conditions: []Condition{conditionSuccess},
 	}
 	endpoint.ValidateAndSetDefaults()
 	result := endpoint.EvaluateHealth()
@@ -342,7 +471,7 @@ func TestEndpoint_getIP(t *testing.T) {
 	endpoint := Endpoint{
 		Name:       "invalid-url-test",
 		URL:        "",
-		Conditions: []*Condition{&conditionSuccess},
+		Conditions: []Condition{conditionSuccess},
 	}
 	result := &Result{}
 	endpoint.getIP(result)
@@ -355,22 +484,22 @@ func TestEndpoint_NeedsToReadBody(t *testing.T) {
 	statusCondition := Condition("[STATUS] == 200")
 	bodyCondition := Condition("[BODY].status == UP")
 	bodyConditionWithLength := Condition("len([BODY].tags) > 0")
-	if (&Endpoint{Conditions: []*Condition{&statusCondition}}).needsToReadBody() {
+	if (&Endpoint{Conditions: []Condition{statusCondition}}).needsToReadBody() {
 		t.Error("expected false, got true")
 	}
-	if !(&Endpoint{Conditions: []*Condition{&bodyCondition}}).needsToReadBody() {
+	if !(&Endpoint{Conditions: []Condition{bodyCondition}}).needsToReadBody() {
 		t.Error("expected true, got false")
 	}
-	if !(&Endpoint{Conditions: []*Condition{&bodyConditionWithLength}}).needsToReadBody() {
+	if !(&Endpoint{Conditions: []Condition{bodyConditionWithLength}}).needsToReadBody() {
 		t.Error("expected true, got false")
 	}
-	if !(&Endpoint{Conditions: []*Condition{&statusCondition, &bodyCondition}}).needsToReadBody() {
+	if !(&Endpoint{Conditions: []Condition{statusCondition, bodyCondition}}).needsToReadBody() {
 		t.Error("expected true, got false")
 	}
-	if !(&Endpoint{Conditions: []*Condition{&bodyCondition, &statusCondition}}).needsToReadBody() {
+	if !(&Endpoint{Conditions: []Condition{bodyCondition, statusCondition}}).needsToReadBody() {
 		t.Error("expected true, got false")
 	}
-	if !(&Endpoint{Conditions: []*Condition{&bodyConditionWithLength, &statusCondition}}).needsToReadBody() {
+	if !(&Endpoint{Conditions: []Condition{bodyConditionWithLength, statusCondition}}).needsToReadBody() {
 		t.Error("expected true, got false")
 	}
 }
--- a/core/result.go
+++ b/core/result.go
@@ -10,10 +10,12 @@ type Result struct {
 	HTTPStatus int `json:"status"`

 	// DNSRCode is the response code of a DNS query in a human-readable format
+	//
+	// Possible values: NOERROR, FORMERR, SERVFAIL, NXDOMAIN, NOTIMP, REFUSED
 	DNSRCode string `json:"-"`

 	// Hostname extracted from Endpoint.URL
-	Hostname string `json:"hostname"`
+	Hostname string `json:"hostname,omitempty"`

 	// IP resolved from the Endpoint URL
 	IP string `json:"-"`
@@ -25,7 +27,7 @@ type Result struct {
 	Duration time.Duration `json:"duration"`

 	// Errors encountered during the evaluation of the Endpoint's health
-	Errors []string `json:"errors"`
+	Errors []string `json:"errors,omitempty"`

 	// ConditionResults results of the Endpoint's conditions
 	ConditionResults []*ConditionResult `json:"conditionResults"`
--- a/core/ui/ui.go
+++ b/core/ui/ui.go
@@ -4,6 +4,8 @@ package ui
 type Config struct {
 	// HideHostname whether to hide the hostname in the Result
 	HideHostname bool `yaml:"hide-hostname"`
+	// HideURL whether to ensure the URL is not displayed in the results. Useful if the URL contains a token.
+	HideURL bool `yaml:"hide-url"`
 	// DontResolveFailedConditions whether to resolve failed conditions in the Result for display in the UI
 	DontResolveFailedConditions bool `yaml:"dont-resolve-failed-conditions"`
 }
@@ -12,6 +14,7 @@ type Config struct {
 func GetDefaultConfig() *Config {
 	return &Config{
 		HideHostname:                false,
+		HideURL:                     false,
 		DontResolveFailedConditions: false,
 	}
 }
--- a/go.mod
+++ b/go.mod
@@ -1,38 +1,49 @@
-module github.com/TwiN/gatus/v3
+module github.com/TwiN/gatus/v4

-go 1.17
+go 1.18

 require (
-	github.com/TwiN/gocache v1.2.4
-	github.com/TwiN/health v1.0.1
-	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/TwiN/g8 v1.3.0
+	github.com/TwiN/gocache/v2 v2.0.0
+	github.com/TwiN/health v1.4.0
+	github.com/coreos/go-oidc/v3 v3.1.0
 	github.com/go-ping/ping v0.0.0-20210911151512-381826476871
-	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/google/uuid v1.3.0 // indirect
+	github.com/google/uuid v1.3.0
 	github.com/gorilla/mux v1.8.0
-	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
 	github.com/lib/pq v1.10.3
-	github.com/mattn/go-isatty v0.0.14 // indirect
-	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
 	github.com/miekg/dns v1.1.43
 	github.com/prometheus/client_golang v1.11.0
+	github.com/wcharczuk/go-chart/v2 v2.1.0
+	golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9
+	golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c
+	gopkg.in/mail.v2 v2.3.1
+	gopkg.in/yaml.v2 v2.4.0
+	modernc.org/sqlite v1.13.1
+)
+
+require (
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
+	github.com/mattn/go-isatty v0.0.14 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
 	github.com/prometheus/client_model v0.2.0 // indirect
 	github.com/prometheus/common v0.31.1 // indirect
 	github.com/prometheus/procfs v0.7.3 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
-	github.com/wcharczuk/go-chart/v2 v2.1.0
-	go.etcd.io/bbolt v1.3.6 // indirect
 	golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d // indirect
 	golang.org/x/mod v0.5.1 // indirect
-	golang.org/x/net v0.0.0-20210929193557-e81a3d93ecf6 // indirect
+	golang.org/x/net v0.0.0-20211209124913-491a49abca63 // indirect
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
 	golang.org/x/sys v0.0.0-20211003122950-b1ebd4e1001c // indirect
 	golang.org/x/tools v0.1.7 // indirect
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	google.golang.org/appengine v1.6.6 // indirect
 	google.golang.org/protobuf v1.27.1 // indirect
-	gopkg.in/yaml.v2 v2.4.0
+	gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect
+	gopkg.in/square/go-jose.v2 v2.5.1 // indirect
 	lukechampine.com/uint128 v1.1.1 // indirect
 	modernc.org/cc/v3 v3.35.8 // indirect
 	modernc.org/ccgo/v3 v3.12.16 // indirect
@@ -40,7 +51,6 @@ require (
 	modernc.org/mathutil v1.4.1 // indirect
 	modernc.org/memory v1.0.5 // indirect
 	modernc.org/opt v0.1.1 // indirect
-	modernc.org/sqlite v1.13.1
 	modernc.org/strutil v1.1.1 // indirect
 	modernc.org/token v1.0.0 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -33,10 +33,12 @@ cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/TwiN/gocache v1.2.4 h1:AfJ1YRcxtQ/zZEN61URDwk/dwFG7LSRenU5qIm9dQzo=
-github.com/TwiN/gocache v1.2.4/go.mod h1:BjabsQQy6z5uHDorHa4LJVPEzFeitLIDbCtdv3gc1gA=
-github.com/TwiN/health v1.0.1 h1:Q8lE6mTMPG4A5nHXq5Xa+NY4Y8LkQdRBWh1ReUkuc6Y=
-github.com/TwiN/health v1.0.1/go.mod h1:Bt+lEvSi6C/9NWb7OoGmUmgtS4dfPeMM9EINnURv5dE=
+github.com/TwiN/g8 v1.3.0 h1:mNv3R35GhDn1gEV0BKMl1oupZ1tDtOWPTHUKu+W/k3U=
+github.com/TwiN/g8 v1.3.0/go.mod h1:SiIdItS0agSUloFqdQQt/RObB2jGSq+nnE9WfFv3RIo=
+github.com/TwiN/gocache/v2 v2.0.0 h1:CPbDNKdSJpmBkh7aWcO7D3KK1yWaMlwX+3dsBPE8/so=
+github.com/TwiN/gocache/v2 v2.0.0/go.mod h1:j4MABVaia2Tp53ERWc/3l4YxkswtPjB2hQzmL/kD/VQ=
+github.com/TwiN/health v1.4.0 h1:Ts7lb4ihYDpVEbFSGAhSEZTSwuDOADnwJLFngFl4xzw=
+github.com/TwiN/health v1.4.0/go.mod h1:CSUh+ryfD2POS2vKtc/yO4IxgR58lKvQ0/8qnoPqPqs=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
@@ -55,7 +57,10 @@ github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5P
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/coreos/go-oidc/v3 v3.1.0 h1:6avEvcdvTa1qYsOZ6I5PRkSYHzpTNWgKYmaJfaYbrRw=
+github.com/coreos/go-oidc/v3 v3.1.0/go.mod h1:rEJ/idjfUyfkBit1eI1fvyr+64/g9dcKpAm8MJMesvo=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
@@ -63,8 +68,6 @@ github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymF
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
@@ -76,7 +79,6 @@ github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
 github.com/go-ping/ping v0.0.0-20210911151512-381826476871 h1:wtjTfjwAR/BYYMJ+QOLI/3J/qGEI0fgrkZvgsEWK2/Q=
 github.com/go-ping/ping v0.0.0-20210911151512-381826476871/go.mod h1:xIFjORFzTxqIV/tDVGO4eDy/bLuSyawEeojSm3GfRGk=
-github.com/go-redis/redis v6.15.9+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
@@ -142,7 +144,6 @@ github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
 github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
@@ -180,16 +181,10 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lN
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
-github.com/onsi/ginkgo v1.14.1/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
-github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
-github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
-github.com/onsi/gomega v1.10.2/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
@@ -223,17 +218,14 @@ github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/tidwall/redcon v1.3.2/go.mod h1:bdYBm4rlcWpst2XMwKVzWDF9CoUxEbUmM7CQrKeOZas=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/wcharczuk/go-chart/v2 v2.1.0 h1:tY2slqVQ6bN+yHSnDYwZebLQFkphK4WNrVwnt7CJZ2I=
 github.com/wcharczuk/go-chart/v2 v2.1.0/go.mod h1:yx7MvAVNcP/kN9lKXM/NTce4au4DFN99j6i1OwDclNA=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=
-go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU=
-go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
@@ -244,6 +236,7 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -278,12 +271,10 @@ golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzB
 golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38=
 golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -304,9 +295,9 @@ golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200505041828-1ed23360d12c/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
@@ -315,14 +306,14 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
 golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210929193557-e81a3d93ecf6 h1:Z04ewVs7JhXaYkmDhBERPi41gnltfQpMWDnTnQbaCqk=
-golang.org/x/net v0.0.0-20210929193557-e81a3d93ecf6/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211209124913-491a49abca63 h1:iocB37TsdFuN6IBRZ+ry36wrkoV51/tl5vOWqkcPGvY=
+golang.org/x/net v0.0.0-20211209124913-491a49abca63/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c h1:pkQiBZBvdos9qq4wBAHqlzuZHEXo07pqV06ef90u1WI=
 golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -338,7 +329,6 @@ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cO
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -349,10 +339,7 @@ golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -368,12 +355,10 @@ golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201126233918-771906719818/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -383,7 +368,6 @@ golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210902050250-f475640dd07b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211003122950-b1ebd4e1001c h1:EyJTLQbOxvk8V6oDdD8ILR1BOs3nEJXThD6aqsiPNkM=
 golang.org/x/sys v0.0.0-20211003122950-b1ebd4e1001c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -466,6 +450,7 @@ google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7
 google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.6 h1:lMO5rYAqUxkmaj76jAkRUvt5JZgFymx/+Q5Mzfivuhc=
 google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
@@ -523,13 +508,17 @@ google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ
 google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ=
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc h1:2gGKlE2+asNV9m7xrywl36YYNnBG5ZQ0r/BOOxqPpmk=
+gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc/go.mod h1:m7x9LTH6d71AHyAX77c9yqWCCa3UKHcVEj9y7hAtKDk=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/mail.v2 v2.3.1 h1:WYFn/oANrAGP2C0dcV6/pbkPzv8yGzqTjPmTeO7qoXk=
+gopkg.in/mail.v2 v2.3.1/go.mod h1:htwXN1Qh09vZJ1NVKxQqHPBaCBbzKhp5GzuJEA4VJWw=
+gopkg.in/square/go-jose.v2 v2.5.1 h1:7odma5RETjNHWJnR32wx8t+Io4djHE1PqxCFx3iiZ2w=
+gopkg.in/square/go-jose.v2 v2.5.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
TwiN	ab2bee9c4b	chore!: Update module from v3 to v4	2022-06-20 21:25:14 -04:00
TwiN	d1ced94030	fix(badge): Regenerate assets and tweak health badge width	2022-06-20 14:27:05 -04:00
asymness	a3e35c862c	feat(badge): Implement UP/DOWN status badge (#291 ) * Implement status badge endpoint * Update integration tests for status badge generation * Add status badge in the UI * Update static assets * Update README with status badge description * Rename constants to pascal-case * Check for success of the endpoint conditions * Rename status badge to health badge	2022-06-20 13:59:45 -04:00
TwiN	0193a200b8	refactor(ci): Wrap benchmark workflow inputs with quotes	2022-06-19 22:37:19 -04:00
TwiN	7224464202	fix(ci): Set default repository to TwiN/gatus	2022-06-18 14:09:24 -04:00
TwiN	c457aadcab	feat(ci): Add benchmark workflow	2022-06-18 14:04:11 -04:00
TwiN	f38b12d55b	refactor(ci): Clean up steps	2022-06-18 13:06:24 -04:00
TwiN	e4c9ad8796	chore(ci): Update actions/checkout to v3	2022-06-18 12:58:26 -04:00
TwiN	5be1465b13	refactor(ci): Uniformize job names	2022-06-18 12:50:31 -04:00
TwiN	7215aa4bd6	docs(metrics): Update Grafana/Prometheus example	2022-06-18 12:42:41 -04:00
TwiN	829a9c2679	fix(dns): Use Cloudflare's DNS instead of Google's DNS	2022-06-16 20:21:44 -04:00
TwiN	dfcdc57a18	test(dns): Fix case with inconsistent results	2022-06-16 20:09:25 -04:00
TwiN	43e8c57701	test(dns): Fix case with inconsistent results	2022-06-16 20:02:46 -04:00
TwiN	076f5c45e8	test(metrics): Improve test coverage	2022-06-16 20:02:46 -04:00
TwiN	6d3c3d0892	refactor(metrics): Rename metric to metrics	2022-06-16 20:02:46 -04:00
TwiN	e620fd1214	docs: List possible values for Result.DNSRCode	2022-06-16 20:02:46 -04:00
asymness	5807d76c2f	feat(ui): Implement parameter to hide URL from results (#294 ) * Add support for HideURL UI config parameter * Redact whole URL when hide-url parameter is set to true * Add integration test for hide-url functionality * Document the hide-url config parameter in README * Apply suggestions from code review Co-authored-by: TwiN <twin@linux.com> * Update test to have client config with 1ms timeout * Re-align README tables * Update core/endpoint_test.go * Update core/endpoint_test.go Co-authored-by: TwiN <twin@linux.com>	2022-06-16 17:53:03 -04:00
mindcrime-ilab	017847240d	feat(alerting): Add overrides for Mattermost (#292 ) * add override support for mattermost * add documentation for override Mattermost webhooks * Apply suggestions from code review Co-authored-by: TwiN <twin@linux.com> * fix formatting Co-authored-by: Michael Engelhardt <me@mindcrime.dev> Co-authored-by: TwiN <twin@linux.com>	2022-06-15 23:25:37 -04:00
TwiN	c873b0ba0c	feat(security)!: Remove deprecated SHA512 parameter for password hashing	2022-06-14 23:48:28 -04:00
TwiN	6f3150d936	feat(api)!: Remove deprecated paths	2022-06-14 23:40:26 -04:00
TwiN	0792f5490b	feat(storage)!: Remove persistence for memory storage	2022-06-14 23:36:18 -04:00
TwiN	326ea1c3d1	refactor(client): Clean up client dns resolver	2022-06-13 20:35:51 -04:00
TwiN	fea95b8479	perf(storage): Improve benchmarks and fix race condition	2022-06-13 20:35:51 -04:00
TwiN	6d64c3c250	chore: Reformat some code and docs	2022-06-12 19:18:58 -04:00
TwiN	2b9d3e99d3	refactor: Fix indent	2022-06-12 19:18:50 -04:00
TwiN	9a5f245440	chore(ui): Update dependencies and rebuild static assets	2022-06-12 19:18:50 -04:00
TwiN	793172c783	feat(ux): Display loading animation while waiting for data to be retrieved Fixes #275	2022-06-12 19:18:50 -04:00
TwiN	9f343bacf7	chore(ui): Move prettifyTimeDifference to helper as generatePrettyTimeDifference	2022-06-12 19:18:50 -04:00
TwiN	c31cb7540d	fix(ui): Second shouldn't be plural if value is 1	2022-06-12 19:18:50 -04:00
TwiN	f9efa28223	fix(ui): Set default refresh interval to 300 (5m)	2022-06-12 19:18:50 -04:00
Andre Bindewald	2cbb35fe3b	feat(client): Added client configuration option for using a custom DNS resolver (#284 )	2022-06-12 18:45:08 -04:00
TwiN	f23fcbedb8	docs: Specify what type of applications can be monitored with TCP	2022-06-12 16:32:08 -04:00
TwiN	ad10f975b4	docs: Set example interval to 5m	2022-06-12 16:31:43 -04:00
TwiN	1c03524ca8	chore(alerting): Order types alphabetically	2022-06-12 14:18:18 -04:00
TwiN	4af135d1fb	docs: Fix table formatting	2022-06-11 22:17:34 -04:00
TwiN	93b5a867bb	chore(alerting): Add missing opsgenie compile-time interface validation	2022-06-07 19:43:23 -04:00
TwiN	f899f41d16	feat(alerting): Add ENDPOINT_GROUP and ENDPOINT_URL placeholders for custom provider related: #282 note: this also phases out the deprecated [SERVICE_NAME] placeholder	2022-06-07 19:37:42 -04:00
TwiN	ab52676f23	build: Prevent Makefile test target from accidentally targeting test folder	2022-06-07 18:04:56 -04:00
mani9223-oss	27fc784411	feat(alerting): Add group-specific WebHook URL for Slack (#279 )	2022-05-30 22:03:09 -04:00
Chris Grindstaff	d929c09c56	docs(cert): list valid units for CERTIFICATE_EXPIRATION (#285 ) Fixes #246	2022-05-29 15:14:25 -04:00
TwiN	cff06e38cb	docs(kubernetes): Add probes to example	2022-05-25 23:59:34 -04:00
TwiN	5b1aeaeb0c	chore(test): Use io instead of io/ioutil	2022-05-16 22:19:42 -04:00
TwiN	90e9b55109	docs(metrics): Document available metrics	2022-05-16 22:18:38 -04:00
wei	cf9c00a2ad	feat(metrics): Add more metrics (#278 ) * add gatus_results_success and gatus_results_duration_seconds * add metrics namespace * add result http metrics * add more metrics * update * extract endpoint type method * initializedMetrics * remove too many metrics * update naming * chore(metrics): Refactor code and merge results_dns_return_code_total, results_http_status_code_total into results_code_total * docs(metrics): Update results_certificate_expiration_seconds description * add TestEndpoint_Type * remove name in table test Co-authored-by: TwiN <twin@linux.com>	2022-05-16 21:10:45 -04:00
TwiN	fbdb5a3f0f	test(maintenance): Add tests for edge cases	2022-05-07 16:46:51 -04:00
Bo-Yi Wu	dde930bed7	feat(alerting): Add group-specific WebHook URL for Google Chat (#272 )	2022-05-07 14:34:21 -04:00
TwiN	a9fc876173	docs: Update description	2022-04-28 17:56:02 -04:00
TwiN	08b31ba263	chore: Update frontend dependencies	2022-04-25 20:47:01 -04:00
TwiN	9ede992e4e	feat(ui): Add support for buttons below header (#106 )	2022-04-25 20:20:32 -04:00
TwiN	dcb997f501	docs: Fix table format	2022-04-25 19:55:17 -04:00
TwiN	c8efdac23a	chore(ci): Update actions/setup-go to v3	2022-04-15 14:32:48 -04:00
Bo-Yi Wu	e307d1ab35	feat(alerting): Add group-specific WebHook URL for Discord (#271 ) * feat(alerting): Add group-specific webhook URL for discord Add group-specific webhook URL for discord alert Provides support for paging multiple Discords based on the group selector while keeping backward compatibility to the old Discords configuration manifest integration per team can be specified in the overrides sections in an array form. ref: #96 Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com> * docs: update Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com> * Update README.md * Update README.md * Update alerting/provider/discord/discord.go Co-authored-by: TwiN <twin@linux.com> * Update README.md Co-authored-by: TwiN <twin@linux.com> * test: revert testing name * Update alerting/provider/discord/discord_test.go Co-authored-by: TwiN <twin@linux.com> Co-authored-by: TwiN <twin@linux.com>	2022-04-11 20:30:21 -04:00
TwiN	e6c6b4e06f	chore: Update TwiN/health to v1.4.0	2022-04-11 01:39:47 -04:00
TwiN	5843c58a36	chore: Update Go to 1.18	2022-03-26 02:15:32 -04:00
Bo-Yi Wu	5281f8068d	feat(alerting): Add group-specific webhook URL for teams (#266 ) * feat(alert): Add group-specific webhook URL for teams Add group-specific webhook URL for teams alert ref: https://github.com/TwiN/gatus/issues/96 Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com> * Update README.md * Update README.md	2022-03-23 20:31:10 -04:00
TwiN	86d5dabf90	security: Pin dependency versions Too many cases of open source projects in the JS ecosystem just going wild lately	2022-03-22 19:34:55 -04:00
Bo-Yi Wu	a81c81e42c	feat(alert): Add group-specific to email list (#264 ) * feat(alert): Add group-specific to email list Add group-specific to list for email alert https://github.com/TwiN/gatus/issues/96 Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com> * docs: update Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com> * Update README.md * Update README.md * Update README.md * chore: update Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com> * Update README.md	2022-03-20 21:54:20 -04:00
Bo-Yi Wu	bec2820969	docs(example): move config.yaml to config folder (#265 ) ref: https://github.com/TwiN/gatus/issues/151#issuecomment-912932934 update all exmaple in docker-compose file. Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com>	2022-03-20 00:04:13 -04:00
TwiN	0bf2271a73	test: Improve coverage for endpoint health evaluation edge cases (#262 )	2022-03-15 20:53:03 -04:00
TwiN	bd4b91bbbd	fix: Display "<redacted>" instead of "host" in errors (#262 )	2022-03-15 20:51:59 -04:00
Shashank D	fdec317df0	fix(config): replace hostname in error string if opted (#262 )	2022-03-15 20:17:57 -04:00
TwiN	8970ad5ad5	refactor: Align new code from #259 with existing code	2022-03-09 21:05:57 -05:00
Andre Bindewald	c4255e65bc	feat(client): OAuth2 Client credential support (#259 ) * Initial implementation * Added OAuth2 support to `client` config * Revert "Initial implementation" This reverts commit `7f2f3a603a`. * Restore vendored clientcredentials * configureOAuth2 is now a func (including tests) * README update * Use the same OAuth2Config in all related tests * Cleanup & comments	2022-03-09 20:53:51 -05:00
Jonah	fcf046cbe8	feat(alerting): Add support for custom Telegram API URL (#257 )	2022-03-05 15:44:11 -05:00
TwiN	6932edc6d0	docs: Fix Google Chat alerting configuration example	2022-02-14 20:03:08 -05:00
TwiN	3f961a7408	fix(ui): Prettify event timestamps Closes #243	2022-02-03 20:16:13 -05:00
TwiN	4d0f3b6997	chore: Update Vue dependencies	2022-02-03 20:08:48 -05:00
TwiN	5a06599d96	chore: Update front-end dependencies	2022-01-30 18:10:39 -05:00
Azaria	d2a73a3590	chore: Fix grammatical issues in README (#241 )	2022-01-23 20:06:55 -05:00
TwiN	932ecc436a	test(security): Replace password-sha512 by password-bcrypt-base64 for test case	2022-01-17 11:55:05 -05:00
TwiN	1613274cb0	style(ui): Improve login UI design	2022-01-17 10:37:09 -05:00
TwiN	0b4720d94b	build(gha): Increase timeout from 30 to 45 minutes	2022-01-16 23:26:24 -05:00
TwiN	16df341581	refactor: Remove unused function prettifyUptime	2022-01-16 22:02:58 -05:00
TwiN	a848776a34	refactor(alerting): Sort alert types alphabetically	2022-01-16 00:07:19 -05:00
TwiN	681b1c63f1	docs: Fix broken Google Chat references	2022-01-16 00:06:03 -05:00
Kostiantyn Polischuk	51a4b63fb5	feat(alerting): Add Google Chat alerting provider (#234 )	2022-01-14 21:00:00 -05:00
Khinshan Khan	3a7977d086	build(docker): support all platforms that publish release supports (#238 )	2022-01-13 21:37:25 -05:00
TwiN	c682520dd9	fix(security): Use LRU eviction policy for OIDC sessions	2022-01-13 18:42:19 -05:00
TwiN	24b7258338	docs: Re-order parameters in Opsgenie and PagerDuty	2022-01-11 20:22:44 -05:00
TwiN	89e6e4abd8	fix(alerting): Omit nil structs within alerting provider struct	2022-01-11 20:13:37 -05:00
TwiN	4700f54798	docs: Remove outdated comment	2022-01-11 20:11:25 -05:00
TwiN	9ca4442e6a	docs: Add missing section "Configuring Opsgenie alerts"	2022-01-11 20:10:06 -05:00
Tom Moitié	ce6f58f403	feat(alerting): Allow specifying a different username for email provider (#231 ) * Update email alerting provider to supply a username, maintaining backwards compatibility with from * Update README.md Co-authored-by: Tom Moitié <tomm@gendius.co.uk> Co-authored-by: TwiN <twin@twinnation.org>	2022-01-11 20:07:25 -05:00
TwiN	c466542990	test(security): Add tests for basic auth with bcrypt	2022-01-08 19:59:45 -05:00
TwiN	9cb8c37298	fix(security): Make sure to panic on start if the security middlewares return an error	2022-01-08 19:59:45 -05:00
TwiN	f6f7e15735	docs(security): Add warning about using a high cost for bcrypt	2022-01-08 19:59:45 -05:00
TwiN	c712133df0	feat(security): Implement Bcrypt for basic auth and deprecate SHA512 I've re-written the code for this several times before but always ended up not going through with it because a hashed Bcrypt string has dollar signs in it, which caused issues with the config due to environment variable support. I finally decided to go through with it by forcing users to base64 encode the bcrypt hash	2022-01-08 19:59:45 -05:00
TwiN	fc016bd682	feat(ui): Make logo link and header configurable Closes #213	2022-01-08 15:24:22 -05:00
TwiN	0e586e4152	refactor: Split direct and indirect modules	2022-01-06 23:24:07 -05:00
TwiN	ea425773e0	style: Use SVG instead of PNG for GitHub's logo	2022-01-03 21:41:53 -05:00
TwiN	10949b11f4	fix(oidc): Default isAuthenticated to true, not false	2022-01-02 21:37:15 -05:00
TwiN	0e022d04b1	chore: Fix inconsistent indentation + Rebuild assets	2022-01-02 21:14:01 -05:00
TwiN	3319e158b5	branding: Update logo	2022-01-02 21:14:01 -05:00
TwiN	f467a77ae2	chore: Upgrade Tailwind from v2 to v3	2022-01-02 21:14:01 -05:00
TwiN	56048725e4	oidc: Display error if applicable	2022-01-02 21:14:01 -05:00
TwiN	425c1d3674	oidc: Add /api/v1/config route for determining whether to display a login button on the UI	2022-01-02 21:14:01 -05:00
TwiN	8838f6f2ad	oidc: Add documentation	2022-01-02 21:14:01 -05:00
TwiN	139a78b2f6	oidc: Log when a subject tries to authenticate but isn't allowed	2022-01-02 21:14:01 -05:00
TwiN	dd5e3ee7ee	Add tests for OIDC	2022-01-02 21:14:01 -05:00
TwiN	9f8f7bb45e	Fix codecov configuration	2022-01-02 21:14:01 -05:00
TwiN	27e246859e	Use code coverage target instead of threshold	2022-01-02 21:14:01 -05:00
TwiN	f1688ac87a	Set code coverage threshold to 75%	2022-01-02 21:14:01 -05:00
TwiN	54779e1db8	Fix basic security tests	2022-01-02 21:14:01 -05:00
TwiN	be9087bee3	#205 : Work on supporting OpenID Connect for auth	2022-01-02 21:14:01 -05:00
TwiN	4ab5724fc1	Default to dark theme	2022-01-02 21:14:01 -05:00
TwiN	45a47940ad	#205 : Start working on adding support for IODC	2022-01-02 21:14:01 -05:00
TwiN	1777d69495	Remove unnecessary check	2021-12-14 23:26:18 -05:00
Bastien Ogier	8676b83fe3	Changed: add maintenance to README on root config table	2021-12-14 19:55:40 -05:00
TwiN	b67701ff6d	BREAKING: Replace metrics	2021-12-13 19:38:20 -05:00
TwiN	eb9acef9b5	Minor update	2021-12-13 19:38:20 -05:00
TwiN	00aec70fb8	Update dependencies	2021-12-13 19:38:20 -05:00
TwiN	18d28fc362	Add tests for validation of description	2021-12-12 17:03:11 -05:00
TwiN	eb3545e994	Add tests for Slack alert body with endpoint that has a group	2021-12-12 17:03:11 -05:00
TwiN	ad71c8db34	Support displaying group name when applicable for every alert provider	2021-12-12 17:03:11 -05:00
TwiN	6da281bf4e	Disallow certain characters in endpoint name, group and alert description	2021-12-12 17:03:11 -05:00
TwiN	3dd8ba1a99	Add missing alert type	2021-12-09 21:18:44 -05:00
TwiN	2503d21522	Refactor Opsgenie alerting provider code	2021-12-09 21:18:25 -05:00
TwiN	36a3419aec	Update .gitignore	2021-12-09 20:40:28 -05:00
Vinicius Reis	7353fad809	Opsgenie Alert Provider (#214 ) * ✨ opsgenie alert provider * ✅ add unit tests * ✏️ typofix * 📝 update readme * ✨ add details * ✨ use group to previne colisions * ✏️ typofix * ✏️ typofix	2021-12-09 20:32:38 -05:00
TwiN	b5a26caa08	Merge pull request #217 from ianagbip1oti/patch-3 Grammatical Fix	2021-12-09 01:19:54 -05:00
Princess Lana	d7206546af	Grammatical Fix	2021-12-08 22:16:06 -08:00
TwiN	4fa86a2c46	Merge pull request #216 from ianagbip1oti/patch-2 Grammatical Fix	2021-12-09 01:14:51 -05:00
Princess Lana	a6ed23b169	Grammatical Fix	2021-12-08 22:13:12 -08:00
TwiN	d9201c5084	Merge pull request #215 from ianagbip1oti/patch-1 Grammatical fix	2021-12-09 01:08:27 -05:00
Princess Lana	d0ba8261e3	Grammatical fix	2021-12-08 22:07:04 -08:00
TwiN	f89447badc	Merge pull request #211 from Juneezee/deprecate-ioutil refactor: move from io/ioutil to io and os packages	2021-12-03 20:31:31 -05:00
TwiN	14c42f6e6d	Fix #212 : Stale endpoint on dashboard after config change	2021-12-03 18:20:14 -05:00
Eng Zer Jun	7a05bdcb82	refactor: move from io/ioutil to io and os packages The io/ioutil package has been deprecated as of Go 1.16, see https://golang.org/doc/go1.16#ioutil. This commit replaces the existing io/ioutil functions with their new definitions in io and os packages. Signed-off-by: Eng Zer Jun <engzerjun@gmail.com>	2021-12-03 14:44:17 +08:00
TwiN	5eb7763052	Implement email alerts	2021-12-02 23:31:14 -05:00
TwiN	8c73ae6035	Fix #22 : Improve alerting provider tests by mocking HTTP client	2021-12-02 23:10:21 -05:00
TwiN	6954e9dde7	Move alerting provider mocked tests at the watchdog level	2021-12-02 22:15:51 -05:00
TwiN	f6336eac4e	Fix #117 : Implement email alerts	2021-12-02 21:05:17 -05:00
TwiN	0331c18401	Make sure cache is disabled for badges and charts	2021-11-24 18:36:31 -05:00
TwiN	1f8fd29dad	Get rid of Discord link I don't have time to manage a community 😩	2021-11-23 19:18:29 -05:00
TwiN	5877c4b2be	Update TwiN/health to v1.3.0	2021-11-19 23:43:24 -05:00
TwiN	c6d0809ecc	Hide Alert.ResolveKey and Alert.Triggered	2021-11-18 00:11:32 -05:00
TwiN	cf8a601104	Add more images to README.md	2021-11-17 21:47:38 -05:00
TwiN	96a0eebc0c	Change license to Apache 2 (#203 ) Call me indecisive if you want, since I've done this once before (see `70c9c4b87c`), but after thing about the pros and cons, I decided that Apache 2 offers better protection for Gatus	2021-11-17 21:47:06 -05:00
TwiN	2af3425b9e	Fix #202 : Postgres error when an endpoint has a second page but others do not	2021-11-16 22:56:16 -05:00
TwiN	31bf2aeb80	Update TwiN/health to v1.1.0	2021-11-15 20:11:13 -05:00
TwiN	787f6f0d74	Add feedback email address	2021-11-12 00:32:11 -05:00
TwiN	17a431321c	Pass http.NoBody instead of nil as body	2021-11-11 00:14:00 -05:00
TwiN	05e9add16d	Regenerate static assets	2021-11-09 00:16:48 -05:00
TwiN	c4ef56511d	Update dependencies	2021-11-09 00:07:44 -05:00
TwiN	cfa2c8ef6f	Minor updates	2021-11-09 00:06:41 -05:00
TwiN	f36b6863ce	Minor update	2021-11-08 23:54:06 -05:00
TwiN	24482cf7a0	Fix icon_url for Mattermost	2021-11-08 21:07:16 -05:00
TwiN	d661a0ea6d	Add logo.png in .github/assets	2021-11-08 21:05:16 -05:00
TwiN	a0ec6941ab	Display number of days rather than hours if >72h	2021-11-08 20:57:58 -05:00
TwiN	5e711fb3b9	Use http.Error instead of writer.Write	2021-11-08 20:56:35 -05:00
TwiN	ab66e7ec8a	Fix badge examples	2021-11-08 02:22:43 -05:00
TwiN	08aba6cd51	Minor updates	2021-11-04 21:40:05 -04:00
TwiN	d3805cd77a	Fix #197 ; Fix #198 : Deprecate storage.file in favor of storage.path and deprecate persistence with memory storage type	2021-11-04 21:33:13 -04:00
TwiN	dd70136e6c	Omit empty hostname and errors field	2021-11-03 22:18:23 -04:00
TwiN	a94c480c22	Fix typo in comment	2021-11-03 22:17:58 -04:00
TwiN	10fd4ecd6b	Minor fixes	2021-11-03 19:48:58 -04:00