feat(connectivity): Allow internet connection validation prior to endpoint execution (#461)

Bumps [golang.org/x/crypto](https://github.com/golang/crypto) from 0.7.0 to 0.8.0.
- [Release notes](https://github.com/golang/crypto/releases)
- [Commits](https://github.com/golang/crypto/compare/v0.7.0...v0.8.0)

---
updated-dependencies:
- dependency-name: golang.org/x/crypto
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.dockerignore

@@ -4,4 +4,5 @@ Dockerfile
 .idea
 .git
 web/app
-*.db
+*.db
+testdata

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

@@ -1,23 +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`.
 
-## Queries
-Gatus uses Prometheus counters.
+![Gatus Grafana dashboard](../../.github/assets/grafana-dashboard.png)
 
-Total results per minute:
+
+## 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:
+### Total successful results per minute
 ```
 sum(rate(gatus_results_total{success="true"}[5m])*60) by (key)
 ```
 
-Total unsuccessful results per minute:
+### Total unsuccessful results per minute
+```
+sum(rate(gatus_results_total{success="false"}[5m])*60) by (key)
 ```
-sum(rate(gatus_results_total{success="true"}[5m])*60) by (key)
-```

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

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

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

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

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

@@ -15,8 +15,266 @@
   "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,
@@ -27,10 +285,10 @@
       "fill": 1,
       "fillGradient": 0,
       "gridPos": {
-        "h": 7,
+        "h": 8,
         "w": 12,
-        "x": 0,
-        "y": 0
+        "x": 12,
+        "y": 8
       },
       "id": 2,
       "interval": "",
@@ -126,8 +384,8 @@
       "gridPos": {
         "h": 7,
         "w": 12,
-        "x": 12,
-        "y": 0
+        "x": 0,
+        "y": 16
       },
       "id": 5,
       "legend": {
@@ -204,94 +462,6 @@
         "alignLevel": null
       }
     },
-    {
-      "cacheTimeout": null,
-      "colorBackground": false,
-      "colorPostfix": false,
-      "colorPrefix": false,
-      "colorValue": true,
-      "colors": [
-        "#299c46",
-        "rgba(237, 129, 40, 0.89)",
-        "#d44a3a"
-      ],
-      "datasource": null,
-      "format": "none",
-      "gauge": {
-        "maxValue": 100,
-        "minValue": 0,
-        "show": false,
-        "thresholdLabels": false,
-        "thresholdMarkers": true
-      },
-      "gridPos": {
-        "h": 7,
-        "w": 12,
-        "x": 0,
-        "y": 7
-      },
-      "id": 7,
-      "interval": "",
-      "links": [],
-      "mappingType": 1,
-      "mappingTypes": [
-        {
-          "name": "value to text",
-          "value": 1
-        },
-        {
-          "name": "range to text",
-          "value": 2
-        }
-      ],
-      "maxDataPoints": 100,
-      "nullPointMode": "connected",
-      "nullText": null,
-      "options": {},
-      "postfix": "",
-      "postfixFontSize": "50%",
-      "prefix": "",
-      "prefixFontSize": "50%",
-      "rangeMaps": [
-        {
-          "from": "null",
-          "text": "N/A",
-          "to": "null"
-        }
-      ],
-      "sparkline": {
-        "fillColor": "rgba(31, 118, 189, 0.18)",
-        "full": false,
-        "lineColor": "rgb(31, 120, 193)",
-        "show": true,
-        "ymax": null,
-        "ymin": null
-      },
-      "tableColumn": "",
-      "targets": [
-        {
-          "expr": "rate(gatus_results_total{success=\"false\"}[1m])*60",
-          "format": "time_series",
-          "instant": false,
-          "intervalFactor": 1,
-          "refId": "A"
-        }
-      ],
-      "thresholds": "1,2",
-      "timeFrom": null,
-      "timeShift": null,
-      "title": "Unsuccessful results",
-      "type": "singlestat",
-      "valueFontSize": "150%",
-      "valueMaps": [
-        {
-          "op": "=",
-          "text": "N/A",
-          "value": "null"
-        }
-      ],
-      "valueName": "current"
-    },
     {
       "aliasColors": {},
       "bars": false,
@@ -304,7 +474,7 @@
         "h": 7,
         "w": 12,
         "x": 12,
-        "y": 7
+        "y": 16
       },
       "id": 3,
       "legend": {
@@ -380,7 +550,7 @@
       }
     }
   ],
-  "refresh": "10s",
+  "refresh": "1m",
   "schemaVersion": 20,
   "style": "dark",
   "tags": [],
@@ -391,9 +561,22 @@
     "from": "now-1h",
     "to": "now"
   },
-  "timepicker": {},
+  "timepicker": {
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ]
+  },
   "timezone": "",
   "title": "Gatus",
   "uid": "KPI7Qj1Wk",
-  "version": 1
+  "version": 2
 }

.examples/docker-compose-mattermost/config/config.yaml

@@ -7,10 +7,9 @@ endpoints:
   - name: example
     url: https://example.org
     interval: 1m
-    alerts:
-      - type: mattermost
-        enabled: true
-        description: "health check failed 3 times in a row"
-        send-on-resolved: true
     conditions:
       - "[STATUS] == 200"
+    alerts:
+      - type: mattermost
+        description: "health check failed 3 times in a row"
+        send-on-resolved: true

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

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

.examples/docker-compose-multiple-config-files/config/backend.yaml

@@ -0,0 +1,21 @@
+endpoints:
+  - name: check-if-api-is-healthy
+    group: backend
+    url: "https://twin.sh/health"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 1000"
+
+  - name: check-if-website-is-pingable
+    url: "icmp://example.org"
+    interval: 1m
+    conditions:
+      - "[CONNECTED] == true"
+
+  - name: check-domain-expiration
+    url: "https://example.org"
+    interval: 6h
+    conditions:
+      - "[DOMAIN_EXPIRATION] > 720h"

.examples/docker-compose-multiple-config-files/config/frontend.yaml

@@ -0,0 +1,8 @@
+endpoints:
+  - name: make-sure-html-rendering-works
+    group: frontend
+    url: "https://example.org"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY] == pat(*<h1>Example Domain</h1>*)" # Check for header in HTML page

.examples/docker-compose-multiple-config-files/config/global.yaml

@@ -0,0 +1,8 @@
+metrics: true
+debug: false
+ui:
+  header: Example Company
+  link: https://example.org
+  buttons:
+    - name: "Home"
+      link: "https://example.org"

.examples/docker-compose-multiple-config-files/docker-compose.yml

@@ -0,0 +1,10 @@
+version: "3.8"
+services:
+  gatus:
+    image: twinproduction/gatus:latest
+    ports:
+      - "8080:8080"
+    environment:
+      - GATUS_CONFIG_PATH=/config
+    volumes:
+      - ./config:/config

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

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

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

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

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

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

.examples/kubernetes/gatus.yaml

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

.github/assets/gatus-diagram.drawio

@@ -1 +1 @@
-<mxfile host="app.diagrams.net" modified="2021-09-12T22:49:28.336Z" agent="5.0 (Windows)" etag="r9FJ6Bphqwq-LaTO-jp3" version="15.0.6" type="device"><diagram id="FBbfVOMCjf6Z2LK8Yagy" name="Page-1">7Vtdb5swFP01edwEOCHJY5t03aR1q9RWbR9d8MCb4TJj8rFfP9OYBOI2YVrTi5S8RPjaxOack2sf7PTIJFlcSprFVxAy0fOccNEj057nDceu/iwDy1WADEarQCR5uAq5m8AN/8NM0DHRgocsbzRUAELxrBkMIE1ZoBoxKiXMm81+gGj2mtGIWYGbgAo7es9DFZuo5zibis+MR3HV9dgzNQmtWptAHtMQ5rUQueiRiQRQq6tkMWGiBK8CZnXfp1dq1yOTLFVtbvj2/UGwZFq4GpXZfXYJ8Yh9MN8yo6IwT2wGq5YVBCzUiJgiSBVDBCkVF5vouYQiDVnZjaNLmzZfATIddHXwJ1NqaeilhQIdilUiTO2qz7KjV5/NhHIoZMB2PJAZv6IyYmrXgw/XFGjtMkiYkkt9o2SCKj5rDoQaFUXrdhuc9YWB+h9g9yzYteKk4mlkwb8Bt0RqHnPFbjL6jMFc/+ReAnKmv4otdkNpP7m5YTQ2ejW/WM8xg5039L+KxTXp+86BwCIYktRoyeWDuf+58FgWPg6q4nRRr5wuTekNpey3lPIIU8n9Ezk7yfEwyRngkrPh47Fe1x1yiIPJjm9NAnOqgjgE/Elg6DYnAUKwJ4HhkeaZUds842NKeWRJOVcgy7U1tpK3lzN9H1vJYwurI5W2O2yrbdQ0XaXCEz+vNhyj8uOe+NnDD6pDcE/5bV9+e2UKeyd+jtVft+eHoPJzrBa7PT+oJttFdtnd54fg5jf/xM8efnB/P2aYNUOUSZjxkEmLuD1+sWkue//vHl1n2LW34a7tta9Ynmuv/cRliI8Y2Xp15A5H7RDzDoaY7bhvBA1+dQ8rj2BjVX1xDatrLS05LdSyg3g56Hi9tIHqC93techn+jIqL28ZTfIqrvupVXUQVB8dVM9OcVQpJhPIVfcAc/tjbMCIBdgtEyySNOkeXN4YXV/H6qi81ruWuKcjjtVRtecHd8//WN+It+aHoL4R9+yd5XI7Dn8zzrJT+Ltxnu0+899CA9G9ibM/agnW4SZO23vyNGEJyA6ag/7AwYZrjJsnm+dvnPfLk8RpmSdRDy0Q2+vmTM54wPISiDKsRwEpetrcPo2D/xKK2LZ3yvMAZNi9PLBGBi0PVIen6vZszgWH7oFFqvkQDyzk7Ui0Q4uk3zJpoq79q1HWtByAhgSEeOF9PfZpr8EQPVMeq5clrb1SH1XPtle6+4Ku4+0ZvwM6tn0ShrDfUqBtj9YS3FWq7bnu8hdSbR7TrLwsEnEWaLevwSolyAONLn1i4hpy/ryaJdMnUAqSWoMzwaOyQsGWlKFQgqdssv53nfM2+vbJfn2Td5W3vUeYQa4iWXqBri3SBtWRrQMs0nRx85fE57raHzvJxV8=</diagram></mxfile>
+<mxfile host="app.diagrams.net" modified="2022-12-07T04:00:31.242Z" agent="5.0 (Windows)" etag="4-CttOJPoGYGt_6RMEMf" version="20.5.3" type="device"><diagram id="oCf8YAkR0GE5Fy88uv5t" name="Page-1">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</diagram></mxfile>

.github/dependabot.yml

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

.github/workflows/benchmark.yml

@@ -0,0 +1,30 @@
+name: benchmark
+on:
+  workflow_run:
+    workflows: [publish-latest]
+    branches: [master]
+    types: [completed]
+  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@v4
+        with:
+          go-version: 1.19
+          repository: "${{ github.event.inputs.repository || 'TwiN/gatus' }}"
+          ref: "${{ github.event.inputs.ref || 'master' }}"
+      - uses: actions/checkout@v3
+      - name: Benchmark
+        run: go test -bench=. ./storage/store

.github/workflows/publish-experimental.yml

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

.github/workflows/publish-latest-to-ghcr.yml

@@ -0,0 +1,38 @@
+name: publish-latest-to-ghcr
+on:
+  workflow_run:
+    workflows: [test]
+    branches: [master]
+    types: [completed]
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: true
+jobs:
+  publish-latest-to-ghcr:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    permissions:
+      contents: read
+      packages: write
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Get image repository
+        run: echo IMAGE_REPOSITORY=$(echo ghcr.io/${{ github.actor }}/${{ github.event.repository.name }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
+      - name: Login to Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v4
+        with:
+          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
+          pull: true
+          push: true
+          tags: ${{ env.IMAGE_REPOSITORY }}:latest

.github/workflows/publish-latest.yml

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

.github/workflows/publish-release-to-ghcr.yml

@@ -0,0 +1,37 @@
+name: publish-release-to-ghcr
+on:
+  release:
+    types: [published]
+jobs:
+  publish-release-to-ghcr:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Get image repository
+        run: echo IMAGE_REPOSITORY=$(echo ghcr.io/${{ github.actor }}/${{ github.event.repository.name }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
+      - name: Get the release
+        run: echo RELEASE=${GITHUB_REF/refs\/tags\//} >> $GITHUB_ENV
+      - name: Login to Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v4
+        with:
+          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
+          pull: true
+          push: true
+          tags: |
+            ${{ env.IMAGE_REPOSITORY }}:${{ env.RELEASE }}
+            ${{ env.IMAGE_REPOSITORY }}:stable
+            ${{ env.IMAGE_REPOSITORY }}:latest

.github/workflows/publish-release.yml

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

.github/workflows/test.yml

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

.gitignore

@@ -1,5 +1,18 @@
+# IDE
+*.iml
 .idea
 .vscode
+
+# OS
+.DS_Store
+
+# JS
+node_modules
+
+# Go
+/vendor
+
+# Misc
 *.db
 *.db-shm
 *.db-wal

Dockerfile

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

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2021 TwiN
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

Makefile

@@ -1,16 +1,19 @@
 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) .
 
 run:
-	GATUS_CONFIG_FILE=./config.yaml ./$(BINARY)
+	GATUS_CONFIG_PATH=./config.yaml ./$(BINARY)
 
 clean:
 	rm $(BINARY)
 
 test:
-	sudo go test ./alerting/... ./client/... ./config/... ./controller/... ./core/... ./jsonpath/... ./pattern/... ./security/... ./storage/... ./util/... ./watchdog/... -cover
+	go test ./... -cover
 
 
 ##########

alerting/alert/alert.go

@@ -17,6 +17,8 @@ type Alert struct {
 
 	// Enabled defines whether the alert is enabled
 	//
+	// Use Alert.IsEnabled() to retrieve the value of this field.
+	//
 	// 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,omitempty"`
@@ -77,9 +79,10 @@ func (alert Alert) GetDescription() string {
 }
 
 // IsEnabled returns whether an alert is enabled or not
+// Returns true if not set
 func (alert Alert) IsEnabled() bool {
 	if alert.Enabled == nil {
-		return false
+		return true
 	}
 	return *alert.Enabled
 }

alerting/alert/alert_test.go

@@ -52,8 +52,8 @@ func TestAlert_ValidateAndSetDefaults(t *testing.T) {
 }
 
 func TestAlert_IsEnabled(t *testing.T) {
-	if (Alert{Enabled: nil}).IsEnabled() {
-		t.Error("alert.IsEnabled() should've returned false, because Enabled was set to nil")
+	if !(Alert{Enabled: nil}).IsEnabled() {
+		t.Error("alert.IsEnabled() should've returned true, because Enabled was set to nil")
 	}
 	if value := false; (Alert{Enabled: &value}).IsEnabled() {
 		t.Error("alert.IsEnabled() should've returned false, because Enabled was set to false")

alerting/alert/type.go

@@ -14,18 +14,33 @@ const (
 	// TypeEmail is the Type for the email alerting provider
 	TypeEmail Type = "email"
 
+	// TypeGitHub is the Type for the github alerting provider
+	TypeGitHub Type = "github"
+
 	// TypeGoogleChat is the Type for the googlechat alerting provider
 	TypeGoogleChat Type = "googlechat"
 
+	// TypeMatrix is the Type for the matrix alerting provider
+	TypeMatrix Type = "matrix"
+
 	// TypeMattermost is the Type for the mattermost alerting provider
 	TypeMattermost Type = "mattermost"
 
 	// TypeMessagebird is the Type for the messagebird alerting provider
 	TypeMessagebird Type = "messagebird"
 
+	// TypeNtfy is the Type for the ntfy alerting provider
+	TypeNtfy Type = "ntfy"
+
+	// TypeOpsgenie is the Type for the opsgenie alerting provider
+	TypeOpsgenie Type = "opsgenie"
+
 	// TypePagerDuty is the Type for the pagerduty alerting provider
 	TypePagerDuty Type = "pagerduty"
 
+	// TypePushover is the Type for the pushover alerting provider
+	TypePushover Type = "pushover"
+
 	// TypeSlack is the Type for the slack alerting provider
 	TypeSlack Type = "slack"
 
@@ -37,7 +52,4 @@ 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"
 )

alerting/config.go

@@ -1,20 +1,28 @@
 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/email"
-	"github.com/TwiN/gatus/v3/alerting/provider/googlechat"
-	"github.com/TwiN/gatus/v3/alerting/provider/mattermost"
-	"github.com/TwiN/gatus/v3/alerting/provider/messagebird"
-	"github.com/TwiN/gatus/v3/alerting/provider/opsgenie"
-	"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"
+	"log"
+	"reflect"
+	"strings"
+
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/alerting/provider"
+	"github.com/TwiN/gatus/v5/alerting/provider/custom"
+	"github.com/TwiN/gatus/v5/alerting/provider/discord"
+	"github.com/TwiN/gatus/v5/alerting/provider/email"
+	"github.com/TwiN/gatus/v5/alerting/provider/github"
+	"github.com/TwiN/gatus/v5/alerting/provider/googlechat"
+	"github.com/TwiN/gatus/v5/alerting/provider/matrix"
+	"github.com/TwiN/gatus/v5/alerting/provider/mattermost"
+	"github.com/TwiN/gatus/v5/alerting/provider/messagebird"
+	"github.com/TwiN/gatus/v5/alerting/provider/ntfy"
+	"github.com/TwiN/gatus/v5/alerting/provider/opsgenie"
+	"github.com/TwiN/gatus/v5/alerting/provider/pagerduty"
+	"github.com/TwiN/gatus/v5/alerting/provider/pushover"
+	"github.com/TwiN/gatus/v5/alerting/provider/slack"
+	"github.com/TwiN/gatus/v5/alerting/provider/teams"
+	"github.com/TwiN/gatus/v5/alerting/provider/telegram"
+	"github.com/TwiN/gatus/v5/alerting/provider/twilio"
 )
 
 // Config is the configuration for alerting providers
@@ -22,24 +30,39 @@ type Config struct {
 	// Custom is the configuration for the custom alerting provider
 	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,omitempty"`
 
 	// Email is the configuration for the email alerting provider
 	Email *email.AlertProvider `yaml:"email,omitempty"`
 
+	// GitHub is the configuration for the github alerting provider
+	GitHub *github.AlertProvider `yaml:"github,omitempty"`
+
+	// GoogleChat is the configuration for the googlechat alerting provider
+	GoogleChat *googlechat.AlertProvider `yaml:"googlechat,omitempty"`
+
+	// Matrix is the configuration for the matrix alerting provider
+	Matrix *matrix.AlertProvider `yaml:"matrix,omitempty"`
+
 	// Mattermost is the configuration for the mattermost alerting provider
 	Mattermost *mattermost.AlertProvider `yaml:"mattermost,omitempty"`
 
 	// Messagebird is the configuration for the messagebird alerting provider
 	Messagebird *messagebird.AlertProvider `yaml:"messagebird,omitempty"`
 
+	// Ntfy is the configuration for the ntfy alerting provider
+	Ntfy *ntfy.AlertProvider `yaml:"ntfy,omitempty"`
+
+	// Opsgenie is the configuration for the opsgenie alerting provider
+	Opsgenie *opsgenie.AlertProvider `yaml:"opsgenie,omitempty"`
+
 	// PagerDuty is the configuration for the pagerduty alerting provider
 	PagerDuty *pagerduty.AlertProvider `yaml:"pagerduty,omitempty"`
 
+	// Pushover is the configuration for the pushover alerting provider
+	Pushover *pushover.AlertProvider `yaml:"pushover,omitempty"`
+
 	// Slack is the configuration for the slack alerting provider
 	Slack *slack.AlertProvider `yaml:"slack,omitempty"`
 
@@ -51,86 +74,33 @@ type Config struct {
 
 	// Twilio is the configuration for the twilio alerting provider
 	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
-func (config Config) GetAlertingProviderByAlertType(alertType alert.Type) provider.AlertProvider {
-	switch alertType {
-	case alert.TypeCustom:
-		if config.Custom == nil {
-			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
-			return nil
+func (config *Config) GetAlertingProviderByAlertType(alertType alert.Type) provider.AlertProvider {
+	entityType := reflect.TypeOf(config).Elem()
+	for i := 0; i < entityType.NumField(); i++ {
+		field := entityType.Field(i)
+		if strings.ToLower(field.Name) == string(alertType) {
+			fieldValue := reflect.ValueOf(config).Elem().Field(i)
+			if fieldValue.IsNil() {
+				return nil
+			}
+			return fieldValue.Interface().(provider.AlertProvider)
 		}
-		return config.Custom
-	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.TypeDiscord:
-		if config.Discord == nil {
-			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
-			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.TypeMattermost:
-		if config.Mattermost == nil {
-			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
-			return nil
-		}
-		return config.Mattermost
-	case alert.TypeMessagebird:
-		if config.Messagebird == nil {
-			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
-			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
-			return nil
-		}
-		return config.PagerDuty
-	case alert.TypeSlack:
-		if config.Slack == nil {
-			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
-			return nil
-		}
-		return config.Slack
-	case alert.TypeTeams:
-		if config.Teams == nil {
-			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
-			return nil
-		}
-		return config.Teams
-	case alert.TypeTelegram:
-		if config.Telegram == nil {
-			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
-			return nil
-		}
-		return config.Telegram
-	case alert.TypeTwilio:
-		if config.Twilio == nil {
-			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
-			return nil
-		}
-		return config.Twilio
 	}
+	log.Printf("[alerting][GetAlertingProviderByAlertType] No alerting provider found for alert type %s", alertType)
 	return nil
 }
+
+// SetAlertingProviderToNil Sets an alerting provider to nil to avoid having to revalidate it every time an
+// alert of its corresponding type is sent.
+func (config *Config) SetAlertingProviderToNil(p provider.AlertProvider) {
+	entityType := reflect.TypeOf(config).Elem()
+	for i := 0; i < entityType.NumField(); i++ {
+		field := entityType.Field(i)
+		if field.Type == reflect.TypeOf(p) {
+			reflect.ValueOf(config).Elem().Field(i).Set(reflect.Zero(field.Type))
+		}
+	}
+}

alerting/provider/custom/custom.go

@@ -7,9 +7,9 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using a custom HTTP request
@@ -50,48 +50,28 @@ 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)
 	}
@@ -99,11 +79,12 @@ func (provider *AlertProvider) buildHTTPRequest(endpointName, alertDescription s
 }
 
 func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
-	request := provider.buildHTTPRequest(endpoint.Name, alert.GetDescription(), resolved)
+	request := provider.buildHTTPRequest(endpoint, alert, resolved)
 	response, err := client.GetHTTPClient(provider.ClientConfig).Do(request)
 	if err != nil {
 		return err
 	}
+	defer response.Body.Close()
 	if response.StatusCode > 399 {
 		body, _ := io.ReadAll(response.Body)
 		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))

alerting/provider/custom/custom_test.go

@@ -1,25 +1,36 @@
 package custom
 
 import (
+	"fmt"
 	"io"
 	"net/http"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/test"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/test"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
-	invalidProvider := AlertProvider{URL: ""}
-	if invalidProvider.IsValid() {
-		t.Error("provider shouldn't have been valid")
-	}
-	validProvider := AlertProvider{URL: "https://example.com"}
-	if !validProvider.IsValid() {
-		t.Error("provider should've been valid")
-	}
+	t.Run("invalid-provider", func(t *testing.T) {
+		invalidProvider := AlertProvider{URL: ""}
+		if invalidProvider.IsValid() {
+			t.Error("provider shouldn't have been valid")
+		}
+	})
+	t.Run("valid-provider", func(t *testing.T) {
+		validProvider := AlertProvider{URL: "https://example.com"}
+		if validProvider.ClientConfig != nil {
+			t.Error("provider client config should have been nil prior to IsValid() being executed")
+		}
+		if !validProvider.IsValid() {
+			t.Error("provider should've been valid")
+		}
+		if validProvider.ClientConfig == nil {
+			t.Error("provider client config should have been set after IsValid() was executed")
+		}
+	})
 }
 
 func TestAlertProvider_Send(t *testing.T) {
@@ -99,77 +110,103 @@ func TestAlertProvider_Send(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"
-	)
+func TestAlertProvider_buildHTTPRequest(t *testing.T) {
 	customAlertProvider := &AlertProvider{
-		URL:     "https://example.com/[ENDPOINT_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
-		Body:    "[ENDPOINT_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
-		Headers: nil,
+		URL:  "https://example.com/[ENDPOINT_GROUP]/[ENDPOINT_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]&url=[ENDPOINT_URL]",
+		Body: "[ENDPOINT_NAME],[ENDPOINT_GROUP],[ALERT_DESCRIPTION],[ENDPOINT_URL],[ALERT_TRIGGERED_OR_RESOLVED]",
 	}
-	request := customAlertProvider.buildHTTPRequest("endpoint-name", "alert-description", true)
-	if request.URL.String() != ExpectedURL {
-		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
+	alertDescription := "alert-description"
+	scenarios := []struct {
+		AlertProvider *AlertProvider
+		Resolved      bool
+		ExpectedURL   string
+		ExpectedBody  string
+	}{
+		{
+			AlertProvider: customAlertProvider,
+			Resolved:      true,
+			ExpectedURL:   "https://example.com/endpoint-group/endpoint-name?event=RESOLVED&description=alert-description&url=https://example.com",
+			ExpectedBody:  "endpoint-name,endpoint-group,alert-description,https://example.com,RESOLVED",
+		},
+		{
+			AlertProvider: customAlertProvider,
+			Resolved:      false,
+			ExpectedURL:   "https://example.com/endpoint-group/endpoint-name?event=TRIGGERED&description=alert-description&url=https://example.com",
+			ExpectedBody:  "endpoint-name,endpoint-group,alert-description,https://example.com,TRIGGERED",
+		},
 	}
-	body, _ := io.ReadAll(request.Body)
-	if string(body) != ExpectedBody {
-		t.Error("expected body to be", ExpectedBody, "was", string(body))
-	}
-}
-
-func TestAlertProvider_buildHTTPRequestWhenTriggered(t *testing.T) {
-	const (
-		ExpectedURL  = "https://example.com/endpoint-name?event=TRIGGERED&description=alert-description"
-		ExpectedBody = "endpoint-name,alert-description,TRIGGERED"
-	)
-	customAlertProvider := &AlertProvider{
-		URL:     "https://example.com/[ENDPOINT_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
-		Body:    "[ENDPOINT_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
-		Headers: map[string]string{"Authorization": "Basic hunter2"},
-	}
-	request := customAlertProvider.buildHTTPRequest("endpoint-name", "alert-description", false)
-	if request.URL.String() != ExpectedURL {
-		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
-	}
-	body, _ := io.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-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, _ := io.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))
@@ -187,26 +224,3 @@ func TestAlertProvider_GetDefaultAlert(t *testing.T) {
 		t.Error("expected default alert to be nil")
 	}
 }
-
-// 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]",
-	}
-	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, _ := io.ReadAll(request.Body)
-	if string(body) != ExpectedBody {
-		t.Error("expected body to be", ExpectedBody, "was", string(body))
-	}
-}

alerting/provider/discord/discord.go

@@ -2,13 +2,14 @@ package discord
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Discord
@@ -17,17 +18,35 @@ type AlertProvider struct {
 
 	// 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 {
+	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.WebhookURL, buffer)
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, provider.getWebhookURLForGroup(endpoint.Group), buffer)
 	if err != nil {
 		return err
 	}
@@ -36,6 +55,7 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	if err != nil {
 		return err
 	}
+	defer response.Body.Close()
 	if response.StatusCode > 399 {
 		body, _ := io.ReadAll(response.Body)
 		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
@@ -43,8 +63,26 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	return err
 }
 
+type Body struct {
+	Content string  `json:"content"`
+	Embeds  []Embed `json:"embeds"`
+}
+
+type Embed struct {
+	Title       string  `json:"title"`
+	Description string  `json:"description"`
+	Color       int     `json:"color"`
+	Fields      []Field `json:"fields"`
+}
+
+type Field struct {
+	Name   string `json:"name"`
+	Value  string `json:"value"`
+	Inline bool   `json:"inline"`
+}
+
 // buildRequestBody builds the request body for the provider
-func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
 	var message, results string
 	var colorCode int
 	if resolved {
@@ -61,29 +99,42 @@ func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *
 		} else {
 			prefix = ":x:"
 		}
-		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
+		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
 	}
 	var description string
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
-		description = ":\\n> " + alertDescription
+		description = ":\n> " + alertDescription
 	}
-	return fmt.Sprintf(`{
-  "content": "",
-  "embeds": [
-    {
-      "title": ":helmet_with_white_cross: Gatus",
-      "description": "%s%s",
-      "color": %d,
-      "fields": [
-        {
-          "name": "Condition results",
-          "value": "%s",
-          "inline": false
-        }
-      ]
-    }
-  ]
-}`, message, description, colorCode, results)
+	body, _ := json.Marshal(Body{
+		Content: "",
+		Embeds: []Embed{
+			{
+				Title:       ":helmet_with_white_cross: Gatus",
+				Description: message + description,
+				Color:       colorCode,
+				Fields: []Field{
+					{
+						Name:   "Condition results",
+						Value:  results,
+						Inline: false,
+					},
+				},
+			},
+		},
+	})
+	return body
+}
+
+// getWebhookURLForGroup returns the appropriate Webhook URL integration to for a given group
+func (provider *AlertProvider) getWebhookURLForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.WebhookURL
+			}
+		}
+	}
+	return provider.WebhookURL
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/discord/discord_test.go

@@ -5,10 +5,10 @@ import (
 	"net/http"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/test"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/test"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
@@ -22,6 +22,43 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
+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"
@@ -114,14 +151,14 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 			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}",
+			ExpectedBody: "{\"content\":\"\",\"embeds\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"description\":\"An alert for **endpoint-name** has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"color\":15158332,\"fields\":[{\"name\":\"Condition results\",\"value\":\":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n:x: - `[BODY] != \\\"\\\"`\\n\",\"inline\":false}]}]}",
 		},
 		{
 			Name:         "resolved",
 			Provider:     AlertProvider{},
 			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
 			Resolved:     true,
-			ExpectedBody: "{\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}",
+			ExpectedBody: "{\"content\":\"\",\"embeds\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"description\":\"An alert for **endpoint-name** has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"color\":3066993,\"fields\":[{\"name\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n:white_check_mark: - `[BODY] != \\\"\\\"`\\n\",\"inline\":false}]}]}",
 		},
 	}
 	for _, scenario := range scenarios {
@@ -133,15 +170,16 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 					ConditionResults: []*core.ConditionResult{
 						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
 						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+						{Condition: "[BODY] != \"\"", Success: scenario.Resolved},
 					},
 				},
 				scenario.Resolved,
 			)
-			if body != scenario.ExpectedBody {
-				t.Errorf("expected %s, got %s", scenario.ExpectedBody, body)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
 			}
 			out := make(map[string]interface{})
-			if err := json.Unmarshal([]byte(body), &out); err != nil {
+			if err := json.Unmarshal(body, &out); err != nil {
 				t.Error("expected body to be valid JSON, got error:", err.Error())
 			}
 		})
@@ -156,3 +194,66 @@ func TestAlertProvider_GetDefaultAlert(t *testing.T) {
 		t.Error("expected default alert to be nil")
 	}
 }
+
+func TestAlertProvider_getWebhookURLForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example01.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getWebhookURLForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getWebhookURLForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
+	}
+}

alerting/provider/email/email.go

@@ -5,8 +5,8 @@ import (
 	"math"
 	"strings"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/core"
 	gomail "gopkg.in/mail.v2"
 )
 
@@ -21,10 +21,29 @@ type AlertProvider struct {
 
 	// 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
 }
 
@@ -39,7 +58,7 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	subject, body := provider.buildMessageSubjectAndBody(endpoint, alert, result, resolved)
 	m := gomail.NewMessage()
 	m.SetHeader("From", provider.From)
-	m.SetHeader("To", strings.Split(provider.To, ",")...)
+	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)
@@ -72,6 +91,18 @@ func (provider *AlertProvider) buildMessageSubjectAndBody(endpoint *core.Endpoin
 	return subject, message + description + "\n\nCondition results:\n" + results
 }
 
+// getToForGroup returns the appropriate email integration to for a given group
+func (provider *AlertProvider) getToForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.To
+			}
+		}
+	}
+	return provider.To
+}
+
 // GetDefaultAlert returns the provider's default alert configuration
 func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
 	return provider.DefaultAlert

alerting/provider/email/email_test.go

@@ -3,11 +3,11 @@ package email
 import (
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/core"
 )
 
-func TestAlertProvider_IsValid(t *testing.T) {
+func TestAlertDefaultProvider_IsValid(t *testing.T) {
 	invalidProvider := AlertProvider{}
 	if invalidProvider.IsValid() {
 		t.Error("provider shouldn't have been valid")
@@ -18,6 +18,47 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
+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"
@@ -77,3 +118,66 @@ func TestAlertProvider_GetDefaultAlert(t *testing.T) {
 		t.Error("expected default alert to be nil")
 	}
 }
+
+func TestAlertProvider_getToForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				To:        "to@example.com",
+				Overrides: nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "to@example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				To:        "to@example.com",
+				Overrides: nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "to@example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				To: "to@example.com",
+				Overrides: []Override{
+					{
+						Group: "group",
+						To:    "to01@example.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "to@example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				To: "to@example.com",
+				Overrides: []Override{
+					{
+						Group: "group",
+						To:    "to01@example.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "to01@example.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getToForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getToForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
+	}
+}

alerting/provider/github/github.go

@@ -0,0 +1,129 @@
+package github
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/google/go-github/v48/github"
+	"golang.org/x/oauth2"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Discord
+type AlertProvider struct {
+	RepositoryURL string `yaml:"repository-url"` // The URL of the GitHub repository to create issues in
+	Token         string `yaml:"token"`          // Token requires at least RW on issues and RO on metadata
+
+	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+
+	username        string
+	repositoryOwner string
+	repositoryName  string
+	githubClient    *github.Client
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	if len(provider.Token) == 0 || len(provider.RepositoryURL) == 0 {
+		return false
+	}
+	// Validate format of the repository URL
+	repositoryURL, err := url.Parse(provider.RepositoryURL)
+	if err != nil {
+		return false
+	}
+	baseURL := repositoryURL.Scheme + "://" + repositoryURL.Host
+	pathParts := strings.Split(repositoryURL.Path, "/")
+	if len(pathParts) != 3 {
+		return false
+	}
+	provider.repositoryOwner = pathParts[1]
+	provider.repositoryName = pathParts[2]
+	// Create oauth2 HTTP client with GitHub token
+	httpClientWithStaticTokenSource := oauth2.NewClient(context.Background(), oauth2.StaticTokenSource(&oauth2.Token{
+		AccessToken: provider.Token,
+	}))
+	// Create GitHub client
+	if baseURL == "https://github.com" {
+		provider.githubClient = github.NewClient(httpClientWithStaticTokenSource)
+	} else {
+		provider.githubClient, err = github.NewEnterpriseClient(baseURL, baseURL, httpClientWithStaticTokenSource)
+		if err != nil {
+			return false
+		}
+	}
+	// Retrieve the username once to validate that the token is valid
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	user, _, err := provider.githubClient.Users.Get(ctx, "")
+	if err != nil {
+		return false
+	}
+	provider.username = *user.Login
+	return true
+}
+
+// Send creates an issue in the designed RepositoryURL if the resolved parameter passed is false,
+// or closes the relevant issue(s) if the resolved parameter passed is true.
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	title := "alert(gatus): " + endpoint.DisplayName()
+	if !resolved {
+		_, _, err := provider.githubClient.Issues.Create(context.Background(), provider.repositoryOwner, provider.repositoryName, &github.IssueRequest{
+			Title: github.String(title),
+			Body:  github.String(provider.buildIssueBody(endpoint, alert, result)),
+		})
+		if err != nil {
+			return fmt.Errorf("failed to create issue: %w", err)
+		}
+	} else {
+		issues, _, err := provider.githubClient.Issues.ListByRepo(context.Background(), provider.repositoryOwner, provider.repositoryName, &github.IssueListByRepoOptions{
+			State:       "open",
+			Creator:     provider.username,
+			ListOptions: github.ListOptions{PerPage: 100},
+		})
+		if err != nil {
+			return fmt.Errorf("failed to list issues: %w", err)
+		}
+		for _, issue := range issues {
+			if *issue.Title == title {
+				_, _, err = provider.githubClient.Issues.Edit(context.Background(), provider.repositoryOwner, provider.repositoryName, *issue.Number, &github.IssueRequest{
+					State: github.String("closed"),
+				})
+				if err != nil {
+					return fmt.Errorf("failed to close issue: %w", err)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// buildIssueBody builds the body of the issue
+func (provider *AlertProvider) buildIssueBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result) string {
+	var results string
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = ":white_check_mark:"
+		} else {
+			prefix = ":x:"
+		}
+		results += fmt.Sprintf("- %s - `%s`\n", prefix, conditionResult.Condition)
+	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = ":\n> " + alertDescription
+	}
+	message := fmt.Sprintf("An alert for **%s** has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
+	return message + description + "\n\n## Condition results\n" + results
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/github/github_test.go

@@ -0,0 +1,158 @@
+package github
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/test"
+	"github.com/google/go-github/v48/github"
+)
+
+func TestAlertDefaultProvider_IsValid(t *testing.T) {
+	scenarios := []struct {
+		Name     string
+		Provider AlertProvider
+		Expected bool
+	}{
+		{
+			Name:     "invalid",
+			Provider: AlertProvider{RepositoryURL: "", Token: ""},
+			Expected: false,
+		},
+		{
+			Name:     "invalid-token",
+			Provider: AlertProvider{RepositoryURL: "https://github.com/TwiN/test", Token: "12345"},
+			Expected: false,
+		},
+		{
+			Name:     "missing-repository-name",
+			Provider: AlertProvider{RepositoryURL: "https://github.com/TwiN", Token: "12345"},
+			Expected: false,
+		},
+		{
+			Name:     "enterprise-client",
+			Provider: AlertProvider{RepositoryURL: "https://github.example.com/TwiN/test", Token: "12345"},
+			Expected: false,
+		},
+		{
+			Name:     "invalid-url",
+			Provider: AlertProvider{RepositoryURL: "github.com/TwiN/test", Token: "12345"},
+			Expected: false,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			if scenario.Provider.IsValid() != scenario.Expected {
+				t.Errorf("expected %t, got %t", scenario.Expected, scenario.Provider.IsValid())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_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-error",
+			Provider:      AlertProvider{RepositoryURL: "https://github.com/TwiN/test", Token: "12345"},
+			Alert:         alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:      false,
+			ExpectedError: true,
+		},
+		{
+			Name:          "resolved-error",
+			Provider:      AlertProvider{RepositoryURL: "https://github.com/TwiN/test", Token: "12345"},
+			Alert:         alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:      true,
+			ExpectedError: true,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			scenario.Provider.githubClient = github.NewClient(nil)
+			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"
+	scenarios := []struct {
+		Name         string
+		Endpoint     core.Endpoint
+		Provider     AlertProvider
+		Alert        alert.Alert
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "https://example.org"},
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, FailureThreshold: 3},
+			ExpectedBody: "An alert for **endpoint-name** has been triggered due to having failed 3 time(s) in a row:\n> description-1\n\n## Condition results\n- :white_check_mark: - `[CONNECTED] == true`\n- :x: - `[STATUS] == 200`",
+		},
+		{
+			Name:         "no-description",
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "https://example.org"},
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{FailureThreshold: 10},
+			ExpectedBody: "An alert for **endpoint-name** has been triggered due to having failed 10 time(s) in a row\n\n## Condition results\n- :white_check_mark: - `[CONNECTED] == true`\n- :x: - `[STATUS] == 200`",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildIssueBody(
+				&scenario.Endpoint,
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: true},
+						{Condition: "[STATUS] == 200", Success: false},
+					},
+				},
+			)
+			if strings.TrimSpace(body) != strings.TrimSpace(scenario.ExpectedBody) {
+				t.Errorf("expected:\n%s\ngot:\n%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")
+	}
+}

alerting/provider/googlechat/googlechat.go

@@ -2,13 +2,14 @@ package googlechat
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Google chat
@@ -20,6 +21,15 @@ type AlertProvider struct {
 
 	// 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
@@ -27,13 +37,22 @@ 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.WebhookURL, buffer)
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, provider.getWebhookURLForGroup(endpoint.Group), buffer)
 	if err != nil {
 		return err
 	}
@@ -42,6 +61,7 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	if err != nil {
 		return err
 	}
+	defer response.Body.Close()
 	if response.StatusCode > 399 {
 		body, _ := io.ReadAll(response.Body)
 		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
@@ -49,8 +69,50 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	return err
 }
 
+type Body struct {
+	Cards []Cards `json:"cards"`
+}
+
+type Cards struct {
+	Sections []Sections `json:"sections"`
+}
+
+type Sections struct {
+	Widgets []Widgets `json:"widgets"`
+}
+
+type Widgets struct {
+	KeyValue *KeyValue `json:"keyValue,omitempty"`
+	Buttons  []Buttons `json:"buttons,omitempty"`
+}
+
+type KeyValue struct {
+	TopLabel         string `json:"topLabel,omitempty"`
+	Content          string `json:"content,omitempty"`
+	ContentMultiline string `json:"contentMultiline,omitempty"`
+	BottomLabel      string `json:"bottomLabel,omitempty"`
+	Icon             string `json:"icon,omitempty"`
+}
+
+type Buttons struct {
+	TextButton TextButton `json:"textButton"`
+}
+
+type TextButton struct {
+	Text    string  `json:"text"`
+	OnClick OnClick `json:"onClick"`
+}
+
+type OnClick struct {
+	OpenLink OpenLink `json:"openLink"`
+}
+
+type OpenLink struct {
+	URL string `json:"url"`
+}
+
 // buildRequestBody builds the request body for the provider
-func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
 	var message, color string
 	if resolved {
 		color = "#36A64F"
@@ -73,49 +135,64 @@ func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *
 	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)
+	payload := Body{
+		Cards: []Cards{
+			{
+				Sections: []Sections{
+					{
+						Widgets: []Widgets{
+							{
+								KeyValue: &KeyValue{
+									TopLabel:         endpoint.DisplayName(),
+									Content:          message,
+									ContentMultiline: "true",
+									BottomLabel:      description,
+									Icon:             "BOOKMARK",
+								},
+							},
+							{
+								KeyValue: &KeyValue{
+									TopLabel:         "Condition results",
+									Content:          results,
+									ContentMultiline: "true",
+									Icon:             "DESCRIPTION",
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+	if endpoint.Type() == core.EndpointTypeHTTP {
+		// We only include a button targeting the URL if the endpoint is an HTTP endpoint
+		// If the URL isn't prefixed with https://, Google Chat will just display a blank message aynways.
+		// See https://github.com/TwiN/gatus/issues/362
+		payload.Cards[0].Sections[0].Widgets = append(payload.Cards[0].Sections[0].Widgets, Widgets{
+			Buttons: []Buttons{
+				{
+					TextButton: TextButton{
+						Text:    "URL",
+						OnClick: OnClick{OpenLink: OpenLink{URL: endpoint.URL}},
+					},
+				},
+			},
+		})
+	}
+	body, _ := json.Marshal(payload)
+	return body
+}
+
+// getWebhookURLForGroup returns the appropriate Webhook URL integration to for a given group
+func (provider *AlertProvider) getWebhookURLForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.WebhookURL
+			}
+		}
+	}
+	return provider.WebhookURL
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/googlechat/googlechat_test.go

@@ -5,13 +5,13 @@ import (
 	"net/http"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/test"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/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")
@@ -22,6 +22,43 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
+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"
@@ -104,6 +141,7 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 	secondDescription := "description-2"
 	scenarios := []struct {
 		Name         string
+		Endpoint     core.Endpoint
 		Provider     AlertProvider
 		Alert        alert.Alert
 		Resolved     bool
@@ -111,23 +149,41 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 	}{
 		{
 			Name:         "triggered",
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "https://example.org"},
 			Provider:     AlertProvider{},
 			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
 			Resolved:     false,
-			ExpectedBody: "{\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}",
+			ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#DD0000'\u003eAn alert has been triggered due to having failed 3 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-1","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"❌   [CONNECTED] == true\u003cbr\u003e❌   [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}},{"buttons":[{"textButton":{"text":"URL","onClick":{"openLink":{"url":"https://example.org"}}}}]}]}]}]}`,
 		},
 		{
 			Name:         "resolved",
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "https://example.org"},
 			Provider:     AlertProvider{},
 			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
 			Resolved:     true,
-			ExpectedBody: "{\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}",
+			ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#36A64F'\u003eAn alert has been resolved after passing successfully 5 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-2","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"✅   [CONNECTED] == true\u003cbr\u003e✅   [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}},{"buttons":[{"textButton":{"text":"URL","onClick":{"openLink":{"url":"https://example.org"}}}}]}]}]}]}`,
+		},
+		{
+			Name:         "icmp-should-not-include-url", // See https://github.com/TwiN/gatus/issues/362
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "icmp://example.org"},
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#DD0000'\u003eAn alert has been triggered due to having failed 3 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-1","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"❌   [CONNECTED] == true\u003cbr\u003e❌   [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}}]}]}]}`,
+		},
+		{
+			Name:         "tcp-should-not-include-url", // See https://github.com/TwiN/gatus/issues/362
+			Endpoint:     core.Endpoint{Name: "endpoint-name", URL: "tcp://example.org"},
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#DD0000'\u003eAn alert has been triggered due to having failed 3 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-1","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"❌   [CONNECTED] == true\u003cbr\u003e❌   [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}}]}]}]}`,
 		},
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
 			body := scenario.Provider.buildRequestBody(
-				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Endpoint,
 				&scenario.Alert,
 				&core.Result{
 					ConditionResults: []*core.ConditionResult{
@@ -137,13 +193,11 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 				},
 				scenario.Resolved,
 			)
-			b, _ := json.Marshal(body)
-			e, _ := json.Marshal(scenario.ExpectedBody)
-			if body != scenario.ExpectedBody {
-				t.Errorf("expected %s, got %s", e, b)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
 			}
 			out := make(map[string]interface{})
-			if err := json.Unmarshal([]byte(body), &out); err != nil {
+			if err := json.Unmarshal(body, &out); err != nil {
 				t.Error("expected body to be valid JSON, got error:", err.Error())
 			}
 		})
@@ -158,3 +212,66 @@ func TestAlertProvider_GetDefaultAlert(t *testing.T) {
 		t.Error("expected default alert to be nil")
 	}
 }
+
+func TestAlertProvider_getWebhookURLForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example01.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getWebhookURLForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getToForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
+	}
+}

alerting/provider/matrix/matrix.go

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

alerting/provider/matrix/matrix_test.go

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

alerting/provider/mattermost/mattermost.go

@@ -2,13 +2,14 @@ package mattermost
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Mattermost
@@ -20,6 +21,15 @@ type AlertProvider struct {
 
 	// 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
@@ -27,13 +37,22 @@ 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
 }
 
 // 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.WebhookURL, buffer)
+	request, err := http.NewRequest(http.MethodPost, provider.getWebhookURLForGroup(endpoint.Group), buffer)
 	if err != nil {
 		return err
 	}
@@ -42,6 +61,7 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	if err != nil {
 		return err
 	}
+	defer response.Body.Close()
 	if response.StatusCode > 399 {
 		body, _ := io.ReadAll(response.Body)
 		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
@@ -49,9 +69,31 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	return err
 }
 
+type Body struct {
+	Text        string       `json:"text"`
+	Username    string       `json:"username"`
+	IconURL     string       `json:"icon_url"`
+	Attachments []Attachment `json:"attachments"`
+}
+
+type Attachment struct {
+	Title    string  `json:"title"`
+	Fallback string  `json:"fallback"`
+	Text     string  `json:"text"`
+	Short    bool    `json:"short"`
+	Color    string  `json:"color"`
+	Fields   []Field `json:"fields"`
+}
+
+type Field struct {
+	Title string `json:"title"`
+	Value string `json:"value"`
+	Short bool   `json:"short"`
+}
+
 // buildRequestBody builds the request body for the provider
-func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
-	var message, color string
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
+	var message, color, results string
 	if resolved {
 		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
 		color = "#36A64F"
@@ -59,7 +101,6 @@ func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *
 		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
 		color = "#DD0000"
 	}
-	var results string
 	for _, conditionResult := range result.ConditionResults {
 		var prefix string
 		if conditionResult.Success {
@@ -67,38 +108,46 @@ func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *
 		} else {
 			prefix = ":x:"
 		}
-		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
+		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
 	}
 	var description string
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
-		description = ":\\n> " + alertDescription
+		description = ":\n> " + alertDescription
 	}
-	return fmt.Sprintf(`{
-  "text": "",
-  "username": "gatus",
-  "icon_url": "https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png",
-  "attachments": [
-    {
-      "title": ":rescue_worker_helmet: Gatus",
-      "fallback": "Gatus - %s",
-      "text": "%s%s",
-      "short": false,
-      "color": "%s",
-      "fields": [
-        {
-          "title": "URL",
-          "value": "%s",
-          "short": false
-        },
-        {
-          "title": "Condition results",
-          "value": "%s",
-          "short": false
-        }
-      ]
-    }
-  ]
-}`, message, message, description, color, endpoint.URL, results)
+	body, _ := json.Marshal(Body{
+		Text:     "",
+		Username: "gatus",
+		IconURL:  "https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png",
+		Attachments: []Attachment{
+			{
+				Title:    ":helmet_with_white_cross: Gatus",
+				Fallback: "Gatus - " + message,
+				Text:     message + description,
+				Short:    false,
+				Color:    color,
+				Fields: []Field{
+					{
+						Title: "Condition results",
+						Value: results,
+						Short: false,
+					},
+				},
+			},
+		},
+	})
+	return body
+}
+
+// getWebhookURLForGroup returns the appropriate Webhook URL integration to for a given group
+func (provider *AlertProvider) getWebhookURLForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.WebhookURL
+			}
+		}
+	}
+	return provider.WebhookURL
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/mattermost/mattermost_test.go

@@ -5,10 +5,10 @@ import (
 	"net/http"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/test"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/test"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
@@ -22,6 +22,47 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
+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")
+	}
+
+	providerWithInvalidOverrideWebHookUrl := AlertProvider{
+		Overrides: []Override{
+			{
+
+				WebhookURL: "",
+				Group:      "group",
+			},
+		},
+	}
+	if providerWithInvalidOverrideWebHookUrl.IsValid() {
+		t.Error("provider WebHookURL shoudn'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"
@@ -114,14 +155,14 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 			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}",
+			ExpectedBody: "{\"text\":\"\",\"username\":\"gatus\",\"icon_url\":\"https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"fallback\":\"Gatus - An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row\",\"text\":\"An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"short\":false,\"color\":\"#DD0000\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
 		},
 		{
 			Name:         "resolved",
 			Provider:     AlertProvider{},
 			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
 			Resolved:     true,
-			ExpectedBody: "{\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}",
+			ExpectedBody: "{\"text\":\"\",\"username\":\"gatus\",\"icon_url\":\"https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"fallback\":\"Gatus - An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row\",\"text\":\"An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"short\":false,\"color\":\"#36A64F\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
 		},
 	}
 	for _, scenario := range scenarios {
@@ -137,11 +178,11 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 				},
 				scenario.Resolved,
 			)
-			if body != scenario.ExpectedBody {
-				t.Errorf("expected %s, got %s", scenario.ExpectedBody, body)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
 			}
 			out := make(map[string]interface{})
-			if err := json.Unmarshal([]byte(body), &out); err != nil {
+			if err := json.Unmarshal(body, &out); err != nil {
 				t.Error("expected body to be valid JSON, got error:", err.Error())
 			}
 		})
@@ -156,3 +197,66 @@ func TestAlertProvider_GetDefaultAlert(t *testing.T) {
 		t.Error("expected default alert to be nil")
 	}
 }
+
+func TestAlertProvider_getWebhookURLForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example01.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getWebhookURLForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getToForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
+	}
+}

alerting/provider/messagebird/messagebird.go

@@ -2,13 +2,14 @@ package messagebird
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 const (
@@ -33,7 +34,7 @@ func (provider *AlertProvider) IsValid() bool {
 // 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)))
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
 	request, err := http.NewRequest(http.MethodPost, restAPIURL, buffer)
 	if err != nil {
 		return err
@@ -44,6 +45,7 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	if err != nil {
 		return err
 	}
+	defer response.Body.Close()
 	if response.StatusCode > 399 {
 		body, _ := io.ReadAll(response.Body)
 		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
@@ -51,19 +53,26 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	return err
 }
 
+type Body struct {
+	Originator string `json:"originator"`
+	Recipients string `json:"recipients"`
+	Body       string `json:"body"`
+}
+
 // buildRequestBody builds the request body for the provider
-func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
 	var message string
 	if resolved {
 		message = fmt.Sprintf("RESOLVED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
 	} else {
 		message = fmt.Sprintf("TRIGGERED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
 	}
-	return fmt.Sprintf(`{
-  "originator": "%s",
-  "recipients": "%s",
-  "body": "%s"
-}`, provider.Originator, provider.Recipients, message)
+	body, _ := json.Marshal(Body{
+		Originator: provider.Originator,
+		Recipients: provider.Recipients,
+		Body:       message,
+	})
+	return body
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/messagebird/messagebird_test.go

@@ -5,10 +5,10 @@ import (
 	"net/http"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/test"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/test"
 )
 
 func TestMessagebirdAlertProvider_IsValid(t *testing.T) {
@@ -118,14 +118,14 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 			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}",
+			ExpectedBody: "{\"originator\":\"2\",\"recipients\":\"3\",\"body\":\"TRIGGERED: endpoint-name - description-1\"}",
 		},
 		{
 			Name:         "resolved",
 			Provider:     AlertProvider{AccessKey: "4", Originator: "5", Recipients: "6"},
 			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
 			Resolved:     true,
-			ExpectedBody: "{\n  \"originator\": \"5\",\n  \"recipients\": \"6\",\n  \"body\": \"RESOLVED: endpoint-name - description-2\"\n}",
+			ExpectedBody: "{\"originator\":\"5\",\"recipients\":\"6\",\"body\":\"RESOLVED: endpoint-name - description-2\"}",
 		},
 	}
 	for _, scenario := range scenarios {
@@ -141,8 +141,8 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 				},
 				scenario.Resolved,
 			)
-			if body != scenario.ExpectedBody {
-				t.Errorf("expected %s, got %s", scenario.ExpectedBody, body)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
 			}
 			out := make(map[string]interface{})
 			if err := json.Unmarshal([]byte(body), &out); err != nil {

alerting/provider/ntfy/ntfy.go

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

alerting/provider/ntfy/ntfy_test.go

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

alerting/provider/opsgenie/opsgenie.go

@@ -9,9 +9,9 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 const (
@@ -83,37 +83,36 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 
 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
+	return provider.sendRequest(restAPI, http.MethodPost, payload)
 }
 
 func (provider *AlertProvider) closeAlert(endpoint *core.Endpoint, alert *alert.Alert) error {
 	payload := provider.buildCloseRequestBody(endpoint, alert)
 	url := restAPI + "/" + provider.alias(buildKey(endpoint)) + "/close?identifierType=alias"
-	_, err := provider.sendRequest(url, http.MethodPost, payload)
-	return err
+	return provider.sendRequest(url, http.MethodPost, payload)
 }
 
-func (provider *AlertProvider) sendRequest(url, method string, payload interface{}) (*http.Response, error) {
+func (provider *AlertProvider) sendRequest(url, method string, payload interface{}) error {
 	body, err := json.Marshal(payload)
 	if err != nil {
-		return nil, fmt.Errorf("fail to build alert payload: %v", payload)
+		return fmt.Errorf("error build alert with payload %v: %w", payload, err)
 	}
 	request, err := http.NewRequest(method, url, bytes.NewBuffer(body))
 	if err != nil {
-		return nil, err
+		return err
 	}
 	request.Header.Set("Content-Type", "application/json")
 	request.Header.Set("Authorization", "GenieKey "+provider.APIKey)
-	res, err := client.GetHTTPClient(nil).Do(request)
+	response, err := client.GetHTTPClient(nil).Do(request)
 	if err != nil {
-		return nil, err
+		return 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))
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		rBody, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(rBody))
 	}
-	return res, nil
+	return nil
 }
 
 func (provider *AlertProvider) buildCreateRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) alertCreateRequest {

alerting/provider/opsgenie/opsgenie_test.go

@@ -5,10 +5,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/test"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/test"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {

alerting/provider/pagerduty/pagerduty.go

@@ -8,9 +8,9 @@ import (
 	"log"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 const (
@@ -53,7 +53,7 @@ func (provider *AlertProvider) IsValid() bool {
 //
 // 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)))
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
 	request, err := http.NewRequest(http.MethodPost, restAPIURL, buffer)
 	if err != nil {
 		return err
@@ -63,6 +63,7 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	if err != nil {
 		return err
 	}
+	defer response.Body.Close()
 	if response.StatusCode > 399 {
 		body, _ := io.ReadAll(response.Body)
 		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
@@ -86,8 +87,21 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	return nil
 }
 
+type Body struct {
+	RoutingKey  string  `json:"routing_key"`
+	DedupKey    string  `json:"dedup_key"`
+	EventAction string  `json:"event_action"`
+	Payload     Payload `json:"payload"`
+}
+
+type Payload struct {
+	Summary  string `json:"summary"`
+	Source   string `json:"source"`
+	Severity string `json:"severity"`
+}
+
 // buildRequestBody builds the request body for the provider
-func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
 	var message, eventAction, resolveKey string
 	if resolved {
 		message = fmt.Sprintf("RESOLVED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
@@ -98,16 +112,17 @@ func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *
 		eventAction = "trigger"
 		resolveKey = ""
 	}
-	return fmt.Sprintf(`{
-  "routing_key": "%s",
-  "dedup_key": "%s",
-  "event_action": "%s",
-  "payload": {
-    "summary": "%s",
-    "source": "%s",
-    "severity": "critical"
-  }
-}`, provider.getIntegrationKeyForGroup(endpoint.Group), resolveKey, eventAction, message, endpoint.Name)
+	body, _ := json.Marshal(Body{
+		RoutingKey:  provider.getIntegrationKeyForGroup(endpoint.Group),
+		DedupKey:    resolveKey,
+		EventAction: eventAction,
+		Payload: Payload{
+			Summary:  message,
+			Source:   "Gatus",
+			Severity: "critical",
+		},
+	})
+	return body
 }
 
 // getIntegrationKeyForGroup returns the appropriate pagerduty integration key for a given group

alerting/provider/pagerduty/pagerduty_test.go

@@ -5,10 +5,10 @@ import (
 	"net/http"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/test"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/test"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
@@ -149,24 +149,24 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 			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}",
+			ExpectedBody: "{\"routing_key\":\"00000000000000000000000000000000\",\"dedup_key\":\"\",\"event_action\":\"trigger\",\"payload\":{\"summary\":\"TRIGGERED: endpoint-name - test\",\"source\":\"Gatus\",\"severity\":\"critical\"}}",
 		},
 		{
 			Name:         "resolved",
 			Provider:     AlertProvider{IntegrationKey: "00000000000000000000000000000000"},
 			Alert:        alert.Alert{Description: &description, ResolveKey: "key"},
 			Resolved:     true,
-			ExpectedBody: "{\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}",
+			ExpectedBody: "{\"routing_key\":\"00000000000000000000000000000000\",\"dedup_key\":\"key\",\"event_action\":\"resolve\",\"payload\":{\"summary\":\"RESOLVED: endpoint-name - test\",\"source\":\"Gatus\",\"severity\":\"critical\"}}",
 		},
 	}
 	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)
+			body := scenario.Provider.buildRequestBody(&core.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &core.Result{}, scenario.Resolved)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
 			}
 			out := make(map[string]interface{})
-			if err := json.Unmarshal([]byte(body), &out); err != nil {
+			if err := json.Unmarshal(body, &out); err != nil {
 				t.Error("expected body to be valid JSON, got error:", err.Error())
 			}
 		})

alerting/provider/provider.go

@@ -1,19 +1,24 @@
 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/email"
-	"github.com/TwiN/gatus/v3/alerting/provider/googlechat"
-	"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/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/alerting/provider/custom"
+	"github.com/TwiN/gatus/v5/alerting/provider/discord"
+	"github.com/TwiN/gatus/v5/alerting/provider/email"
+	"github.com/TwiN/gatus/v5/alerting/provider/github"
+	"github.com/TwiN/gatus/v5/alerting/provider/googlechat"
+	"github.com/TwiN/gatus/v5/alerting/provider/matrix"
+	"github.com/TwiN/gatus/v5/alerting/provider/mattermost"
+	"github.com/TwiN/gatus/v5/alerting/provider/messagebird"
+	"github.com/TwiN/gatus/v5/alerting/provider/ntfy"
+	"github.com/TwiN/gatus/v5/alerting/provider/opsgenie"
+	"github.com/TwiN/gatus/v5/alerting/provider/pagerduty"
+	"github.com/TwiN/gatus/v5/alerting/provider/pushover"
+	"github.com/TwiN/gatus/v5/alerting/provider/slack"
+	"github.com/TwiN/gatus/v5/alerting/provider/teams"
+	"github.com/TwiN/gatus/v5/alerting/provider/telegram"
+	"github.com/TwiN/gatus/v5/alerting/provider/twilio"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 // AlertProvider is the interface that each providers should implement
@@ -55,10 +60,15 @@ var (
 	_ AlertProvider = (*custom.AlertProvider)(nil)
 	_ AlertProvider = (*discord.AlertProvider)(nil)
 	_ AlertProvider = (*email.AlertProvider)(nil)
+	_ AlertProvider = (*github.AlertProvider)(nil)
 	_ AlertProvider = (*googlechat.AlertProvider)(nil)
+	_ AlertProvider = (*matrix.AlertProvider)(nil)
 	_ AlertProvider = (*mattermost.AlertProvider)(nil)
 	_ AlertProvider = (*messagebird.AlertProvider)(nil)
+	_ AlertProvider = (*ntfy.AlertProvider)(nil)
+	_ AlertProvider = (*opsgenie.AlertProvider)(nil)
 	_ AlertProvider = (*pagerduty.AlertProvider)(nil)
+	_ AlertProvider = (*pushover.AlertProvider)(nil)
 	_ AlertProvider = (*slack.AlertProvider)(nil)
 	_ AlertProvider = (*teams.AlertProvider)(nil)
 	_ AlertProvider = (*telegram.AlertProvider)(nil)

alerting/provider/provider_test.go

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

alerting/provider/pushover/pushover.go

@@ -0,0 +1,112 @@
+package pushover
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+)
+
+const (
+	restAPIURL      = "https://api.pushover.net/1/messages.json"
+	defaultPriority = 0
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Pushover
+type AlertProvider struct {
+	// Key used to authenticate the application sending
+	// See "Your Applications" on the dashboard, or add a new one: https://pushover.net/apps/build
+	ApplicationToken string `yaml:"application-token"`
+
+	// Key of the user or group the messages should be sent to
+	UserKey string `yaml:"user-key"`
+
+	// The title of your message, likely the application name
+	// default: the name of your application in Pushover
+	Title string `yaml:"title,omitempty"`
+
+	// Priority of all messages, ranging from -2 (very low) to 2 (Emergency)
+	// default: 0
+	Priority int `yaml:"priority,omitempty"`
+
+	// Sound of the messages (see: https://pushover.net/api#sounds)
+	// default: "" (pushover)
+	Sound string `yaml:"sound,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"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	if provider.Priority == 0 {
+		provider.Priority = defaultPriority
+	}
+	return len(provider.ApplicationToken) == 30 && len(provider.UserKey) == 30 && provider.Priority >= -2 && provider.Priority <= 2
+}
+
+// Send an alert using the provider
+// Reference doc for pushover: https://pushover.net/api
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, restAPIURL, buffer)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+type Body struct {
+	Token    string `json:"token"`
+	User     string `json:"user"`
+	Title    string `json:"title,omitempty"`
+	Message  string `json:"message"`
+	Priority int    `json:"priority"`
+	Sound    string `json:"sound,omitempty"`
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
+	var message string
+	if resolved {
+		message = fmt.Sprintf("RESOLVED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
+	} else {
+		message = fmt.Sprintf("TRIGGERED: %s - %s", endpoint.DisplayName(), alert.GetDescription())
+	}
+	body, _ := json.Marshal(Body{
+		Token:    provider.ApplicationToken,
+		User:     provider.UserKey,
+		Title:    provider.Title,
+		Message:  message,
+		Priority: provider.priority(),
+		Sound:    provider.Sound,
+	})
+	return body
+}
+
+func (provider *AlertProvider) priority() int {
+	if provider.Priority == 0 {
+		return defaultPriority
+	}
+	return provider.Priority
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/pushover/pushover_test.go

@@ -0,0 +1,181 @@
+package pushover
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/test"
+)
+
+func TestPushoverAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{
+		ApplicationToken: "aTokenWithLengthOf30characters",
+		UserKey:          "aTokenWithLengthOf30characters",
+		Title:            "Gatus Notification",
+		Priority:         1,
+	}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestPushoverAlertProvider_IsInvalid(t *testing.T) {
+	invalidProvider := AlertProvider{
+		ApplicationToken: "aTokenWithLengthOfMoreThan30characters",
+		UserKey:          "aTokenWithLengthOfMoreThan30characters",
+		Priority:         5,
+	}
+	if invalidProvider.IsValid() {
+		t.Error("provider should've been invalid")
+	}
+}
+
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{ApplicationToken: "TokenWithLengthOf30Characters1", UserKey: "TokenWithLengthOf30Characters4"},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\"token\":\"TokenWithLengthOf30Characters1\",\"user\":\"TokenWithLengthOf30Characters4\",\"message\":\"TRIGGERED: endpoint-name - description-1\",\"priority\":0}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{ApplicationToken: "TokenWithLengthOf30Characters2", UserKey: "TokenWithLengthOf30Characters5", Title: "Gatus Notifications", Priority: 2},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"token\":\"TokenWithLengthOf30Characters2\",\"user\":\"TokenWithLengthOf30Characters5\",\"title\":\"Gatus Notifications\",\"message\":\"RESOLVED: endpoint-name - description-2\",\"priority\":2}",
+		},
+		{
+			Name:         "with-sound",
+			Provider:     AlertProvider{ApplicationToken: "TokenWithLengthOf30Characters2", UserKey: "TokenWithLengthOf30Characters5", Title: "Gatus Notifications", Priority: 2, Sound: "falling"},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\"token\":\"TokenWithLengthOf30Characters2\",\"user\":\"TokenWithLengthOf30Characters5\",\"title\":\"Gatus Notifications\",\"message\":\"RESOLVED: endpoint-name - description-2\",\"priority\":2,\"sound\":\"falling\"}",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal(body, &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}

alerting/provider/slack/slack.go

@@ -2,32 +2,49 @@ package slack
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/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,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
 }
 
 // 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.WebhookURL, buffer)
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, provider.getWebhookURLForGroup(endpoint.Group), buffer)
 	if err != nil {
 		return err
 	}
@@ -36,6 +53,7 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	if err != nil {
 		return err
 	}
+	defer response.Body.Close()
 	if response.StatusCode > 399 {
 		body, _ := io.ReadAll(response.Body)
 		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
@@ -43,8 +61,27 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	return err
 }
 
+type Body struct {
+	Text        string       `json:"text"`
+	Attachments []Attachment `json:"attachments"`
+}
+
+type Attachment struct {
+	Title  string  `json:"title"`
+	Text   string  `json:"text"`
+	Short  bool    `json:"short"`
+	Color  string  `json:"color"`
+	Fields []Field `json:"fields"`
+}
+
+type Field struct {
+	Title string `json:"title"`
+	Value string `json:"value"`
+	Short bool   `json:"short"`
+}
+
 // buildRequestBody builds the request body for the provider
-func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
 	var message, color, results string
 	if resolved {
 		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
@@ -60,30 +97,43 @@ func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *
 		} else {
 			prefix = ":x:"
 		}
-		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
+		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
 	}
 	var description string
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
-		description = ":\\n> " + alertDescription
+		description = ":\n> " + alertDescription
 	}
-	return fmt.Sprintf(`{
-  "text": "",
-  "attachments": [
-    {
-      "title": ":helmet_with_white_cross: Gatus",
-      "text": "%s%s",
-      "short": false,
-      "color": "%s",
-      "fields": [
-        {
-          "title": "Condition results",
-          "value": "%s",
-          "short": false
-        }
-      ]
-    }
-  ]
-}`, message, description, color, results)
+	body, _ := json.Marshal(Body{
+		Text: "",
+		Attachments: []Attachment{
+			{
+				Title: ":helmet_with_white_cross: Gatus",
+				Text:  message + description,
+				Short: false,
+				Color: color,
+				Fields: []Field{
+					{
+						Title: "Condition results",
+						Value: results,
+						Short: false,
+					},
+				},
+			},
+		},
+	})
+	return body
+}
+
+// getWebhookURLForGroup returns the appropriate Webhook URL integration to for a given group
+func (provider *AlertProvider) getWebhookURLForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.WebhookURL
+			}
+		}
+	}
+	return provider.WebhookURL
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/slack/slack_test.go

@@ -5,13 +5,13 @@ import (
 	"net/http"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/test"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/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")
@@ -22,6 +22,43 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
+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"
@@ -79,7 +116,7 @@ func TestAlertProvider_Send(t *testing.T) {
 		t.Run(scenario.Name, func(t *testing.T) {
 			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
 			err := scenario.Provider.Send(
-				&core.Endpoint{Name: "name"},
+				&core.Endpoint{Name: "endpoint-name"},
 				&scenario.Alert,
 				&core.Result{
 					ConditionResults: []*core.ConditionResult{
@@ -116,7 +153,7 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 			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}",
+			ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *name* has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"short\":false,\"color\":\"#DD0000\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
 		},
 		{
 			Name:         "triggered-with-group",
@@ -124,7 +161,7 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 			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}",
+			ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *group/name* has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"short\":false,\"color\":\"#DD0000\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
 		},
 		{
 			Name:         "resolved",
@@ -132,7 +169,7 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 			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}",
+			ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *name* has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"short\":false,\"color\":\"#36A64F\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
 		},
 		{
 			Name:         "resolved-with-group",
@@ -140,7 +177,7 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 			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}",
+			ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *group/name* has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"short\":false,\"color\":\"#36A64F\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\"short\":false}]}]}",
 		},
 	}
 	for _, scenario := range scenarios {
@@ -156,11 +193,11 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 				},
 				scenario.Resolved,
 			)
-			if body != scenario.ExpectedBody {
-				t.Errorf("expected %s, got %s", scenario.ExpectedBody, body)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
 			}
 			out := make(map[string]interface{})
-			if err := json.Unmarshal([]byte(body), &out); err != nil {
+			if err := json.Unmarshal(body, &out); err != nil {
 				t.Error("expected body to be valid JSON, got error:", err.Error())
 			}
 		})
@@ -175,3 +212,66 @@ func TestAlertProvider_GetDefaultAlert(t *testing.T) {
 		t.Error("expected default alert to be nil")
 	}
 }
+
+func TestAlertProvider_getWebhookURLForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example01.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getWebhookURLForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getWebhookURLForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
+	}
+}

alerting/provider/teams/teams.go

@@ -2,13 +2,14 @@ package teams
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Teams
@@ -17,17 +18,35 @@ type AlertProvider struct {
 
 	// 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 {
+	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.WebhookURL, buffer)
+	buffer := bytes.NewBuffer(provider.buildRequestBody(endpoint, alert, result, resolved))
+	request, err := http.NewRequest(http.MethodPost, provider.getWebhookURLForGroup(endpoint.Group), buffer)
 	if err != nil {
 		return err
 	}
@@ -36,6 +55,7 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	if err != nil {
 		return err
 	}
+	defer response.Body.Close()
 	if response.StatusCode > 399 {
 		body, _ := io.ReadAll(response.Body)
 		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
@@ -43,8 +63,22 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	return err
 }
 
+type Body struct {
+	Type       string    `json:"@type"`
+	Context    string    `json:"@context"`
+	ThemeColor string    `json:"themeColor"`
+	Title      string    `json:"title"`
+	Text       string    `json:"text"`
+	Sections   []Section `json:"sections"`
+}
+
+type Section struct {
+	ActivityTitle string `json:"activityTitle"`
+	Text          string `json:"text"`
+}
+
 // buildRequestBody builds the request body for the provider
-func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) []byte {
 	var message, color string
 	if resolved {
 		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
@@ -65,25 +99,34 @@ func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *
 	}
 	var description string
 	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
-		description = ":\\n> " + alertDescription
+		description = ": " + alertDescription
 	}
-	return fmt.Sprintf(`{
-  "@type": "MessageCard",
-  "@context": "http://schema.org/extensions",
-  "themeColor": "%s",
-  "title": "🚨 Gatus",
-  "text": "%s%s",
-  "sections": [
-    {
-      "activityTitle": "URL",
-      "text": "%s"
-    },
-    {
-      "activityTitle": "Condition results",
-      "text": "%s"
-    }
-  ]
-}`, color, message, description, endpoint.URL, results)
+	body, _ := json.Marshal(Body{
+		Type:       "MessageCard",
+		Context:    "http://schema.org/extensions",
+		ThemeColor: color,
+		Title:      "🚨 Gatus",
+		Text:       message + description,
+		Sections: []Section{
+			{
+				ActivityTitle: "Condition results",
+				Text:          results,
+			},
+		},
+	})
+	return body
+}
+
+// getWebhookURLForGroup returns the appropriate Webhook URL integration to for a given group
+func (provider *AlertProvider) getWebhookURLForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.WebhookURL
+			}
+		}
+	}
+	return provider.WebhookURL
 }
 
 // GetDefaultAlert returns the provider's default alert configuration

alerting/provider/teams/teams_test.go

@@ -5,13 +5,13 @@ import (
 	"net/http"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/test"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/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")
@@ -22,6 +22,43 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
+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"
@@ -114,14 +151,14 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 			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}",
+			ExpectedBody: "{\"@type\":\"MessageCard\",\"@context\":\"http://schema.org/extensions\",\"themeColor\":\"#DD0000\",\"title\":\"\\u0026#x1F6A8; Gatus\",\"text\":\"An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row: description-1\",\"sections\":[{\"activityTitle\":\"Condition results\",\"text\":\"\\u0026#x274C; - `[CONNECTED] == true`\\u003cbr/\\u003e\\u0026#x274C; - `[STATUS] == 200`\\u003cbr/\\u003e\"}]}",
 		},
 		{
 			Name:         "resolved",
 			Provider:     AlertProvider{},
 			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
 			Resolved:     true,
-			ExpectedBody: "{\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}",
+			ExpectedBody: "{\"@type\":\"MessageCard\",\"@context\":\"http://schema.org/extensions\",\"themeColor\":\"#36A64F\",\"title\":\"\\u0026#x1F6A8; Gatus\",\"text\":\"An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row: description-2\",\"sections\":[{\"activityTitle\":\"Condition results\",\"text\":\"\\u0026#x2705; - `[CONNECTED] == true`\\u003cbr/\\u003e\\u0026#x2705; - `[STATUS] == 200`\\u003cbr/\\u003e\"}]}",
 		},
 	}
 	for _, scenario := range scenarios {
@@ -137,11 +174,11 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 				},
 				scenario.Resolved,
 			)
-			if body != scenario.ExpectedBody {
-				t.Errorf("expected %s, got %s", scenario.ExpectedBody, body)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
 			}
 			out := make(map[string]interface{})
-			if err := json.Unmarshal([]byte(body), &out); err != nil {
+			if err := json.Unmarshal(body, &out); err != nil {
 				t.Error("expected body to be valid JSON, got error:", err.Error())
 			}
 		})
@@ -156,3 +193,66 @@ func TestAlertProvider_GetDefaultAlert(t *testing.T) {
 		t.Error("expected default alert to be nil")
 	}
 }
+
+func TestAlertProvider_getWebhookURLForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides:  nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "http://example.com",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				WebhookURL: "http://example.com",
+				Overrides: []Override{
+					{
+						Group:      "group",
+						WebhookURL: "http://example01.com",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "http://example01.com",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getWebhookURLForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getToForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
+	}
+}

alerting/provider/telegram/telegram.go

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

alerting/provider/telegram/telegram_test.go

@@ -5,21 +5,31 @@ import (
 	"net/http"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/test"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/test"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
-	invalidProvider := AlertProvider{Token: "", ID: ""}
-	if invalidProvider.IsValid() {
-		t.Error("provider shouldn't have been valid")
-	}
-	validProvider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}
-	if !validProvider.IsValid() {
-		t.Error("provider should've been valid")
-	}
+	t.Run("invalid-provider", func(t *testing.T) {
+		invalidProvider := AlertProvider{Token: "", ID: ""}
+		if invalidProvider.IsValid() {
+			t.Error("provider shouldn't have been valid")
+		}
+	})
+	t.Run("valid-provider", func(t *testing.T) {
+		validProvider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}
+		if validProvider.ClientConfig != nil {
+			t.Error("provider client config should have been nil prior to IsValid() being executed")
+		}
+		if !validProvider.IsValid() {
+			t.Error("provider should've been valid")
+		}
+		if validProvider.ClientConfig == nil {
+			t.Error("provider client config should have been set after IsValid() was executed")
+		}
+	})
 }
 
 func TestAlertProvider_Send(t *testing.T) {
@@ -114,14 +124,14 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 			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\"}",
+			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\"}",
+			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\"}",
 		},
 	}
 	for _, scenario := range scenarios {
@@ -137,11 +147,11 @@ func TestAlertProvider_buildRequestBody(t *testing.T) {
 				},
 				scenario.Resolved,
 			)
-			if body != scenario.ExpectedBody {
-				t.Errorf("expected %s, got %s", scenario.ExpectedBody, body)
+			if string(body) != scenario.ExpectedBody {
+				t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body)
 			}
 			out := make(map[string]interface{})
-			if err := json.Unmarshal([]byte(body), &out); err != nil {
+			if err := json.Unmarshal(body, &out); err != nil {
 				t.Error("expected body to be valid JSON, got error:", err.Error())
 			}
 		})

alerting/provider/twilio/twilio.go

@@ -8,9 +8,9 @@ import (
 	"net/http"
 	"net/url"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Twilio
@@ -42,6 +42,7 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 	if err != nil {
 		return err
 	}
+	defer response.Body.Close()
 	if response.StatusCode > 399 {
 		body, _ := io.ReadAll(response.Body)
 		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))

alerting/provider/twilio/twilio_test.go

@@ -3,8 +3,8 @@ package twilio
 import (
 	"testing"
 
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 func TestTwilioAlertProvider_IsValid(t *testing.T) {

client/client.go

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

client/client_test.go

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

client/config.go

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

client/config_test.go

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

config.yaml

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

config/config.go

@@ -2,25 +2,33 @@ package config
 
 import (
 	"errors"
+	"fmt"
+	"io/fs"
 	"log"
 	"os"
+	"path/filepath"
+	"strings"
 	"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"
-	"gopkg.in/yaml.v2"
+	"github.com/TwiN/deepmerge"
+	"github.com/TwiN/gatus/v5/alerting"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/alerting/provider"
+	"github.com/TwiN/gatus/v5/config/connectivity"
+	"github.com/TwiN/gatus/v5/config/maintenance"
+	"github.com/TwiN/gatus/v5/config/remote"
+	"github.com/TwiN/gatus/v5/config/ui"
+	"github.com/TwiN/gatus/v5/config/web"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/security"
+	"github.com/TwiN/gatus/v5/storage"
+	"github.com/TwiN/gatus/v5/util"
+	"gopkg.in/yaml.v3"
 )
 
 const (
 	// DefaultConfigurationFilePath is the default path that will be used to search for the configuration file
-	// if a custom path isn't configured through the GATUS_CONFIG_FILE environment variable
+	// if a custom path isn't configured through the GATUS_CONFIG_PATH environment variable
 	DefaultConfigurationFilePath = "config/config.yaml"
 
 	// DefaultFallbackConfigurationFilePath is the default fallback path that will be used to search for the
@@ -29,14 +37,17 @@ const (
 )
 
 var (
-	// ErrNoEndpointInConfig is an error returned when a configuration file has no endpoints configured
-	ErrNoEndpointInConfig = errors.New("configuration file should contain at least 1 endpoint")
+	// ErrNoEndpointInConfig is an error returned when a configuration file or directory has no endpoints configured
+	ErrNoEndpointInConfig = errors.New("configuration should contain at least 1 endpoint")
 
-	// ErrConfigFileNotFound is an error returned when the configuration file could not be found
+	// ErrConfigFileNotFound is an error returned when a configuration file could not be found
 	ErrConfigFileNotFound = errors.New("configuration file not found")
 
 	// ErrInvalidSecurityConfig is an error returned when the security configuration is invalid
 	ErrInvalidSecurityConfig = errors.New("invalid security configuration")
+
+	// errEarlyReturn is returned to break out of a loop from a callback early
+	errEarlyReturn = errors.New("early escape")
 )
 
 // Config is the main configuration structure
@@ -65,14 +76,6 @@ type Config struct {
 	// Endpoints List of endpoints to monitor
 	Endpoints []*core.Endpoint `yaml:"endpoints,omitempty"`
 
-	// Services List of endpoints to monitor
-	//
-	// XXX: Remove this in v5.0.0
-	// XXX: This is not a typo -- not v4.0.0, but v5.0.0 -- I want to give enough time for people to migrate
-	//
-	// Deprecated in favor of Endpoints
-	Services []*core.Endpoint `yaml:"services,omitempty"`
-
 	// Storage is the configuration for how the data is stored
 	Storage *storage.Config `yaml:"storage,omitempty"`
 
@@ -85,83 +88,148 @@ type Config struct {
 	// Maintenance is the configuration for creating a maintenance window in which no alerts are sent
 	Maintenance *maintenance.Config `yaml:"maintenance,omitempty"`
 
-	filePath        string    // path to the file from which config was loaded from
+	// Remote is the configuration for remote Gatus instances
+	// WARNING: This is in ALPHA and may change or be completely removed in the future
+	Remote *remote.Config `yaml:"remote,omitempty"`
+
+	// Connectivity is the configuration for connectivity
+	Connectivity *connectivity.Config `yaml:"connectivity,omitempty"`
+
+	configPath      string    // path to the file or directory from which config was loaded
 	lastFileModTime time.Time // last modification time
 }
 
-// HasLoadedConfigurationFileBeenModified returns whether the file that the
-// configuration has been loaded from has been modified since it was last read
-func (config Config) HasLoadedConfigurationFileBeenModified() bool {
-	if fileInfo, err := os.Stat(config.filePath); err == nil {
-		if !fileInfo.ModTime().IsZero() {
-			return config.lastFileModTime.Unix() != fileInfo.ModTime().Unix()
+func (config *Config) GetEndpointByKey(key string) *core.Endpoint {
+	// TODO: Should probably add a mutex here to prevent concurrent access
+	for i := 0; i < len(config.Endpoints); i++ {
+		ep := config.Endpoints[i]
+		if util.ConvertGroupAndEndpointNameToKey(ep.Group, ep.Name) == key {
+			return ep
 		}
 	}
-	return false
+	return nil
+}
+
+// HasLoadedConfigurationBeenModified returns whether one of the file that the
+// configuration has been loaded from has been modified since it was last read
+func (config Config) HasLoadedConfigurationBeenModified() bool {
+	lastMod := config.lastFileModTime.Unix()
+	fileInfo, err := os.Stat(config.configPath)
+	if err != nil {
+		return false
+	}
+	if fileInfo.IsDir() {
+		err = walkConfigDir(config.configPath, func(path string, d fs.DirEntry, err error) error {
+			if info, err := d.Info(); err == nil && lastMod < info.ModTime().Unix() {
+				return errEarlyReturn
+			}
+			return nil
+		})
+		return err == errEarlyReturn
+	}
+	return !fileInfo.ModTime().IsZero() && config.lastFileModTime.Unix() < fileInfo.ModTime().Unix()
 }
 
 // UpdateLastFileModTime refreshes Config.lastFileModTime
 func (config *Config) UpdateLastFileModTime() {
-	if fileInfo, err := os.Stat(config.filePath); err == nil {
-		if !fileInfo.ModTime().IsZero() {
-			config.lastFileModTime = fileInfo.ModTime()
+	config.lastFileModTime = time.Now()
+}
+
+// LoadConfiguration loads the full configuration composed from the main configuration file
+// and all composed configuration files
+func LoadConfiguration(configPath string) (*Config, error) {
+	var configBytes []byte
+	var fileInfo os.FileInfo
+	var usedConfigPath string
+	// Figure out what config path we'll use (either configPath or the default config path)
+	for _, configurationPath := range []string{configPath, DefaultConfigurationFilePath, DefaultFallbackConfigurationFilePath} {
+		if len(configurationPath) == 0 {
+			continue
+		}
+		var err error
+		fileInfo, err = os.Stat(configurationPath)
+		if err != nil {
+			continue
+		}
+		usedConfigPath = configurationPath
+		break
+	}
+	if len(usedConfigPath) == 0 {
+		return nil, ErrConfigFileNotFound
+	}
+	var config *Config
+	if fileInfo.IsDir() {
+		err := walkConfigDir(configPath, func(path string, d fs.DirEntry, err error) error {
+			if err != nil {
+				log.Printf("[config][LoadConfiguration] Error walking path=%s: %s", path, err)
+				return err
+			}
+			log.Printf("[config][LoadConfiguration] Reading configuration from %s", path)
+			data, err := os.ReadFile(path)
+			if err != nil {
+				log.Printf("[config][LoadConfiguration] Error reading configuration from %s: %s", path, err)
+				return fmt.Errorf("error reading configuration from file %s: %w", path, err)
+			}
+			configBytes, err = deepmerge.YAML(configBytes, data)
+			return err
+		})
+		if err != nil {
+			return nil, fmt.Errorf("error reading configuration from directory %s: %w", usedConfigPath, err)
 		}
 	} else {
-		log.Println("[config][UpdateLastFileModTime] Ran into error updating lastFileModTime:", err.Error())
-	}
-}
-
-// Load loads a custom configuration file
-// Note that the misconfiguration of some fields may lead to panics. This is on purpose.
-func Load(configFile string) (*Config, error) {
-	log.Printf("[config][Load] Reading configuration from configFile=%s", configFile)
-	cfg, err := readConfigurationFile(configFile)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil, ErrConfigFileNotFound
+		log.Printf("[config][LoadConfiguration] Reading configuration from configFile=%s", configPath)
+		if data, err := os.ReadFile(usedConfigPath); err != nil {
+			return nil, err
+		} else {
+			configBytes = data
 		}
+	}
+	if len(configBytes) == 0 {
+		return nil, ErrConfigFileNotFound
+	}
+	config, err := parseAndValidateConfigBytes(configBytes)
+	if err != nil {
 		return nil, err
 	}
-	cfg.filePath = configFile
-	cfg.UpdateLastFileModTime()
-	return cfg, nil
+	config.configPath = usedConfigPath
+	config.UpdateLastFileModTime()
+	return config, err
 }
 
-// LoadDefaultConfiguration loads the default configuration file
-func LoadDefaultConfiguration() (*Config, error) {
-	cfg, err := Load(DefaultConfigurationFilePath)
-	if err != nil {
-		if err == ErrConfigFileNotFound {
-			return Load(DefaultFallbackConfigurationFilePath)
+// walkConfigDir is a wrapper for filepath.WalkDir that strips directories and non-config files
+func walkConfigDir(path string, fn fs.WalkDirFunc) error {
+	if len(path) == 0 {
+		// If the user didn't provide a directory, we'll just use the default config file, so we can return nil now.
+		return nil
+	}
+	return filepath.WalkDir(path, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return nil
 		}
-		return nil, err
-	}
-	return cfg, nil
-}
-
-func readConfigurationFile(fileName string) (config *Config, err error) {
-	var bytes []byte
-	if bytes, err = os.ReadFile(fileName); err == nil {
-		// file exists, so we'll parse it and return it
-		return parseAndValidateConfigBytes(bytes)
-	}
-	return
+		if d == nil || d.IsDir() {
+			return nil
+		}
+		ext := filepath.Ext(path)
+		if ext != ".yml" && ext != ".yaml" {
+			return nil
+		}
+		return fn(path, d, err)
+	})
 }
 
 // parseAndValidateConfigBytes parses a Gatus configuration file into a Config struct and validates its parameters
 func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
+	// Replace $$ with __GATUS_LITERAL_DOLLAR_SIGN__ to prevent os.ExpandEnv from treating "$$" as if it was an
+	// environment variable. This allows Gatus to support literal "$" in the configuration file.
+	yamlBytes = []byte(strings.ReplaceAll(string(yamlBytes), "$$", "__GATUS_LITERAL_DOLLAR_SIGN__"))
 	// Expand environment variables
 	yamlBytes = []byte(os.ExpandEnv(string(yamlBytes)))
+	// Replace __GATUS_LITERAL_DOLLAR_SIGN__ with "$" to restore the literal "$" in the configuration file
+	yamlBytes = []byte(strings.ReplaceAll(string(yamlBytes), "__GATUS_LITERAL_DOLLAR_SIGN__", "$"))
 	// Parse configuration file
 	if err = yaml.Unmarshal(yamlBytes, &config); err != nil {
 		return
 	}
-	if config != nil && len(config.Services) > 0 { // XXX: Remove this in v5.0.0
-		log.Println("WARNING: Your configuration is using 'services:', which is deprecated in favor of 'endpoints:'.")
-		log.Println("WARNING: See https://github.com/TwiN/gatus/issues/191 for more information")
-		config.Endpoints = append(config.Endpoints, config.Services...)
-		config.Services = nil
-	}
 	// Check if the configuration file at least has endpoints configured
 	if config == nil || config.Endpoints == nil || len(config.Endpoints) == 0 {
 		err = ErrNoEndpointInConfig
@@ -185,10 +253,32 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 		if err := validateStorageConfig(config); err != nil {
 			return nil, err
 		}
+		if err := validateRemoteConfig(config); err != nil {
+			return nil, err
+		}
+		if err := validateConnectivityConfig(config); err != nil {
+			return nil, err
+		}
 	}
 	return
 }
 
+func validateConnectivityConfig(config *Config) error {
+	if config.Connectivity != nil {
+		return config.Connectivity.ValidateAndSetDefaults()
+	}
+	return nil
+}
+
+func validateRemoteConfig(config *Config) error {
+	if config.Remote != nil {
+		if err := config.Remote.ValidateAndSetDefaults(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func validateStorageConfig(config *Config) error {
 	if config.Storage == nil {
 		config.Storage = &storage.Config{
@@ -239,7 +329,7 @@ func validateEndpointsConfig(config *Config) error {
 			log.Printf("[config][validateEndpointsConfig] Validating endpoint '%s'", endpoint.Name)
 		}
 		if err := endpoint.ValidateAndSetDefaults(); err != nil {
-			return err
+			return fmt.Errorf("invalid endpoint %s: %w", endpoint.DisplayName(), err)
 		}
 	}
 	log.Printf("[config][validateEndpointsConfig] Validated %d endpoints", len(config.Endpoints))
@@ -273,11 +363,16 @@ func validateAlertingConfig(alertingConfig *alerting.Config, endpoints []*core.E
 	alertTypes := []alert.Type{
 		alert.TypeCustom,
 		alert.TypeDiscord,
+		alert.TypeGitHub,
+		alert.TypeGoogleChat,
 		alert.TypeEmail,
+		alert.TypeMatrix,
 		alert.TypeMattermost,
 		alert.TypeMessagebird,
+		alert.TypeNtfy,
 		alert.TypeOpsgenie,
 		alert.TypePagerDuty,
+		alert.TypePushover,
 		alert.TypeSlack,
 		alert.TypeTeams,
 		alert.TypeTelegram,
@@ -305,6 +400,7 @@ func validateAlertingConfig(alertingConfig *alerting.Config, endpoints []*core.E
 			} else {
 				log.Printf("[config][validateAlertingConfig] Ignoring provider=%s because configuration is invalid", alertType)
 				invalidProviders = append(invalidProviders, alertType)
+				alertingConfig.SetAlertingProviderToNil(alertProvider)
 			}
 		} else {
 			invalidProviders = append(invalidProviders, alertType)

config/config_test.go

@@ -1,48 +1,304 @@
 package config
 
 import (
+	"errors"
 	"fmt"
+	"os"
+	"path/filepath"
 	"testing"
 	"time"
 
-	"github.com/TwiN/gatus/v3/alerting"
-	"github.com/TwiN/gatus/v3/alerting/alert"
-	"github.com/TwiN/gatus/v3/alerting/provider/custom"
-	"github.com/TwiN/gatus/v3/alerting/provider/discord"
-	"github.com/TwiN/gatus/v3/alerting/provider/mattermost"
-	"github.com/TwiN/gatus/v3/alerting/provider/messagebird"
-	"github.com/TwiN/gatus/v3/alerting/provider/pagerduty"
-	"github.com/TwiN/gatus/v3/alerting/provider/slack"
-	"github.com/TwiN/gatus/v3/alerting/provider/teams"
-	"github.com/TwiN/gatus/v3/alerting/provider/telegram"
-	"github.com/TwiN/gatus/v3/alerting/provider/twilio"
-	"github.com/TwiN/gatus/v3/client"
-	"github.com/TwiN/gatus/v3/config/ui"
-	"github.com/TwiN/gatus/v3/config/web"
-	"github.com/TwiN/gatus/v3/core"
-	"github.com/TwiN/gatus/v3/storage"
+	"github.com/TwiN/gatus/v5/alerting"
+	"github.com/TwiN/gatus/v5/alerting/alert"
+	"github.com/TwiN/gatus/v5/alerting/provider"
+	"github.com/TwiN/gatus/v5/alerting/provider/custom"
+	"github.com/TwiN/gatus/v5/alerting/provider/discord"
+	"github.com/TwiN/gatus/v5/alerting/provider/email"
+	"github.com/TwiN/gatus/v5/alerting/provider/github"
+	"github.com/TwiN/gatus/v5/alerting/provider/googlechat"
+	"github.com/TwiN/gatus/v5/alerting/provider/matrix"
+	"github.com/TwiN/gatus/v5/alerting/provider/mattermost"
+	"github.com/TwiN/gatus/v5/alerting/provider/messagebird"
+	"github.com/TwiN/gatus/v5/alerting/provider/ntfy"
+	"github.com/TwiN/gatus/v5/alerting/provider/opsgenie"
+	"github.com/TwiN/gatus/v5/alerting/provider/pagerduty"
+	"github.com/TwiN/gatus/v5/alerting/provider/pushover"
+	"github.com/TwiN/gatus/v5/alerting/provider/slack"
+	"github.com/TwiN/gatus/v5/alerting/provider/teams"
+	"github.com/TwiN/gatus/v5/alerting/provider/telegram"
+	"github.com/TwiN/gatus/v5/alerting/provider/twilio"
+	"github.com/TwiN/gatus/v5/client"
+	"github.com/TwiN/gatus/v5/config/web"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/storage"
+	"gopkg.in/yaml.v3"
 )
 
-func TestLoadFileThatDoesNotExist(t *testing.T) {
-	_, err := Load("file-that-does-not-exist.yaml")
-	if err == nil {
-		t.Error("Should've returned an error, because the file specified doesn't exist")
+func TestLoadConfiguration(t *testing.T) {
+	dir := t.TempDir()
+	scenarios := []struct {
+		name           string
+		configPath     string            // value to pass as the configPath parameter in LoadConfiguration
+		pathAndFiles   map[string]string // files to create in dir
+		expectedConfig *Config
+		expectedError  error
+	}{
+		{
+			name:       "empty-config-file",
+			configPath: filepath.Join(dir, "config.yaml"),
+			pathAndFiles: map[string]string{
+				"config.yaml": "",
+			},
+			expectedError: ErrConfigFileNotFound,
+		},
+		{
+			name:          "config-file-that-does-not-exist",
+			configPath:    filepath.Join(dir, "config.yaml"),
+			expectedError: ErrConfigFileNotFound,
+		},
+		{
+			name:       "config-file-with-endpoint-that-has-no-url",
+			configPath: filepath.Join(dir, "config.yaml"),
+			pathAndFiles: map[string]string{
+				"config.yaml": `
+endpoints:
+  - name: website`,
+			},
+			expectedError: core.ErrEndpointWithNoURL,
+		},
+		{
+			name:       "config-file-with-endpoint-that-has-no-conditions",
+			configPath: filepath.Join(dir, "config.yaml"),
+			pathAndFiles: map[string]string{
+				"config.yaml": `
+endpoints:
+  - name: website
+    url: https://twin.sh/health`,
+			},
+			expectedError: core.ErrEndpointWithNoCondition,
+		},
+		{
+			name:       "config-file",
+			configPath: filepath.Join(dir, "config.yaml"),
+			pathAndFiles: map[string]string{
+				"config.yaml": `
+endpoints:
+  - name: website
+    url: https://twin.sh/health
+    conditions:
+      - "[STATUS] == 200"`,
+			},
+			expectedConfig: &Config{
+				Endpoints: []*core.Endpoint{
+					{
+						Name:       "website",
+						URL:        "https://twin.sh/health",
+						Conditions: []core.Condition{"[STATUS] == 200"},
+					},
+				},
+			},
+		},
+		{
+			name:          "empty-dir",
+			configPath:    dir,
+			pathAndFiles:  map[string]string{},
+			expectedError: ErrConfigFileNotFound,
+		},
+		{
+			name:       "dir-with-empty-config-file",
+			configPath: dir,
+			pathAndFiles: map[string]string{
+				"config.yaml": "",
+			},
+			expectedError: ErrNoEndpointInConfig,
+		},
+		{
+			name:       "dir-with-two-config-files",
+			configPath: dir,
+			pathAndFiles: map[string]string{
+				"config.yaml": `endpoints: 
+  - name: one
+    url: https://example.com
+    conditions:
+      - "[CONNECTED] == true"
+      - "[STATUS] == 200"
+
+  - name: two
+    url: https://example.org
+    conditions:
+      - "len([BODY]) > 0"`,
+				"config.yml": `endpoints: 
+  - name: three
+    url: https://twin.sh/health
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"`,
+			},
+			expectedConfig: &Config{
+				Endpoints: []*core.Endpoint{
+					{
+						Name:       "one",
+						URL:        "https://example.com",
+						Conditions: []core.Condition{"[CONNECTED] == true", "[STATUS] == 200"},
+					},
+					{
+						Name:       "two",
+						URL:        "https://example.org",
+						Conditions: []core.Condition{"len([BODY]) > 0"},
+					},
+					{
+						Name:       "three",
+						URL:        "https://twin.sh/health",
+						Conditions: []core.Condition{"[STATUS] == 200", "[BODY].status == UP"},
+					},
+				},
+			},
+		},
+		{
+			name:       "dir-with-2-config-files-deep-merge-with-map-slice-and-primitive",
+			configPath: dir,
+			pathAndFiles: map[string]string{
+				"a.yaml": `
+metrics: true
+
+alerting:
+  slack:
+    webhook-url: https://hooks.slack.com/services/xxx/yyy/zzz
+
+endpoints:
+  - name: example
+    url: https://example.org
+    interval: 5s
+    conditions:
+      - "[STATUS] == 200"`,
+				"b.yaml": `
+debug: true
+
+alerting:
+  discord:
+    webhook-url: https://discord.com/api/webhooks/xxx/yyy
+
+endpoints:
+  - name: frontend
+    url: https://example.com
+    conditions:
+      - "[STATUS] == 200"`,
+			},
+			expectedConfig: &Config{
+				Debug:   true,
+				Metrics: true,
+				Alerting: &alerting.Config{
+					Discord: &discord.AlertProvider{WebhookURL: "https://discord.com/api/webhooks/xxx/yyy"},
+					Slack:   &slack.AlertProvider{WebhookURL: "https://hooks.slack.com/services/xxx/yyy/zzz"},
+				},
+				Endpoints: []*core.Endpoint{
+					{
+						Name:       "example",
+						URL:        "https://example.org",
+						Interval:   5 * time.Second,
+						Conditions: []core.Condition{"[STATUS] == 200"},
+					},
+					{
+						Name:       "frontend",
+						URL:        "https://example.com",
+						Conditions: []core.Condition{"[STATUS] == 200"},
+					},
+				},
+			},
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			for path, content := range scenario.pathAndFiles {
+				if err := os.WriteFile(filepath.Join(dir, path), []byte(content), 0644); err != nil {
+					t.Fatalf("[%s] failed to write file: %v", scenario.name, err)
+				}
+			}
+			defer func(pathAndFiles map[string]string) {
+				for path := range pathAndFiles {
+					_ = os.Remove(filepath.Join(dir, path))
+				}
+			}(scenario.pathAndFiles)
+			config, err := LoadConfiguration(scenario.configPath)
+			if !errors.Is(err, scenario.expectedError) {
+				t.Errorf("[%s] expected error %v, got %v", scenario.name, scenario.expectedError, err)
+				return
+			} else if err != nil && errors.Is(err, scenario.expectedError) {
+				return
+			}
+			// parse the expected output so that expectations are closer to reality (under the right circumstances, even I can be poetic)
+			expectedConfigAsYAML, _ := yaml.Marshal(scenario.expectedConfig)
+			expectedConfigAfterBeingParsedAndValidated, err := parseAndValidateConfigBytes(expectedConfigAsYAML)
+			if err != nil {
+				t.Fatalf("[%s] failed to parse expected config: %v", scenario.name, err)
+			}
+			// Marshal em' before comparing em' so that we don't have to deal with formatting and ordering
+			actualConfigAsYAML, err := yaml.Marshal(config)
+			if err != nil {
+				t.Fatalf("[%s] failed to marshal actual config: %v", scenario.name, err)
+			}
+			expectedConfigAfterBeingParsedAndValidatedAsYAML, _ := yaml.Marshal(expectedConfigAfterBeingParsedAndValidated)
+			if string(actualConfigAsYAML) != string(expectedConfigAfterBeingParsedAndValidatedAsYAML) {
+				t.Errorf("[%s] expected config %s, got %s", scenario.name, string(expectedConfigAfterBeingParsedAndValidatedAsYAML), string(actualConfigAsYAML))
+			}
+		})
 	}
 }
 
-func TestLoadDefaultConfigurationFile(t *testing.T) {
-	_, err := LoadDefaultConfiguration()
-	if err == nil {
-		t.Error("Should've returned an error, because there's no configuration files at the default path nor the default fallback path")
-	}
+func TestConfig_HasLoadedConfigurationBeenModified(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+
+	configFilePath := filepath.Join(dir, "config.yaml")
+	_ = os.WriteFile(configFilePath, []byte(`endpoints:
+  - name: website
+    url: https://twin.sh/health
+    conditions:
+      - "[STATUS] == 200"
+`), 0644)
+
+	t.Run("config-file-as-config-path", func(t *testing.T) {
+		config, err := LoadConfiguration(configFilePath)
+		if err != nil {
+			t.Fatalf("failed to load configuration: %v", err)
+		}
+		if config.HasLoadedConfigurationBeenModified() {
+			t.Errorf("expected config.HasLoadedConfigurationBeenModified() to return false because nothing has happened since it was created")
+		}
+		time.Sleep(time.Second) // Because the file mod time only has second precision, we have to wait for a second
+		// Update the config file
+		if err = os.WriteFile(filepath.Join(dir, "config.yaml"), []byte(`endpoints:
+  - name: website
+    url: https://twin.sh/health
+    conditions:
+      - "[STATUS] == 200"`), 0644); err != nil {
+			t.Fatalf("failed to overwrite config file: %v", err)
+		}
+		if !config.HasLoadedConfigurationBeenModified() {
+			t.Errorf("expected config.HasLoadedConfigurationBeenModified() to return true because a new file has been added in the directory")
+		}
+	})
+	t.Run("config-directory-as-config-path", func(t *testing.T) {
+		config, err := LoadConfiguration(dir)
+		if err != nil {
+			t.Fatalf("failed to load configuration: %v", err)
+		}
+		if config.HasLoadedConfigurationBeenModified() {
+			t.Errorf("expected config.HasLoadedConfigurationBeenModified() to return false because nothing has happened since it was created")
+		}
+		time.Sleep(time.Second) // Because the file mod time only has second precision, we have to wait for a second
+		// Update the config file
+		if err = os.WriteFile(filepath.Join(dir, "metrics.yaml"), []byte(`metrics: true`), 0644); err != nil {
+			t.Fatalf("failed to overwrite config file: %v", err)
+		}
+		if !config.HasLoadedConfigurationBeenModified() {
+			t.Errorf("expected config.HasLoadedConfigurationBeenModified() to return true because a new file has been added in the directory")
+		}
+	})
 }
 
 func TestParseAndValidateConfigBytes(t *testing.T) {
 	file := t.TempDir() + "/test.db"
-	ui.StaticFolder = "../web/static"
-	defer func() {
-		ui.StaticFolder = "./web/static"
-	}()
 	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
 storage:
   type: sqlite
@@ -53,7 +309,14 @@ maintenance:
   duration: 4h
   every: [Monday, Thursday]
 ui:
-  title: Test
+  title: T
+  header: H
+  link: https://example.org
+  buttons:
+    - name: "Home"
+      link: "https://example.org"
+    - name: "Status page"
+      link: "https://status.example.org"
 endpoints:
   - name: website
     url: https://twin.sh/health
@@ -88,8 +351,8 @@ endpoints:
 	if config.Storage == nil || config.Storage.Path != file || config.Storage.Type != storage.TypeSQLite {
 		t.Error("expected storage to be set to sqlite, got", config.Storage)
 	}
-	if config.UI == nil || config.UI.Title != "Test" {
-		t.Error("Expected Config.UI.Title to be Test")
+	if config.UI == nil || config.UI.Title != "T" || config.UI.Header != "H" || config.UI.Link != "https://example.org" || len(config.UI.Buttons) != 2 || config.UI.Buttons[0].Name != "Home" || config.UI.Buttons[0].Link != "https://example.org" || config.UI.Buttons[1].Name != "Status page" || config.UI.Buttons[1].Link != "https://status.example.org" {
+		t.Error("expected ui to be set to T, H, https://example.org, 2 buttons, Home and Status page, got", config.UI)
 	}
 	if mc := config.Maintenance; mc == nil || mc.Start != "00:00" || !mc.IsEnabled() || mc.Duration != 4*time.Hour || len(mc.Every) != 2 {
 		t.Error("Expected Config.Maintenance to be configured properly")
@@ -422,6 +685,9 @@ alerting:
     webhook-url: "http://example.org"
   pagerduty:
     integration-key: "00000000000000000000000000000000"
+  pushover:
+    application-token: "000000000000000000000000000000"
+    user-key: "000000000000000000000000000000"
   mattermost:
     webhook-url: "http://example.com"
     client:
@@ -446,26 +712,22 @@ endpoints:
     url: https://twin.sh/health
     alerts:
       - type: slack
-        enabled: true
       - type: pagerduty
-        enabled: true
         failure-threshold: 7
         success-threshold: 5
         description: "Healthcheck failed 7 times in a row"
       - type: mattermost
-        enabled: true
       - type: messagebird
+        enabled: false
       - type: discord
-        enabled: true
         failure-threshold: 10
       - type: telegram
         enabled: true
       - type: twilio
-        enabled: true
         failure-threshold: 12
         success-threshold: 15
       - type: teams
-        enabled: true
+      - type: pushover
     conditions:
       - "[STATUS] == 200"
 `))
@@ -492,8 +754,8 @@ endpoints:
 	if config.Endpoints[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
 	}
-	if len(config.Endpoints[0].Alerts) != 8 {
-		t.Fatal("There should've been 8 alerts configured")
+	if len(config.Endpoints[0].Alerts) != 9 {
+		t.Fatal("There should've been 9 alerts configured")
 	}
 
 	if config.Endpoints[0].Alerts[0].Type != alert.TypeSlack {
@@ -593,6 +855,13 @@ endpoints:
 	if config.Endpoints[0].Alerts[7].SuccessThreshold != 2 {
 		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Endpoints[0].Alerts[7].SuccessThreshold)
 	}
+
+	if config.Endpoints[0].Alerts[8].Type != alert.TypePushover {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypePushover, config.Endpoints[0].Alerts[8].Type)
+	}
+	if !config.Endpoints[0].Alerts[8].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
 }
 
 func TestParseAndValidateConfigBytesWithAlertingAndDefaultAlert(t *testing.T) {
@@ -617,6 +886,14 @@ alerting:
       description: default description
       failure-threshold: 7
       success-threshold: 5
+  pushover:
+    application-token: "000000000000000000000000000000"
+    user-key: "000000000000000000000000000000"
+    default-alert:
+      enabled: true
+      description: default description
+      failure-threshold: 5
+      success-threshold: 3
   mattermost:
     webhook-url: "http://example.com"
     default-alert:
@@ -660,6 +937,7 @@ endpoints:
      - type: telegram
      - type: twilio
      - type: teams
+     - type: pushover
    conditions:
      - "[STATUS] == 200"
 `))
@@ -696,6 +974,19 @@ endpoints:
 		t.Errorf("PagerDuty integration key should've been %s, but was %s", "00000000000000000000000000000000", config.Alerting.PagerDuty.IntegrationKey)
 	}
 
+	if config.Alerting.Pushover == nil || !config.Alerting.Pushover.IsValid() {
+		t.Fatal("Pushover alerting config should've been valid")
+	}
+	if config.Alerting.Pushover.GetDefaultAlert() == nil {
+		t.Fatal("Pushover.GetDefaultAlert() shouldn't have returned nil")
+	}
+	if config.Alerting.Pushover.ApplicationToken != "000000000000000000000000000000" {
+		t.Errorf("Pushover application token should've been %s, but was %s", "000000000000000000000000000000", config.Alerting.Pushover.ApplicationToken)
+	}
+	if config.Alerting.Pushover.UserKey != "000000000000000000000000000000" {
+		t.Errorf("Pushover user key should've been %s, but was %s", "000000000000000000000000000000", config.Alerting.Pushover.UserKey)
+	}
+
 	if config.Alerting.Mattermost == nil || !config.Alerting.Mattermost.IsValid() {
 		t.Fatal("Mattermost alerting config should've been valid")
 	}
@@ -769,8 +1060,8 @@ endpoints:
 	if config.Endpoints[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
 	}
-	if len(config.Endpoints[0].Alerts) != 8 {
-		t.Fatal("There should've been 8 alerts configured")
+	if len(config.Endpoints[0].Alerts) != 9 {
+		t.Fatal("There should've been 9 alerts configured")
 	}
 
 	if config.Endpoints[0].Alerts[0].Type != alert.TypeSlack {
@@ -874,6 +1165,19 @@ endpoints:
 		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Endpoints[0].Alerts[7].SuccessThreshold)
 	}
 
+	if config.Endpoints[0].Alerts[8].Type != alert.TypePushover {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypePushover, config.Endpoints[0].Alerts[8].Type)
+	}
+	if !config.Endpoints[0].Alerts[8].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Endpoints[0].Alerts[8].FailureThreshold != 5 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 3, config.Endpoints[0].Alerts[8].FailureThreshold)
+	}
+	if config.Endpoints[0].Alerts[8].SuccessThreshold != 3 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Endpoints[0].Alerts[8].SuccessThreshold)
+	}
+
 }
 
 func TestParseAndValidateConfigBytesWithAlertingAndDefaultAlertAndMultipleAlertsOfSameTypeWithOverriddenParameters(t *testing.T) {
@@ -977,11 +1281,34 @@ endpoints:
 	if config.Alerting == nil {
 		t.Fatal("config.Alerting shouldn't have been nil")
 	}
-	if config.Alerting.PagerDuty == nil {
-		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+	if config.Alerting.PagerDuty != nil {
+		t.Fatal("PagerDuty alerting config should've been set to nil, because its IsValid() method returned false and therefore alerting.Config.SetAlertingProviderToNil() should've been called")
 	}
-	if config.Alerting.PagerDuty.IsValid() {
-		t.Fatal("PagerDuty alerting config should've been invalid")
+}
+func TestParseAndValidateConfigBytesWithInvalidPushoverAlertingConfig(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+alerting:
+  pushover:
+    application-token: "INVALID_TOKEN"
+endpoints:
+  - name: website
+    url: https://twin.sh/health
+    alerts:
+      - type: pushover
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Alerting == nil {
+		t.Fatal("config.Alerting shouldn't have been nil")
+	}
+	if config.Alerting.Pushover != nil {
+		t.Fatal("Pushover alerting config should've been set to nil, because its IsValid() method returned false and therefore alerting.Config.SetAlertingProviderToNil() should've been called")
 	}
 }
 
@@ -1012,7 +1339,7 @@ endpoints:
 		t.Fatal("config.Alerting shouldn't have been nil")
 	}
 	if config.Alerting.Custom == nil {
-		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+		t.Fatal("Custom alerting config shouldn't have been nil")
 	}
 	if !config.Alerting.Custom.IsValid() {
 		t.Fatal("Custom alerting config should've been valid")
@@ -1057,7 +1384,7 @@ endpoints:
 		t.Fatal("config.Alerting shouldn't have been nil")
 	}
 	if config.Alerting.Custom == nil {
-		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+		t.Fatal("Custom alerting config shouldn't have been nil")
 	}
 	if !config.Alerting.Custom.IsValid() {
 		t.Fatal("Custom alerting config should've been valid")
@@ -1097,7 +1424,7 @@ endpoints:
 		t.Fatal("config.Alerting shouldn't have been nil")
 	}
 	if config.Alerting.Custom == nil {
-		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+		t.Fatal("Custom alerting config shouldn't have been nil")
 	}
 	if !config.Alerting.Custom.IsValid() {
 		t.Fatal("Custom alerting config should've been valid")
@@ -1118,7 +1445,7 @@ endpoints:
     conditions:
       - "[STATUS] == 200"
 `))
-	if err != core.ErrEndpointWithNoName {
+	if err == nil {
 		t.Error("should've returned an error")
 	}
 }
@@ -1203,11 +1530,38 @@ endpoints:
 		t.Errorf("config.Security.Basic.Username should've been %s, but was %s", expectedUsername, config.Security.Basic.Username)
 	}
 	if config.Security.Basic.PasswordBcryptHashBase64Encoded != expectedPasswordHash {
-		t.Errorf("config.Security.Basic.PasswordBcryptHashBase64Encoded should've been %s, but was %s", expectedPasswordHash, config.Security.Basic.PasswordSha512Hash)
+		t.Errorf("config.Security.Basic.PasswordBcryptHashBase64Encoded should've been %s, but was %s", expectedPasswordHash, config.Security.Basic.PasswordBcryptHashBase64Encoded)
 	}
 }
 
-func TestParseAndValidateConfigBytesWithNoEndpointsOrAutoDiscovery(t *testing.T) {
+func TestParseAndValidateConfigBytesWithLiteralDollarSign(t *testing.T) {
+	os.Setenv("GATUS_TestParseAndValidateConfigBytesWithLiteralDollarSign", "whatever")
+	config, err := parseAndValidateConfigBytes([]byte(`
+endpoints:
+  - name: website
+    url: https://twin.sh/health
+    conditions:
+      - "[BODY] == $$GATUS_TestParseAndValidateConfigBytesWithLiteralDollarSign"
+      - "[BODY] == $GATUS_TestParseAndValidateConfigBytesWithLiteralDollarSign"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Endpoints[0].URL != "https://twin.sh/health" {
+		t.Errorf("URL should have been %s", "https://twin.sh/health")
+	}
+	if config.Endpoints[0].Conditions[0] != "[BODY] == $GATUS_TestParseAndValidateConfigBytesWithLiteralDollarSign" {
+		t.Errorf("Condition should have been %s", "[BODY] == $GATUS_TestParseAndValidateConfigBytesWithLiteralDollarSign")
+	}
+	if config.Endpoints[0].Conditions[1] != "[BODY] == whatever" {
+		t.Errorf("Condition should have been %s", "[BODY] == whatever")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithNoEndpoints(t *testing.T) {
 	_, err := parseAndValidateConfigBytes([]byte(``))
 	if err != ErrNoEndpointInConfig {
 		t.Error("The error returned should have been of type ErrNoEndpointInConfig")
@@ -1218,137 +1572,47 @@ func TestGetAlertingProviderByAlertType(t *testing.T) {
 	alertingConfig := &alerting.Config{
 		Custom:      &custom.AlertProvider{},
 		Discord:     &discord.AlertProvider{},
+		Email:       &email.AlertProvider{},
+		GitHub:      &github.AlertProvider{},
+		GoogleChat:  &googlechat.AlertProvider{},
+		Matrix:      &matrix.AlertProvider{},
 		Mattermost:  &mattermost.AlertProvider{},
 		Messagebird: &messagebird.AlertProvider{},
+		Ntfy:        &ntfy.AlertProvider{},
+		Opsgenie:    &opsgenie.AlertProvider{},
 		PagerDuty:   &pagerduty.AlertProvider{},
+		Pushover:    &pushover.AlertProvider{},
 		Slack:       &slack.AlertProvider{},
 		Telegram:    &telegram.AlertProvider{},
 		Twilio:      &twilio.AlertProvider{},
 		Teams:       &teams.AlertProvider{},
 	}
-	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeCustom) != alertingConfig.Custom {
-		t.Error("expected Custom configuration")
+	scenarios := []struct {
+		alertType alert.Type
+		expected  provider.AlertProvider
+	}{
+		{alertType: alert.TypeCustom, expected: alertingConfig.Custom},
+		{alertType: alert.TypeDiscord, expected: alertingConfig.Discord},
+		{alertType: alert.TypeEmail, expected: alertingConfig.Email},
+		{alertType: alert.TypeGitHub, expected: alertingConfig.GitHub},
+		{alertType: alert.TypeGoogleChat, expected: alertingConfig.GoogleChat},
+		{alertType: alert.TypeMatrix, expected: alertingConfig.Matrix},
+		{alertType: alert.TypeMattermost, expected: alertingConfig.Mattermost},
+		{alertType: alert.TypeMessagebird, expected: alertingConfig.Messagebird},
+		{alertType: alert.TypeNtfy, expected: alertingConfig.Ntfy},
+		{alertType: alert.TypeOpsgenie, expected: alertingConfig.Opsgenie},
+		{alertType: alert.TypePagerDuty, expected: alertingConfig.PagerDuty},
+		{alertType: alert.TypePushover, expected: alertingConfig.Pushover},
+		{alertType: alert.TypeSlack, expected: alertingConfig.Slack},
+		{alertType: alert.TypeTelegram, expected: alertingConfig.Telegram},
+		{alertType: alert.TypeTwilio, expected: alertingConfig.Twilio},
+		{alertType: alert.TypeTeams, expected: alertingConfig.Teams},
 	}
-	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeDiscord) != alertingConfig.Discord {
-		t.Error("expected Discord configuration")
-	}
-	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeMattermost) != alertingConfig.Mattermost {
-		t.Error("expected Mattermost configuration")
-	}
-	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeMessagebird) != alertingConfig.Messagebird {
-		t.Error("expected Messagebird configuration")
-	}
-	if alertingConfig.GetAlertingProviderByAlertType(alert.TypePagerDuty) != alertingConfig.PagerDuty {
-		t.Error("expected PagerDuty configuration")
-	}
-	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeSlack) != alertingConfig.Slack {
-		t.Error("expected Slack configuration")
-	}
-	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeTelegram) != alertingConfig.Telegram {
-		t.Error("expected Telegram configuration")
-	}
-	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeTwilio) != alertingConfig.Twilio {
-		t.Error("expected Twilio configuration")
-	}
-	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeTeams) != alertingConfig.Teams {
-		t.Error("expected Teams configuration")
-	}
-}
-
-// XXX: Remove this in v5.0.0
-func TestParseAndValidateConfigBytes_backwardCompatibleWithServices(t *testing.T) {
-	config, err := parseAndValidateConfigBytes([]byte(`
-services:
-  - name: website
-    url: https://twin.sh/actuator/health
-    conditions:
-      - "[STATUS] == 200"
-`))
-	if err != nil {
-		t.Error("expected no error, got", err.Error())
-	}
-	if config == nil {
-		t.Fatal("Config shouldn't have been nil")
-	}
-	if config.Endpoints[0].URL != "https://twin.sh/actuator/health" {
-		t.Errorf("URL should have been %s", "https://twin.sh/actuator/health")
-	}
-	if config.Endpoints[0].Interval != 60*time.Second {
-		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
-	}
-}
-
-// XXX: Remove this in v5.0.0
-func TestParseAndValidateConfigBytes_backwardCompatibleMergeServicesInEndpoints(t *testing.T) {
-	config, err := parseAndValidateConfigBytes([]byte(`
-services:
-  - name: website1
-    url: https://twin.sh/actuator/health
-    conditions:
-      - "[STATUS] == 200"
-endpoints:
-  - name: website2
-    url: https://twin.sh/actuator/health
-    conditions:
-      - "[STATUS] == 200"
-`))
-	if err != nil {
-		t.Error("expected no error, got", err.Error())
-	}
-	if config == nil {
-		t.Fatal("Config shouldn't have been nil")
-	}
-	if len(config.Endpoints) != 2 {
-		t.Error("services should've been merged in endpoints")
-	}
-}
-
-// XXX: Remove this in v4.0.0
-func TestParseAndValidateConfigBytes_backwardCompatibleWithStorageFile(t *testing.T) {
-	file := t.TempDir() + "/test.db"
-	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
-storage:
-  type: sqlite
-  file: %s
-
-endpoints:
-  - name: website
-    url: https://twin.sh/actuator/health
-    conditions:
-      - "[STATUS] == 200"
-`, file)))
-	if err != nil {
-		t.Error("expected no error, got", err.Error())
-	}
-	if config == nil {
-		t.Fatal("Config shouldn't have been nil")
-	}
-	if config.Storage == nil || config.Storage.Path != file || config.Storage.Type != storage.TypeSQLite {
-		t.Error("expected storage to be set to sqlite, got", config.Storage)
-	}
-}
-
-// XXX: Remove this in v4.0.0
-func TestParseAndValidateConfigBytes_backwardCompatibleWithStorageTypeMemoryAndFile(t *testing.T) {
-	file := t.TempDir() + "/test.db"
-	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
-storage:
-  type: memory
-  file: %s
-
-endpoints:
-  - name: website
-    url: https://twin.sh/actuator/health
-    conditions:
-      - "[STATUS] == 200"
-`, file)))
-	if err != nil {
-		t.Error("expected no error, got", err.Error())
-	}
-	if config == nil {
-		t.Fatal("Config shouldn't have been nil")
-	}
-	if config.Storage == nil || config.Storage.Path != file || config.Storage.Type != storage.TypeMemory {
-		t.Error("expected storage to be set to memory, got", config.Storage)
+	for _, scenario := range scenarios {
+		t.Run(string(scenario.alertType), func(t *testing.T) {
+			if alertingConfig.GetAlertingProviderByAlertType(scenario.alertType) != scenario.expected {
+				t.Errorf("expected %s configuration", scenario.alertType)
+			}
+		})
 	}
 }

config/connectivity/connectivity.go

@@ -0,0 +1,53 @@
+package connectivity
+
+import (
+	"errors"
+	"strings"
+	"time"
+
+	"github.com/TwiN/gatus/v5/client"
+)
+
+var (
+	ErrInvalidInterval  = errors.New("connectivity.checker.interval must be 5s or higher")
+	ErrInvalidDNSTarget = errors.New("connectivity.checker.target must be suffixed with :53")
+)
+
+// Config is the configuration for the connectivity checker.
+type Config struct {
+	Checker *Checker `yaml:"checker,omitempty"`
+}
+
+func (c *Config) ValidateAndSetDefaults() error {
+	if c.Checker != nil {
+		if c.Checker.Interval == 0 {
+			c.Checker.Interval = 60 * time.Second
+		} else if c.Checker.Interval < 5*time.Second {
+			return ErrInvalidInterval
+		}
+		if !strings.HasSuffix(c.Checker.Target, ":53") {
+			return ErrInvalidDNSTarget
+		}
+	}
+	return nil
+}
+
+// Checker is the configuration for making sure Gatus has access to the internet.
+type Checker struct {
+	Target   string        `yaml:"target"` // e.g. 1.1.1.1:53
+	Interval time.Duration `yaml:"interval,omitempty"`
+
+	isConnected bool
+	lastCheck   time.Time
+}
+
+func (c Checker) Check() bool {
+	return client.CanCreateTCPConnection(c.Target, &client.Config{Timeout: 5 * time.Second})
+}
+
+func (c *Checker) IsConnected() bool {
+	if now := time.Now(); now.After(c.lastCheck.Add(c.Interval)) {
+		c.lastCheck, c.isConnected = now, c.Check()
+	}
+	return c.isConnected
+}

config/connectivity/connectivity_test.go

@@ -0,0 +1,62 @@
+package connectivity
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func TestConfig(t *testing.T) {
+	scenarios := []struct {
+		name             string
+		cfg              *Config
+		expectedErr      error
+		expectedInterval time.Duration
+	}{
+		{
+			name:             "good-config",
+			cfg:              &Config{Checker: &Checker{Target: "1.1.1.1:53", Interval: 10 * time.Second}},
+			expectedInterval: 10 * time.Second,
+		},
+		{
+			name:             "good-config-with-default-interval",
+			cfg:              &Config{Checker: &Checker{Target: "8.8.8.8:53", Interval: 0}},
+			expectedInterval: 60 * time.Second,
+		},
+		{
+			name:        "config-with-interval-too-low",
+			cfg:         &Config{Checker: &Checker{Target: "1.1.1.1:53", Interval: 4 * time.Second}},
+			expectedErr: ErrInvalidInterval,
+		},
+		{
+			name:        "config-with-invalid-target-due-to-missing-port",
+			cfg:         &Config{Checker: &Checker{Target: "1.1.1.1", Interval: 15 * time.Second}},
+			expectedErr: ErrInvalidDNSTarget,
+		},
+		{
+			name:        "config-with-invalid-target-due-to-invalid-dns-port",
+			cfg:         &Config{Checker: &Checker{Target: "1.1.1.1:52", Interval: 15 * time.Second}},
+			expectedErr: ErrInvalidDNSTarget,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			err := scenario.cfg.ValidateAndSetDefaults()
+			if fmt.Sprintf("%s", err) != fmt.Sprintf("%s", scenario.expectedErr) {
+				t.Errorf("expected error %v, got %v", scenario.expectedErr, err)
+			}
+			if err == nil && scenario.expectedErr == nil {
+				if scenario.cfg.Checker.Interval != scenario.expectedInterval {
+					t.Errorf("expected interval %v, got %v", scenario.expectedInterval, scenario.cfg.Checker.Interval)
+				}
+			}
+		})
+	}
+}
+
+func TestChecker_IsConnected(t *testing.T) {
+	checker := &Checker{Target: "1.1.1.1:53", Interval: 10 * time.Second}
+	if !checker.IsConnected() {
+		t.Error("expected checker.IsConnected() to be true")
+	}
+}

config/maintenance/maintenance_test.go

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

config/remote/remote.go

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

config/ui/ui.go

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

config/ui/ui_test.go

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

config/web/web.go

@@ -1,6 +1,8 @@
 package web
 
 import (
+	"crypto/tls"
+	"errors"
 	"fmt"
 	"math"
 )
@@ -21,6 +23,19 @@ type Config struct {
 
 	// Port to listen on (default to 8080 specified by DefaultPort)
 	Port int `yaml:"port"`
+
+	// TLS configuration (optional)
+	TLS *TLSConfig `yaml:"tls,omitempty"`
+}
+
+type TLSConfig struct {
+	// CertificateFile is the public certificate for TLS in PEM format.
+	CertificateFile string `yaml:"certificate-file,omitempty"`
+
+	// PrivateKeyFile is the private key file for TLS in PEM format.
+	PrivateKeyFile string `yaml:"private-key-file,omitempty"`
+
+	tlsConfig *tls.Config
 }
 
 // GetDefaultConfig returns a Config struct with the default values
@@ -40,6 +55,12 @@ func (web *Config) ValidateAndSetDefaults() error {
 	} else if web.Port < 0 || web.Port > math.MaxUint16 {
 		return fmt.Errorf("invalid port: value should be between %d and %d", 0, math.MaxUint16)
 	}
+	// Try to load the TLS certificates
+	if web.TLS != nil {
+		if err := web.TLS.loadConfig(); err != nil {
+			return fmt.Errorf("invalid tls config: %w", err)
+		}
+	}
 	return nil
 }
 
@@ -47,3 +68,22 @@ func (web *Config) ValidateAndSetDefaults() error {
 func (web *Config) SocketAddress() string {
 	return fmt.Sprintf("%s:%d", web.Address, web.Port)
 }
+
+func (t *TLSConfig) loadConfig() error {
+	if len(t.CertificateFile) > 0 && len(t.PrivateKeyFile) > 0 {
+		certificate, err := tls.LoadX509KeyPair(t.CertificateFile, t.PrivateKeyFile)
+		if err != nil {
+			return err
+		}
+		t.tlsConfig = &tls.Config{Certificates: []tls.Certificate{certificate}}
+		return nil
+	}
+	return errors.New("certificate-file and private-key-file must be specified")
+}
+
+func (web *Config) TLSConfig() *tls.Config {
+	if web.TLS != nil {
+		return web.TLS.tlsConfig
+	}
+	return nil
+}

config/web/web_test.go

@@ -12,6 +12,9 @@ func TestGetDefaultConfig(t *testing.T) {
 	if defaultConfig.Address != DefaultAddress {
 		t.Error("expected default config to have the default address")
 	}
+	if defaultConfig.TLS != nil {
+		t.Error("expected default config to have TLS disabled")
+	}
 }
 
 func TestConfig_ValidateAndSetDefaults(t *testing.T) {
@@ -63,3 +66,56 @@ func TestConfig_SocketAddress(t *testing.T) {
 		t.Errorf("expected %s, got %s", "0.0.0.0:8081", web.SocketAddress())
 	}
 }
+
+func TestConfig_TLSConfig(t *testing.T) {
+	scenarios := []struct {
+		name        string
+		cfg         *Config
+		expectedErr bool
+	}{
+		{
+			name:        "good-tls-config",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "../../testdata/cert.pem", PrivateKeyFile: "../../testdata/cert.key"}},
+			expectedErr: false,
+		},
+		{
+			name:        "missing-crt-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "doesnotexist", PrivateKeyFile: "../../testdata/cert.key"}},
+			expectedErr: true,
+		},
+		{
+			name:        "bad-crt-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "../../testdata/badcert.pem", PrivateKeyFile: "../../testdata/cert.key"}},
+			expectedErr: true,
+		},
+		{
+			name:        "missing-private-key-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "../../testdata/cert.pem", PrivateKeyFile: "doesnotexist"}},
+			expectedErr: true,
+		},
+		{
+			name:        "bad-private-key-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "../../testdata/cert.pem", PrivateKeyFile: "../../testdata/badcert.key"}},
+			expectedErr: true,
+		},
+		{
+			name:        "bad-cert-and-private-key-file",
+			cfg:         &Config{TLS: &TLSConfig{CertificateFile: "../../testdata/badcert.pem", PrivateKeyFile: "../../testdata/badcert.key"}},
+			expectedErr: true,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			err := scenario.cfg.ValidateAndSetDefaults()
+			if (err != nil) != scenario.expectedErr {
+				t.Errorf("expected the existence of an error to be %v, got %v", scenario.expectedErr, err)
+				return
+			}
+			if !scenario.expectedErr {
+				if scenario.cfg.TLS.tlsConfig == nil {
+					t.Error("TLS configuration was not correctly loaded although no error was returned")
+				}
+			}
+		})
+	}
+}

controller/controller.go

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

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/v5/config"
+	"github.com/TwiN/gatus/v5/config/web"
+	"github.com/TwiN/gatus/v5/core"
 )
 
 func TestHandle(t *testing.T) {
@@ -32,7 +32,7 @@ func TestHandle(t *testing.T) {
 	_ = os.Setenv("ROUTER_TEST", "true")
 	_ = os.Setenv("ENVIRONMENT", "dev")
 	defer os.Clearenv()
-	Handle(cfg.Security, cfg.Web, cfg.UI, cfg.Metrics)
+	Handle(cfg)
 	defer Shutdown()
 	request, _ := http.NewRequest("GET", "/health", http.NoBody)
 	responseRecorder := httptest.NewRecorder()
@@ -45,6 +45,48 @@ func TestHandle(t *testing.T) {
 	}
 }
 
+func TestHandleTLS(t *testing.T) {
+	scenarios := []struct {
+		name               string
+		tls                *web.TLSConfig
+		expectedStatusCode int
+	}{
+		{
+			name:               "good-tls-config",
+			tls:                &web.TLSConfig{CertificateFile: "../testdata/cert.pem", PrivateKeyFile: "../testdata/cert.key"},
+			expectedStatusCode: 200,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			cfg := &config.Config{
+				Web: &web.Config{Address: "0.0.0.0", Port: rand.Intn(65534), TLS: scenario.tls},
+				Endpoints: []*core.Endpoint{
+					{Name: "frontend", Group: "core"},
+					{Name: "backend", Group: "core"},
+				},
+			}
+			if err := cfg.Web.ValidateAndSetDefaults(); err != nil {
+				t.Error("expected no error from web (TLS) validation, got", err)
+			}
+			_ = os.Setenv("ROUTER_TEST", "true")
+			_ = os.Setenv("ENVIRONMENT", "dev")
+			defer os.Clearenv()
+			Handle(cfg)
+			defer Shutdown()
+			request, _ := http.NewRequest("GET", "/health", http.NoBody)
+			responseRecorder := httptest.NewRecorder()
+			server.Handler.ServeHTTP(responseRecorder, request)
+			if responseRecorder.Code != scenario.expectedStatusCode {
+				t.Errorf("expected GET /health to return status code %d, got %d", scenario.expectedStatusCode, responseRecorder.Code)
+			}
+			if server == nil {
+				t.Fatal("server should've been set (but because we set ROUTER_TEST, it shouldn't have been started)")
+			}
+		})
+	}
+}
+
 func TestShutdown(t *testing.T) {
 	// Pretend that we called controller.Handle(), which initializes the server variable
 	server = &http.Server{}

controller/handler/badge.go

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

controller/handler/badge_test.go

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

controller/handler/chart.go

@@ -7,8 +7,8 @@ import (
 	"sort"
 	"time"
 
-	"github.com/TwiN/gatus/v3/storage/store"
-	"github.com/TwiN/gatus/v3/storage/store/common"
+	"github.com/TwiN/gatus/v5/storage/store"
+	"github.com/TwiN/gatus/v5/storage/store/common"
 	"github.com/gorilla/mux"
 	"github.com/wcharczuk/go-chart/v2"
 	"github.com/wcharczuk/go-chart/v2/drawing"

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/v5/config"
+	"github.com/TwiN/gatus/v5/core"
+	"github.com/TwiN/gatus/v5/storage/store"
+	"github.com/TwiN/gatus/v5/watchdog"
 )
 
 func TestResponseTimeChart(t *testing.T) {
@@ -30,7 +30,7 @@ func TestResponseTimeChart(t *testing.T) {
 	}
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+	router := CreateRouter(cfg)
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -58,11 +58,6 @@ 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) {

controller/handler/config.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/TwiN/gatus/v3/security"
+	"github.com/TwiN/gatus/v5/security"
 )
 
 // ConfigHandler is a handler that returns information for the front end of the application.

controller/handler/config_test.go

@@ -5,7 +5,7 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/TwiN/gatus/v3/security"
+	"github.com/TwiN/gatus/v5/security"
 	"github.com/gorilla/mux"
 )
 

controller/handler/endpoint_status.go

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

controller/handler/endpoint_status_test.go

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