Add support for armv6

* Added support for pagerduty integration per group

* Added pagerduty per group tests

* bugfix: if no team is provided and no general integration is provided return the first pagerduty integration in team integrations

* Updated README

* Update README.md

Co-authored-by: Chris <twin@twinnation.org>

* Update alerting/provider/pagerduty/pagerduty.go

Co-authored-by: Chris <twin@twinnation.org>

* Update alerting/provider/pagerduty/pagerduty.go

Co-authored-by: Chris <twin@twinnation.org>

Co-authored-by: Achref Ben Saad <achref.bensaad@cimpress.com>
Co-authored-by: Chris <twin@twinnation.org>

.dockerignore

@@ -1,5 +1,7 @@
-example
+examples
 Dockerfile
 .github
 .idea
 .git
+web/app
+*.db

.gitattributes

@@ -1 +1 @@
-* text=lf
+* text=auto eol=lf

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [TwiN]

.github/assets/gatus-diagram.drawio

@@ -0,0 +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>

.github/codecov.yml

@@ -0,0 +1,7 @@
+ignore:
+  - "watchdog/watchdog.go"
+  - "storage/store/sql/specific_postgres.go" # Can't test for postgres
+
+coverage:
+  status:
+    patch: off

.github/workflows/build.yml

@@ -14,18 +14,20 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
-      - name: Set up Go 1.15
-        uses: actions/setup-go@v1
+      - name: Set up Go
+        uses: actions/setup-go@v2
         with:
-          go-version: 1.15
-        id: go
+          go-version: 1.16
       - name: Check out code into the Go module directory
         uses: actions/checkout@v2
       - name: Build binary to make sure it works
         run: go build -mod vendor
       - name: Test
-        run: go test -mod vendor ./... -race -coverprofile=coverage.txt -covermode=atomic
+        # We're using "sudo" because one of the tests leverages ping, which requires super-user privileges.
+        # As for the 'env "PATH=$PATH" "GOROOT=$GOROOT"', we need it to use the same "go" executable that
+        # was configured by the "Set up Go 1.15" step (otherwise, it'd use sudo's "go" executable)
+        run: sudo env "PATH=$PATH" "GOROOT=$GOROOT" go test -mod vendor ./... -race -coverprofile=coverage.txt -covermode=atomic
       - name: Codecov
-        uses: codecov/codecov-action@v1.0.14
+        uses: codecov/codecov-action@v1.5.2
         with:
           file: ./coverage.txt

.github/workflows/publish-latest.yml

@@ -0,0 +1,34 @@
+name: publish-latest
+on:
+  workflow_run:
+    workflows: ["build"]
+    branches: [master]
+    types: [completed]
+jobs:
+  publish-latest:
+    name: Publish latest
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    timeout-minutes: 30
+    steps:
+      - name: Check out code
+        uses: actions/checkout@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
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Build and push docker image
+        uses: docker/build-push-action@v2
+        with:
+          platforms: linux/amd64
+          pull: true
+          push: true
+          tags: |
+            ${{ env.IMAGE_REPOSITORY }}:latest

.github/workflows/publish-release.yml

@@ -0,0 +1,33 @@
+name: publish-release
+on:
+  release:
+    types: [published]
+jobs:
+  publish-release:
+    name: Publish release
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - name: Check out code
+        uses: actions/checkout@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
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Build and push docker image
+        uses: docker/build-push-action@v2
+        with:
+          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
+          pull: true
+          push: true
+          tags: |
+            ${{ env.IMAGE_REPOSITORY }}:${{ env.RELEASE }}

.gitignore

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

Dockerfile

@@ -13,7 +13,7 @@ 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/static static/
+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.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 TwinProduction
+Copyright (c) 2021 TwiN
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

Makefile

@@ -0,0 +1,37 @@
+BINARY=gatus
+
+install:
+	go build -mod vendor -o $(BINARY) .
+
+run:
+	GATUS_CONFIG_FILE=./config.yaml ./$(BINARY)
+
+clean:
+	rm $(BINARY)
+
+test:
+	sudo go test ./alerting/... ./client/... ./config/... ./controller/... ./core/... ./jsonpath/... ./pattern/... ./security/... ./storage/... ./util/... ./watchdog/... -cover
+
+
+##########
+# Docker #
+##########
+
+docker-build:
+	docker build -t twinproduction/gatus:latest .
+
+docker-run:
+	docker run -p 8080:8080 --name gatus twinproduction/gatus:latest
+
+docker-build-and-run: docker-build docker-run
+
+
+#############
+# Front end #
+#############
+
+frontend-build:
+	npm --prefix web/app run build
+
+frontend-run:
+	npm --prefix web/app run serve

alerting/alert/alert.go

@@ -0,0 +1,69 @@
+package alert
+
+// Alert is the service's alert configuration
+type Alert struct {
+	// Type of alert (required)
+	Type Type `yaml:"type"`
+
+	// Enabled defines whether or not the alert is enabled
+	//
+	// 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"`
+
+	// FailureThreshold is the number of failures in a row needed before triggering the alert
+	FailureThreshold int `yaml:"failure-threshold"`
+
+	// Description of the alert. Will be included in the alert sent.
+	//
+	// 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.
+	Description *string `yaml:"description"`
+
+	// SendOnResolved defines whether to send a second notification when the issue has been resolved
+	//
+	// 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. Use Alert.IsSendingOnResolved() for a non-pointer
+	SendOnResolved *bool `yaml:"send-on-resolved"`
+
+	// SuccessThreshold defines how many successful executions must happen in a row before an ongoing incident is marked as resolved
+	SuccessThreshold int `yaml:"success-threshold"`
+
+	// ResolveKey is an optional field that is used by some providers (i.e. PagerDuty's dedup_key) to resolve
+	// ongoing/triggered incidents
+	ResolveKey string
+
+	// Triggered is used to determine whether an alert has been triggered. When an alert is resolved, this value
+	// should be set back to false. It is used to prevent the same alert from going out twice.
+	//
+	// This value should only be modified if the provider.AlertProvider's Send function does not return an error for an
+	// alert that hasn't been triggered yet. This doubles as a lazy retry. The reason why this behavior isn't also
+	// applied for alerts that are already triggered and has become "healthy" again is to prevent a case where, for
+	// some reason, the alert provider always returns errors when trying to send the resolved notification
+	// (SendOnResolved).
+	Triggered bool
+}
+
+// GetDescription retrieves the description of the alert
+func (alert Alert) GetDescription() string {
+	if alert.Description == nil {
+		return ""
+	}
+	return *alert.Description
+}
+
+// IsEnabled returns whether an alert is enabled or not
+func (alert Alert) IsEnabled() bool {
+	if alert.Enabled == nil {
+		return false
+	}
+	return *alert.Enabled
+}
+
+// IsSendingOnResolved returns whether an alert is sending on resolve or not
+func (alert Alert) IsSendingOnResolved() bool {
+	if alert.SendOnResolved == nil {
+		return false
+	}
+	return *alert.SendOnResolved
+}

alerting/alert/alert_test.go

@@ -0,0 +1,36 @@
+package alert
+
+import "testing"
+
+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 value := false; (Alert{Enabled: &value}).IsEnabled() {
+		t.Error("alert.IsEnabled() should've returned false, because Enabled was set to false")
+	}
+	if value := true; !(Alert{Enabled: &value}).IsEnabled() {
+		t.Error("alert.IsEnabled() should've returned true, because Enabled was set to true")
+	}
+}
+
+func TestAlert_GetDescription(t *testing.T) {
+	if (Alert{Description: nil}).GetDescription() != "" {
+		t.Error("alert.GetDescription() should've returned an empty string, because Description was set to nil")
+	}
+	if value := "description"; (Alert{Description: &value}).GetDescription() != value {
+		t.Error("alert.GetDescription() should've returned false, because Description was set to 'description'")
+	}
+}
+
+func TestAlert_IsSendingOnResolved(t *testing.T) {
+	if (Alert{SendOnResolved: nil}).IsSendingOnResolved() {
+		t.Error("alert.IsSendingOnResolved() should've returned false, because SendOnResolved was set to nil")
+	}
+	if value := false; (Alert{SendOnResolved: &value}).IsSendingOnResolved() {
+		t.Error("alert.IsSendingOnResolved() should've returned false, because SendOnResolved was set to false")
+	}
+	if value := true; !(Alert{SendOnResolved: &value}).IsSendingOnResolved() {
+		t.Error("alert.IsSendingOnResolved() should've returned true, because SendOnResolved was set to true")
+	}
+}

alerting/alert/type.go

@@ -0,0 +1,34 @@
+package alert
+
+// Type is the type of the alert.
+// The value will generally be the name of the alert provider
+type Type string
+
+const (
+	// TypeCustom is the Type for the custom alerting provider
+	TypeCustom Type = "custom"
+
+	// TypeDiscord is the Type for the discord alerting provider
+	TypeDiscord Type = "discord"
+
+	// TypeMattermost is the Type for the mattermost alerting provider
+	TypeMattermost Type = "mattermost"
+
+	// TypeMessagebird is the Type for the messagebird alerting provider
+	TypeMessagebird Type = "messagebird"
+
+	// TypePagerDuty is the Type for the pagerduty alerting provider
+	TypePagerDuty Type = "pagerduty"
+
+	// TypeSlack is the Type for the slack alerting provider
+	TypeSlack Type = "slack"
+
+	// TypeTeams is the Type for the teams alerting provider
+	TypeTeams Type = "teams"
+
+	// TypeTelegram is the Type for the telegram alerting provider
+	TypeTelegram Type = "telegram"
+
+	// TypeTwilio is the Type for the twilio alerting provider
+	TypeTwilio Type = "twilio"
+)

alerting/config.go

@@ -1,18 +1,26 @@
 package alerting
 
 import (
-	"github.com/TwinProduction/gatus/alerting/provider/custom"
-	"github.com/TwinProduction/gatus/alerting/provider/mattermost"
-	"github.com/TwinProduction/gatus/alerting/provider/messagebird"
-	"github.com/TwinProduction/gatus/alerting/provider/pagerduty"
-	"github.com/TwinProduction/gatus/alerting/provider/slack"
-	"github.com/TwinProduction/gatus/alerting/provider/twilio"
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/alerting/provider"
+	"github.com/TwiN/gatus/v3/alerting/provider/custom"
+	"github.com/TwiN/gatus/v3/alerting/provider/discord"
+	"github.com/TwiN/gatus/v3/alerting/provider/mattermost"
+	"github.com/TwiN/gatus/v3/alerting/provider/messagebird"
+	"github.com/TwiN/gatus/v3/alerting/provider/pagerduty"
+	"github.com/TwiN/gatus/v3/alerting/provider/slack"
+	"github.com/TwiN/gatus/v3/alerting/provider/teams"
+	"github.com/TwiN/gatus/v3/alerting/provider/telegram"
+	"github.com/TwiN/gatus/v3/alerting/provider/twilio"
 )
 
 // Config is the configuration for alerting providers
 type Config struct {
-	// Slack is the configuration for the slack alerting provider
-	Slack *slack.AlertProvider `yaml:"slack"`
+	// Custom is the configuration for the custom alerting provider
+	Custom *custom.AlertProvider `yaml:"custom"`
+
+	// Discord is the configuration for the discord alerting provider
+	Discord *discord.AlertProvider `yaml:"discord"`
 
 	// Mattermost is the configuration for the mattermost alerting provider
 	Mattermost *mattermost.AlertProvider `yaml:"mattermost"`
@@ -20,12 +28,79 @@ type Config struct {
 	// Messagebird is the configuration for the messagebird alerting provider
 	Messagebird *messagebird.AlertProvider `yaml:"messagebird"`
 
-	// Pagerduty is the configuration for the pagerduty alerting provider
+	// PagerDuty is the configuration for the pagerduty alerting provider
 	PagerDuty *pagerduty.AlertProvider `yaml:"pagerduty"`
 
+	// Slack is the configuration for the slack alerting provider
+	Slack *slack.AlertProvider `yaml:"slack"`
+
+	// Teams is the configuration for the teams alerting provider
+	Teams *teams.AlertProvider `yaml:"teams"`
+
+	// Telegram is the configuration for the telegram alerting provider
+	Telegram *telegram.AlertProvider `yaml:"telegram"`
+
 	// Twilio is the configuration for the twilio alerting provider
 	Twilio *twilio.AlertProvider `yaml:"twilio"`
-
-	// Custom is the configuration for the custom alerting provider
-	Custom *custom.AlertProvider `yaml:"custom"`
+}
+
+// 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
+		}
+		return config.Custom
+	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.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.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
+	}
+	return nil
 }

alerting/provider/custom/custom.go

@@ -2,39 +2,66 @@ package custom
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"os"
 	"strings"
 
-	"github.com/TwinProduction/gatus/client"
-	"github.com/TwinProduction/gatus/core"
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/client"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using a custom HTTP request
 // Technically, all alert providers should be reachable using the custom alert provider
 type AlertProvider struct {
-	URL      string            `yaml:"url"`
-	Method   string            `yaml:"method,omitempty"`
-	Insecure bool              `yaml:"insecure,omitempty"`
-	Body     string            `yaml:"body,omitempty"`
-	Headers  map[string]string `yaml:"headers,omitempty"`
+	URL          string                       `yaml:"url"`
+	Method       string                       `yaml:"method,omitempty"`
+	Body         string                       `yaml:"body,omitempty"`
+	Headers      map[string]string            `yaml:"headers,omitempty"`
+	Placeholders map[string]map[string]string `yaml:"placeholders,omitempty"`
+
+	// ClientConfig is the configuration of the client used to communicate with the provider's target
+	ClientConfig *client.Config `yaml:"client"`
+
+	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert"`
 }
 
 // IsValid returns whether the provider's configuration is valid
 func (provider *AlertProvider) IsValid() bool {
-	return len(provider.URL) > 0
+	if provider.ClientConfig == nil {
+		provider.ClientConfig = client.GetDefaultConfig()
+	}
+	return len(provider.URL) > 0 && provider.ClientConfig != nil
 }
 
 // ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *AlertProvider {
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *alert.Alert, result *core.Result, resolved bool) *AlertProvider {
 	return provider
 }
 
-func (provider *AlertProvider) buildRequest(serviceName, alertDescription string, resolved bool) *http.Request {
+// GetAlertStatePlaceholderValue returns the Placeholder value for ALERT_TRIGGERED_OR_RESOLVED if configured
+func (provider *AlertProvider) GetAlertStatePlaceholderValue(resolved bool) string {
+	status := "TRIGGERED"
+	if resolved {
+		status = "RESOLVED"
+	}
+	if _, ok := provider.Placeholders["ALERT_TRIGGERED_OR_RESOLVED"]; ok {
+		if val, ok := provider.Placeholders["ALERT_TRIGGERED_OR_RESOLVED"][status]; ok {
+			return val
+		}
+	}
+	return status
+}
+
+func (provider *AlertProvider) buildHTTPRequest(serviceName, 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)
 	}
@@ -43,9 +70,9 @@ func (provider *AlertProvider) buildRequest(serviceName, alertDescription string
 	}
 	if strings.Contains(body, "[ALERT_TRIGGERED_OR_RESOLVED]") {
 		if resolved {
-			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", "RESOLVED")
+			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(true))
 		} else {
-			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", "TRIGGERED")
+			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(false))
 		}
 	}
 	if strings.Contains(providerURL, "[ALERT_DESCRIPTION]") {
@@ -56,9 +83,9 @@ func (provider *AlertProvider) buildRequest(serviceName, alertDescription string
 	}
 	if strings.Contains(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]") {
 		if resolved {
-			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", "RESOLVED")
+			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(true))
 		} else {
-			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", "TRIGGERED")
+			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(false))
 		}
 	}
 	if len(method) == 0 {
@@ -74,8 +101,14 @@ func (provider *AlertProvider) buildRequest(serviceName, alertDescription string
 
 // Send a request to the alert provider and return the body
 func (provider *AlertProvider) Send(serviceName, alertDescription string, resolved bool) ([]byte, error) {
-	request := provider.buildRequest(serviceName, alertDescription, resolved)
-	response, err := client.GetHTTPClient(provider.Insecure).Do(request)
+	if os.Getenv("MOCK_ALERT_PROVIDER") == "true" {
+		if os.Getenv("MOCK_ALERT_PROVIDER_ERROR") == "true" {
+			return nil, errors.New("error")
+		}
+		return []byte("{}"), nil
+	}
+	request := provider.buildHTTPRequest(serviceName, alertDescription, resolved)
+	response, err := client.GetHTTPClient(provider.ClientConfig).Do(request)
 	if err != nil {
 		return nil, err
 	}
@@ -88,3 +121,8 @@ func (provider *AlertProvider) Send(serviceName, alertDescription string, resolv
 	}
 	return ioutil.ReadAll(response.Body)
 }
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/custom/custom_test.go

@@ -1,9 +1,11 @@
 package custom
 
 import (
-	"github.com/TwinProduction/gatus/core"
 	"io/ioutil"
 	"testing"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
@@ -17,7 +19,7 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
-func TestAlertProvider_buildRequestWhenResolved(t *testing.T) {
+func TestAlertProvider_buildHTTPRequestWhenResolved(t *testing.T) {
 	const (
 		ExpectedURL  = "http://example.com/service-name?event=RESOLVED&description=alert-description"
 		ExpectedBody = "service-name,alert-description,RESOLVED"
@@ -27,7 +29,7 @@ func TestAlertProvider_buildRequestWhenResolved(t *testing.T) {
 		Body:    "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
 		Headers: nil,
 	}
-	request := customAlertProvider.buildRequest("service-name", "alert-description", true)
+	request := customAlertProvider.buildHTTPRequest("service-name", "alert-description", true)
 	if request.URL.String() != ExpectedURL {
 		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
 	}
@@ -37,7 +39,7 @@ func TestAlertProvider_buildRequestWhenResolved(t *testing.T) {
 	}
 }
 
-func TestAlertProvider_buildRequestWhenTriggered(t *testing.T) {
+func TestAlertProvider_buildHTTPRequestWhenTriggered(t *testing.T) {
 	const (
 		ExpectedURL  = "http://example.com/service-name?event=TRIGGERED&description=alert-description"
 		ExpectedBody = "service-name,alert-description,TRIGGERED"
@@ -47,7 +49,7 @@ func TestAlertProvider_buildRequestWhenTriggered(t *testing.T) {
 		Body:    "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
 		Headers: map[string]string{"Authorization": "Basic hunter2"},
 	}
-	request := customAlertProvider.buildRequest("service-name", "alert-description", false)
+	request := customAlertProvider.buildHTTPRequest("service-name", "alert-description", false)
 	if request.URL.String() != ExpectedURL {
 		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
 	}
@@ -59,11 +61,51 @@ func TestAlertProvider_buildRequestWhenTriggered(t *testing.T) {
 
 func TestAlertProvider_ToCustomAlertProvider(t *testing.T) {
 	provider := AlertProvider{URL: "http://example.com"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{}, true)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
-	if customAlertProvider != customAlertProvider {
-		t.Error("customAlertProvider should've been equal to customAlertProvider")
+	if customAlertProvider.URL != "http://example.com" {
+		t.Error("expected URL to be http://example.com, got", customAlertProvider.URL)
+	}
+}
+
+func TestAlertProvider_buildHTTPRequestWithCustomPlaceholder(t *testing.T) {
+	const (
+		ExpectedURL  = "http://example.com/service-name?event=test&description=alert-description"
+		ExpectedBody = "service-name,alert-description,test"
+	)
+	customAlertProvider := &AlertProvider{
+		URL:     "http://example.com/[SERVICE_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
+		Body:    "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
+		Headers: nil,
+		Placeholders: map[string]map[string]string{
+			"ALERT_TRIGGERED_OR_RESOLVED": {
+				"RESOLVED": "test",
+			},
+		},
+	}
+	request := customAlertProvider.buildHTTPRequest("service-name", "alert-description", true)
+	if request.URL.String() != ExpectedURL {
+		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
+	}
+	body, _ := ioutil.ReadAll(request.Body)
+	if string(body) != ExpectedBody {
+		t.Error("expected body to be", ExpectedBody, "was", string(body))
+	}
+}
+
+func TestAlertProvider_GetAlertStatePlaceholderValueDefaults(t *testing.T) {
+	customAlertProvider := &AlertProvider{
+		URL:          "http://example.com/[SERVICE_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
+		Body:         "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
+		Headers:      nil,
+		Placeholders: nil,
+	}
+	if customAlertProvider.GetAlertStatePlaceholderValue(true) != "RESOLVED" {
+		t.Error("expected RESOLVED, got", customAlertProvider.GetAlertStatePlaceholderValue(true))
+	}
+	if customAlertProvider.GetAlertStatePlaceholderValue(false) != "TRIGGERED" {
+		t.Error("expected TRIGGERED, got", customAlertProvider.GetAlertStatePlaceholderValue(false))
 	}
 }

alerting/provider/discord/discord.go

@@ -0,0 +1,76 @@
+package discord
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/alerting/provider/custom"
+	"github.com/TwiN/gatus/v3/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Discord
+type AlertProvider struct {
+	WebhookURL string `yaml:"webhook-url"`
+
+	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.WebhookURL) > 0
+}
+
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+	var message, results string
+	var colorCode int
+	if resolved {
+		message = fmt.Sprintf("An alert for **%s** has been resolved after passing successfully %d time(s) in a row", service.Name, alert.SuccessThreshold)
+		colorCode = 3066993
+	} else {
+		message = fmt.Sprintf("An alert for **%s** has been triggered due to having failed %d time(s) in a row", service.Name, alert.FailureThreshold)
+		colorCode = 15158332
+	}
+	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
+	}
+	return &custom.AlertProvider{
+		URL:    provider.WebhookURL,
+		Method: http.MethodPost,
+		Body: fmt.Sprintf(`{
+  "content": "",
+  "embeds": [
+    {
+      "title": ":helmet_with_white_cross: Gatus",
+      "description": "%s%s",
+      "color": %d,
+      "fields": [
+        {
+          "name": "Condition results",
+          "value": "%s",
+          "inline": false
+        }
+      ]
+    }
+  ]
+}`, message, description, colorCode, results),
+		Headers: map[string]string{"Content-Type": "application/json"},
+	}
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/discord/discord_test.go

@@ -0,0 +1,70 @@
+package discord
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/core"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{WebhookURL: ""}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{WebhookURL: "http://example.com"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.com"}
+	alertDescription := "test"
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "resolved") {
+		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	}
+	if customAlertProvider.URL != "http://example.com" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+	if expected := "An alert for **svc** has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["embeds"].([]interface{})[0].(map[string]interface{})["description"] {
+		t.Errorf("expected $.embeds[0].description to be %s, got %s", expected, body["embeds"].([]interface{})[0].(map[string]interface{})["description"])
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.com"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "triggered") {
+		t.Error("customAlertProvider.Body should've contained the substring triggered")
+	}
+	if customAlertProvider.URL != "http://example.com" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}

alerting/provider/mattermost/mattermost.go

@@ -4,23 +4,33 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/TwinProduction/gatus/alerting/provider/custom"
-	"github.com/TwinProduction/gatus/core"
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/alerting/provider/custom"
+	"github.com/TwiN/gatus/v3/client"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Mattermost
 type AlertProvider struct {
 	WebhookURL string `yaml:"webhook-url"`
-	Insecure   bool   `yaml:"insecure,omitempty"`
+
+	// ClientConfig is the configuration of the client used to communicate with the provider's target
+	ClientConfig *client.Config `yaml:"client"`
+
+	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert"`
 }
 
 // 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.WebhookURL) > 0
 }
 
 // ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
 	var message string
 	var color string
 	if resolved {
@@ -38,21 +48,25 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		} 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
 	}
 	return &custom.AlertProvider{
-		URL:      provider.WebhookURL,
-		Method:   http.MethodPost,
-		Insecure: provider.Insecure,
+		URL:          provider.WebhookURL,
+		Method:       http.MethodPost,
+		ClientConfig: provider.ClientConfig,
 		Body: fmt.Sprintf(`{
   "text": "",
   "username": "gatus",
-  "icon_url": "https://raw.githubusercontent.com/TwinProduction/gatus/master/static/logo.png",
+  "icon_url": "https://raw.githubusercontent.com/TwiN/gatus/master/static/logo.png",
   "attachments": [
     {
       "title": ":rescue_worker_helmet: Gatus",
       "fallback": "Gatus - %s",
-      "text": "%s:\n> %s",
+      "text": "%s%s",
       "short": false,
       "color": "%s",
       "fields": [
@@ -69,7 +83,12 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
       ]
     }
   ]
-}`, message, message, alert.Description, color, service.URL, results),
+}`, message, message, description, color, service.URL, results),
 		Headers: map[string]string{"Content-Type": "application/json"},
 	}
 }
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/mattermost/mattermost_test.go

@@ -1,9 +1,13 @@
 package mattermost
 
 import (
-	"github.com/TwinProduction/gatus/core"
+	"encoding/json"
+	"net/http"
 	"strings"
 	"testing"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
@@ -18,23 +22,49 @@ func TestAlertProvider_IsValid(t *testing.T) {
 }
 
 func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.com"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	provider := AlertProvider{WebhookURL: "http://example.org"}
+	alertDescription := "test"
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "resolved") {
 		t.Error("customAlertProvider.Body should've contained the substring resolved")
 	}
+	if customAlertProvider.URL != "http://example.org" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+	if expected := "An alert for *svc* has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["attachments"].([]interface{})[0].(map[string]interface{})["text"] {
+		t.Errorf("expected $.attachments[0].description to be %s, got %s", expected, body["attachments"].([]interface{})[0].(map[string]interface{})["text"])
+	}
 }
 
 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.com"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	provider := AlertProvider{WebhookURL: "http://example.org"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "triggered") {
 		t.Error("customAlertProvider.Body should've contained the substring triggered")
 	}
+	if customAlertProvider.URL != "http://example.org" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }

alerting/provider/messagebird/messagebird.go

@@ -4,8 +4,9 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/TwinProduction/gatus/alerting/provider/custom"
-	"github.com/TwinProduction/gatus/core"
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/alerting/provider/custom"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 const (
@@ -17,6 +18,9 @@ type AlertProvider struct {
 	AccessKey  string `yaml:"access-key"`
 	Originator string `yaml:"originator"`
 	Recipients string `yaml:"recipients"`
+
+	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert"`
 }
 
 // IsValid returns whether the provider's configuration is valid
@@ -26,14 +30,13 @@ func (provider *AlertProvider) IsValid() bool {
 
 // ToCustomAlertProvider converts the provider into a custom.AlertProvider
 // Reference doc for messagebird https://developers.messagebird.com/api/sms-messaging/#send-outbound-sms
-func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *alert.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
 	var message string
 	if resolved {
-		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.Description)
+		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.GetDescription())
 	} else {
-		message = fmt.Sprintf("TRIGGERED: %s - %s", service.Name, alert.Description)
+		message = fmt.Sprintf("TRIGGERED: %s - %s", service.Name, alert.GetDescription())
 	}
-
 	return &custom.AlertProvider{
 		URL:    restAPIURL,
 		Method: http.MethodPost,
@@ -48,3 +51,8 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		},
 	}
 }
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/messagebird/messagebird_test.go

@@ -1,10 +1,13 @@
 package messagebird
 
 import (
+	"encoding/json"
+	"net/http"
 	"strings"
 	"testing"
 
-	"github.com/TwinProduction/gatus/core"
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 func TestMessagebirdAlertProvider_IsValid(t *testing.T) {
@@ -28,13 +31,24 @@ func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 		Originator: "1",
 		Recipients: "1",
 	}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{}, true)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
 		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
 	}
+	if customAlertProvider.URL != "https://rest.messagebird.com/messages" {
+		t.Errorf("expected URL to be %s, got %s", "https://rest.messagebird.com/messages", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }
 
 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
@@ -43,11 +57,22 @@ func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
 		Originator: "1",
 		Recipients: "1",
 	}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, false)
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{}, false)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
 		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
 	}
+	if customAlertProvider.URL != "https://rest.messagebird.com/messages" {
+		t.Errorf("expected URL to be %s, got %s", "https://rest.messagebird.com/messages", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }

alerting/provider/pagerduty/pagerduty.go

@@ -4,36 +4,63 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/TwinProduction/gatus/alerting/provider/custom"
-	"github.com/TwinProduction/gatus/core"
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/alerting/provider/custom"
+	"github.com/TwiN/gatus/v3/core"
+)
+
+const (
+	restAPIURL = "https://events.pagerduty.com/v2/enqueue"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using PagerDuty
 type AlertProvider struct {
 	IntegrationKey string `yaml:"integration-key"`
+
+	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert"`
+
+	// Overrides is a list of Override that may be prioritized over the default configuration
+	Overrides []Override `yaml:"overrides"`
+}
+
+// Override is a case under which the default integration is overridden
+type Override struct {
+	Group          string `yaml:"group"`
+	IntegrationKey string `yaml:"integration-key"`
 }
 
 // IsValid returns whether the provider's configuration is valid
 func (provider *AlertProvider) IsValid() bool {
-	return len(provider.IntegrationKey) == 32
+	registeredGroups := make(map[string]bool)
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" || len(override.IntegrationKey) != 32 {
+				return false
+			}
+			registeredGroups[override.Group] = true
+		}
+	}
+	// Either the default integration key has the right length, or there are overrides who are properly configured.
+	return len(provider.IntegrationKey) == 32 || len(provider.Overrides) != 0
 }
 
 // ToCustomAlertProvider converts the provider into a custom.AlertProvider
 //
 // relevant: https://developer.pagerduty.com/docs/events-api-v2/trigger-events/
-func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *alert.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
 	var message, eventAction, resolveKey string
 	if resolved {
-		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.Description)
+		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.GetDescription())
 		eventAction = "resolve"
 		resolveKey = alert.ResolveKey
 	} else {
-		message = fmt.Sprintf("TRIGGERED: %s - %s", service.Name, alert.Description)
+		message = fmt.Sprintf("TRIGGERED: %s - %s", service.Name, alert.GetDescription())
 		eventAction = "trigger"
 		resolveKey = ""
 	}
 	return &custom.AlertProvider{
-		URL:    "https://events.pagerduty.com/v2/enqueue",
+		URL:    restAPIURL,
 		Method: http.MethodPost,
 		Body: fmt.Sprintf(`{
   "routing_key": "%s",
@@ -44,9 +71,29 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
     "source": "%s",
     "severity": "critical"
   }
-}`, provider.IntegrationKey, resolveKey, eventAction, message, service.Name),
+}`, provider.getPagerDutyIntegrationKeyForGroup(service.Group), resolveKey, eventAction, message, service.Name),
 		Headers: map[string]string{
 			"Content-Type": "application/json",
 		},
 	}
 }
+
+// getPagerDutyIntegrationKeyForGroup returns the appropriate pagerduty integration key for a given group
+func (provider *AlertProvider) getPagerDutyIntegrationKeyForGroup(group string) string {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return override.IntegrationKey
+			}
+		}
+	}
+	if provider.IntegrationKey != "" {
+		return provider.IntegrationKey
+	}
+	return ""
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/pagerduty/pagerduty_test.go

@@ -1,9 +1,13 @@
 package pagerduty
 
 import (
-	"github.com/TwinProduction/gatus/core"
+	"encoding/json"
+	"net/http"
 	"strings"
 	"testing"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
@@ -17,24 +21,205 @@ func TestAlertProvider_IsValid(t *testing.T) {
 	}
 }
 
+func TestAlertProvider_IsValidWithOverride(t *testing.T) {
+	providerWithInvalidOverrideGroup := AlertProvider{
+		Overrides: []Override{
+			{
+				IntegrationKey: "00000000000000000000000000000000",
+				Group:          "",
+			},
+		},
+	}
+	if providerWithInvalidOverrideGroup.IsValid() {
+		t.Error("provider Group shouldn't have been valid")
+	}
+	providerWithInvalidOverrideIntegrationKey := AlertProvider{
+		Overrides: []Override{
+			{
+				IntegrationKey: "",
+				Group:          "group",
+			},
+		},
+	}
+	if providerWithInvalidOverrideIntegrationKey.IsValid() {
+		t.Error("provider integration key shouldn't have been valid")
+	}
+	providerWithValidOverride := AlertProvider{
+		Overrides: []Override{
+			{
+				IntegrationKey: "00000000000000000000000000000000",
+				Group:          "group",
+			},
+		},
+	}
+	if !providerWithValidOverride.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
 func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	provider := AlertProvider{IntegrationKey: "00000000000000000000000000000000"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{}, true)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
 		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
 	}
+	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
+		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlertAndOverride(t *testing.T) {
+	provider := AlertProvider{
+		IntegrationKey: "",
+		Overrides: []Override{
+			{
+				IntegrationKey: "00000000000000000000000000000000",
+				Group:          "group",
+			},
+		},
+	}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{}, true)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
+		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
+	}
+	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
+		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }
 
 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
 	provider := AlertProvider{IntegrationKey: "00000000000000000000000000000000"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, false)
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{}, false)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
 		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
 	}
+	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
+		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlertAndOverride(t *testing.T) {
+	provider := AlertProvider{
+		IntegrationKey: "",
+		Overrides: []Override{
+			{
+				IntegrationKey: "00000000000000000000000000000000",
+				Group:          "group",
+			},
+		},
+	}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{}, false)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
+		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
+	}
+	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
+		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}
+
+func TestAlertProvider_getPagerDutyIntegrationKey(t *testing.T) {
+	scenarios := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput string
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				IntegrationKey: "00000000000000000000000000000001",
+				Overrides:      nil,
+			},
+			InputGroup:     "",
+			ExpectedOutput: "00000000000000000000000000000001",
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				IntegrationKey: "00000000000000000000000000000001",
+				Overrides:      nil,
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "00000000000000000000000000000001",
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				IntegrationKey: "00000000000000000000000000000001",
+				Overrides: []Override{
+					{
+						Group:          "group",
+						IntegrationKey: "00000000000000000000000000000002",
+					},
+				},
+			},
+			InputGroup:     "",
+			ExpectedOutput: "00000000000000000000000000000001",
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				IntegrationKey: "00000000000000000000000000000001",
+				Overrides: []Override{
+					{
+						Group:          "group",
+						IntegrationKey: "00000000000000000000000000000002",
+					},
+				},
+			},
+			InputGroup:     "group",
+			ExpectedOutput: "00000000000000000000000000000002",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			if output := scenario.Provider.getPagerDutyIntegrationKeyForGroup(scenario.InputGroup); output != scenario.ExpectedOutput {
+				t.Errorf("expected %s, got %s", scenario.ExpectedOutput, output)
+			}
+		})
+	}
 }

alerting/provider/provider.go

@@ -1,13 +1,17 @@
 package provider
 
 import (
-	"github.com/TwinProduction/gatus/alerting/provider/custom"
-	"github.com/TwinProduction/gatus/alerting/provider/mattermost"
-	"github.com/TwinProduction/gatus/alerting/provider/messagebird"
-	"github.com/TwinProduction/gatus/alerting/provider/pagerduty"
-	"github.com/TwinProduction/gatus/alerting/provider/slack"
-	"github.com/TwinProduction/gatus/alerting/provider/twilio"
-	"github.com/TwinProduction/gatus/core"
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/alerting/provider/custom"
+	"github.com/TwiN/gatus/v3/alerting/provider/discord"
+	"github.com/TwiN/gatus/v3/alerting/provider/mattermost"
+	"github.com/TwiN/gatus/v3/alerting/provider/messagebird"
+	"github.com/TwiN/gatus/v3/alerting/provider/pagerduty"
+	"github.com/TwiN/gatus/v3/alerting/provider/slack"
+	"github.com/TwiN/gatus/v3/alerting/provider/teams"
+	"github.com/TwiN/gatus/v3/alerting/provider/telegram"
+	"github.com/TwiN/gatus/v3/alerting/provider/twilio"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 // AlertProvider is the interface that each providers should implement
@@ -16,15 +20,43 @@ type AlertProvider interface {
 	IsValid() bool
 
 	// ToCustomAlertProvider converts the provider into a custom.AlertProvider
-	ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *custom.AlertProvider
+	ToCustomAlertProvider(service *core.Service, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider
+
+	// GetDefaultAlert returns the provider's default alert configuration
+	GetDefaultAlert() *alert.Alert
+}
+
+// ParseWithDefaultAlert parses a service alert by using the provider's default alert as a baseline
+func ParseWithDefaultAlert(providerDefaultAlert, serviceAlert *alert.Alert) {
+	if providerDefaultAlert == nil || serviceAlert == nil {
+		return
+	}
+	if serviceAlert.Enabled == nil {
+		serviceAlert.Enabled = providerDefaultAlert.Enabled
+	}
+	if serviceAlert.SendOnResolved == nil {
+		serviceAlert.SendOnResolved = providerDefaultAlert.SendOnResolved
+	}
+	if serviceAlert.Description == nil {
+		serviceAlert.Description = providerDefaultAlert.Description
+	}
+	if serviceAlert.FailureThreshold == 0 {
+		serviceAlert.FailureThreshold = providerDefaultAlert.FailureThreshold
+	}
+	if serviceAlert.SuccessThreshold == 0 {
+		serviceAlert.SuccessThreshold = providerDefaultAlert.SuccessThreshold
+	}
 }
 
 var (
 	// Validate interface implementation on compile
 	_ AlertProvider = (*custom.AlertProvider)(nil)
-	_ AlertProvider = (*twilio.AlertProvider)(nil)
-	_ AlertProvider = (*slack.AlertProvider)(nil)
+	_ AlertProvider = (*discord.AlertProvider)(nil)
 	_ AlertProvider = (*mattermost.AlertProvider)(nil)
 	_ AlertProvider = (*messagebird.AlertProvider)(nil)
 	_ AlertProvider = (*pagerduty.AlertProvider)(nil)
+	_ AlertProvider = (*slack.AlertProvider)(nil)
+	_ AlertProvider = (*teams.AlertProvider)(nil)
+	_ AlertProvider = (*telegram.AlertProvider)(nil)
+	_ AlertProvider = (*twilio.AlertProvider)(nil)
 )

alerting/provider/provider_test.go

@@ -0,0 +1,153 @@
+package provider
+
+import (
+	"testing"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+)
+
+func TestParseWithDefaultAlert(t *testing.T) {
+	type Scenario struct {
+		Name                                            string
+		DefaultAlert, ServiceAlert, ExpectedOutputAlert *alert.Alert
+	}
+	enabled := true
+	disabled := false
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []Scenario{
+		{
+			Name: "service-alert-type-only",
+			DefaultAlert: &alert.Alert{
+				Enabled:          &enabled,
+				SendOnResolved:   &enabled,
+				Description:      &firstDescription,
+				FailureThreshold: 5,
+				SuccessThreshold: 10,
+			},
+			ServiceAlert: &alert.Alert{
+				Type: alert.TypeDiscord,
+			},
+			ExpectedOutputAlert: &alert.Alert{
+				Type:             alert.TypeDiscord,
+				Enabled:          &enabled,
+				SendOnResolved:   &enabled,
+				Description:      &firstDescription,
+				FailureThreshold: 5,
+				SuccessThreshold: 10,
+			},
+		},
+		{
+			Name: "service-alert-overwrites-default-alert",
+			DefaultAlert: &alert.Alert{
+				Enabled:          &disabled,
+				SendOnResolved:   &disabled,
+				Description:      &firstDescription,
+				FailureThreshold: 5,
+				SuccessThreshold: 10,
+			},
+			ServiceAlert: &alert.Alert{
+				Type:             alert.TypeTelegram,
+				Enabled:          &enabled,
+				SendOnResolved:   &enabled,
+				Description:      &secondDescription,
+				FailureThreshold: 6,
+				SuccessThreshold: 11,
+			},
+			ExpectedOutputAlert: &alert.Alert{
+				Type:             alert.TypeTelegram,
+				Enabled:          &enabled,
+				SendOnResolved:   &enabled,
+				Description:      &secondDescription,
+				FailureThreshold: 6,
+				SuccessThreshold: 11,
+			},
+		},
+		{
+			Name: "service-alert-partially-overwrites-default-alert",
+			DefaultAlert: &alert.Alert{
+				Enabled:          &enabled,
+				SendOnResolved:   &enabled,
+				Description:      &firstDescription,
+				FailureThreshold: 5,
+				SuccessThreshold: 10,
+			},
+			ServiceAlert: &alert.Alert{
+				Type:             alert.TypeDiscord,
+				Enabled:          nil,
+				SendOnResolved:   nil,
+				FailureThreshold: 6,
+				SuccessThreshold: 11,
+			},
+			ExpectedOutputAlert: &alert.Alert{
+				Type:             alert.TypeDiscord,
+				Enabled:          &enabled,
+				SendOnResolved:   &enabled,
+				Description:      &firstDescription,
+				FailureThreshold: 6,
+				SuccessThreshold: 11,
+			},
+		},
+		{
+			Name: "default-alert-type-should-be-ignored",
+			DefaultAlert: &alert.Alert{
+				Type:             alert.TypeTelegram,
+				Enabled:          &enabled,
+				SendOnResolved:   &enabled,
+				Description:      &firstDescription,
+				FailureThreshold: 5,
+				SuccessThreshold: 10,
+			},
+			ServiceAlert: &alert.Alert{
+				Type: alert.TypeDiscord,
+			},
+			ExpectedOutputAlert: &alert.Alert{
+				Type:             alert.TypeDiscord,
+				Enabled:          &enabled,
+				SendOnResolved:   &enabled,
+				Description:      &firstDescription,
+				FailureThreshold: 5,
+				SuccessThreshold: 10,
+			},
+		},
+		{
+			Name: "no-default-alert",
+			DefaultAlert: &alert.Alert{
+				Type:             alert.TypeDiscord,
+				Enabled:          nil,
+				SendOnResolved:   nil,
+				Description:      &firstDescription,
+				FailureThreshold: 2,
+				SuccessThreshold: 5,
+			},
+			ServiceAlert:        nil,
+			ExpectedOutputAlert: nil,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			ParseWithDefaultAlert(scenario.DefaultAlert, scenario.ServiceAlert)
+			if scenario.ExpectedOutputAlert == nil {
+				if scenario.ServiceAlert != nil {
+					t.Fail()
+				}
+				return
+			}
+			if scenario.ServiceAlert.IsEnabled() != scenario.ExpectedOutputAlert.IsEnabled() {
+				t.Errorf("expected ServiceAlert.IsEnabled() to be %v, got %v", scenario.ExpectedOutputAlert.IsEnabled(), scenario.ServiceAlert.IsEnabled())
+			}
+			if scenario.ServiceAlert.IsSendingOnResolved() != scenario.ExpectedOutputAlert.IsSendingOnResolved() {
+				t.Errorf("expected ServiceAlert.IsSendingOnResolved() to be %v, got %v", scenario.ExpectedOutputAlert.IsSendingOnResolved(), scenario.ServiceAlert.IsSendingOnResolved())
+			}
+			if scenario.ServiceAlert.GetDescription() != scenario.ExpectedOutputAlert.GetDescription() {
+				t.Errorf("expected ServiceAlert.GetDescription() to be %v, got %v", scenario.ExpectedOutputAlert.GetDescription(), scenario.ServiceAlert.GetDescription())
+			}
+			if scenario.ServiceAlert.FailureThreshold != scenario.ExpectedOutputAlert.FailureThreshold {
+				t.Errorf("expected ServiceAlert.FailureThreshold to be %v, got %v", scenario.ExpectedOutputAlert.FailureThreshold, scenario.ServiceAlert.FailureThreshold)
+			}
+			if scenario.ServiceAlert.SuccessThreshold != scenario.ExpectedOutputAlert.SuccessThreshold {
+				t.Errorf("expected ServiceAlert.SuccessThreshold to be %v, got %v", scenario.ExpectedOutputAlert.SuccessThreshold, scenario.ServiceAlert.SuccessThreshold)
+			}
+		})
+	}
+}

alerting/provider/slack/slack.go

@@ -4,13 +4,17 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/TwinProduction/gatus/alerting/provider/custom"
-	"github.com/TwinProduction/gatus/core"
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/alerting/provider/custom"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Slack
 type AlertProvider struct {
-	WebhookURL string `yaml:"webhook-url"`
+	WebhookURL string `yaml:"webhook-url"` // Slack webhook URL
+
+	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert"`
 }
 
 // IsValid returns whether the provider's configuration is valid
@@ -19,7 +23,7 @@ func (provider *AlertProvider) IsValid() bool {
 }
 
 // ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
 	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", service.Name, alert.SuccessThreshold)
@@ -31,11 +35,15 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 	for _, conditionResult := range result.ConditionResults {
 		var prefix string
 		if conditionResult.Success {
-			prefix = ":heavy_check_mark:"
+			prefix = ":white_check_mark:"
 		} 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
 	}
 	return &custom.AlertProvider{
 		URL:    provider.WebhookURL,
@@ -45,7 +53,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
   "attachments": [
     {
       "title": ":helmet_with_white_cross: Gatus",
-      "text": "%s:\n> %s",
+      "text": "%s%s",
       "short": false,
       "color": "%s",
       "fields": [
@@ -57,7 +65,12 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
       ]
     }
   ]
-}`, message, alert.Description, color, results),
+}`, message, description, color, results),
 		Headers: map[string]string{"Content-Type": "application/json"},
 	}
 }
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/slack/slack_test.go

@@ -1,10 +1,13 @@
 package slack
 
 import (
+	"encoding/json"
+	"net/http"
 	"strings"
 	"testing"
 
-	"github.com/TwinProduction/gatus/core"
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 func TestAlertProvider_IsValid(t *testing.T) {
@@ -20,22 +23,48 @@ func TestAlertProvider_IsValid(t *testing.T) {
 
 func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	provider := AlertProvider{WebhookURL: "http://example.com"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	alertDescription := "test"
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "resolved") {
 		t.Error("customAlertProvider.Body should've contained the substring resolved")
 	}
+	if customAlertProvider.URL != "http://example.com" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+	if expected := "An alert for *svc* has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["attachments"].([]interface{})[0].(map[string]interface{})["text"] {
+		t.Errorf("expected $.attachments[0].description to be %s, got %s", expected, body["attachments"].([]interface{})[0].(map[string]interface{})["text"])
+	}
 }
 
 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
 	provider := AlertProvider{WebhookURL: "http://example.com"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "triggered") {
 		t.Error("customAlertProvider.Body should've contained the substring triggered")
 	}
+	if customAlertProvider.URL != "http://example.com" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }

alerting/provider/teams/teams.go

@@ -0,0 +1,77 @@
+package teams
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/alerting/provider/custom"
+	"github.com/TwiN/gatus/v3/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Teams
+type AlertProvider struct {
+	WebhookURL string `yaml:"webhook-url"`
+
+	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.WebhookURL) > 0
+}
+
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+	var message string
+	var color string
+	if resolved {
+		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", service.Name, alert.SuccessThreshold)
+		color = "#36A64F"
+	} else {
+		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", service.Name, alert.FailureThreshold)
+		color = "#DD0000"
+	}
+	var results string
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = "✅"
+		} else {
+			prefix = "❌"
+		}
+		results += fmt.Sprintf("%s - `%s`<br/>", prefix, conditionResult.Condition)
+	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = ":\\n> " + alertDescription
+	}
+	return &custom.AlertProvider{
+		URL:    provider.WebhookURL,
+		Method: http.MethodPost,
+		Body: fmt.Sprintf(`{
+  "@type": "MessageCard",
+  "@context": "http://schema.org/extensions",
+  "themeColor": "%s",
+  "title": "&#x1F6A8; Gatus",
+  "text": "%s%s",
+  "sections": [
+    {
+      "activityTitle": "URL",
+      "text": "%s"
+    },
+    {
+      "activityTitle": "Condition results",
+      "text": "%s"
+    }
+  ]
+}`, color, message, description, service.URL, results),
+		Headers: map[string]string{"Content-Type": "application/json"},
+	}
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/teams/teams_test.go

@@ -0,0 +1,70 @@
+package teams
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/core"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{WebhookURL: ""}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{WebhookURL: "http://example.com"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.org"}
+	alertDescription := "test"
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "resolved") {
+		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	}
+	if customAlertProvider.URL != "http://example.org" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+	if expected := "An alert for *svc* has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["text"] {
+		t.Errorf("expected $.text to be %s, got %s", expected, body["text"])
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.org"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "triggered") {
+		t.Error("customAlertProvider.Body should've contained the substring triggered")
+	}
+	if customAlertProvider.URL != "http://example.org" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}

alerting/provider/telegram/telegram.go

@@ -0,0 +1,60 @@
+package telegram
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/alerting/provider/custom"
+	"github.com/TwiN/gatus/v3/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Telegram
+type AlertProvider struct {
+	Token string `yaml:"token"`
+	ID    string `yaml:"id"`
+
+	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.Token) > 0 && len(provider.ID) > 0
+}
+
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+	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—  ", service.Name, alert.FailureThreshold)
+	} else {
+		message = fmt.Sprintf("An alert for *%s* has been triggered:\\n—\\n    _healthcheck failed %d time(s) in a row_\\n—  ", service.Name, alert.FailureThreshold)
+	}
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = "✅"
+		} else {
+			prefix = "❌"
+		}
+		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
+	}
+	var 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)
+	} else {
+		text = fmt.Sprintf("⛑ *Gatus* \\n%s \\n*Condition results*\\n%s", message, results)
+	}
+	return &custom.AlertProvider{
+		URL:     fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token),
+		Method:  http.MethodPost,
+		Body:    fmt.Sprintf(`{"chat_id": "%s", "text": "%s", "parse_mode": "MARKDOWN"}`, provider.ID, text),
+		Headers: map[string]string{"Content-Type": "application/json"},
+	}
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/telegram/telegram_test.go

@@ -0,0 +1,91 @@
+package telegram
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/core"
+)
+
+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")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "resolved") {
+		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	}
+	if customAlertProvider.URL != fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token) {
+		t.Errorf("expected URL to be %s, got %s", fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token), customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	//_, err := json.Marshal(customAlertProvider.Body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "0123456789"}
+	description := "Healthcheck Successful"
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{Description: &description}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "triggered") {
+		t.Error("customAlertProvider.Body should've contained the substring triggered")
+	}
+	if customAlertProvider.URL != fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token) {
+		t.Errorf("expected URL to be %s, got %s", fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token), customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithDescription(t *testing.T) {
+	provider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "0123456789"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "triggered") {
+		t.Error("customAlertProvider.Body should've contained the substring triggered")
+	}
+	if customAlertProvider.URL != fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token) {
+		t.Errorf("expected URL to be %s, got %s", fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", provider.Token), customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}

alerting/provider/twilio/twilio.go

@@ -6,8 +6,9 @@ import (
 	"net/http"
 	"net/url"
 
-	"github.com/TwinProduction/gatus/alerting/provider/custom"
-	"github.com/TwinProduction/gatus/core"
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/alerting/provider/custom"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Twilio
@@ -16,6 +17,9 @@ type AlertProvider struct {
 	Token string `yaml:"token"`
 	From  string `yaml:"from"`
 	To    string `yaml:"to"`
+
+	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert"`
 }
 
 // IsValid returns whether the provider's configuration is valid
@@ -24,12 +28,12 @@ func (provider *AlertProvider) IsValid() bool {
 }
 
 // ToCustomAlertProvider converts the provider into a custom.AlertProvider
-func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *alert.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
 	var message string
 	if resolved {
-		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.Description)
+		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.GetDescription())
 	} else {
-		message = fmt.Sprintf("TRIGGERED: %s - %s", service.Name, alert.Description)
+		message = fmt.Sprintf("TRIGGERED: %s - %s", service.Name, alert.GetDescription())
 	}
 	return &custom.AlertProvider{
 		URL:    fmt.Sprintf("https://api.twilio.com/2010-04-01/Accounts/%s/Messages.json", provider.SID),
@@ -45,3 +49,8 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		},
 	}
 }
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/twilio/twilio_test.go

@@ -1,9 +1,12 @@
 package twilio
 
 import (
-	"github.com/TwinProduction/gatus/core"
+	"net/http"
 	"strings"
 	"testing"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/core"
 )
 
 func TestTwilioAlertProvider_IsValid(t *testing.T) {
@@ -25,31 +28,51 @@ func TestTwilioAlertProvider_IsValid(t *testing.T) {
 func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	provider := AlertProvider{
 		SID:   "1",
-		Token: "1",
-		From:  "1",
-		To:    "1",
+		Token: "2",
+		From:  "3",
+		To:    "4",
 	}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
+	description := "alert-description"
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "service-name"}, &alert.Alert{Description: &description}, &core.Result{}, true)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
 		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
 	}
+	if customAlertProvider.URL != "https://api.twilio.com/2010-04-01/Accounts/1/Messages.json" {
+		t.Errorf("expected URL to be %s, got %s", "https://api.twilio.com/2010-04-01/Accounts/1/Messages.json", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	if customAlertProvider.Body != "Body=RESOLVED%3A+service-name+-+alert-description&From=3&To=4" {
+		t.Errorf("expected body to be %s, got %s", "Body=RESOLVED%3A+service-name+-+alert-description&From=3&To=4", customAlertProvider.Body)
+	}
 }
 
 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
 	provider := AlertProvider{
-		SID:   "1",
-		Token: "1",
-		From:  "1",
+		SID:   "4",
+		Token: "3",
+		From:  "2",
 		To:    "1",
 	}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, false)
+	description := "alert-description"
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "service-name"}, &alert.Alert{Description: &description}, &core.Result{}, false)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
 		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
 	}
+	if customAlertProvider.URL != "https://api.twilio.com/2010-04-01/Accounts/4/Messages.json" {
+		t.Errorf("expected URL to be %s, got %s", "https://api.twilio.com/2010-04-01/Accounts/4/Messages.json", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	if customAlertProvider.Body != "Body=TRIGGERED%3A+service-name+-+alert-description&From=2&To=1" {
+		t.Errorf("expected body to be %s, got %s", "Body=TRIGGERED%3A+service-name+-+alert-description&From=2&To=1", customAlertProvider.Body)
+	}
 }

client/client.go

@@ -2,51 +2,105 @@ package client
 
 import (
 	"crypto/tls"
+	"crypto/x509"
+	"errors"
 	"net"
 	"net/http"
+	"net/smtp"
+	"runtime"
+	"strings"
 	"time"
-)
 
-var (
-	secureHTTPClient   *http.Client
-	insecureHTTPClient *http.Client
+	"github.com/go-ping/ping"
 )
 
 // GetHTTPClient returns the shared HTTP client
-func GetHTTPClient(insecure bool) *http.Client {
-	if insecure {
-		if insecureHTTPClient == nil {
-			insecureHTTPClient = &http.Client{
-				Timeout: time.Second * 10,
-				Transport: &http.Transport{
-					MaxIdleConns:        100,
-					MaxIdleConnsPerHost: 20,
-					TLSClientConfig: &tls.Config{
-						InsecureSkipVerify: true,
-					},
-				},
-			}
-		}
-		return insecureHTTPClient
+func GetHTTPClient(config *Config) *http.Client {
+	if config == nil {
+		return defaultConfig.getHTTPClient()
 	}
-	if secureHTTPClient == nil {
-		secureHTTPClient = &http.Client{
-			Timeout: time.Second * 10,
-			Transport: &http.Transport{
-				MaxIdleConns:        100,
-				MaxIdleConnsPerHost: 20,
-			},
-		}
-	}
-	return secureHTTPClient
+	return config.getHTTPClient()
 }
 
-// CanCreateConnectionToTCPService checks whether a connection can be established with a TCP service
-func CanCreateConnectionToTCPService(address string) bool {
-	conn, err := net.DialTimeout("tcp", address, 5*time.Second)
+// CanCreateTCPConnection checks whether a connection can be established with a TCP service
+func CanCreateTCPConnection(address string, config *Config) bool {
+	conn, err := net.DialTimeout("tcp", address, config.Timeout)
 	if err != nil {
 		return false
 	}
 	_ = conn.Close()
 	return true
 }
+
+// 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, ":")
+	if len(hostAndPort) != 2 {
+		return false, nil, errors.New("invalid address for starttls, format must be host:port")
+	}
+	connection, err := net.DialTimeout("tcp", address, config.Timeout)
+	if err != nil {
+		return
+	}
+	smtpClient, err := smtp.NewClient(connection, hostAndPort[0])
+	if err != nil {
+		return
+	}
+	err = smtpClient.StartTLS(&tls.Config{
+		InsecureSkipVerify: config.Insecure,
+		ServerName:         hostAndPort[0],
+	})
+	if err != nil {
+		return
+	}
+	if state, ok := smtpClient.TLSConnectionState(); ok {
+		certificate = state.PeerCertificates[0]
+	} else {
+		return false, nil, errors.New("could not get TLS connection state")
+	}
+	return true, certificate, nil
+}
+
+// CanPerformTLS checks whether a connection can be established to an address using the TLS protocol
+func CanPerformTLS(address string, config *Config) (connected bool, certificate *x509.Certificate, err error) {
+	connection, err := tls.DialWithDialer(&net.Dialer{Timeout: config.Timeout}, "tcp", address, nil)
+	if err != nil {
+		return
+	}
+	defer connection.Close()
+	verifiedChains := connection.ConnectionState().VerifiedChains
+	if len(verifiedChains) == 0 || len(verifiedChains[0]) == 0 {
+		return
+	}
+	return true, verifiedChains[0][0], nil
+}
+
+// Ping checks if an address can be pinged and returns the round-trip time if the address can be pinged
+//
+// Note that this function takes at least 100ms, even if the address is 127.0.0.1
+func Ping(address string, config *Config) (bool, time.Duration) {
+	pinger, err := ping.NewPinger(address)
+	if err != nil {
+		return false, 0
+	}
+	pinger.Count = 1
+	pinger.Timeout = config.Timeout
+	// Set the pinger's privileged mode to true for every GOOS except darwin
+	// 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
+	pinger.SetPrivileged(runtime.GOOS != "darwin")
+	err = pinger.Run()
+	if err != nil {
+		return false, 0
+	}
+	if pinger.Statistics() != nil {
+		// If the packet loss is 100, it means that the packet didn't reach the host
+		if pinger.Statistics().PacketLoss == 100 {
+			return false, pinger.Timeout
+		}
+		return true, pinger.Statistics().MaxRtt
+	}
+	return true, 0
+}

client/client_test.go

@@ -2,27 +2,147 @@ package client
 
 import (
 	"testing"
+	"time"
 )
 
-func TestGetHttpClient(t *testing.T) {
-	if secureHTTPClient != nil {
-		t.Error("secureHTTPClient should've been nil since it hasn't been called a single time yet")
+func TestGetHTTPClient(t *testing.T) {
+	cfg := &Config{
+		Insecure:       false,
+		IgnoreRedirect: false,
+		Timeout:        0,
 	}
-	if insecureHTTPClient != nil {
-		t.Error("insecureHTTPClient should've been nil since it hasn't been called a single time yet")
+	cfg.ValidateAndSetDefaults()
+	if GetHTTPClient(cfg) == nil {
+		t.Error("expected client to not be nil")
 	}
-	_ = GetHTTPClient(false)
-	if secureHTTPClient == nil {
-		t.Error("secureHTTPClient shouldn't have been nil, since it has been called once")
-	}
-	if insecureHTTPClient != nil {
-		t.Error("insecureHTTPClient should've been nil since it hasn't been called a single time yet")
-	}
-	_ = GetHTTPClient(true)
-	if secureHTTPClient == nil {
-		t.Error("secureHTTPClient shouldn't have been nil, since it has been called once")
-	}
-	if insecureHTTPClient == nil {
-		t.Error("insecureHTTPClient shouldn't have been nil, since it has been called once")
+	if GetHTTPClient(nil) == nil {
+		t.Error("expected client to not be nil")
+	}
+}
+
+func TestPing(t *testing.T) {
+	if success, rtt := Ping("127.0.0.1", &Config{Timeout: 500 * time.Millisecond}); !success {
+		t.Error("expected true")
+		if rtt == 0 {
+			t.Error("Round-trip time returned on success should've higher than 0")
+		}
+	}
+	if success, rtt := Ping("256.256.256.256", &Config{Timeout: 500 * time.Millisecond}); success {
+		t.Error("expected false, because the IP is invalid")
+		if rtt != 0 {
+			t.Error("Round-trip time returned on failure should've been 0")
+		}
+	}
+	if success, rtt := Ping("192.168.152.153", &Config{Timeout: 500 * time.Millisecond}); success {
+		t.Error("expected false, because the IP is valid but the host should be unreachable")
+		if rtt != 0 {
+			t.Error("Round-trip time returned on failure should've been 0")
+		}
+	}
+}
+
+func TestCanPerformStartTLS(t *testing.T) {
+	type args struct {
+		address  string
+		insecure bool
+	}
+	tests := []struct {
+		name          string
+		args          args
+		wantConnected bool
+		wantErr       bool
+	}{
+		{
+			name: "invalid address",
+			args: args{
+				address: "test",
+			},
+			wantConnected: false,
+			wantErr:       true,
+		},
+		{
+			name: "error dial",
+			args: args{
+				address: "test:1234",
+			},
+			wantConnected: false,
+			wantErr:       true,
+		},
+		{
+			name: "valid starttls",
+			args: args{
+				address: "smtp.gmail.com:587",
+			},
+			wantConnected: true,
+			wantErr:       false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			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)
+				return
+			}
+			if connected != tt.wantConnected {
+				t.Errorf("CanPerformStartTLS() connected=%v, wantConnected=%v", connected, tt.wantConnected)
+			}
+		})
+	}
+}
+
+func TestCanPerformTLS(t *testing.T) {
+	type args struct {
+		address  string
+		insecure bool
+	}
+	tests := []struct {
+		name          string
+		args          args
+		wantConnected bool
+		wantErr       bool
+	}{
+		{
+			name: "invalid address",
+			args: args{
+				address: "test",
+			},
+			wantConnected: false,
+			wantErr:       true,
+		},
+		{
+			name: "error dial",
+			args: args{
+				address: "test:1234",
+			},
+			wantConnected: false,
+			wantErr:       true,
+		},
+		{
+			name: "valid tls",
+			args: args{
+				address: "smtp.gmail.com:465",
+			},
+			wantConnected: true,
+			wantErr:       false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			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)
+				return
+			}
+			if connected != tt.wantConnected {
+				t.Errorf("CanPerformTLS() connected=%v, wantConnected=%v", connected, tt.wantConnected)
+			}
+		})
+	}
+}
+
+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")
 	}
 }

client/config.go

@@ -0,0 +1,73 @@
+package client
+
+import (
+	"crypto/tls"
+	"net/http"
+	"time"
+)
+
+const (
+	defaultHTTPTimeout = 10 * time.Second
+)
+
+var (
+	// DefaultConfig is the default client configuration
+	defaultConfig = Config{
+		Insecure:       false,
+		IgnoreRedirect: false,
+		Timeout:        defaultHTTPTimeout,
+	}
+)
+
+// GetDefaultConfig returns a copy of the default configuration
+func GetDefaultConfig() *Config {
+	cfg := defaultConfig
+	return &cfg
+}
+
+// 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"`
+
+	// IgnoreRedirect determines whether to ignore redirects (true) or follow them (false, default)
+	IgnoreRedirect bool `yaml:"ignore-redirect"`
+
+	// Timeout for the client
+	Timeout time.Duration `yaml:"timeout"`
+
+	httpClient *http.Client
+}
+
+// ValidateAndSetDefaults validates the client configuration and sets the default values if necessary
+func (c *Config) ValidateAndSetDefaults() {
+	if c.Timeout < time.Millisecond {
+		c.Timeout = 10 * time.Second
+	}
+}
+
+// GetHTTPClient return a HTTP client matching the Config's parameters.
+func (c *Config) getHTTPClient() *http.Client {
+	if c.httpClient == nil {
+		c.httpClient = &http.Client{
+			Timeout: c.Timeout,
+			Transport: &http.Transport{
+				MaxIdleConns:        100,
+				MaxIdleConnsPerHost: 20,
+				Proxy:               http.ProxyFromEnvironment,
+				TLSClientConfig: &tls.Config{
+					InsecureSkipVerify: c.Insecure,
+				},
+			},
+			CheckRedirect: func(req *http.Request, via []*http.Request) error {
+				if c.IgnoreRedirect {
+					// Don't follow redirects
+					return http.ErrUseLastResponse
+				}
+				// Follow redirects
+				return nil
+			},
+		}
+	}
+	return c.httpClient
+}

client/config_test.go

@@ -0,0 +1,37 @@
+package client
+
+import (
+	"net/http"
+	"testing"
+	"time"
+)
+
+func TestConfig_getHTTPClient(t *testing.T) {
+	insecureConfig := &Config{Insecure: true}
+	insecureConfig.ValidateAndSetDefaults()
+	insecureClient := insecureConfig.getHTTPClient()
+	if !(insecureClient.Transport).(*http.Transport).TLSClientConfig.InsecureSkipVerify {
+		t.Error("expected Config.Insecure set to true to cause the HTTP client to skip certificate verification")
+	}
+	if insecureClient.Timeout != defaultHTTPTimeout {
+		t.Error("expected Config.Timeout to default the HTTP client to a timeout of 10s")
+	}
+	request, _ := http.NewRequest("GET", "", nil)
+	if err := insecureClient.CheckRedirect(request, nil); err != nil {
+		t.Error("expected Config.IgnoreRedirect set to false to cause the HTTP client's CheckRedirect to return nil")
+	}
+
+	secureConfig := &Config{IgnoreRedirect: true, Timeout: 5 * time.Second}
+	secureConfig.ValidateAndSetDefaults()
+	secureClient := secureConfig.getHTTPClient()
+	if (secureClient.Transport).(*http.Transport).TLSClientConfig.InsecureSkipVerify {
+		t.Error("expected Config.Insecure set to false to cause the HTTP client to not skip certificate verification")
+	}
+	if secureClient.Timeout != 5*time.Second {
+		t.Error("expected Config.Timeout to cause the HTTP client to have a timeout of 5s")
+	}
+	request, _ = http.NewRequest("GET", "", nil)
+	if err := secureClient.CheckRedirect(request, nil); err != http.ErrUseLastResponse {
+		t.Error("expected Config.IgnoreRedirect set to true to cause the HTTP client's CheckRedirect to return http.ErrUseLastResponse")
+	}
+}

config.yaml

@@ -1,16 +1,47 @@
-metrics: true
 services:
-  - name: twinnation
-    url: "https://twinnation.org/health"
-    interval: 30s
-    conditions:
-      - "[STATUS] == 200"
-      - "[BODY].status == UP"
-      - "[RESPONSE_TIME] < 1000"
-  - name: cat-fact
-    url: "https://cat-fact.herokuapp.com/facts/random"
+  - name: front-end
+    group: core
+    url: "https://twin.sh/health"
     interval: 1m
     conditions:
       - "[STATUS] == 200"
-      - "[BODY].deleted == false"
-      - "len([BODY].text) > 0"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 150"
+
+  - name: back-end
+    group: core
+    url: "https://example.org/"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+      - "[CERTIFICATE_EXPIRATION] > 48h"
+
+  - name: monitoring
+    group: internal
+    url: "https://example.org/"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+
+  - name: nas
+    group: internal
+    url: "https://example.org/"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+
+  - name: example-dns-query
+    url: "8.8.8.8" # Address of the DNS server to use
+    interval: 5m
+    dns:
+      query-name: "example.com"
+      query-type: "A"
+    conditions:
+      - "[BODY] == 93.184.216.34"
+      - "[DNS_RCODE] == NOERROR"
+
+  - name: icmp-ping
+    url: "icmp://example.org"
+    interval: 1m
+    conditions:
+      - "[CONNECTED] == true"

config/config.go

@@ -5,12 +5,17 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
+	"time"
 
-	"github.com/TwinProduction/gatus/alerting"
-	"github.com/TwinProduction/gatus/alerting/provider"
-	"github.com/TwinProduction/gatus/core"
-	"github.com/TwinProduction/gatus/k8s"
-	"github.com/TwinProduction/gatus/security"
+	"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"
 )
 
@@ -22,15 +27,6 @@ const (
 	// DefaultFallbackConfigurationFilePath is the default fallback path that will be used to search for the
 	// configuration file if DefaultConfigurationFilePath didn't work
 	DefaultFallbackConfigurationFilePath = "config/config.yml"
-
-	// DefaultAddress is the default address the service will bind to
-	DefaultAddress = "0.0.0.0"
-
-	// DefaultPort is the default port the service will listen on
-	DefaultPort = 8080
-
-	// DefaultContextRoot is the default context root of the web application
-	DefaultContextRoot = "/"
 )
 
 var (
@@ -40,13 +36,8 @@ var (
 	// ErrConfigFileNotFound is an error returned when the configuration file could not be found
 	ErrConfigFileNotFound = errors.New("configuration file not found")
 
-	// ErrConfigNotLoaded is an error returned when an attempt to Get() the configuration before loading it is made
-	ErrConfigNotLoaded = errors.New("configuration is nil")
-
 	// ErrInvalidSecurityConfig is an error returned when the security configuration is invalid
 	ErrInvalidSecurityConfig = errors.New("invalid security configuration")
-
-	config *Config
 )
 
 // Config is the main configuration structure
@@ -57,6 +48,10 @@ type Config struct {
 	// Metrics Whether to expose metrics at /metrics
 	Metrics bool `yaml:"metrics"`
 
+	// SkipInvalidConfigUpdate Whether to make the application ignore invalid configuration
+	// if the configuration file is updated while the application is running
+	SkipInvalidConfigUpdate bool `yaml:"skip-invalid-config-update"`
+
 	// DisableMonitoringLock Whether to disable the monitoring lock
 	// The monitoring lock is what prevents multiple services from being processed at the same time.
 	// Disabling this may lead to inaccurate response times
@@ -71,46 +66,70 @@ type Config struct {
 	// Services List of services to monitor
 	Services []*core.Service `yaml:"services"`
 
-	// Kubernetes is the Kubernetes configuration
-	Kubernetes *k8s.Config `yaml:"kubernetes"`
+	// Storage is the configuration for how the data is stored
+	Storage *storage.Config `yaml:"storage"`
 
 	// Web is the configuration for the web listener
-	Web *webConfig `yaml:"web"`
+	Web *web.Config `yaml:"web"`
+
+	// UI is the configuration for the UI
+	UI *ui.Config `yaml:"ui"`
+
+	// Maintenance is the configuration for creating a maintenance window in which no alerts are sent
+	Maintenance *maintenance.Config `yaml:"maintenance"`
+
+	filePath        string    // path to the file from which config was loaded from
+	lastFileModTime time.Time // last modification time
 }
 
-// Get returns the configuration, or panics if the configuration hasn't loaded yet
-func Get() *Config {
-	if config == nil {
-		panic(ErrConfigNotLoaded)
+// 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()
+		}
+	}
+	return false
+}
+
+// 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()
+		}
+	} else {
+		log.Println("[config][UpdateLastFileModTime] Ran into error updating lastFileModTime:", err.Error())
 	}
-	return config
 }
 
 // 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) error {
+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 ErrConfigFileNotFound
+			return nil, ErrConfigFileNotFound
 		}
-		return err
+		return nil, err
 	}
-	config = cfg
-	return nil
+	cfg.filePath = configFile
+	cfg.UpdateLastFileModTime()
+	return cfg, nil
 }
 
 // LoadDefaultConfiguration loads the default configuration file
-func LoadDefaultConfiguration() error {
-	err := Load(DefaultConfigurationFilePath)
+func LoadDefaultConfiguration() (*Config, error) {
+	cfg, err := Load(DefaultConfigurationFilePath)
 	if err != nil {
 		if err == ErrConfigFileNotFound {
 			return Load(DefaultFallbackConfigurationFilePath)
 		}
-		return err
+		return nil, err
 	}
-	return nil
+	return cfg, nil
 }
 
 func readConfigurationFile(fileName string) (config *Config, err error) {
@@ -130,57 +149,102 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 	if err != nil {
 		return
 	}
-	// Check if the configuration file at least has services configured or Kubernetes auto discovery enabled
-	if config == nil || ((config.Services == nil || len(config.Services) == 0) && (config.Kubernetes == nil || !config.Kubernetes.AutoDiscover)) {
+	// Check if the configuration file at least has services configured
+	if config == nil || config.Services == nil || len(config.Services) == 0 {
 		err = ErrNoServiceInConfig
 	} else {
 		// Note that the functions below may panic, and this is on purpose to prevent Gatus from starting with
 		// invalid configurations
-		validateAlertingConfig(config)
-		validateSecurityConfig(config)
-		validateServicesConfig(config)
-		validateKubernetesConfig(config)
-		validateWebConfig(config)
+		validateAlertingConfig(config.Alerting, config.Services, config.Debug)
+		if err := validateSecurityConfig(config); err != nil {
+			return nil, err
+		}
+		if err := validateServicesConfig(config); err != nil {
+			return nil, err
+		}
+		if err := validateWebConfig(config); err != nil {
+			return nil, err
+		}
+		if err := validateUIConfig(config); err != nil {
+			return nil, err
+		}
+		if err := validateMaintenanceConfig(config); err != nil {
+			return nil, err
+		}
+		if err := validateStorageConfig(config); err != nil {
+			return nil, err
+		}
 	}
 	return
 }
 
-func validateWebConfig(config *Config) {
-	if config.Web == nil {
-		config.Web = &webConfig{Address: DefaultAddress, Port: DefaultPort, ContextRoot: DefaultContextRoot}
+func validateStorageConfig(config *Config) error {
+	if config.Storage == nil {
+		config.Storage = &storage.Config{
+			Type: storage.TypeMemory,
+		}
+	}
+	err := storage.Initialize(config.Storage)
+	if err != nil {
+		return err
+	}
+	// Remove all ServiceStatus that represent services which no longer exist in the configuration
+	var keys []string
+	for _, service := range config.Services {
+		keys = append(keys, service.Key())
+	}
+	numberOfServiceStatusesDeleted := storage.Get().DeleteAllServiceStatusesNotInKeys(keys)
+	if numberOfServiceStatusesDeleted > 0 {
+		log.Printf("[config][validateStorageConfig] Deleted %d service statuses because their matching services no longer existed", numberOfServiceStatusesDeleted)
+	}
+	return nil
+}
+
+func validateMaintenanceConfig(config *Config) error {
+	if config.Maintenance == nil {
+		config.Maintenance = maintenance.GetDefaultConfig()
 	} else {
-		config.Web.validateAndSetDefaults()
+		if err := config.Maintenance.ValidateAndSetDefaults(); err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
-func validateKubernetesConfig(config *Config) {
-	if config.Kubernetes != nil && config.Kubernetes.AutoDiscover {
-		if config.Kubernetes.ServiceTemplate == nil {
-			panic("kubernetes.service-template cannot be nil")
+func validateUIConfig(config *Config) error {
+	if config.UI == nil {
+		config.UI = ui.GetDefaultConfig()
+	} else {
+		if err := config.UI.ValidateAndSetDefaults(); err != nil {
+			return err
 		}
-		if config.Debug {
-			log.Println("[config][validateKubernetesConfig] Automatically discovering Kubernetes services...")
-		}
-		discoveredServices, err := k8s.DiscoverServices(config.Kubernetes)
-		if err != nil {
-			panic(err)
-		}
-		config.Services = append(config.Services, discoveredServices...)
-		log.Printf("[config][validateKubernetesConfig] Discovered %d Kubernetes services", len(discoveredServices))
 	}
+	return nil
 }
 
-func validateServicesConfig(config *Config) {
+func validateWebConfig(config *Config) error {
+	if config.Web == nil {
+		config.Web = web.GetDefaultConfig()
+	} else {
+		return config.Web.ValidateAndSetDefaults()
+	}
+	return nil
+}
+
+func validateServicesConfig(config *Config) error {
 	for _, service := range config.Services {
 		if config.Debug {
 			log.Printf("[config][validateServicesConfig] Validating service '%s'", service.Name)
 		}
-		service.ValidateAndSetDefaults()
+		if err := service.ValidateAndSetDefaults(); err != nil {
+			return err
+		}
 	}
 	log.Printf("[config][validateServicesConfig] Validated %d services", len(config.Services))
+	return nil
 }
 
-func validateSecurityConfig(config *Config) {
+func validateSecurityConfig(config *Config) error {
 	if config.Security != nil {
 		if config.Security.IsValid() {
 			if config.Debug {
@@ -189,29 +253,50 @@ func validateSecurityConfig(config *Config) {
 		} else {
 			// If there was an attempt to configure security, then it must mean that some confidential or private
 			// data are exposed. As a result, we'll force a panic because it's better to be safe than sorry.
-			panic(ErrInvalidSecurityConfig)
+			return ErrInvalidSecurityConfig
 		}
 	}
+	return nil
 }
 
-func validateAlertingConfig(config *Config) {
-	if config.Alerting == nil {
+// validateAlertingConfig validates the alerting configuration
+// Note that the alerting configuration has to be validated before the service configuration, because the default alert
+// returned by provider.AlertProvider.GetDefaultAlert() must be parsed before core.Service.ValidateAndSetDefaults()
+// sets the default alert values when none are set.
+func validateAlertingConfig(alertingConfig *alerting.Config, services []*core.Service, debug bool) {
+	if alertingConfig == nil {
 		log.Printf("[config][validateAlertingConfig] Alerting is not configured")
 		return
 	}
-	alertTypes := []core.AlertType{
-		core.SlackAlert,
-		core.MattermostAlert,
-		core.MessagebirdAlert,
-		core.TwilioAlert,
-		core.PagerDutyAlert,
-		core.CustomAlert,
+	alertTypes := []alert.Type{
+		alert.TypeCustom,
+		alert.TypeDiscord,
+		alert.TypeMattermost,
+		alert.TypeMessagebird,
+		alert.TypePagerDuty,
+		alert.TypeSlack,
+		alert.TypeTeams,
+		alert.TypeTelegram,
+		alert.TypeTwilio,
 	}
-	var validProviders, invalidProviders []core.AlertType
+	var validProviders, invalidProviders []alert.Type
 	for _, alertType := range alertTypes {
-		alertProvider := GetAlertingProviderByAlertType(config, alertType)
+		alertProvider := alertingConfig.GetAlertingProviderByAlertType(alertType)
 		if alertProvider != nil {
 			if alertProvider.IsValid() {
+				// Parse alerts with the provider's default alert
+				if alertProvider.GetDefaultAlert() != nil {
+					for _, service := range services {
+						for alertIndex, serviceAlert := range service.Alerts {
+							if alertType == serviceAlert.Type {
+								if debug {
+									log.Printf("[config][validateAlertingConfig] Parsing alert %d with provider's default alert for provider=%s in service=%s", alertIndex, alertType, service.Name)
+								}
+								provider.ParseWithDefaultAlert(alertProvider.GetDefaultAlert(), serviceAlert)
+							}
+						}
+					}
+				}
 				validProviders = append(validProviders, alertType)
 			} else {
 				log.Printf("[config][validateAlertingConfig] Ignoring provider=%s because configuration is invalid", alertType)
@@ -223,46 +308,3 @@ func validateAlertingConfig(config *Config) {
 	}
 	log.Printf("[config][validateAlertingConfig] configuredProviders=%s; ignoredProviders=%s", validProviders, invalidProviders)
 }
-
-// GetAlertingProviderByAlertType returns an provider.AlertProvider by its corresponding core.AlertType
-func GetAlertingProviderByAlertType(config *Config, alertType core.AlertType) provider.AlertProvider {
-	switch alertType {
-	case core.SlackAlert:
-		if config.Alerting.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.Alerting.Slack
-	case core.MattermostAlert:
-		if config.Alerting.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.Alerting.Mattermost
-	case core.MessagebirdAlert:
-		if config.Alerting.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.Alerting.Messagebird
-	case core.TwilioAlert:
-		if config.Alerting.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.Alerting.Twilio
-	case core.PagerDutyAlert:
-		if config.Alerting.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.Alerting.PagerDuty
-	case core.CustomAlert:
-		if config.Alerting.Custom == nil {
-			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
-			return nil
-		}
-		return config.Alerting.Custom
-	}
-	return nil
-}

config/maintenance/maintenance.go

@@ -0,0 +1,146 @@
+package maintenance
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var (
+	errInvalidMaintenanceStartFormat = errors.New("invalid maintenance start format: must be hh:mm, between 00:00 and 23:59 inclusively (e.g. 23:00)")
+	errInvalidMaintenanceDuration    = errors.New("invalid maintenance duration: must be bigger than 0 (e.g. 30m)")
+	errInvalidDayName                = fmt.Errorf("invalid value specified for 'on'. supported values are %s", longDayNames)
+
+	longDayNames = []string{
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday",
+	}
+)
+
+// Config allows for the configuration of a maintenance period.
+// During this maintenance period, no alerts will be sent.
+//
+// Uses UTC.
+type Config struct {
+	Enabled  *bool         `yaml:"enabled"`  // Whether the maintenance period is enabled. Enabled by default if nil.
+	Start    string        `yaml:"start"`    // Time at which the maintenance period starts (e.g. 23:00)
+	Duration time.Duration `yaml:"duration"` // Duration of the maintenance period (e.g. 4h)
+
+	// Every is a list of days of the week during which maintenance period applies.
+	// See longDayNames for list of valid values.
+	// Every day if empty.
+	Every []string `yaml:"every"`
+
+	durationToStartFromMidnight time.Duration
+	timeLocation                *time.Location
+}
+
+func GetDefaultConfig() *Config {
+	defaultValue := false
+	return &Config{
+		Enabled: &defaultValue,
+	}
+}
+
+// IsEnabled returns whether maintenance is enabled or not
+func (c Config) IsEnabled() bool {
+	if c.Enabled == nil {
+		return true
+	}
+	return *c.Enabled
+}
+
+// ValidateAndSetDefaults validates the maintenance configuration and sets the default values if necessary.
+//
+// Must be called once in the application's lifecycle before IsUnderMaintenance is called, since it
+// also sets durationToStartFromMidnight.
+func (c *Config) ValidateAndSetDefaults() error {
+	if c == nil || !c.IsEnabled() {
+		// Don't waste time validating if maintenance is not enabled.
+		return nil
+	}
+	for _, day := range c.Every {
+		isDayValid := false
+		for _, longDayName := range longDayNames {
+			if day == longDayName {
+				isDayValid = true
+				break
+			}
+		}
+		if !isDayValid {
+			return errInvalidDayName
+		}
+	}
+	var err error
+	c.durationToStartFromMidnight, err = hhmmToDuration(c.Start)
+	if err != nil {
+		return err
+	}
+	if c.Duration <= 0 || c.Duration >= 24*time.Hour {
+		return errInvalidMaintenanceDuration
+	}
+	return nil
+}
+
+// IsUnderMaintenance checks whether the services that Gatus monitors are within the configured maintenance window
+func (c Config) IsUnderMaintenance() bool {
+	if !c.IsEnabled() {
+		return false
+	}
+	now := time.Now().UTC()
+	var dayWhereMaintenancePeriodWouldStart time.Time
+	if now.Hour() >= int(c.durationToStartFromMidnight.Hours()) {
+		dayWhereMaintenancePeriodWouldStart = now.Truncate(24 * time.Hour)
+	} else {
+		dayWhereMaintenancePeriodWouldStart = now.Add(-c.Duration).Truncate(24 * time.Hour)
+	}
+	hasMaintenanceEveryDay := len(c.Every) == 0
+	hasMaintenancePeriodScheduledToStartOnThatWeekday := c.hasDay(dayWhereMaintenancePeriodWouldStart.Weekday().String())
+	if !hasMaintenanceEveryDay && !hasMaintenancePeriodScheduledToStartOnThatWeekday {
+		// The day when the maintenance period would start is not scheduled
+		// to have any maintenance, so we can just return false.
+		return false
+	}
+	startOfMaintenancePeriod := dayWhereMaintenancePeriodWouldStart.Add(c.durationToStartFromMidnight)
+	endOfMaintenancePeriod := startOfMaintenancePeriod.Add(c.Duration)
+	return now.After(startOfMaintenancePeriod) && now.Before(endOfMaintenancePeriod)
+}
+
+func (c Config) hasDay(day string) bool {
+	for _, d := range c.Every {
+		if d == day {
+			return true
+		}
+	}
+	return false
+}
+
+func hhmmToDuration(s string) (time.Duration, error) {
+	if len(s) != 5 {
+		return 0, errInvalidMaintenanceStartFormat
+	}
+	var hours, minutes int
+	var err error
+	if hours, err = extractNumericalValueFromPotentiallyZeroPaddedString(s[:2]); err != nil {
+		return 0, err
+	}
+	if minutes, err = extractNumericalValueFromPotentiallyZeroPaddedString(s[3:5]); err != nil {
+		return 0, err
+	}
+	duration := (time.Duration(hours) * time.Hour) + (time.Duration(minutes) * time.Minute)
+	if hours < 0 || hours > 23 || minutes < 0 || minutes > 59 || duration < 0 || duration >= 24*time.Hour {
+		return 0, errInvalidMaintenanceStartFormat
+	}
+	return duration, nil
+}
+
+func extractNumericalValueFromPotentiallyZeroPaddedString(s string) (int, error) {
+	return strconv.Atoi(strings.TrimPrefix(s, "0"))
+}

config/maintenance/maintenance_test.go

@@ -0,0 +1,226 @@
+package maintenance
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"testing"
+	"time"
+)
+
+func TestGetDefaultConfig(t *testing.T) {
+	if *GetDefaultConfig().Enabled {
+		t.Fatal("expected default config to be disabled by default")
+	}
+}
+
+func TestConfig_ValidateAndSetDefaults(t *testing.T) {
+	yes, no := true, false
+	scenarios := []struct {
+		name          string
+		cfg           *Config
+		expectedError error
+	}{
+		{
+			name:          "nil",
+			cfg:           nil,
+			expectedError: nil,
+		},
+		{
+			name: "disabled",
+			cfg: &Config{
+				Enabled: &no,
+			},
+			expectedError: nil,
+		},
+		{
+			name: "invalid-day",
+			cfg: &Config{
+				Every: []string{"invalid-day"},
+			},
+			expectedError: errInvalidDayName,
+		},
+		{
+			name: "invalid-day",
+			cfg: &Config{
+				Every: []string{"invalid-day"},
+			},
+			expectedError: errInvalidDayName,
+		},
+		{
+			name: "invalid-start-format",
+			cfg: &Config{
+				Start: "0000",
+			},
+			expectedError: errInvalidMaintenanceStartFormat,
+		},
+		{
+			name: "invalid-start-hours",
+			cfg: &Config{
+				Start: "25:00",
+			},
+			expectedError: errInvalidMaintenanceStartFormat,
+		},
+		{
+			name: "invalid-start-minutes",
+			cfg: &Config{
+				Start: "0:61",
+			},
+			expectedError: errInvalidMaintenanceStartFormat,
+		},
+		{
+			name: "invalid-start-minutes-non-numerical",
+			cfg: &Config{
+				Start: "00:zz",
+			},
+			expectedError: strconv.ErrSyntax,
+		},
+		{
+			name: "invalid-start-hours-non-numerical",
+			cfg: &Config{
+				Start: "zz:00",
+			},
+			expectedError: strconv.ErrSyntax,
+		},
+		{
+			name: "invalid-duration",
+			cfg: &Config{
+				Start:    "23:00",
+				Duration: 0,
+			},
+			expectedError: errInvalidMaintenanceDuration,
+		},
+		{
+			name: "every-day-at-2300",
+			cfg: &Config{
+				Start:    "23:00",
+				Duration: time.Hour,
+			},
+			expectedError: nil,
+		},
+		{
+			name: "every-monday-at-0000",
+			cfg: &Config{
+				Start:    "00:00",
+				Duration: 30 * time.Minute,
+				Every:    []string{"Monday"},
+			},
+			expectedError: nil,
+		},
+		{
+			name: "every-friday-and-sunday-at-0000-explicitly-enabled",
+			cfg: &Config{
+				Enabled:  &yes,
+				Start:    "08:00",
+				Duration: 8 * time.Hour,
+				Every:    []string{"Friday", "Sunday"},
+			},
+			expectedError: nil,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			err := scenario.cfg.ValidateAndSetDefaults()
+			if !errors.Is(err, scenario.expectedError) {
+				t.Errorf("expected %v, got %v", scenario.expectedError, err)
+			}
+		})
+	}
+}
+
+func TestConfig_IsUnderMaintenance(t *testing.T) {
+	yes, no := true, false
+	now := time.Now().UTC()
+	scenarios := []struct {
+		name     string
+		cfg      *Config
+		expected bool
+	}{
+		{
+			name: "disabled",
+			cfg: &Config{
+				Enabled: &no,
+			},
+			expected: false,
+		},
+		{
+			name: "under-maintenance-explicitly-enabled",
+			cfg: &Config{
+				Enabled:  &yes,
+				Start:    fmt.Sprintf("%02d:00", now.Hour()),
+				Duration: 2 * time.Hour,
+			},
+			expected: true,
+		},
+		{
+			name: "under-maintenance-starting-now-for-2h",
+			cfg: &Config{
+				Start:    fmt.Sprintf("%02d:00", now.Hour()),
+				Duration: 2 * time.Hour,
+			},
+			expected: true,
+		},
+		{
+			name: "under-maintenance-starting-now-for-8h",
+			cfg: &Config{
+				Start:    fmt.Sprintf("%02d:00", now.Hour()),
+				Duration: 8 * time.Hour,
+			},
+			expected: true,
+		},
+		{
+			name: "under-maintenance-starting-4h-ago-for-8h",
+			cfg: &Config{
+				Start:    fmt.Sprintf("%02d:00", normalizeHour(now.Hour()-4)),
+				Duration: 8 * time.Hour,
+			},
+			expected: true,
+		},
+		{
+			name: "under-maintenance-starting-4h-ago-for-3h",
+			cfg: &Config{
+				Start:    fmt.Sprintf("%02d:00", normalizeHour(now.Hour()-4)),
+				Duration: 3 * time.Hour,
+			},
+			expected: false,
+		},
+		{
+			name: "under-maintenance-starting-5h-ago-for-1h",
+			cfg: &Config{
+				Start:    fmt.Sprintf("%02d:00", normalizeHour(now.Hour()-5)),
+				Duration: time.Hour,
+			},
+			expected: false,
+		},
+		{
+			name: "not-under-maintenance-today",
+			cfg: &Config{
+				Start:    fmt.Sprintf("%02d:00", now.Hour()),
+				Duration: time.Hour,
+				Every:    []string{now.Add(48 * time.Hour).Weekday().String()},
+			},
+			expected: false,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			t.Log(scenario.cfg.Start)
+			t.Log(now)
+			if err := scenario.cfg.ValidateAndSetDefaults(); err != nil {
+				t.Fatal("validation shouldn't have returned an error, got", err)
+			}
+			isUnderMaintenance := scenario.cfg.IsUnderMaintenance()
+			if isUnderMaintenance != scenario.expected {
+				t.Errorf("expected %v, got %v", scenario.expected, isUnderMaintenance)
+				t.Logf("start=%v; duration=%v; now=%v", scenario.cfg.Start, scenario.cfg.Duration, time.Now().UTC())
+			}
+		})
+	}
+}
+
+func normalizeHour(hour int) int {
+	if hour < 0 {
+		return hour + 24
+	}
+	return hour
+}

config/ui/ui.go

@@ -0,0 +1,48 @@
+package ui
+
+import (
+	"bytes"
+	"html/template"
+)
+
+const (
+	defaultTitle = "Health Dashboard | Gatus"
+	defaultLogo  = ""
+)
+
+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"
+)
+
+// Config is the configuration for the UI of Gatus
+type Config struct {
+	Title string `yaml:"title"` // Title of the page
+	Logo  string `yaml:"logo"`  // Logo to display on the page
+}
+
+// GetDefaultConfig returns a Config struct with the default values
+func GetDefaultConfig() *Config {
+	return &Config{
+		Title: defaultTitle,
+		Logo:  defaultLogo,
+	}
+}
+
+// ValidateAndSetDefaults validates the UI configuration and sets the default values if necessary.
+func (cfg *Config) ValidateAndSetDefaults() error {
+	if len(cfg.Title) == 0 {
+		cfg.Title = defaultTitle
+	}
+	t, err := template.ParseFiles(StaticFolder + "/index.html")
+	if err != nil {
+		return err
+	}
+	var buffer bytes.Buffer
+	err = t.Execute(&buffer, cfg)
+	if err != nil {
+		return err
+	}
+	return nil
+}

config/ui/ui_test.go

@@ -0,0 +1,26 @@
+package ui
+
+import (
+	"testing"
+)
+
+func TestConfig_ValidateAndSetDefaults(t *testing.T) {
+	StaticFolder = "../../web/static"
+	defer func() {
+		StaticFolder = "./web/static"
+	}()
+	cfg := &Config{Title: ""}
+	if err := cfg.ValidateAndSetDefaults(); err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+}
+
+func TestGetDefaultConfig(t *testing.T) {
+	defaultConfig := GetDefaultConfig()
+	if defaultConfig.Title != defaultTitle {
+		t.Error("expected GetDefaultConfig() to return defaultTitle, got", defaultConfig.Title)
+	}
+	if defaultConfig.Logo != defaultLogo {
+		t.Error("expected GetDefaultConfig() to return defaultLogo, got", defaultConfig.Logo)
+	}
+}

config/web.go

@@ -1,63 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"math"
-	"net/url"
-	"strings"
-)
-
-// webConfig is the structure which supports the configuration of the endpoint
-// which provides access to the web frontend
-type webConfig struct {
-	// Address to listen on (defaults to 0.0.0.0 specified by DefaultAddress)
-	Address string `yaml:"address"`
-
-	// Port to listen on (default to 8080 specified by DefaultPort)
-	Port int `yaml:"port"`
-
-	// ContextRoot set the root context for the web application
-	ContextRoot string `yaml:"context-root"`
-}
-
-// validateAndSetDefaults checks and sets the default values for fields that are not set
-func (web *webConfig) validateAndSetDefaults() {
-	// Validate the Address
-	if len(web.Address) == 0 {
-		web.Address = DefaultAddress
-	}
-	// Validate the Port
-	if web.Port == 0 {
-		web.Port = DefaultPort
-	} else if web.Port < 0 || web.Port > math.MaxUint16 {
-		panic(fmt.Sprintf("invalid port: value should be between %d and %d", 0, math.MaxUint16))
-	}
-	// Validate the ContextRoot
-	if len(web.ContextRoot) == 0 {
-		web.ContextRoot = DefaultContextRoot
-	} else {
-		trimmedContextRoot := strings.Trim(web.ContextRoot, "/")
-		if len(trimmedContextRoot) == 0 {
-			web.ContextRoot = DefaultContextRoot
-			return
-		}
-		rootContextURL, err := url.Parse(trimmedContextRoot)
-		if err != nil {
-			panic("invalid context root:" + err.Error())
-		}
-		if rootContextURL.Path != trimmedContextRoot {
-			panic("invalid context root: too complex")
-		}
-		web.ContextRoot = "/" + strings.Trim(rootContextURL.Path, "/") + "/"
-	}
-}
-
-// SocketAddress returns the combination of the Address and the Port
-func (web *webConfig) SocketAddress() string {
-	return fmt.Sprintf("%s:%d", web.Address, web.Port)
-}
-
-// PrependWithContextRoot appends the given path to the ContextRoot
-func (web *webConfig) PrependWithContextRoot(path string) string {
-	return web.ContextRoot + strings.Trim(path, "/") + "/"
-}

config/web/web.go

@@ -0,0 +1,49 @@
+package web
+
+import (
+	"fmt"
+	"math"
+)
+
+const (
+	// DefaultAddress is the default address the service will bind to
+	DefaultAddress = "0.0.0.0"
+
+	// DefaultPort is the default port the service will listen on
+	DefaultPort = 8080
+)
+
+// Config is the structure which supports the configuration of the endpoint
+// which provides access to the web frontend
+type Config struct {
+	// Address to listen on (defaults to 0.0.0.0 specified by DefaultAddress)
+	Address string `yaml:"address"`
+
+	// Port to listen on (default to 8080 specified by DefaultPort)
+	Port int `yaml:"port"`
+}
+
+// GetDefaultConfig returns a Config struct with the default values
+func GetDefaultConfig() *Config {
+	return &Config{Address: DefaultAddress, Port: DefaultPort}
+}
+
+// ValidateAndSetDefaults validates the web configuration and sets the default values if necessary.
+func (web *Config) ValidateAndSetDefaults() error {
+	// Validate the Address
+	if len(web.Address) == 0 {
+		web.Address = DefaultAddress
+	}
+	// Validate the Port
+	if web.Port == 0 {
+		web.Port = DefaultPort
+	} else if web.Port < 0 || web.Port > math.MaxUint16 {
+		return fmt.Errorf("invalid port: value should be between %d and %d", 0, math.MaxUint16)
+	}
+	return nil
+}
+
+// SocketAddress returns the combination of the Address and the Port
+func (web *Config) SocketAddress() string {
+	return fmt.Sprintf("%s:%d", web.Address, web.Port)
+}

config/web/web_test.go

@@ -0,0 +1,65 @@
+package web
+
+import (
+	"testing"
+)
+
+func TestGetDefaultConfig(t *testing.T) {
+	defaultConfig := GetDefaultConfig()
+	if defaultConfig.Port != DefaultPort {
+		t.Error("expected default config to have the default port")
+	}
+	if defaultConfig.Address != DefaultAddress {
+		t.Error("expected default config to have the default address")
+	}
+}
+
+func TestConfig_ValidateAndSetDefaults(t *testing.T) {
+	scenarios := []struct {
+		name            string
+		cfg             *Config
+		expectedAddress string
+		expectedPort    int
+		expectedErr     bool
+	}{
+		{
+			name:            "no-explicit-config",
+			cfg:             &Config{},
+			expectedAddress: "0.0.0.0",
+			expectedPort:    8080,
+			expectedErr:     false,
+		},
+		{
+			name:        "invalid-port",
+			cfg:         &Config{Port: 100000000},
+			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.Port != scenario.expectedPort {
+					t.Errorf("expected port to be %d, got %d", scenario.expectedPort, scenario.cfg.Port)
+				}
+				if scenario.cfg.Address != scenario.expectedAddress {
+					t.Errorf("expected address to be %s, got %s", scenario.expectedAddress, scenario.cfg.Address)
+				}
+			}
+		})
+	}
+}
+
+func TestConfig_SocketAddress(t *testing.T) {
+	web := &Config{
+		Address: "0.0.0.0",
+		Port:    8081,
+	}
+	if web.SocketAddress() != "0.0.0.0:8081" {
+		t.Errorf("expected %s, got %s", "0.0.0.0:8081", web.SocketAddress())
+	}
+}

config/web_test.go

@@ -1,101 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestWebConfig_SocketAddress(t *testing.T) {
-	web := &webConfig{
-		Address: "0.0.0.0",
-		Port:    8081,
-	}
-	if web.SocketAddress() != "0.0.0.0:8081" {
-		t.Errorf("expected %s, got %s", "0.0.0.0:8081", web.SocketAddress())
-	}
-}
-
-func TestWebConfig_PrependWithContextRoot(t *testing.T) {
-	web := &webConfig{ContextRoot: "/status/"}
-	if result := web.PrependWithContextRoot("/api/v1/results"); result != "/status/api/v1/results/" {
-		t.Errorf("expected %s, got %s", "/status/api/v1/results/", result)
-	}
-	if result := web.PrependWithContextRoot("/health"); result != "/status/health/" {
-		t.Errorf("expected %s, got %s", "/status/health/", result)
-	}
-	if result := web.PrependWithContextRoot("/health/"); result != "/status/health/" {
-		t.Errorf("expected %s, got %s", "/status/health/", result)
-	}
-}
-
-// validContextRootTest specifies all test case which should end up in
-// a valid context root used to bind the web interface to
-var validContextRootTests = []struct {
-	name         string
-	path         string
-	expectedPath string
-}{
-	{"Empty", "", "/"},
-	{"/", "/", "/"},
-	{"///", "///", "/"},
-	{"Single character 'a'", "a", "/a/"},
-	{"Slash at the beginning", "/status", "/status/"},
-	{"Slashes at start and end", "/status/", "/status/"},
-	{"Multiple slashes at start", "//status", "/status/"},
-	{"Mutliple slashes at start and end", "///status////", "/status/"},
-	{"Contains '@' in path'", "me@/status/gatus", "/me@/status/gatus/"},
-	{"nested context with trailing slash", "/status/gatus/", "/status/gatus/"},
-	{"nested context without trailing slash", "/status/gatus/system", "/status/gatus/system/"},
-}
-
-func TestWebConfig_ValidContextRoots(t *testing.T) {
-	for idx, test := range validContextRootTests {
-		t.Run(fmt.Sprintf("%d: %s", idx, test.name), func(t *testing.T) {
-			expectValidResultForContextRoot(t, test.path, test.expectedPath)
-		})
-	}
-}
-
-// invalidContextRootTests contains all tests for context root which are
-// expected to fail and stop program execution
-var invalidContextRootTests = []struct {
-	name string
-	path string
-}{
-	{"Only a fragment identifier", "#"},
-	{"Invalid character in path", "/invalid" + string([]byte{0x7F}) + "/"},
-	{"Starts with protocol", "http://status/gatus"},
-	{"Path with fragment", "/status/gatus#here"},
-	{"starts with '://'", "://status"},
-	{"contains query parameter", "/status/h?ello=world"},
-	{"contains '?'", "/status?/"},
-}
-
-func TestWebConfig_InvalidContextRoots(t *testing.T) {
-	for idx, test := range invalidContextRootTests {
-		t.Run(fmt.Sprintf("%d: %s", idx, test.name), func(t *testing.T) {
-			expectInvalidResultForContextRoot(t, test.path)
-		})
-	}
-}
-
-func expectInvalidResultForContextRoot(t *testing.T, path string) {
-	defer func() { recover() }()
-
-	web := &webConfig{ContextRoot: path}
-	web.validateAndSetDefaults()
-
-	t.Fatal(fmt.Sprintf("Should've panicked because the configuration specifies an invalid context root: %s", path))
-}
-
-func expectValidResultForContextRoot(t *testing.T, path string, expected string) {
-	web := &webConfig{
-		ContextRoot: path,
-	}
-
-	web.validateAndSetDefaults()
-
-	if web.ContextRoot != expected {
-		t.Errorf("expected %s, got %s", expected, web.ContextRoot)
-	}
-}

controller/controller.go

@@ -0,0 +1,49 @@
+package controller
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"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"
+)
+
+var (
+	// server is the http.Server created by Handle.
+	// The only reason it exists is for testing purposes.
+	server *http.Server
+)
+
+// 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)
+	if os.Getenv("ENVIRONMENT") == "dev" {
+		router = handler.DevelopmentCORS(router)
+	}
+	server = &http.Server{
+		Addr:         fmt.Sprintf("%s:%d", webConfig.Address, webConfig.Port),
+		Handler:      router,
+		ReadTimeout:  15 * time.Second,
+		WriteTimeout: 15 * time.Second,
+		IdleTimeout:  15 * time.Second,
+	}
+	log.Println("[controller][Handle] Listening on " + webConfig.SocketAddress())
+	if os.Getenv("ROUTER_TEST") == "true" {
+		return
+	}
+	log.Println("[controller][Handle]", server.ListenAndServe())
+}
+
+// Shutdown stops the server
+func Shutdown() {
+	if server != nil {
+		_ = server.Shutdown(context.TODO())
+		server = nil
+	}
+}

controller/controller_test.go

@@ -0,0 +1,55 @@
+package controller
+
+import (
+	"math/rand"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+
+	"github.com/TwiN/gatus/v3/config"
+	"github.com/TwiN/gatus/v3/config/web"
+	"github.com/TwiN/gatus/v3/core"
+)
+
+func TestHandle(t *testing.T) {
+	cfg := &config.Config{
+		Web: &web.Config{
+			Address: "0.0.0.0",
+			Port:    rand.Intn(65534),
+		},
+		Services: []*core.Service{
+			{
+				Name:  "frontend",
+				Group: "core",
+			},
+			{
+				Name:  "backend",
+				Group: "core",
+			},
+		},
+	}
+	_ = os.Setenv("ROUTER_TEST", "true")
+	_ = os.Setenv("ENVIRONMENT", "dev")
+	defer os.Clearenv()
+	Handle(cfg.Security, cfg.Web, cfg.UI, cfg.Metrics)
+	defer Shutdown()
+	request, _ := http.NewRequest("GET", "/health", nil)
+	responseRecorder := httptest.NewRecorder()
+	server.Handler.ServeHTTP(responseRecorder, request)
+	if responseRecorder.Code != http.StatusOK {
+		t.Error("expected GET /health to return status code 200")
+	}
+	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{}
+	Shutdown()
+	if server != nil {
+		t.Error("server should've been shut down")
+	}
+}

controller/handler/badge.go

@@ -0,0 +1,229 @@
+package handler
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/TwiN/gatus/v3/storage"
+	"github.com/TwiN/gatus/v3/storage/store/common"
+	"github.com/gorilla/mux"
+)
+
+const (
+	badgeColorHexAwesome  = "#40cc11"
+	badgeColorHexGreat    = "#94cc11"
+	badgeColorHexGood     = "#ccd311"
+	badgeColorHexPassable = "#ccb311"
+	badgeColorHexBad      = "#cc8111"
+	badgeColorHexVeryBad  = "#c7130a"
+)
+
+// UptimeBadge handles the automatic generation of badge based on the group name and service name passed.
+//
+// Valid values for {duration}: 7d, 24h, 1h
+func UptimeBadge(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 uptime 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"]
+	uptime, err := storage.Get().GetUptimeByKey(key, from, time.Now())
+	if err != nil {
+		if err == common.ErrServiceNotFound {
+			writer.WriteHeader(http.StatusNotFound)
+		} else if err == common.ErrInvalidTimeRange {
+			writer.WriteHeader(http.StatusBadRequest)
+		} else {
+			writer.WriteHeader(http.StatusInternalServerError)
+		}
+		_, _ = writer.Write([]byte(err.Error()))
+		return
+	}
+	formattedDate := time.Now().Format(http.TimeFormat)
+	writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	writer.Header().Set("Date", formattedDate)
+	writer.Header().Set("Expires", formattedDate)
+	writer.Header().Set("Content-Type", "image/svg+xml")
+	_, _ = writer.Write(generateUptimeBadgeSVG(duration, uptime))
+}
+
+// ResponseTimeBadge handles the automatic generation of badge based on the group name and service 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
+	}
+	key := variables["key"]
+	averageResponseTime, err := storage.Get().GetAverageResponseTimeByKey(key, from, time.Now())
+	if err != nil {
+		if err == common.ErrServiceNotFound {
+			writer.WriteHeader(http.StatusNotFound)
+		} else if err == common.ErrInvalidTimeRange {
+			writer.WriteHeader(http.StatusBadRequest)
+		} else {
+			writer.WriteHeader(http.StatusInternalServerError)
+		}
+		_, _ = writer.Write([]byte(err.Error()))
+		return
+	}
+	formattedDate := time.Now().Format(http.TimeFormat)
+	writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	writer.Header().Set("Date", formattedDate)
+	writer.Header().Set("Expires", formattedDate)
+	writer.Header().Set("Content-Type", "image/svg+xml")
+	_, _ = writer.Write(generateResponseTimeBadgeSVG(duration, averageResponseTime))
+}
+
+func generateUptimeBadgeSVG(duration string, uptime float64) []byte {
+	var labelWidth, valueWidth, valueWidthAdjustment int
+	switch duration {
+	case "7d":
+		labelWidth = 65
+	case "24h":
+		labelWidth = 70
+	case "1h":
+		labelWidth = 65
+	default:
+	}
+	color := getBadgeColorFromUptime(uptime)
+	sanitizedValue := strings.TrimRight(strings.TrimRight(fmt.Sprintf("%.2f", uptime*100), "0"), ".") + "%"
+	if strings.Contains(sanitizedValue, ".") {
+		valueWidthAdjustment = -10
+	}
+	valueWidth = (len(sanitizedValue) * 11) + valueWidthAdjustment
+	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">
+      uptime %s
+    </text>
+    <text x="%d" y="14">
+      uptime %s
+    </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, duration, labelX, duration, valueX, sanitizedValue, valueX, sanitizedValue))
+	return svg
+}
+
+func getBadgeColorFromUptime(uptime float64) string {
+	if uptime >= 0.975 {
+		return badgeColorHexAwesome
+	} else if uptime >= 0.95 {
+		return badgeColorHexGreat
+	} else if uptime >= 0.9 {
+		return badgeColorHexGood
+	} else if uptime >= 0.8 {
+		return badgeColorHexPassable
+	} else if uptime >= 0.65 {
+		return badgeColorHexBad
+	}
+	return badgeColorHexVeryBad
+}
+
+func generateResponseTimeBadgeSVG(duration string, averageResponseTime int) []byte {
+	var labelWidth, valueWidth int
+	switch duration {
+	case "7d":
+		labelWidth = 105
+	case "24h":
+		labelWidth = 110
+	case "1h":
+		labelWidth = 105
+	default:
+	}
+	color := getBadgeColorFromResponseTime(averageResponseTime)
+	sanitizedValue := strconv.Itoa(averageResponseTime) + "ms"
+	valueWidth = len(sanitizedValue) * 11
+	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">
+      response time %s
+    </text>
+    <text x="%d" y="14">
+      response time %s
+    </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, duration, labelX, duration, valueX, sanitizedValue, valueX, sanitizedValue))
+	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
+	}
+	return badgeColorHexVeryBad
+}

controller/handler/badge_test.go

@@ -0,0 +1,221 @@
+package handler
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/TwiN/gatus/v3/config"
+	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v3/storage"
+	"github.com/TwiN/gatus/v3/watchdog"
+)
+
+func TestUptimeBadge(t *testing.T) {
+	defer storage.Get().Clear()
+	defer cache.Clear()
+	cfg := &config.Config{
+		Metrics: true,
+		Services: []*core.Service{
+			{
+				Name:  "frontend",
+				Group: "core",
+			},
+			{
+				Name:  "backend",
+				Group: "core",
+			},
+		},
+	}
+	watchdog.UpdateServiceStatuses(cfg.Services[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
+	watchdog.UpdateServiceStatuses(cfg.Services[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
+	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+	type Scenario struct {
+		Name         string
+		Path         string
+		ExpectedCode int
+		Gzip         bool
+	}
+	scenarios := []Scenario{
+		{
+			Name:         "badge-uptime-1h",
+			Path:         "/api/v1/services/core_frontend/uptimes/1h/badge.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badge-uptime-24h",
+			Path:         "/api/v1/services/core_backend/uptimes/24h/badge.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badge-uptime-7d",
+			Path:         "/api/v1/services/core_frontend/uptimes/7d/badge.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badge-uptime-with-invalid-duration",
+			Path:         "/api/v1/services/core_backend/uptimes/3d/badge.svg",
+			ExpectedCode: http.StatusBadRequest,
+		},
+		{
+			Name:         "badge-uptime-for-invalid-key",
+			Path:         "/api/v1/services/invalid_key/uptimes/7d/badge.svg",
+			ExpectedCode: http.StatusNotFound,
+		},
+		{
+			Name:         "badge-response-time-1h",
+			Path:         "/api/v1/services/core_frontend/response-times/1h/badge.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badge-response-time-24h",
+			Path:         "/api/v1/services/core_backend/response-times/24h/badge.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badge-response-time-7d",
+			Path:         "/api/v1/services/core_frontend/response-times/7d/badge.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badge-response-time-with-invalid-duration",
+			Path:         "/api/v1/services/core_backend/response-times/3d/badge.svg",
+			ExpectedCode: http.StatusBadRequest,
+		},
+		{
+			Name:         "badge-response-time-for-invalid-key",
+			Path:         "/api/v1/services/invalid_key/response-times/7d/badge.svg",
+			ExpectedCode: http.StatusNotFound,
+		},
+		{
+			Name:         "chart-response-time-24h",
+			Path:         "/api/v1/services/core_backend/response-times/24h/chart.svg",
+			ExpectedCode: http.StatusOK,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			if scenario.Gzip {
+				request.Header.Set("Accept-Encoding", "gzip")
+			}
+			responseRecorder := httptest.NewRecorder()
+			router.ServeHTTP(responseRecorder, request)
+			if responseRecorder.Code != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			}
+		})
+	}
+}
+
+func TestGetBadgeColorFromUptime(t *testing.T) {
+	scenarios := []struct {
+		Uptime        float64
+		ExpectedColor string
+	}{
+		{
+			Uptime:        1,
+			ExpectedColor: badgeColorHexAwesome,
+		},
+		{
+			Uptime:        0.99,
+			ExpectedColor: badgeColorHexAwesome,
+		},
+		{
+			Uptime:        0.97,
+			ExpectedColor: badgeColorHexGreat,
+		},
+		{
+			Uptime:        0.95,
+			ExpectedColor: badgeColorHexGreat,
+		},
+		{
+			Uptime:        0.93,
+			ExpectedColor: badgeColorHexGood,
+		},
+		{
+			Uptime:        0.9,
+			ExpectedColor: badgeColorHexGood,
+		},
+		{
+			Uptime:        0.85,
+			ExpectedColor: badgeColorHexPassable,
+		},
+		{
+			Uptime:        0.7,
+			ExpectedColor: badgeColorHexBad,
+		},
+		{
+			Uptime:        0.65,
+			ExpectedColor: badgeColorHexBad,
+		},
+		{
+			Uptime:        0.6,
+			ExpectedColor: badgeColorHexVeryBad,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run("uptime-"+strconv.Itoa(int(scenario.Uptime*100)), func(t *testing.T) {
+			if getBadgeColorFromUptime(scenario.Uptime) != scenario.ExpectedColor {
+				t.Errorf("expected %s from %f, got %v", scenario.ExpectedColor, scenario.Uptime, getBadgeColorFromUptime(scenario.Uptime))
+			}
+		})
+	}
+}
+
+func TestGetBadgeColorFromResponseTime(t *testing.T) {
+	scenarios := []struct {
+		ResponseTime  int
+		ExpectedColor string
+	}{
+		{
+			ResponseTime:  10,
+			ExpectedColor: badgeColorHexAwesome,
+		},
+		{
+			ResponseTime:  50,
+			ExpectedColor: badgeColorHexAwesome,
+		},
+		{
+			ResponseTime:  75,
+			ExpectedColor: badgeColorHexGreat,
+		},
+		{
+			ResponseTime:  150,
+			ExpectedColor: badgeColorHexGreat,
+		},
+		{
+			ResponseTime:  201,
+			ExpectedColor: badgeColorHexGood,
+		},
+		{
+			ResponseTime:  300,
+			ExpectedColor: badgeColorHexGood,
+		},
+		{
+			ResponseTime:  301,
+			ExpectedColor: badgeColorHexPassable,
+		},
+		{
+			ResponseTime:  450,
+			ExpectedColor: badgeColorHexPassable,
+		},
+		{
+			ResponseTime:  700,
+			ExpectedColor: badgeColorHexBad,
+		},
+		{
+			ResponseTime:  1500,
+			ExpectedColor: badgeColorHexVeryBad,
+		},
+	}
+	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))
+			}
+		})
+	}
+}

controller/handler/chart.go

@@ -0,0 +1,121 @@
+package handler
+
+import (
+	"log"
+	"math"
+	"net/http"
+	"sort"
+	"time"
+
+	"github.com/TwiN/gatus/v3/storage"
+	"github.com/TwiN/gatus/v3/storage/store/common"
+	"github.com/gorilla/mux"
+	"github.com/wcharczuk/go-chart/v2"
+	"github.com/wcharczuk/go-chart/v2/drawing"
+)
+
+const timeFormat = "3:04PM"
+
+var (
+	gridStyle = chart.Style{
+		StrokeColor: drawing.Color{R: 119, G: 119, B: 119, A: 40},
+		StrokeWidth: 1.0,
+	}
+	axisStyle = chart.Style{
+		FontColor: drawing.Color{R: 119, G: 119, B: 119, A: 255},
+	}
+	transparentStyle = chart.Style{
+		FillColor: drawing.Color{R: 255, G: 255, B: 255, A: 0},
+	}
+)
+
+func ResponseTimeChart(writer http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	duration := vars["duration"]
+	var from time.Time
+	switch duration {
+	case "7d":
+		from = time.Now().Truncate(time.Hour).Add(-24 * 7 * time.Hour)
+	case "24h":
+		from = time.Now().Truncate(time.Hour).Add(-24 * time.Hour)
+	default:
+		http.Error(writer, "Durations supported: 7d, 24h", http.StatusBadRequest)
+		return
+	}
+	hourlyAverageResponseTime, err := storage.Get().GetHourlyAverageResponseTimeByKey(vars["key"], from, time.Now())
+	if err != nil {
+		if err == common.ErrServiceNotFound {
+			writer.WriteHeader(http.StatusNotFound)
+		} else if err == common.ErrInvalidTimeRange {
+			writer.WriteHeader(http.StatusBadRequest)
+		} else {
+			writer.WriteHeader(http.StatusInternalServerError)
+		}
+		_, _ = writer.Write([]byte(err.Error()))
+		return
+	}
+	if len(hourlyAverageResponseTime) == 0 {
+		writer.WriteHeader(http.StatusNoContent)
+		_, _ = writer.Write(nil)
+		return
+	}
+	series := chart.TimeSeries{
+		Name: "Average response time per hour",
+		Style: chart.Style{
+			StrokeWidth: 1.5,
+			DotWidth:    2.0,
+		},
+	}
+	keys := make([]int, 0, len(hourlyAverageResponseTime))
+	earliestTimestamp := int64(0)
+	for hourlyTimestamp := range hourlyAverageResponseTime {
+		keys = append(keys, int(hourlyTimestamp))
+		if earliestTimestamp == 0 || hourlyTimestamp < earliestTimestamp {
+			earliestTimestamp = hourlyTimestamp
+		}
+	}
+	for earliestTimestamp > from.Unix() {
+		earliestTimestamp -= int64(time.Hour.Seconds())
+		keys = append(keys, int(earliestTimestamp))
+	}
+	sort.Ints(keys)
+	var maxAverageResponseTime float64
+	for _, key := range keys {
+		averageResponseTime := float64(hourlyAverageResponseTime[int64(key)])
+		if maxAverageResponseTime < averageResponseTime {
+			maxAverageResponseTime = averageResponseTime
+		}
+		series.XValues = append(series.XValues, time.Unix(int64(key), 0))
+		series.YValues = append(series.YValues, averageResponseTime)
+	}
+	graph := chart.Chart{
+		Canvas:     transparentStyle,
+		Background: transparentStyle,
+		Width:      1280,
+		Height:     300,
+		XAxis: chart.XAxis{
+			ValueFormatter: chart.TimeValueFormatterWithFormat(timeFormat),
+			GridMajorStyle: gridStyle,
+			GridMinorStyle: gridStyle,
+			Style:          axisStyle,
+			NameStyle:      axisStyle,
+		},
+		YAxis: chart.YAxis{
+			Name:           "Average response time",
+			GridMajorStyle: gridStyle,
+			GridMinorStyle: gridStyle,
+			Style:          axisStyle,
+			NameStyle:      axisStyle,
+			Range: &chart.ContinuousRange{
+				Min: 0,
+				Max: math.Ceil(maxAverageResponseTime * 1.25),
+			},
+		},
+		Series: []chart.Series{series},
+	}
+	writer.Header().Set("Content-Type", "image/svg+xml")
+	if err := graph.Render(chart.SVG, writer); err != nil {
+		log.Println("[handler][ResponseTimeChart] Failed to render response time chart:", err.Error())
+		return
+	}
+}

controller/handler/chart_test.go

@@ -0,0 +1,75 @@
+package handler
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/TwiN/gatus/v3/config"
+	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v3/storage"
+	"github.com/TwiN/gatus/v3/watchdog"
+)
+
+func TestResponseTimeChart(t *testing.T) {
+	defer storage.Get().Clear()
+	defer cache.Clear()
+	cfg := &config.Config{
+		Metrics: true,
+		Services: []*core.Service{
+			{
+				Name:  "frontend",
+				Group: "core",
+			},
+			{
+				Name:  "backend",
+				Group: "core",
+			},
+		},
+	}
+	watchdog.UpdateServiceStatuses(cfg.Services[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
+	watchdog.UpdateServiceStatuses(cfg.Services[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
+	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+	type Scenario struct {
+		Name         string
+		Path         string
+		ExpectedCode int
+		Gzip         bool
+	}
+	scenarios := []Scenario{
+		{
+			Name:         "chart-response-time-24h",
+			Path:         "/api/v1/services/core_backend/response-times/24h/chart.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "chart-response-time-7d",
+			Path:         "/api/v1/services/core_frontend/response-times/7d/chart.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "chart-response-time-with-invalid-duration",
+			Path:         "/api/v1/services/core_backend/response-times/3d/chart.svg",
+			ExpectedCode: http.StatusBadRequest,
+		},
+		{
+			Name:         "chart-response-time-for-invalid-key",
+			Path:         "/api/v1/services/invalid_key/response-times/7d/chart.svg",
+			ExpectedCode: http.StatusNotFound,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			if scenario.Gzip {
+				request.Header.Set("Accept-Encoding", "gzip")
+			}
+			responseRecorder := httptest.NewRecorder()
+			router.ServeHTTP(responseRecorder, request)
+			if responseRecorder.Code != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			}
+		})
+	}
+}

controller/handler/cors.go

@@ -0,0 +1,10 @@
+package handler
+
+import "net/http"
+
+func DevelopmentCORS(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "http://localhost:8081")
+		next.ServeHTTP(w, r)
+	})
+}

controller/handler/favicon.go

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

controller/handler/favicon_test.go

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

controller/handler/gzip.go

@@ -0,0 +1,59 @@
+package handler
+
+import (
+	"compress/gzip"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"sync"
+)
+
+var gzPool = sync.Pool{
+	New: func() interface{} {
+		return gzip.NewWriter(ioutil.Discard)
+	},
+}
+
+type gzipResponseWriter struct {
+	io.Writer
+	http.ResponseWriter
+}
+
+// WriteHeader sends an HTTP response header with the provided status code.
+// It also deletes the Content-Length header, since the GZIP compression may modify the size of the payload
+func (w *gzipResponseWriter) WriteHeader(status int) {
+	w.Header().Del("Content-Length")
+	w.ResponseWriter.WriteHeader(status)
+}
+
+// Write writes len(b) bytes from b to the underlying data stream.
+func (w *gzipResponseWriter) Write(b []byte) (int, error) {
+	return w.Writer.Write(b)
+}
+
+// GzipHandler compresses the response of a given http.Handler if the request's headers specify that the client
+// supports gzip encoding
+func GzipHandler(next http.Handler) http.Handler {
+	return GzipHandlerFunc(func(writer http.ResponseWriter, r *http.Request) {
+		next.ServeHTTP(writer, r)
+	})
+}
+
+// GzipHandlerFunc compresses the response of a given http.HandlerFunc if the request's headers specify that the client
+// supports gzip encoding
+func GzipHandlerFunc(next http.HandlerFunc) http.HandlerFunc {
+	return func(writer http.ResponseWriter, r *http.Request) {
+		// If the request doesn't specify that it supports gzip, then don't compress it
+		if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
+			next.ServeHTTP(writer, r)
+			return
+		}
+		writer.Header().Set("Content-Encoding", "gzip")
+		gz := gzPool.Get().(*gzip.Writer)
+		defer gzPool.Put(gz)
+		gz.Reset(writer)
+		defer gz.Close()
+		next.ServeHTTP(&gzipResponseWriter{ResponseWriter: writer, Writer: gz}, r)
+	}
+}

controller/handler/handler.go

@@ -0,0 +1,41 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/TwiN/gatus/v3/config/ui"
+	"github.com/TwiN/gatus/v3/security"
+	"github.com/TwiN/health"
+	"github.com/gorilla/mux"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+func CreateRouter(staticFolder string, securityConfig *security.Config, uiConfig *ui.Config, enabledMetrics bool) *mux.Router {
+	router := mux.NewRouter()
+	if enabledMetrics {
+		router.Handle("/metrics", promhttp.Handler()).Methods("GET")
+	}
+	router.Handle("/health", health.Handler().WithJSON(true)).Methods("GET")
+	router.HandleFunc("/favicon.ico", FavIcon(staticFolder)).Methods("GET")
+	// Endpoints
+	router.HandleFunc("/api/v1/services/statuses", secureIfNecessary(securityConfig, ServiceStatuses)).Methods("GET") // No GzipHandler for this one, because we cache the content as Gzipped already
+	router.HandleFunc("/api/v1/services/{key}/statuses", secureIfNecessary(securityConfig, GzipHandlerFunc(ServiceStatus))).Methods("GET")
+	// TODO: router.HandleFunc("/api/v1/services/{key}/uptimes", secureIfNecessary(securityConfig, GzipHandlerFunc(serviceUptimesHandler))).Methods("GET")
+	// TODO: router.HandleFunc("/api/v1/services/{key}/events", secureIfNecessary(securityConfig, GzipHandlerFunc(serviceEventsHandler))).Methods("GET")
+	router.HandleFunc("/api/v1/services/{key}/uptimes/{duration}/badge.svg", UptimeBadge).Methods("GET")
+	router.HandleFunc("/api/v1/services/{key}/response-times/{duration}/badge.svg", ResponseTimeBadge).Methods("GET")
+	router.HandleFunc("/api/v1/services/{key}/response-times/{duration}/chart.svg", ResponseTimeChart).Methods("GET")
+	// SPA
+	router.HandleFunc("/services/{service}", SinglePageApplication(staticFolder, uiConfig)).Methods("GET")
+	router.HandleFunc("/", SinglePageApplication(staticFolder, uiConfig)).Methods("GET")
+	// Everything else falls back on static content
+	router.PathPrefix("/").Handler(GzipHandler(http.FileServer(http.Dir(staticFolder))))
+	return router
+}
+
+func secureIfNecessary(securityConfig *security.Config, handler http.HandlerFunc) http.HandlerFunc {
+	if securityConfig != nil && securityConfig.IsValid() {
+		return security.Handler(handler, securityConfig)
+	}
+	return handler
+}

controller/handler/handler_test.go

@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestCreateRouter(t *testing.T) {
+	router := CreateRouter("../../web/static", nil, nil, true)
+	type Scenario struct {
+		Name         string
+		Path         string
+		ExpectedCode int
+		Gzip         bool
+	}
+	scenarios := []Scenario{
+		{
+			Name:         "health",
+			Path:         "/health",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "metrics",
+			Path:         "/metrics",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "scripts",
+			Path:         "/js/app.js",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "scripts-gzipped",
+			Path:         "/js/app.js",
+			ExpectedCode: http.StatusOK,
+			Gzip:         true,
+		},
+		{
+			Name:         "index-redirect",
+			Path:         "/index.html",
+			ExpectedCode: http.StatusMovedPermanently,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			if scenario.Gzip {
+				request.Header.Set("Accept-Encoding", "gzip")
+			}
+			responseRecorder := httptest.NewRecorder()
+			router.ServeHTTP(responseRecorder, request)
+			if responseRecorder.Code != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			}
+		})
+	}
+}

controller/handler/service_status.go

@@ -0,0 +1,103 @@
+package handler
+
+import (
+	"bytes"
+	"compress/gzip"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/TwiN/gatus/v3/storage"
+	"github.com/TwiN/gatus/v3/storage/store/common"
+	"github.com/TwiN/gatus/v3/storage/store/common/paging"
+	"github.com/TwiN/gocache"
+	"github.com/gorilla/mux"
+)
+
+const (
+	cacheTTL = 10 * time.Second
+)
+
+var (
+	cache = gocache.NewCache().WithMaxSize(100).WithEvictionPolicy(gocache.FirstInFirstOut)
+)
+
+// ServiceStatuses handles requests to retrieve all service statuses
+// Due to the size of the response, this function leverages a cache.
+// Must not be wrapped by GzipHandler
+func ServiceStatuses(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("service-status-%d-%d-gzipped", page, pageSize))
+	} else {
+		value, exists = cache.Get(fmt.Sprintf("service-status-%d-%d", page, pageSize))
+	}
+	var data []byte
+	if !exists {
+		var err error
+		buffer := &bytes.Buffer{}
+		gzipWriter := gzip.NewWriter(buffer)
+		serviceStatuses, err := storage.Get().GetAllServiceStatuses(paging.NewServiceStatusParams().WithResults(page, pageSize))
+		if err != nil {
+			log.Printf("[handler][ServiceStatuses] Failed to retrieve service statuses: %s", err.Error())
+			http.Error(writer, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		data, err = json.Marshal(serviceStatuses)
+		if err != nil {
+			log.Printf("[handler][ServiceStatuses] 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("service-status-%d-%d", page, pageSize), data, cacheTTL)
+		cache.SetWithTTL(fmt.Sprintf("service-status-%d-%d-gzipped", page, pageSize), gzippedData, cacheTTL)
+		if gzipped {
+			data = gzippedData
+		}
+	} else {
+		data = value.([]byte)
+	}
+	writer.Header().Add("Content-Type", "application/json")
+	writer.WriteHeader(http.StatusOK)
+	_, _ = writer.Write(data)
+}
+
+// ServiceStatus retrieves a single ServiceStatus by group name and service name
+func ServiceStatus(writer http.ResponseWriter, r *http.Request) {
+	page, pageSize := extractPageAndPageSizeFromRequest(r)
+	vars := mux.Vars(r)
+	serviceStatus, err := storage.Get().GetServiceStatusByKey(vars["key"], paging.NewServiceStatusParams().WithResults(page, pageSize).WithEvents(1, common.MaximumNumberOfEvents))
+	if err != nil {
+		if err == common.ErrServiceNotFound {
+			http.Error(writer, err.Error(), http.StatusNotFound)
+			return
+		}
+		log.Printf("[handler][ServiceStatus] Failed to retrieve service status: %s", err.Error())
+		http.Error(writer, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if serviceStatus == nil {
+		log.Printf("[handler][ServiceStatus] Service with key=%s not found", vars["key"])
+		http.Error(writer, "not found", http.StatusNotFound)
+		return
+	}
+	output, err := json.Marshal(serviceStatus)
+	if err != nil {
+		log.Printf("[handler][ServiceStatus] Unable to marshal object to JSON: %s", err.Error())
+		http.Error(writer, "unable to marshal object to JSON", http.StatusInternalServerError)
+		return
+	}
+	writer.Header().Add("Content-Type", "application/json")
+	writer.WriteHeader(http.StatusOK)
+	_, _ = writer.Write(output)
+}

controller/handler/service_status_test.go

@@ -0,0 +1,215 @@
+package handler
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/TwiN/gatus/v3/config"
+	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v3/storage"
+	"github.com/TwiN/gatus/v3/watchdog"
+)
+
+var (
+	firstCondition  = core.Condition("[STATUS] == 200")
+	secondCondition = core.Condition("[RESPONSE_TIME] < 500")
+	thirdCondition  = core.Condition("[CERTIFICATE_EXPIRATION] < 72h")
+
+	timestamp = time.Now()
+
+	testService = core.Service{
+		Name:                    "name",
+		Group:                   "group",
+		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,
+	}
+	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,
+			},
+		},
+	}
+	testUnsuccessfulResult = core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Errors:                []string{"error-1", "error-2"},
+		Connected:             true,
+		Success:               false,
+		Timestamp:             timestamp,
+		Duration:              750 * time.Millisecond,
+		CertificateExpiration: 10 * time.Hour,
+		ConditionResults: []*core.ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   false,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   false,
+			},
+		},
+	}
+)
+
+func TestServiceStatus(t *testing.T) {
+	defer storage.Get().Clear()
+	defer cache.Clear()
+	cfg := &config.Config{
+		Metrics: true,
+		Services: []*core.Service{
+			{
+				Name:  "frontend",
+				Group: "core",
+			},
+			{
+				Name:  "backend",
+				Group: "core",
+			},
+		},
+	}
+	watchdog.UpdateServiceStatuses(cfg.Services[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
+	watchdog.UpdateServiceStatuses(cfg.Services[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
+	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+
+	type Scenario struct {
+		Name         string
+		Path         string
+		ExpectedCode int
+		Gzip         bool
+	}
+	scenarios := []Scenario{
+		{
+			Name:         "service-status",
+			Path:         "/api/v1/services/core_frontend/statuses",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "service-status-gzip",
+			Path:         "/api/v1/services/core_frontend/statuses",
+			ExpectedCode: http.StatusOK,
+			Gzip:         true,
+		},
+		{
+			Name:         "service-status-pagination",
+			Path:         "/api/v1/services/core_frontend/statuses?page=1&pageSize=20",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "service-status-for-invalid-key",
+			Path:         "/api/v1/services/invalid_key/statuses",
+			ExpectedCode: http.StatusNotFound,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			if scenario.Gzip {
+				request.Header.Set("Accept-Encoding", "gzip")
+			}
+			responseRecorder := httptest.NewRecorder()
+			router.ServeHTTP(responseRecorder, request)
+			if responseRecorder.Code != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			}
+		})
+	}
+}
+
+func TestServiceStatuses(t *testing.T) {
+	defer storage.Get().Clear()
+	defer cache.Clear()
+	firstResult := &testSuccessfulResult
+	secondResult := &testUnsuccessfulResult
+	storage.Get().Insert(&testService, firstResult)
+	storage.Get().Insert(&testService, secondResult)
+	// 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)
+
+	type Scenario struct {
+		Name         string
+		Path         string
+		ExpectedCode int
+		ExpectedBody string
+	}
+	scenarios := []Scenario{
+		{
+			Name:         "no-pagination",
+			Path:         "/api/v1/services/statuses",
+			ExpectedCode: http.StatusOK,
+			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"errors":null,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}],"events":[]}]`,
+		},
+		{
+			Name:         "pagination-first-result",
+			Path:         "/api/v1/services/statuses?page=1&pageSize=1",
+			ExpectedCode: http.StatusOK,
+			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}],"events":[]}]`,
+		},
+		{
+			Name:         "pagination-second-result",
+			Path:         "/api/v1/services/statuses?page=2&pageSize=1",
+			ExpectedCode: http.StatusOK,
+			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"errors":null,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"}],"events":[]}]`,
+		},
+		{
+			Name:         "pagination-no-results",
+			Path:         "/api/v1/services/statuses?page=5&pageSize=20",
+			ExpectedCode: http.StatusOK,
+			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[],"events":[]}]`,
+		},
+		{
+			Name:         "invalid-pagination-should-fall-back-to-default",
+			Path:         "/api/v1/services/statuses?page=INVALID&pageSize=INVALID",
+			ExpectedCode: http.StatusOK,
+			ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"errors":null,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}],"events":[]}]`,
+		},
+	}
+
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			responseRecorder := httptest.NewRecorder()
+			router.ServeHTTP(responseRecorder, request)
+			if responseRecorder.Code != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			}
+			output := responseRecorder.Body.String()
+			if output != scenario.ExpectedBody {
+				t.Errorf("expected:\n %s\n\ngot:\n %s", scenario.ExpectedBody, output)
+			}
+		})
+	}
+}

controller/handler/spa.go

@@ -0,0 +1,27 @@
+package handler
+
+import (
+	"html/template"
+	"log"
+	"net/http"
+
+	"github.com/TwiN/gatus/v3/config/ui"
+)
+
+func SinglePageApplication(staticFolder string, ui *ui.Config) http.HandlerFunc {
+	return func(writer http.ResponseWriter, request *http.Request) {
+		t, err := template.ParseFiles(staticFolder + "/index.html")
+		if err != nil {
+			log.Println("[handler][SinglePageApplication] Failed to parse template:", err.Error())
+			http.ServeFile(writer, request, staticFolder+"/index.html")
+			return
+		}
+		writer.Header().Set("Content-Type", "text/html")
+		err = t.Execute(writer, ui)
+		if err != nil {
+			log.Println("[handler][SinglePageApplication] Failed to parse template:", err.Error())
+			http.ServeFile(writer, request, staticFolder+"/index.html")
+			return
+		}
+	}
+}

controller/handler/spa_test.go

@@ -0,0 +1,65 @@
+package handler
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/TwiN/gatus/v3/config"
+	"github.com/TwiN/gatus/v3/core"
+	"github.com/TwiN/gatus/v3/storage"
+	"github.com/TwiN/gatus/v3/watchdog"
+)
+
+func TestSinglePageApplication(t *testing.T) {
+	defer storage.Get().Clear()
+	defer cache.Clear()
+	cfg := &config.Config{
+		Metrics: true,
+		Services: []*core.Service{
+			{
+				Name:  "frontend",
+				Group: "core",
+			},
+			{
+				Name:  "backend",
+				Group: "core",
+			},
+		},
+	}
+	watchdog.UpdateServiceStatuses(cfg.Services[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
+	watchdog.UpdateServiceStatuses(cfg.Services[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
+	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+	type Scenario struct {
+		Name         string
+		Path         string
+		ExpectedCode int
+		Gzip         bool
+	}
+	scenarios := []Scenario{
+		{
+			Name:         "frontend-home",
+			Path:         "/",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "frontend-service",
+			Path:         "/services/core_frontend",
+			ExpectedCode: http.StatusOK,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			if scenario.Gzip {
+				request.Header.Set("Accept-Encoding", "gzip")
+			}
+			responseRecorder := httptest.NewRecorder()
+			router.ServeHTTP(responseRecorder, request)
+			if responseRecorder.Code != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			}
+		})
+	}
+}

controller/handler/util.go

@@ -0,0 +1,48 @@
+package handler
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/TwiN/gatus/v3/storage/store/common"
+)
+
+const (
+	// DefaultPage is the default page to use if none is specified or an invalid value is provided
+	DefaultPage = 1
+
+	// DefaultPageSize is the default page siZE to use if none is specified or an invalid value is provided
+	DefaultPageSize = 20
+
+	// MaximumPageSize is the maximum page size allowed
+	MaximumPageSize = common.MaximumNumberOfResults
+)
+
+func extractPageAndPageSizeFromRequest(r *http.Request) (page int, pageSize int) {
+	var err error
+	if pageParameter := r.URL.Query().Get("page"); len(pageParameter) == 0 {
+		page = DefaultPage
+	} else {
+		page, err = strconv.Atoi(pageParameter)
+		if err != nil {
+			page = DefaultPage
+		}
+		if page < 1 {
+			page = DefaultPage
+		}
+	}
+	if pageSizeParameter := r.URL.Query().Get("pageSize"); len(pageSizeParameter) == 0 {
+		pageSize = DefaultPageSize
+	} else {
+		pageSize, err = strconv.Atoi(pageSizeParameter)
+		if err != nil {
+			pageSize = DefaultPageSize
+		}
+		if pageSize > MaximumPageSize {
+			pageSize = MaximumPageSize
+		} else if pageSize < 1 {
+			pageSize = DefaultPageSize
+		}
+	}
+	return
+}

controller/handler/util_test.go

@@ -0,0 +1,67 @@
+package handler
+
+import (
+	"fmt"
+	"net/http"
+	"testing"
+)
+
+func TestExtractPageAndPageSizeFromRequest(t *testing.T) {
+	type Scenario struct {
+		Name             string
+		Page             string
+		PageSize         string
+		ExpectedPage     int
+		ExpectedPageSize int
+	}
+	scenarios := []Scenario{
+		{
+			Page:             "1",
+			PageSize:         "20",
+			ExpectedPage:     1,
+			ExpectedPageSize: 20,
+		},
+		{
+			Page:             "2",
+			PageSize:         "10",
+			ExpectedPage:     2,
+			ExpectedPageSize: 10,
+		},
+		{
+			Page:             "2",
+			PageSize:         "10",
+			ExpectedPage:     2,
+			ExpectedPageSize: 10,
+		},
+		{
+			Page:             "1",
+			PageSize:         "999999",
+			ExpectedPage:     1,
+			ExpectedPageSize: MaximumPageSize,
+		},
+		{
+			Page:             "-1",
+			PageSize:         "-1",
+			ExpectedPage:     DefaultPage,
+			ExpectedPageSize: DefaultPageSize,
+		},
+		{
+			Page:             "invalid",
+			PageSize:         "invalid",
+			ExpectedPage:     DefaultPage,
+			ExpectedPageSize: DefaultPageSize,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run("page-"+scenario.Page+"-pageSize-"+scenario.PageSize, func(t *testing.T) {
+			request, _ := http.NewRequest("GET", fmt.Sprintf("/api/v1/statuses?page=%s&pageSize=%s", scenario.Page, scenario.PageSize), nil)
+			actualPage, actualPageSize := extractPageAndPageSizeFromRequest(request)
+			if actualPage != scenario.ExpectedPage {
+				t.Errorf("expected %d, got %d", scenario.ExpectedPage, actualPage)
+			}
+			if actualPageSize != scenario.ExpectedPageSize {
+				t.Errorf("expected %d, got %d", scenario.ExpectedPageSize, actualPageSize)
+			}
+		})
+	}
+}

core/alert.go

@@ -1,54 +0,0 @@
-package core
-
-// Alert is the service's alert configuration
-type Alert struct {
-	// Type of alert
-	Type AlertType `yaml:"type"`
-
-	// Enabled defines whether or not the alert is enabled
-	Enabled bool `yaml:"enabled"`
-
-	// FailureThreshold is the number of failures in a row needed before triggering the alert
-	FailureThreshold int `yaml:"failure-threshold"`
-
-	// Description of the alert. Will be included in the alert sent.
-	Description string `yaml:"description"`
-
-	// SendOnResolved defines whether to send a second notification when the issue has been resolved
-	SendOnResolved bool `yaml:"send-on-resolved"`
-
-	// SuccessThreshold defines how many successful executions must happen in a row before an ongoing incident is marked as resolved
-	SuccessThreshold int `yaml:"success-threshold"`
-
-	// ResolveKey is an optional field that is used by some providers (i.e. PagerDuty's dedup_key) to resolve
-	// ongoing/triggered incidents
-	ResolveKey string
-
-	// Triggered is used to determine whether an alert has been triggered. When an alert is resolved, this value
-	// should be set back to false. It is used to prevent the same alert from going out twice.
-	Triggered bool
-}
-
-// AlertType is the type of the alert.
-// The value will generally be the name of the alert provider
-type AlertType string
-
-const (
-	// SlackAlert is the AlertType for the slack alerting provider
-	SlackAlert AlertType = "slack"
-
-	// MattermostAlert is the AlertType for the mattermost alerting provider
-	MattermostAlert AlertType = "mattermost"
-
-	// MessagebirdAlert is the AlertType for the messagebird alerting provider
-	MessagebirdAlert AlertType = "messagebird"
-
-	// PagerDutyAlert is the AlertType for the pagerduty alerting provider
-	PagerDutyAlert AlertType = "pagerduty"
-
-	// TwilioAlert is the AlertType for the twilio alerting provider
-	TwilioAlert AlertType = "twilio"
-
-	// CustomAlert is the AlertType for the custom alerting provider
-	CustomAlert AlertType = "custom"
-)

core/condition.go

@@ -2,13 +2,12 @@ package core
 
 import (
 	"fmt"
-	"log"
 	"strconv"
 	"strings"
 	"time"
 
-	"github.com/TwinProduction/gatus/jsonpath"
-	"github.com/TwinProduction/gatus/pattern"
+	"github.com/TwiN/gatus/v3/jsonpath"
+	"github.com/TwiN/gatus/v3/pattern"
 )
 
 const (
@@ -24,7 +23,7 @@ const (
 
 	// DNSRCodePlaceholder is a place holder for DNS_RCODE
 	//
-	// Values that could be NOERROR, FORMERR, SERVFAIL, NXDOMAIN, NOTIMP and REFUSED
+	// Values that could replace the placeholder: NOERROR, FORMERR, SERVFAIL, NXDOMAIN, NOTIMP, REFUSED
 	DNSRCodePlaceholder = "[DNS_RCODE]"
 
 	// ResponseTimePlaceholder is a placeholder for the request response time, in milliseconds.
@@ -48,101 +47,163 @@ const (
 	CertificateExpirationPlaceholder = "[CERTIFICATE_EXPIRATION]"
 
 	// LengthFunctionPrefix is the prefix for the length function
+	//
+	// Usage: len([BODY].articles) == 10, len([BODY].name) > 5
 	LengthFunctionPrefix = "len("
 
+	// HasFunctionPrefix is the prefix for the has function
+	//
+	// Usage: has([BODY].errors) == true
+	HasFunctionPrefix = "has("
+
 	// PatternFunctionPrefix is the prefix for the pattern function
+	//
+	// Usage: [IP] == pat(192.168.*.*)
 	PatternFunctionPrefix = "pat("
 
+	// AnyFunctionPrefix is the prefix for the any function
+	//
+	// Usage: [IP] == any(1.1.1.1, 1.0.0.1)
+	AnyFunctionPrefix = "any("
+
 	// FunctionSuffix is the suffix for all functions
 	FunctionSuffix = ")"
 
 	// InvalidConditionElementSuffix is the suffix that will be appended to an invalid condition
 	InvalidConditionElementSuffix = "(INVALID)"
+
+	// maximumLengthBeforeTruncatingWhenComparedWithPattern is the maximum length an element being compared to a
+	// pattern can have.
+	//
+	// This is only used for aesthetic purposes; it does not influence whether the condition evaluation results in a
+	// success or a failure
+	maximumLengthBeforeTruncatingWhenComparedWithPattern = 25
 )
 
 // Condition is a condition that needs to be met in order for a Service to be considered healthy.
 type Condition string
 
 // evaluate the Condition with the Result of the health check
-func (c *Condition) evaluate(result *Result) bool {
-	condition := string(*c)
+// TODO: Add a mandatory space between each operators (e.g. " == " instead of "==") (BREAKING CHANGE)
+func (c Condition) evaluate(result *Result, dontResolveFailedConditions bool) bool {
+	condition := string(c)
 	success := false
-	var resolvedCondition string
+	conditionToDisplay := condition
 	if strings.Contains(condition, "==") {
-		parts := sanitizeAndResolve(strings.Split(condition, "=="), result)
-		success = isEqual(parts[0], parts[1])
-		resolvedCondition = fmt.Sprintf("%v == %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolve(strings.Split(condition, "=="), result)
+		success = isEqual(resolvedParameters[0], resolvedParameters[1])
+		if !success && !dontResolveFailedConditions {
+			conditionToDisplay = prettify(parameters, resolvedParameters, "==")
+		}
 	} else if strings.Contains(condition, "!=") {
-		parts := sanitizeAndResolve(strings.Split(condition, "!="), result)
-		success = !isEqual(parts[0], parts[1])
-		resolvedCondition = fmt.Sprintf("%v != %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolve(strings.Split(condition, "!="), result)
+		success = !isEqual(resolvedParameters[0], resolvedParameters[1])
+		if !success && !dontResolveFailedConditions {
+			conditionToDisplay = prettify(parameters, resolvedParameters, "!=")
+		}
 	} else if strings.Contains(condition, "<=") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, "<="), result)
-		success = parts[0] <= parts[1]
-		resolvedCondition = fmt.Sprintf("%v <= %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, "<="), result)
+		success = resolvedParameters[0] <= resolvedParameters[1]
+		if !success && !dontResolveFailedConditions {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, "<=")
+		}
 	} else if strings.Contains(condition, ">=") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, ">="), result)
-		success = parts[0] >= parts[1]
-		resolvedCondition = fmt.Sprintf("%v >= %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, ">="), result)
+		success = resolvedParameters[0] >= resolvedParameters[1]
+		if !success && !dontResolveFailedConditions {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, ">=")
+		}
 	} else if strings.Contains(condition, ">") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, ">"), result)
-		success = parts[0] > parts[1]
-		resolvedCondition = fmt.Sprintf("%v > %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, ">"), result)
+		success = resolvedParameters[0] > resolvedParameters[1]
+		if !success && !dontResolveFailedConditions {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, ">")
+		}
 	} else if strings.Contains(condition, "<") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, "<"), result)
-		success = parts[0] < parts[1]
-		resolvedCondition = fmt.Sprintf("%v < %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, "<"), result)
+		success = resolvedParameters[0] < resolvedParameters[1]
+		if !success && !dontResolveFailedConditions {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, "<")
+		}
 	} else {
-		result.Errors = append(result.Errors, fmt.Sprintf("invalid condition '%s' has been provided", condition))
+		result.AddError(fmt.Sprintf("invalid condition '%s' has been provided", condition))
 		return false
 	}
-	conditionToDisplay := condition
-	// If the condition isn't a success, return what the resolved condition was too
 	if !success {
-		log.Printf("[Condition][evaluate] Condition '%s' did not succeed because '%s' is false", condition, resolvedCondition)
-		// Check if the resolved condition was an invalid path
-		isResolvedConditionInvalidPath := strings.ReplaceAll(resolvedCondition, fmt.Sprintf("%s ", InvalidConditionElementSuffix), "") == condition
-		if isResolvedConditionInvalidPath {
-			// Since, in the event of an invalid path, the resolvedCondition contains the condition itself,
-			// we'll only display the resolvedCondition
-			conditionToDisplay = resolvedCondition
-		} else {
-			conditionToDisplay = fmt.Sprintf("%s (%s)", condition, resolvedCondition)
-		}
+		//log.Printf("[Condition][evaluate] Condition '%s' did not succeed because '%s' is false", condition, condition)
 	}
 	result.ConditionResults = append(result.ConditionResults, &ConditionResult{Condition: conditionToDisplay, Success: success})
 	return success
 }
 
-// isEqual compares two strings.
-//
-// It also supports the pattern function. That is to say, if one of the strings starts with PatternFunctionPrefix
-// and ends with FunctionSuffix, it will be treated like a pattern.
-func isEqual(first, second string) bool {
-	var isFirstPattern, isSecondPattern bool
-	if strings.HasPrefix(first, PatternFunctionPrefix) && strings.HasSuffix(first, FunctionSuffix) {
-		isFirstPattern = true
-		first = strings.TrimSuffix(strings.TrimPrefix(first, PatternFunctionPrefix), FunctionSuffix)
-	}
-	if strings.HasPrefix(second, PatternFunctionPrefix) && strings.HasSuffix(second, FunctionSuffix) {
-		isSecondPattern = true
-		second = strings.TrimSuffix(strings.TrimPrefix(second, PatternFunctionPrefix), FunctionSuffix)
-	}
-	if isFirstPattern && !isSecondPattern {
-		return pattern.Match(first, second)
-	} else if !isFirstPattern && isSecondPattern {
-		return pattern.Match(second, first)
-	} else {
-		return first == second
-	}
+// hasBodyPlaceholder checks whether the condition has a BodyPlaceholder
+// Used for determining whether the response body should be read or not
+func (c Condition) hasBodyPlaceholder() bool {
+	return strings.Contains(string(c), BodyPlaceholder)
 }
 
-// sanitizeAndResolve sanitizes and resolves a list of element and returns the list of resolved elements
-func sanitizeAndResolve(list []string, result *Result) []string {
-	var sanitizedList []string
-	body := strings.TrimSpace(string(result.Body))
-	for _, element := range list {
+// isEqual compares two strings.
+//
+// Supports the pattern and the any functions.
+// i.e. if one of the parameters starts with PatternFunctionPrefix and ends with FunctionSuffix, it will be treated like
+// a pattern.
+func isEqual(first, second string) bool {
+	firstHasFunctionSuffix := strings.HasSuffix(first, FunctionSuffix)
+	secondHasFunctionSuffix := strings.HasSuffix(second, FunctionSuffix)
+	if firstHasFunctionSuffix || secondHasFunctionSuffix {
+		var isFirstPattern, isSecondPattern bool
+		if strings.HasPrefix(first, PatternFunctionPrefix) && firstHasFunctionSuffix {
+			isFirstPattern = true
+			first = strings.TrimSuffix(strings.TrimPrefix(first, PatternFunctionPrefix), FunctionSuffix)
+		}
+		if strings.HasPrefix(second, PatternFunctionPrefix) && secondHasFunctionSuffix {
+			isSecondPattern = true
+			second = strings.TrimSuffix(strings.TrimPrefix(second, PatternFunctionPrefix), FunctionSuffix)
+		}
+		if isFirstPattern && !isSecondPattern {
+			return pattern.Match(first, second)
+		} else if !isFirstPattern && isSecondPattern {
+			return pattern.Match(second, first)
+		}
+		var isFirstAny, isSecondAny bool
+		if strings.HasPrefix(first, AnyFunctionPrefix) && firstHasFunctionSuffix {
+			isFirstAny = true
+			first = strings.TrimSuffix(strings.TrimPrefix(first, AnyFunctionPrefix), FunctionSuffix)
+		}
+		if strings.HasPrefix(second, AnyFunctionPrefix) && secondHasFunctionSuffix {
+			isSecondAny = true
+			second = strings.TrimSuffix(strings.TrimPrefix(second, AnyFunctionPrefix), FunctionSuffix)
+		}
+		if isFirstAny && !isSecondAny {
+			options := strings.Split(first, ",")
+			for _, option := range options {
+				if strings.TrimSpace(option) == second {
+					return true
+				}
+			}
+			return false
+		} else if !isFirstAny && isSecondAny {
+			options := strings.Split(second, ",")
+			for _, option := range options {
+				if strings.TrimSpace(option) == first {
+					return true
+				}
+			}
+			return false
+		}
+	}
+	return first == second
+}
+
+// sanitizeAndResolve sanitizes and resolves a list of elements and returns the list of parameters as well as a list
+// of resolved parameters
+func sanitizeAndResolve(elements []string, result *Result) ([]string, []string) {
+	parameters := make([]string, len(elements))
+	resolvedParameters := make([]string, len(elements))
+	body := strings.TrimSpace(string(result.body))
+	for i, element := range elements {
 		element = strings.TrimSpace(element)
+		parameters[i] = element
 		switch strings.ToUpper(element) {
 		case StatusPlaceholder:
 			element = strconv.Itoa(result.HTTPStatus)
@@ -161,47 +222,93 @@ func sanitizeAndResolve(list []string, result *Result) []string {
 		default:
 			// if contains the BodyPlaceholder, then evaluate json path
 			if strings.Contains(element, BodyPlaceholder) {
-				wantLength := false
+				checkingForLength := false
+				checkingForExistence := false
 				if strings.HasPrefix(element, LengthFunctionPrefix) && strings.HasSuffix(element, FunctionSuffix) {
-					wantLength = true
+					checkingForLength = true
 					element = strings.TrimSuffix(strings.TrimPrefix(element, LengthFunctionPrefix), FunctionSuffix)
 				}
-				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.Replace(element, fmt.Sprintf("%s.", BodyPlaceholder), "", 1), result.Body)
-				if err != nil {
-					if err.Error() != "unexpected end of JSON input" {
-						result.Errors = append(result.Errors, err.Error())
-					}
-					if wantLength {
-						element = fmt.Sprintf("len(%s) %s", element, InvalidConditionElementSuffix)
+				if strings.HasPrefix(element, HasFunctionPrefix) && strings.HasSuffix(element, FunctionSuffix) {
+					checkingForExistence = true
+					element = strings.TrimSuffix(strings.TrimPrefix(element, HasFunctionPrefix), FunctionSuffix)
+				}
+				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.TrimPrefix(strings.TrimPrefix(element, BodyPlaceholder), "."), result.body)
+				if checkingForExistence {
+					if err != nil {
+						element = "false"
 					} else {
-						element = fmt.Sprintf("%s %s", element, InvalidConditionElementSuffix)
+						element = "true"
 					}
 				} else {
-					if wantLength {
-						element = fmt.Sprintf("%d", resolvedElementLength)
+					if err != nil {
+						if err.Error() != "unexpected end of JSON input" {
+							result.AddError(err.Error())
+						}
+						if checkingForLength {
+							element = LengthFunctionPrefix + element + FunctionSuffix + " " + InvalidConditionElementSuffix
+						} else {
+							element = element + " " + InvalidConditionElementSuffix
+						}
 					} else {
-						element = resolvedElement
+						if checkingForLength {
+							element = strconv.Itoa(resolvedElementLength)
+						} else {
+							element = resolvedElement
+						}
 					}
 				}
 			}
 		}
-		sanitizedList = append(sanitizedList, element)
+		resolvedParameters[i] = element
 	}
-	return sanitizedList
+	return parameters, resolvedParameters
 }
 
-func sanitizeAndResolveNumerical(list []string, result *Result) []int64 {
-	var sanitizedNumbers []int64
-	sanitizedList := sanitizeAndResolve(list, result)
-	for _, element := range sanitizedList {
+func sanitizeAndResolveNumerical(list []string, result *Result) (parameters []string, resolvedNumericalParameters []int64) {
+	parameters, resolvedParameters := sanitizeAndResolve(list, result)
+	for _, element := range resolvedParameters {
 		if duration, err := time.ParseDuration(element); duration != 0 && err == nil {
-			sanitizedNumbers = append(sanitizedNumbers, duration.Milliseconds())
+			resolvedNumericalParameters = append(resolvedNumericalParameters, duration.Milliseconds())
 		} else if number, err := strconv.ParseInt(element, 10, 64); err != nil {
 			// Default to 0 if the string couldn't be converted to an integer
-			sanitizedNumbers = append(sanitizedNumbers, 0)
+			resolvedNumericalParameters = append(resolvedNumericalParameters, 0)
 		} else {
-			sanitizedNumbers = append(sanitizedNumbers, number)
+			resolvedNumericalParameters = append(resolvedNumericalParameters, number)
 		}
 	}
-	return sanitizedNumbers
+	return parameters, resolvedNumericalParameters
+}
+
+func prettifyNumericalParameters(parameters []string, resolvedParameters []int64, operator string) string {
+	return prettify(parameters, []string{strconv.Itoa(int(resolvedParameters[0])), strconv.Itoa(int(resolvedParameters[1]))}, operator)
+}
+
+// XXX: make this configurable? i.e. show-resolved-conditions-on-failure
+func prettify(parameters []string, resolvedParameters []string, operator string) string {
+	// Since, in the event of an invalid path, the resolvedParameters also contain the condition itself,
+	// we'll return the resolvedParameters as-is.
+	if strings.HasSuffix(resolvedParameters[0], InvalidConditionElementSuffix) || strings.HasSuffix(resolvedParameters[1], InvalidConditionElementSuffix) {
+		return resolvedParameters[0] + " " + operator + " " + resolvedParameters[1]
+	}
+	// If using the pattern function, truncate the parameter it's being compared to if said parameter is long enough
+	if strings.HasPrefix(parameters[0], PatternFunctionPrefix) && strings.HasSuffix(parameters[0], FunctionSuffix) && len(resolvedParameters[1]) > maximumLengthBeforeTruncatingWhenComparedWithPattern {
+		resolvedParameters[1] = fmt.Sprintf("%.25s...(truncated)", resolvedParameters[1])
+	}
+	if strings.HasPrefix(parameters[1], PatternFunctionPrefix) && strings.HasSuffix(parameters[1], FunctionSuffix) && len(resolvedParameters[0]) > maximumLengthBeforeTruncatingWhenComparedWithPattern {
+		resolvedParameters[0] = fmt.Sprintf("%.25s...(truncated)", resolvedParameters[0])
+	}
+	// First element is a placeholder
+	if parameters[0] != resolvedParameters[0] && parameters[1] == resolvedParameters[1] {
+		return parameters[0] + " (" + resolvedParameters[0] + ") " + operator + " " + parameters[1]
+	}
+	// Second element is a placeholder
+	if parameters[0] == resolvedParameters[0] && parameters[1] != resolvedParameters[1] {
+		return parameters[0] + " " + operator + " " + parameters[1] + " (" + resolvedParameters[1] + ")"
+	}
+	// Both elements are placeholders...?
+	if parameters[0] != resolvedParameters[0] && parameters[1] != resolvedParameters[1] {
+		return parameters[0] + " (" + resolvedParameters[0] + ") " + operator + " " + parameters[1] + " (" + resolvedParameters[1] + ")"
+	}
+	// Neither elements are placeholders
+	return parameters[0] + " " + operator + " " + parameters[1]
 }

core/condition_bench_test.go

@@ -0,0 +1,84 @@
+package core
+
+import "testing"
+
+func BenchmarkCondition_evaluateWithBodyStringAny(b *testing.B) {
+	condition := Condition("[BODY].name == any(john.doe, jane.doe)")
+	for n := 0; n < b.N; n++ {
+		result := &Result{body: []byte("{\"name\": \"john.doe\"}")}
+		condition.evaluate(result, false)
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkCondition_evaluateWithBodyStringAnyFailure(b *testing.B) {
+	condition := Condition("[BODY].name == any(john.doe, jane.doe)")
+	for n := 0; n < b.N; n++ {
+		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
+		condition.evaluate(result, false)
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkCondition_evaluateWithBodyString(b *testing.B) {
+	condition := Condition("[BODY].name == john.doe")
+	for n := 0; n < b.N; n++ {
+		result := &Result{body: []byte("{\"name\": \"john.doe\"}")}
+		condition.evaluate(result, false)
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkCondition_evaluateWithBodyStringFailure(b *testing.B) {
+	condition := Condition("[BODY].name == john.doe")
+	for n := 0; n < b.N; n++ {
+		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
+		condition.evaluate(result, false)
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkCondition_evaluateWithBodyStringFailureInvalidPath(b *testing.B) {
+	condition := Condition("[BODY].user.name == bob.doe")
+	for n := 0; n < b.N; n++ {
+		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
+		condition.evaluate(result, false)
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkCondition_evaluateWithBodyStringLen(b *testing.B) {
+	condition := Condition("len([BODY].name) == 8")
+	for n := 0; n < b.N; n++ {
+		result := &Result{body: []byte("{\"name\": \"john.doe\"}")}
+		condition.evaluate(result, false)
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkCondition_evaluateWithBodyStringLenFailure(b *testing.B) {
+	condition := Condition("len([BODY].name) == 8")
+	for n := 0; n < b.N; n++ {
+		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
+		condition.evaluate(result, false)
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkCondition_evaluateWithStatus(b *testing.B) {
+	condition := Condition("[STATUS] == 200")
+	for n := 0; n < b.N; n++ {
+		result := &Result{HTTPStatus: 200}
+		condition.evaluate(result, false)
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkCondition_evaluateWithStatusFailure(b *testing.B) {
+	condition := Condition("[STATUS] == 200")
+	for n := 0; n < b.N; n++ {
+		result := &Result{HTTPStatus: 400}
+		condition.evaluate(result, false)
+	}
+	b.ReportAllocs()
+}

core/condition_result.go

@@ -0,0 +1,10 @@
+package core
+
+// ConditionResult result of a Condition
+type ConditionResult struct {
+	// Condition that was evaluated
+	Condition string `json:"condition"`
+
+	// Success whether the condition was met (successful) or not (failed)
+	Success bool `json:"success"`
+}

core/condition_test.go

@@ -6,383 +6,480 @@ import (
 	"time"
 )
 
-func TestCondition_evaluateWithIP(t *testing.T) {
-	condition := Condition("[IP] == 127.0.0.1")
-	result := &Result{IP: "127.0.0.1"}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
+func TestCondition_evaluate(t *testing.T) {
+	scenarios := []struct {
+		Name                        string
+		Condition                   Condition
+		Result                      *Result
+		DontResolveFailedConditions bool
+		ExpectedSuccess             bool
+		ExpectedOutput              string
+	}{
+		{
+			Name:            "ip",
+			Condition:       Condition("[IP] == 127.0.0.1"),
+			Result:          &Result{IP: "127.0.0.1"},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[IP] == 127.0.0.1",
+		},
+		{
+			Name:            "status",
+			Condition:       Condition("[STATUS] == 200"),
+			Result:          &Result{HTTPStatus: 200},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[STATUS] == 200",
+		},
+		{
+			Name:            "status-failure",
+			Condition:       Condition("[STATUS] == 200"),
+			Result:          &Result{HTTPStatus: 500},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[STATUS] (500) == 200",
+		},
+		{
+			Name:            "status-using-less-than",
+			Condition:       Condition("[STATUS] < 300"),
+			Result:          &Result{HTTPStatus: 201},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[STATUS] < 300",
+		},
+		{
+			Name:            "status-using-less-than-failure",
+			Condition:       Condition("[STATUS] < 300"),
+			Result:          &Result{HTTPStatus: 404},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[STATUS] (404) < 300",
+		},
+		{
+			Name:            "response-time-using-less-than",
+			Condition:       Condition("[RESPONSE_TIME] < 500"),
+			Result:          &Result{Duration: 50 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] < 500",
+		},
+		{
+			Name:            "response-time-using-less-than-with-duration",
+			Condition:       Condition("[RESPONSE_TIME] < 1s"),
+			Result:          &Result{Duration: 50 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] < 1s",
+		},
+		{
+			Name:            "response-time-using-less-than-invalid",
+			Condition:       Condition("[RESPONSE_TIME] < potato"),
+			Result:          &Result{Duration: 50 * time.Millisecond},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[RESPONSE_TIME] (50) < potato (0)", // Non-numerical values automatically resolve to 0
+		},
+		{
+			Name:            "response-time-using-greater-than",
+			Condition:       Condition("[RESPONSE_TIME] > 500"),
+			Result:          &Result{Duration: 750 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] > 500",
+		},
+		{
+			Name:            "response-time-using-greater-than-with-duration",
+			Condition:       Condition("[RESPONSE_TIME] > 1s"),
+			Result:          &Result{Duration: 2 * time.Second},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] > 1s",
+		},
+		{
+			Name:            "response-time-using-greater-than-or-equal-to-equal",
+			Condition:       Condition("[RESPONSE_TIME] >= 500"),
+			Result:          &Result{Duration: 500 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] >= 500",
+		},
+		{
+			Name:            "response-time-using-greater-than-or-equal-to-greater",
+			Condition:       Condition("[RESPONSE_TIME] >= 500"),
+			Result:          &Result{Duration: 499 * time.Millisecond},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[RESPONSE_TIME] (499) >= 500",
+		},
+		{
+			Name:            "response-time-using-greater-than-or-equal-to-failure",
+			Condition:       Condition("[RESPONSE_TIME] >= 500"),
+			Result:          &Result{Duration: 499 * time.Millisecond},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[RESPONSE_TIME] (499) >= 500",
+		},
+		{
+			Name:            "response-time-using-less-than-or-equal-to-equal",
+			Condition:       Condition("[RESPONSE_TIME] <= 500"),
+			Result:          &Result{Duration: 500 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] <= 500",
+		},
+		{
+			Name:            "response-time-using-less-than-or-equal-to-less",
+			Condition:       Condition("[RESPONSE_TIME] <= 500"),
+			Result:          &Result{Duration: 25 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] <= 500",
+		},
+		{
+			Name:            "response-time-using-less-than-or-equal-to-failure",
+			Condition:       Condition("[RESPONSE_TIME] <= 500"),
+			Result:          &Result{Duration: 750 * time.Millisecond},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[RESPONSE_TIME] (750) <= 500",
+		},
+		{
+			Name:            "body",
+			Condition:       Condition("[BODY] == test"),
+			Result:          &Result{body: []byte("test")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY] == test",
+		},
+		{
+			Name:            "body-jsonpath",
+			Condition:       Condition("[BODY].status == UP"),
+			Result:          &Result{body: []byte("{\"status\":\"UP\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].status == UP",
+		},
+		{
+			Name:            "body-jsonpath-complex",
+			Condition:       Condition("[BODY].data.name == john"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1, \"name\": \"john\"}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].data.name == john",
+		},
+		{
+			Name:            "body-jsonpath-complex-invalid",
+			Condition:       Condition("[BODY].data.name == john"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].data.name (INVALID) == john",
+		},
+		{
+			Name:            "body-jsonpath-complex-len",
+			Condition:       Condition("len([BODY].data.name) == 4"),
+			Result:          &Result{body: []byte("{\"data\": {\"name\": \"john\"}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "len([BODY].data.name) == 4",
+		},
+		{
+			Name:            "body-jsonpath-complex-len-invalid",
+			Condition:       Condition("len([BODY].data.name) == john"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "len([BODY].data.name) (INVALID) == john",
+		},
+		{
+			Name:            "body-jsonpath-double-placeholder",
+			Condition:       Condition("[BODY].user.firstName != [BODY].user.lastName"),
+			Result:          &Result{body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].user.firstName != [BODY].user.lastName",
+		},
+		{
+			Name:            "body-jsonpath-double-placeholder-failure",
+			Condition:       Condition("[BODY].user.firstName == [BODY].user.lastName"),
+			Result:          &Result{body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].user.firstName (john) == [BODY].user.lastName (doe)",
+		},
+		{
+			Name:            "body-jsonpath-when-body-is-array",
+			Condition:       Condition("[BODY][0].id == 1"),
+			Result:          &Result{body: []byte("[{\"id\": 1}, {\"id\": 2}]")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY][0].id == 1",
+		},
+		{
+			Name:            "body-jsonpath-complex-int",
+			Condition:       Condition("[BODY].data.id == 1"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].data.id == 1",
+		},
+		{
+			Name:            "body-jsonpath-complex-array-int",
+			Condition:       Condition("[BODY].data[1].id == 2"),
+			Result:          &Result{body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].data[1].id == 2",
+		},
+		{
+			Name:            "body-jsonpath-complex-int-using-greater-than",
+			Condition:       Condition("[BODY].data.id > 0"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].data.id > 0",
+		},
+		{
+			Name:            "body-jsonpath-complex-int-using-greater-than-failure",
+			Condition:       Condition("[BODY].data.id > 5"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].data.id (1) > 5",
+		},
+		{
+			Name:            "body-jsonpath-complex-int-using-less-than",
+			Condition:       Condition("[BODY].data.id < 5"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 2}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].data.id < 5",
+		},
+		{
+			Name:            "body-jsonpath-complex-int-using-less-than-failure",
+			Condition:       Condition("[BODY].data.id < 5"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 10}}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].data.id (10) < 5",
+		},
+		{
+			Name:            "body-len-array",
+			Condition:       Condition("len([BODY].data) == 3"),
+			Result:          &Result{body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "len([BODY].data) == 3",
+		},
+		{
+			Name:            "body-len-array-invalid",
+			Condition:       Condition("len([BODY].data) == 8"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "len([BODY].data) (INVALID) == 8",
+		},
+		{
+			Name:            "body-len-string",
+			Condition:       Condition("len([BODY].name) == 8"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "len([BODY].name) == 8",
+		},
+		{
+			Name:            "body-pattern",
+			Condition:       Condition("[BODY] == pat(*john*)"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY] == pat(*john*)",
+		},
+		{
+			Name:            "body-pattern-2",
+			Condition:       Condition("[BODY].name == pat(john*)"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].name == pat(john*)",
+		},
+		{
+			Name:            "body-pattern-failure",
+			Condition:       Condition("[BODY].name == pat(bob*)"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].name (john.doe) == pat(bob*)",
+		},
+		{
+			Name:            "body-pattern-html",
+			Condition:       Condition("[BODY] == pat(*<div id=\"user\">john.doe</div>*)"),
+			Result:          &Result{body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">john.doe</div></body></html>`)},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY] == pat(*<div id=\"user\">john.doe</div>*)",
+		},
+		{
+			Name:            "body-pattern-html-failure",
+			Condition:       Condition("[BODY] == pat(*<div id=\"user\">john.doe</div>*)"),
+			Result:          &Result{body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">jane.doe</div></body></html>`)},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY] (<!DOCTYPE html><html lang...(truncated)) == pat(*<div id=\"user\">john.doe</div>*)",
+		},
+		{
+			Name:            "body-pattern-html-failure-alt",
+			Condition:       Condition("pat(*<div id=\"user\">john.doe</div>*) == [BODY]"),
+			Result:          &Result{body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">jane.doe</div></body></html>`)},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "pat(*<div id=\"user\">john.doe</div>*) == [BODY] (<!DOCTYPE html><html lang...(truncated))",
+		},
+		{
+			Name:            "ip-pattern",
+			Condition:       Condition("[IP] == pat(10.*)"),
+			Result:          &Result{IP: "10.0.0.0"},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[IP] == pat(10.*)",
+		},
+		{
+			Name:            "ip-pattern-failure",
+			Condition:       Condition("[IP] == pat(10.*)"),
+			Result:          &Result{IP: "255.255.255.255"},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[IP] (255.255.255.255) == pat(10.*)",
+		},
+		{
+			Name:            "status-pattern",
+			Condition:       Condition("[STATUS] == pat(4*)"),
+			Result:          &Result{HTTPStatus: 404},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[STATUS] == pat(4*)",
+		},
+		{
+			Name:            "status-pattern-failure",
+			Condition:       Condition("[STATUS] == pat(4*)"),
+			Result:          &Result{HTTPStatus: 200},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[STATUS] (200) == pat(4*)",
+		},
+		{
+			Name:            "body-any",
+			Condition:       Condition("[BODY].name == any(john.doe, jane.doe)"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].name == any(john.doe, jane.doe)",
+		},
+		{
+			Name:            "body-any-2",
+			Condition:       Condition("[BODY].name == any(john.doe, jane.doe)"),
+			Result:          &Result{body: []byte("{\"name\": \"jane.doe\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].name == any(john.doe, jane.doe)",
+		},
+		{
+			Name:            "body-any-failure",
+			Condition:       Condition("[BODY].name == any(john.doe, jane.doe)"),
+			Result:          &Result{body: []byte("{\"name\": \"bob\"}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].name (bob) == any(john.doe, jane.doe)",
+		},
+		{
+			Name:            "status-any",
+			Condition:       Condition("[STATUS] == any(200, 429)"),
+			Result:          &Result{HTTPStatus: 200},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[STATUS] == any(200, 429)",
+		},
+		{
+			Name:            "status-any-2",
+			Condition:       Condition("[STATUS] == any(200, 429)"),
+			Result:          &Result{HTTPStatus: 429},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[STATUS] == any(200, 429)",
+		},
+		{
+			Name:            "status-any-reverse",
+			Condition:       Condition("any(200, 429) == [STATUS]"),
+			Result:          &Result{HTTPStatus: 429},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "any(200, 429) == [STATUS]",
+		},
+		{
+			Name:            "status-any-failure",
+			Condition:       Condition("[STATUS] == any(200, 429)"),
+			Result:          &Result{HTTPStatus: 404},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[STATUS] (404) == any(200, 429)",
+		},
+		{
+			Name:                        "status-any-failure-but-dont-resolve",
+			Condition:                   Condition("[STATUS] == any(200, 429)"),
+			Result:                      &Result{HTTPStatus: 404},
+			DontResolveFailedConditions: true,
+			ExpectedSuccess:             false,
+			ExpectedOutput:              "[STATUS] == any(200, 429)",
+		},
+		{
+			Name:            "connected",
+			Condition:       Condition("[CONNECTED] == true"),
+			Result:          &Result{Connected: true},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[CONNECTED] == true",
+		},
+		{
+			Name:            "connected-failure",
+			Condition:       Condition("[CONNECTED] == true"),
+			Result:          &Result{Connected: false},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[CONNECTED] (false) == true",
+		},
+		{
+			Name:            "certificate-expiration-not-set",
+			Condition:       Condition("[CERTIFICATE_EXPIRATION] == 0"),
+			Result:          &Result{},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[CERTIFICATE_EXPIRATION] == 0",
+		},
+		{
+			Name:            "certificate-expiration-greater-than-numerical",
+			Condition:       Condition("[CERTIFICATE_EXPIRATION] > " + strconv.FormatInt((time.Hour*24*28).Milliseconds(), 10)),
+			Result:          &Result{CertificateExpiration: time.Hour * 24 * 60},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[CERTIFICATE_EXPIRATION] > 2419200000",
+		},
+		{
+			Name:            "certificate-expiration-greater-than-numerical-failure",
+			Condition:       Condition("[CERTIFICATE_EXPIRATION] > " + strconv.FormatInt((time.Hour*24*28).Milliseconds(), 10)),
+			Result:          &Result{CertificateExpiration: time.Hour * 24 * 14},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[CERTIFICATE_EXPIRATION] (1209600000) > 2419200000",
+		},
+		{
+			Name:            "certificate-expiration-greater-than-duration",
+			Condition:       Condition("[CERTIFICATE_EXPIRATION] > 12h"),
+			Result:          &Result{CertificateExpiration: 24 * time.Hour},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[CERTIFICATE_EXPIRATION] > 12h",
+		},
+		{
+			Name:            "certificate-expiration-greater-than-duration",
+			Condition:       Condition("[CERTIFICATE_EXPIRATION] > 48h"),
+			Result:          &Result{CertificateExpiration: 24 * time.Hour},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[CERTIFICATE_EXPIRATION] (86400000) > 48h (172800000)",
+		},
+		{
+			Name:            "has",
+			Condition:       Condition("has([BODY].errors) == false"),
+			Result:          &Result{body: []byte("{}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "has([BODY].errors) == false",
+		},
+		{
+			Name:            "has-failure",
+			Condition:       Condition("has([BODY].errors) == false"),
+			Result:          &Result{body: []byte("{\"errors\": [\"1\"]}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "has([BODY].errors) (true) == false",
+		},
+		{
+			Name:                        "has-failure-but-dont-resolve",
+			Condition:                   Condition("has([BODY].errors) == false"),
+			Result:                      &Result{body: []byte("{\"errors\": [\"1\"]}")},
+			DontResolveFailedConditions: true,
+			ExpectedSuccess:             false,
+			ExpectedOutput:              "has([BODY].errors) == false",
+		},
+		{
+			Name:            "no-placeholders",
+			Condition:       Condition("1 == 2"),
+			Result:          &Result{},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "1 == 2",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			scenario.Condition.evaluate(scenario.Result, scenario.DontResolveFailedConditions)
+			if scenario.Result.ConditionResults[0].Success != scenario.ExpectedSuccess {
+				t.Errorf("Condition '%s' should have been success=%v", scenario.Condition, scenario.ExpectedSuccess)
+			}
+			if scenario.Result.ConditionResults[0].Condition != scenario.ExpectedOutput {
+				t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", scenario.Condition, scenario.ExpectedOutput, scenario.Result.ConditionResults[0].Condition)
+			}
+		})
 	}
 }
 
-func TestCondition_evaluateWithStatus(t *testing.T) {
-	condition := Condition("[STATUS] == 201")
+func TestCondition_evaluateWithInvalidOperator(t *testing.T) {
+	condition := Condition("[STATUS] ? 201")
 	result := &Result{HTTPStatus: 201}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithStatusFailure(t *testing.T) {
-	condition := Condition("[STATUS] == 200")
-	result := &Result{HTTPStatus: 500}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithStatusUsingLessThan(t *testing.T) {
-	condition := Condition("[STATUS] < 300")
-	result := &Result{HTTPStatus: 201}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithStatusFailureUsingLessThan(t *testing.T) {
-	condition := Condition("[STATUS] < 300")
-	result := &Result{HTTPStatus: 404}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithResponseTimeUsingLessThan(t *testing.T) {
-	condition := Condition("[RESPONSE_TIME] < 500")
-	result := &Result{Duration: time.Millisecond * 50}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithResponseTimeUsingLessThanDuration(t *testing.T) {
-	condition := Condition("[RESPONSE_TIME] < 1s")
-	result := &Result{Duration: time.Millisecond * 50}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithResponseTimeUsingLessThanInvalid(t *testing.T) {
-	condition := Condition("[RESPONSE_TIME] < potato")
-	result := &Result{Duration: time.Millisecond * 50}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have failed because the condition has an invalid numerical value that should've automatically resolved to 0", condition)
-	}
-}
-
-func TestCondition_evaluateWithResponseTimeUsingGreaterThan(t *testing.T) {
-	// Not exactly sure why you'd want to have a condition that checks if the response time is too fast,
-	// but hey, who am I to judge?
-	condition := Condition("[RESPONSE_TIME] > 500")
-	result := &Result{Duration: time.Millisecond * 750}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithResponseTimeUsingGreaterThanDuration(t *testing.T) {
-	condition := Condition("[RESPONSE_TIME] > 1s")
-	result := &Result{Duration: time.Second * 2}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithResponseTimeUsingGreaterThanOrEqualTo(t *testing.T) {
-	condition := Condition("[RESPONSE_TIME] >= 500")
-	result := &Result{Duration: time.Millisecond * 500}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithResponseTimeUsingLessThanOrEqualTo(t *testing.T) {
-	condition := Condition("[RESPONSE_TIME] <= 500")
-	result := &Result{Duration: time.Millisecond * 500}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBody(t *testing.T) {
-	condition := Condition("[BODY] == test")
-	result := &Result{Body: []byte("test")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJSONPath(t *testing.T) {
-	condition := Condition("[BODY].status == UP")
-	result := &Result{Body: []byte("{\"status\":\"UP\"}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJSONPathComplex(t *testing.T) {
-	condition := Condition("[BODY].data.name == john")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 1, \"name\": \"john\"}}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithInvalidBodyJSONPathComplex(t *testing.T) {
-	expectedResolvedCondition := "[BODY].data.name (INVALID) == john"
-	condition := Condition("[BODY].data.name == john")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure, because the path was invalid", condition)
-	}
-	if result.ConditionResults[0].Condition != expectedResolvedCondition {
-		t.Errorf("Condition '%s' should have resolved to '%s', but resolved to '%s' instead", condition, expectedResolvedCondition, result.ConditionResults[0].Condition)
-	}
-}
-
-func TestCondition_evaluateWithInvalidBodyJSONPathComplexWithLengthFunction(t *testing.T) {
-	expectedResolvedCondition := "len([BODY].data.name) (INVALID) == john"
-	condition := Condition("len([BODY].data.name) == john")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure, because the path was invalid", condition)
-	}
-	if result.ConditionResults[0].Condition != expectedResolvedCondition {
-		t.Errorf("Condition '%s' should have resolved to '%s', but resolved to '%s' instead", condition, expectedResolvedCondition, result.ConditionResults[0].Condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJSONPathDoublePlaceholders(t *testing.T) {
-	condition := Condition("[BODY].user.firstName != [BODY].user.lastName")
-	result := &Result{Body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJSONPathDoublePlaceholdersFailure(t *testing.T) {
-	condition := Condition("[BODY].user.firstName == [BODY].user.lastName")
-	result := &Result{Body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJSONPathLongInt(t *testing.T) {
-	condition := Condition("[BODY].data.id == 1")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJSONPathComplexInt(t *testing.T) {
-	condition := Condition("[BODY].data[1].id == 2")
-	result := &Result{Body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJSONPathComplexIntUsingGreaterThan(t *testing.T) {
-	condition := Condition("[BODY].data.id > 0")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJSONPathComplexIntFailureUsingGreaterThan(t *testing.T) {
-	condition := Condition("[BODY].data.id > 5")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJSONPathComplexIntUsingLessThan(t *testing.T) {
-	condition := Condition("[BODY].data.id < 5")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 2}}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJSONPathComplexIntFailureUsingLessThan(t *testing.T) {
-	condition := Condition("[BODY].data.id < 5")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 10}}")}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodySliceLength(t *testing.T) {
-	condition := Condition("len([BODY].data) == 3")
-	result := &Result{Body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyStringLength(t *testing.T) {
-	condition := Condition("len([BODY].name) == 8")
-	result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyStringPattern(t *testing.T) {
-	condition := Condition("[BODY].name == pat(*ohn*)")
-	result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyStringPatternFailure(t *testing.T) {
-	condition := Condition("[BODY].name == pat(bob*)")
-	result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyPatternFailure(t *testing.T) {
-	condition := Condition("[BODY] == pat(*john*)")
-	result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithIPPattern(t *testing.T) {
-	condition := Condition("[IP] == pat(10.*)")
-	result := &Result{IP: "10.0.0.0"}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithIPPatternFailure(t *testing.T) {
-	condition := Condition("[IP] == pat(10.*)")
-	result := &Result{IP: "255.255.255.255"}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithStatusPattern(t *testing.T) {
-	condition := Condition("[STATUS] == pat(4*)")
-	result := &Result{HTTPStatus: 404}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithStatusPatternFailure(t *testing.T) {
-	condition := Condition("[STATUS] != pat(4*)")
-	result := &Result{HTTPStatus: 404}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithConnected(t *testing.T) {
-	condition := Condition("[CONNECTED] == true")
-	result := &Result{Connected: true}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithConnectedFailure(t *testing.T) {
-	condition := Condition("[CONNECTED] == true")
-	result := &Result{Connected: false}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithUnsetCertificateExpiration(t *testing.T) {
-	condition := Condition("[CERTIFICATE_EXPIRATION] == 0")
-	result := &Result{}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithCertificateExpirationGreaterThanNumerical(t *testing.T) {
-	acceptable := (time.Hour * 24 * 28).Milliseconds()
-	condition := Condition("[CERTIFICATE_EXPIRATION] > " + strconv.FormatInt(acceptable, 10))
-	result := &Result{CertificateExpiration: time.Hour * 24 * 60}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithCertificateExpirationGreaterThanNumericalFailure(t *testing.T) {
-	acceptable := (time.Hour * 24 * 28).Milliseconds()
-	condition := Condition("[CERTIFICATE_EXPIRATION] > " + strconv.FormatInt(acceptable, 10))
-	result := &Result{CertificateExpiration: time.Hour * 24 * 14}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithCertificateExpirationGreaterThanDuration(t *testing.T) {
-	condition := Condition("[CERTIFICATE_EXPIRATION] > 12h")
-	result := &Result{CertificateExpiration: 24 * time.Hour}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithCertificateExpirationGreaterThanDurationFailure(t *testing.T) {
-	condition := Condition("[CERTIFICATE_EXPIRATION] > 48h")
-	result := &Result{CertificateExpiration: 24 * time.Hour}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
+	condition.evaluate(result, false)
+	if result.Success {
+		t.Error("condition was invalid, result should've been a failure")
+	}
+	if len(result.Errors) != 1 {
+		t.Error("condition was invalid, result should've had an error")
 	}
 }

core/dns.go

@@ -11,6 +11,7 @@ import (
 var (
 	// ErrDNSWithNoQueryName is the error with which gatus will panic if a dns is configured without query name
 	ErrDNSWithNoQueryName = errors.New("you must specify a query name for DNS")
+
 	// ErrDNSWithInvalidQueryType is the error with which gatus will panic if a dns is configured with invalid query type
 	ErrDNSWithInvalidQueryType = errors.New("invalid query type")
 )
@@ -19,23 +20,26 @@ const (
 	dnsPort = 53
 )
 
+// DNS is the configuration for a Service of type DNS
 type DNS struct {
 	// QueryType is the type for the DNS records like A, AAAA, CNAME...
 	QueryType string `yaml:"query-type"`
+
 	// QueryName is the query for DNS
 	QueryName string `yaml:"query-name"`
 }
 
-func (d *DNS) validateAndSetDefault() {
+func (d *DNS) validateAndSetDefault() error {
 	if len(d.QueryName) == 0 {
-		panic(ErrDNSWithNoQueryName)
+		return ErrDNSWithNoQueryName
 	}
 	if !strings.HasSuffix(d.QueryName, ".") {
 		d.QueryName += "."
 	}
 	if _, ok := dns.StringToType[d.QueryType]; !ok {
-		panic(ErrDNSWithInvalidQueryType)
+		return ErrDNSWithInvalidQueryType
 	}
+	return nil
 }
 
 func (d *DNS) query(url string, result *Result) {
@@ -48,7 +52,7 @@ func (d *DNS) query(url string, result *Result) {
 	m.SetQuestion(d.QueryName, queryType)
 	r, _, err := c.Exchange(m, url)
 	if err != nil {
-		result.Errors = append(result.Errors, err.Error())
+		result.AddError(err.Error())
 		return
 	}
 	result.Connected = true
@@ -57,26 +61,26 @@ func (d *DNS) query(url string, result *Result) {
 		switch rr.Header().Rrtype {
 		case dns.TypeA:
 			if a, ok := rr.(*dns.A); ok {
-				result.Body = []byte(a.A.String())
+				result.body = []byte(a.A.String())
 			}
 		case dns.TypeAAAA:
 			if aaaa, ok := rr.(*dns.AAAA); ok {
-				result.Body = []byte(aaaa.AAAA.String())
+				result.body = []byte(aaaa.AAAA.String())
 			}
 		case dns.TypeCNAME:
 			if cname, ok := rr.(*dns.CNAME); ok {
-				result.Body = []byte(cname.Target)
+				result.body = []byte(cname.Target)
 			}
 		case dns.TypeMX:
 			if mx, ok := rr.(*dns.MX); ok {
-				result.Body = []byte(mx.Mx)
+				result.body = []byte(mx.Mx)
 			}
 		case dns.TypeNS:
 			if ns, ok := rr.(*dns.NS); ok {
-				result.Body = []byte(ns.Ns)
+				result.body = []byte(ns.Ns)
 			}
 		default:
-			result.Body = []byte("query type is not supported yet")
+			result.body = []byte("query type is not supported yet")
 		}
 	}
 }

core/dns_test.go

@@ -2,6 +2,8 @@ package core
 
 import (
 	"testing"
+
+	"github.com/TwiN/gatus/v3/pattern"
 )
 
 func TestIntegrationQuery(t *testing.T) {
@@ -61,7 +63,7 @@ func TestIntegrationQuery(t *testing.T) {
 			},
 			inputURL:        "8.8.8.8",
 			expectedDNSCode: "NOERROR",
-			expectedBody:    "b.iana-servers.net.",
+			expectedBody:    "*.iana-servers.net.",
 		},
 		{
 			name: "test DNS with fake type and retrieve error",
@@ -87,8 +89,15 @@ func TestIntegrationQuery(t *testing.T) {
 				t.Errorf("DNSRCodePlaceholder '%s' should have been %s", result.DNSRCode, test.expectedDNSCode)
 			}
 
-			if string(result.Body) != test.expectedBody {
-				t.Errorf("got %s, expected result %s,", string(result.Body), test.expectedBody)
+			if test.inputDNS.QueryType == "NS" {
+				// Because there are often multiple nameservers backing a single domain, we'll only look at the suffix
+				if !pattern.Match(test.expectedBody, string(result.body)) {
+					t.Errorf("got %s, expected result %s,", string(result.body), test.expectedBody)
+				}
+			} else {
+				if string(result.body) != test.expectedBody {
+					t.Errorf("got %s, expected result %s,", string(result.body), test.expectedBody)
+				}
 			}
 		})
 	}
@@ -100,8 +109,10 @@ func TestService_ValidateAndSetDefaultsWithNoDNSQueryName(t *testing.T) {
 		QueryType: "A",
 		QueryName: "",
 	}
-	dns.validateAndSetDefault()
-	t.Fatal("Should've panicked because service`s dns didn't have a query name, which is a mandatory field for dns")
+	err := dns.validateAndSetDefault()
+	if err == nil {
+		t.Fatal("Should've returned an error because service`s dns didn't have a query name, which is a mandatory field for dns")
+	}
 }
 
 func TestService_ValidateAndSetDefaultsWithInvalidDNSQueryType(t *testing.T) {
@@ -110,6 +121,8 @@ func TestService_ValidateAndSetDefaultsWithInvalidDNSQueryType(t *testing.T) {
 		QueryType: "B",
 		QueryName: "example.com",
 	}
-	dns.validateAndSetDefault()
-	t.Fatal("Should've panicked because service`s dns query type is invalid, it needs to be a valid query name like A, AAAA, CNAME...")
+	err := dns.validateAndSetDefault()
+	if err == nil {
+		t.Fatal("Should've returned an error because service`s dns query type is invalid, it needs to be a valid query name like A, AAAA, CNAME...")
+	}
 }

core/event.go

@@ -0,0 +1,37 @@
+package core
+
+import "time"
+
+// Event is something that happens at a specific time
+type Event struct {
+	// Type is the kind of event
+	Type EventType `json:"type"`
+
+	// Timestamp is the moment at which the event happened
+	Timestamp time.Time `json:"timestamp"`
+}
+
+// EventType is, uh, the types of events?
+type EventType string
+
+var (
+	// EventStart is a type of event that represents when a service starts being monitored
+	EventStart EventType = "START"
+
+	// EventHealthy is a type of event that represents a service passing all of its conditions
+	EventHealthy EventType = "HEALTHY"
+
+	// EventUnhealthy is a type of event that represents a service failing one or more of its conditions
+	EventUnhealthy EventType = "UNHEALTHY"
+)
+
+// NewEventFromResult creates an Event from a Result
+func NewEventFromResult(result *Result) *Event {
+	event := &Event{Timestamp: result.Timestamp}
+	if result.Success {
+		event.Type = EventHealthy
+	} else {
+		event.Type = EventUnhealthy
+	}
+	return event
+}

core/event_test.go

@@ -0,0 +1,12 @@
+package core
+
+import "testing"
+
+func TestNewEventFromResult(t *testing.T) {
+	if event := NewEventFromResult(&Result{Success: true}); event.Type != EventHealthy {
+		t.Error("expected event.Type to be EventHealthy")
+	}
+	if event := NewEventFromResult(&Result{Success: false}); event.Type != EventUnhealthy {
+		t.Error("expected event.Type to be EventUnhealthy")
+	}
+}

core/health_status.go

@@ -0,0 +1,11 @@
+package core
+
+// HealthStatus is the status of Gatus
+type HealthStatus struct {
+	// Status is the state of Gatus (UP/DOWN)
+	Status string `json:"status"`
+
+	// Message is an accompanying description of why the status is as reported.
+	// If the Status is UP, no message will be provided
+	Message string `json:"message,omitempty"`
+}

core/result.go

@@ -0,0 +1,60 @@
+package core
+
+import (
+	"time"
+)
+
+// Result of the evaluation of a Service
+type Result struct {
+	// HTTPStatus is the HTTP response status code
+	HTTPStatus int `json:"status"`
+
+	// DNSRCode is the response code of a DNS query in a human readable format
+	DNSRCode string `json:"-"`
+
+	// Hostname extracted from Service.URL
+	Hostname string `json:"hostname"`
+
+	// IP resolved from the Service URL
+	IP string `json:"-"`
+
+	// Connected whether a connection to the host was established successfully
+	Connected bool `json:"-"`
+
+	// Duration time that the request took
+	Duration time.Duration `json:"duration"`
+
+	// Errors encountered during the evaluation of the service's health
+	Errors []string `json:"errors"`
+
+	// ConditionResults results of the service's conditions
+	ConditionResults []*ConditionResult `json:"conditionResults"`
+
+	// Success whether the result signifies a success or not
+	Success bool `json:"success"`
+
+	// Timestamp when the request was sent
+	Timestamp time.Time `json:"timestamp"`
+
+	// CertificateExpiration is the duration before the certificate expires
+	CertificateExpiration time.Duration `json:"-"`
+
+	// body is the response body
+	//
+	// Note that this variable is only used during the evaluation of a service's health.
+	// This means that the call Service.EvaluateHealth both populates the body (if necessary)
+	// and sets it to nil after the evaluation has been completed.
+	body []byte
+}
+
+// AddError adds an error to the result's list of errors.
+// It also ensures that there are no duplicates.
+func (r *Result) AddError(error string) {
+	for _, resultError := range r.Errors {
+		if resultError == error {
+			// If the error already exists, don't add it
+			return
+		}
+	}
+	r.Errors = append(r.Errors, error)
+}

core/result_test.go

@@ -0,0 +1,21 @@
+package core
+
+import (
+	"testing"
+)
+
+func TestResult_AddError(t *testing.T) {
+	result := &Result{}
+	result.AddError("potato")
+	if len(result.Errors) != 1 {
+		t.Error("should've had 1 error")
+	}
+	result.AddError("potato")
+	if len(result.Errors) != 1 {
+		t.Error("should've still had 1 error, because a duplicate error was added")
+	}
+	result.AddError("tomato")
+	if len(result.Errors) != 2 {
+		t.Error("should've had 2 error")
+	}
+}

core/service.go

@@ -2,6 +2,7 @@ package core
 
 import (
 	"bytes"
+	"crypto/x509"
 	"encoding/json"
 	"errors"
 	"io/ioutil"
@@ -11,25 +12,49 @@ import (
 	"strings"
 	"time"
 
-	"github.com/TwinProduction/gatus/client"
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/client"
+	"github.com/TwiN/gatus/v3/core/ui"
+	"github.com/TwiN/gatus/v3/util"
+)
+
+const (
+	// HostHeader is the name of the header used to specify the host
+	HostHeader = "Host"
+
+	// ContentTypeHeader is the name of the header used to specify the content type
+	ContentTypeHeader = "Content-Type"
+
+	// UserAgentHeader is the name of the header used to specify the request's user agent
+	UserAgentHeader = "User-Agent"
+
+	// GatusUserAgent is the default user agent that Gatus uses to send requests.
+	GatusUserAgent = "Gatus/1.0"
 )
 
 var (
-	// ErrServiceWithNoCondition is the error with which gatus will panic if a service is configured with no conditions
+	// ErrServiceWithNoCondition is the error with which Gatus will panic if a service is configured with no conditions
 	ErrServiceWithNoCondition = errors.New("you must specify at least one condition per service")
 
-	// ErrServiceWithNoURL is the error with which gatus will panic if a service is configured with no url
+	// ErrServiceWithNoURL is the error with which Gatus will panic if a service is configured with no url
 	ErrServiceWithNoURL = errors.New("you must specify an url for each service")
 
-	// ErrServiceWithNoName is the error with which gatus will panic if a service is configured with no name
+	// ErrServiceWithNoName is the error with which Gatus will panic if a service is configured with no name
 	ErrServiceWithNoName = errors.New("you must specify a name for each service")
 )
 
 // Service is the configuration of a monitored endpoint
+// XXX: Rename this to Endpoint in v4.0.0?
 type Service struct {
+	// Enabled defines whether to enable the service
+	Enabled *bool `yaml:"enabled,omitempty"`
+
 	// Name of the service. Can be anything.
 	Name string `yaml:"name"`
 
+	// Group the service is a part of. Used for grouping multiple services together on the front end.
+	Group string `yaml:"group,omitempty"`
+
 	// URL to send the request to
 	URL string `yaml:"url"`
 
@@ -55,21 +80,40 @@ type Service struct {
 	Conditions []*Condition `yaml:"conditions"`
 
 	// Alerts is the alerting configuration for the service in case of failure
-	Alerts []*Alert `yaml:"alerts"`
+	Alerts []*alert.Alert `yaml:"alerts"`
 
-	// Insecure is whether to skip verifying the server's certificate chain and host name
-	Insecure bool `yaml:"insecure,omitempty"`
+	// ClientConfig is the configuration of the client used to communicate with the service's target
+	ClientConfig *client.Config `yaml:"client"`
+
+	// UIConfig is the configuration for the UI
+	UIConfig *ui.Config `yaml:"ui"`
 
 	// NumberOfFailuresInARow is the number of unsuccessful evaluations in a row
 	NumberOfFailuresInARow int
 
-	// NumberOfFailuresInARow is the number of successful evaluations in a row
+	// NumberOfSuccessesInARow is the number of successful evaluations in a row
 	NumberOfSuccessesInARow int
 }
 
+// IsEnabled returns whether the service is enabled or not
+func (service Service) IsEnabled() bool {
+	if service.Enabled == nil {
+		return true
+	}
+	return *service.Enabled
+}
+
 // ValidateAndSetDefaults validates the service's configuration and sets the default value of fields that have one
-func (service *Service) ValidateAndSetDefaults() {
+func (service *Service) ValidateAndSetDefaults() error {
 	// Set default values
+	if service.ClientConfig == nil {
+		service.ClientConfig = client.GetDefaultConfig()
+	} else {
+		service.ClientConfig.ValidateAndSetDefaults()
+	}
+	if service.UIConfig == nil {
+		service.UIConfig = ui.GetDefaultConfig()
+	}
 	if service.Interval == 0 {
 		service.Interval = 1 * time.Minute
 	}
@@ -79,34 +123,46 @@ func (service *Service) ValidateAndSetDefaults() {
 	if len(service.Headers) == 0 {
 		service.Headers = make(map[string]string)
 	}
-	for _, alert := range service.Alerts {
-		if alert.FailureThreshold <= 0 {
-			alert.FailureThreshold = 3
+	// Automatically add user agent header if there isn't one specified in the service configuration
+	if _, userAgentHeaderExists := service.Headers[UserAgentHeader]; !userAgentHeaderExists {
+		service.Headers[UserAgentHeader] = GatusUserAgent
+	}
+	// Automatically add "Content-Type: application/json" header if there's no Content-Type set
+	// and service.GraphQL is set to true
+	if _, contentTypeHeaderExists := service.Headers[ContentTypeHeader]; !contentTypeHeaderExists && service.GraphQL {
+		service.Headers[ContentTypeHeader] = "application/json"
+	}
+	for _, serviceAlert := range service.Alerts {
+		if serviceAlert.FailureThreshold <= 0 {
+			serviceAlert.FailureThreshold = 3
 		}
-		if alert.SuccessThreshold <= 0 {
-			alert.SuccessThreshold = 2
+		if serviceAlert.SuccessThreshold <= 0 {
+			serviceAlert.SuccessThreshold = 2
 		}
 	}
 	if len(service.Name) == 0 {
-		panic(ErrServiceWithNoName)
+		return ErrServiceWithNoName
 	}
 	if len(service.URL) == 0 {
-		panic(ErrServiceWithNoURL)
+		return ErrServiceWithNoURL
 	}
 	if len(service.Conditions) == 0 {
-		panic(ErrServiceWithNoCondition)
+		return ErrServiceWithNoCondition
 	}
-
 	if service.DNS != nil {
-		service.DNS.validateAndSetDefault()
-		return
+		return service.DNS.validateAndSetDefault()
 	}
-
 	// Make sure that the request can be created
 	_, err := http.NewRequest(service.Method, service.URL, bytes.NewBuffer([]byte(service.Body)))
 	if err != nil {
-		panic(err)
+		return err
 	}
+	return nil
+}
+
+// Key returns the unique key for the Service
+func (service Service) Key() string {
+	return util.ConvertGroupAndServiceToKey(service.Group, service.Name)
 }
 
 // EvaluateHealth sends a request to the service's URL and evaluates the conditions of the service.
@@ -119,44 +175,35 @@ func (service *Service) EvaluateHealth() *Result {
 		result.Success = false
 	}
 	for _, condition := range service.Conditions {
-		success := condition.evaluate(result)
+		success := condition.evaluate(result, service.UIConfig.DontResolveFailedConditions)
 		if !success {
 			result.Success = false
 		}
 	}
 	result.Timestamp = time.Now()
+	// No need to keep the body after the service has been evaluated
+	result.body = nil
+	// Clean up parameters that we don't need to keep in the results
+	if service.UIConfig.HideHostname {
+		result.Hostname = ""
+	}
 	return result
 }
 
-// GetAlertsTriggered returns a slice of alerts that have been triggered
-func (service *Service) GetAlertsTriggered() []Alert {
-	var alerts []Alert
-	if service.NumberOfFailuresInARow == 0 {
-		return alerts
-	}
-	for _, alert := range service.Alerts {
-		if alert.Enabled && alert.FailureThreshold == service.NumberOfFailuresInARow {
-			alerts = append(alerts, *alert)
-			continue
-		}
-	}
-	return alerts
-}
-
 func (service *Service) getIP(result *Result) {
 	if service.DNS != nil {
 		result.Hostname = strings.TrimSuffix(service.URL, ":53")
 	} else {
 		urlObject, err := url.Parse(service.URL)
 		if err != nil {
-			result.Errors = append(result.Errors, err.Error())
+			result.AddError(err.Error())
 			return
 		}
 		result.Hostname = urlObject.Hostname()
 	}
 	ips, err := net.LookupIP(result.Hostname)
 	if err != nil {
-		result.Errors = append(result.Errors, err.Error())
+		result.AddError(err.Error())
 		return
 	}
 	result.IP = ips[0].String()
@@ -166,9 +213,13 @@ func (service *Service) call(result *Result) {
 	var request *http.Request
 	var response *http.Response
 	var err error
-	isServiceTCP := strings.HasPrefix(service.URL, "tcp://")
+	var certificate *x509.Certificate
 	isServiceDNS := service.DNS != nil
-	isServiceHTTP := !isServiceTCP && !isServiceDNS
+	isServiceTCP := strings.HasPrefix(service.URL, "tcp://")
+	isServiceICMP := strings.HasPrefix(service.URL, "icmp://")
+	isServiceStartTLS := strings.HasPrefix(service.URL, "starttls://")
+	isServiceTLS := strings.HasPrefix(service.URL, "tls://")
+	isServiceHTTP := !isServiceDNS && !isServiceTCP && !isServiceICMP && !isServiceStartTLS && !isServiceTLS
 	if isServiceHTTP {
 		request = service.buildHTTPRequest()
 	}
@@ -176,25 +227,43 @@ func (service *Service) call(result *Result) {
 	if isServiceDNS {
 		service.DNS.query(service.URL, result)
 		result.Duration = time.Since(startTime)
-	} else if isServiceTCP {
-		result.Connected = client.CanCreateConnectionToTCPService(strings.TrimPrefix(service.URL, "tcp://"))
-		result.Duration = time.Since(startTime)
-	} else {
-		response, err = client.GetHTTPClient(service.Insecure).Do(request)
-		result.Duration = time.Since(startTime)
+	} else if isServiceStartTLS || isServiceTLS {
+		if isServiceStartTLS {
+			result.Connected, certificate, err = client.CanPerformStartTLS(strings.TrimPrefix(service.URL, "starttls://"), service.ClientConfig)
+		} else {
+			result.Connected, certificate, err = client.CanPerformTLS(strings.TrimPrefix(service.URL, "tls://"), service.ClientConfig)
+		}
 		if err != nil {
-			result.Errors = append(result.Errors, err.Error())
+			result.AddError(err.Error())
 			return
 		}
+		result.Duration = time.Since(startTime)
+		result.CertificateExpiration = time.Until(certificate.NotAfter)
+	} else if isServiceTCP {
+		result.Connected = client.CanCreateTCPConnection(strings.TrimPrefix(service.URL, "tcp://"), service.ClientConfig)
+		result.Duration = time.Since(startTime)
+	} else if isServiceICMP {
+		result.Connected, result.Duration = client.Ping(strings.TrimPrefix(service.URL, "icmp://"), service.ClientConfig)
+	} else {
+		response, err = client.GetHTTPClient(service.ClientConfig).Do(request)
+		result.Duration = time.Since(startTime)
+		if err != nil {
+			result.AddError(err.Error())
+			return
+		}
+		defer response.Body.Close()
 		if response.TLS != nil && len(response.TLS.PeerCertificates) > 0 {
-			certificate := response.TLS.PeerCertificates[0]
-			result.CertificateExpiration = certificate.NotAfter.Sub(time.Now())
+			certificate = response.TLS.PeerCertificates[0]
+			result.CertificateExpiration = time.Until(certificate.NotAfter)
 		}
 		result.HTTPStatus = response.StatusCode
 		result.Connected = response.StatusCode > 0
-		result.Body, err = ioutil.ReadAll(response.Body)
-		if err != nil {
-			result.Errors = append(result.Errors, err.Error())
+		// Only read the body if there's a condition that uses the BodyPlaceholder
+		if service.needsToReadBody() {
+			result.body, err = ioutil.ReadAll(response.Body)
+			if err != nil {
+				result.AddError(err.Error())
+			}
 		}
 	}
 }
@@ -213,6 +282,19 @@ func (service *Service) buildHTTPRequest() *http.Request {
 	request, _ := http.NewRequest(service.Method, service.URL, bodyBuffer)
 	for k, v := range service.Headers {
 		request.Header.Set(k, v)
+		if k == HostHeader {
+			request.Host = v
+		}
 	}
 	return request
 }
+
+// needsToReadBody checks if there's any conditions that requires the response body to be read
+func (service *Service) needsToReadBody() bool {
+	for _, condition := range service.Conditions {
+		if condition.hasBodyPlaceholder() {
+			return true
+		}
+	}
+	return false
+}

core/service_status.go

@@ -0,0 +1,38 @@
+package core
+
+// ServiceStatus contains the evaluation Results of a Service
+type ServiceStatus struct {
+	// Name of the service
+	Name string `json:"name,omitempty"`
+
+	// Group the service is a part of. Used for grouping multiple services together on the front end.
+	Group string `json:"group,omitempty"`
+
+	// Key is the key representing the ServiceStatus
+	Key string `json:"key"`
+
+	// Results is the list of service evaluation results
+	Results []*Result `json:"results"`
+
+	// Events is a list of events
+	Events []*Event `json:"events"`
+
+	// Uptime information on the service's uptime
+	//
+	// Used by the memory store.
+	//
+	// To retrieve the uptime between two time, use store.GetUptimeByKey.
+	Uptime *Uptime `json:"-"`
+}
+
+// NewServiceStatus creates a new ServiceStatus
+func NewServiceStatus(serviceKey, serviceGroup, serviceName string) *ServiceStatus {
+	return &ServiceStatus{
+		Name:    serviceName,
+		Group:   serviceGroup,
+		Key:     serviceKey,
+		Results: make([]*Result, 0),
+		Events:  make([]*Event, 0),
+		Uptime:  NewUptime(),
+	}
+}

core/service_status_test.go

@@ -0,0 +1,19 @@
+package core
+
+import (
+	"testing"
+)
+
+func TestNewServiceStatus(t *testing.T) {
+	service := &Service{Name: "name", Group: "group"}
+	serviceStatus := NewServiceStatus(service.Key(), service.Group, service.Name)
+	if serviceStatus.Name != service.Name {
+		t.Errorf("expected %s, got %s", service.Name, serviceStatus.Name)
+	}
+	if serviceStatus.Group != service.Group {
+		t.Errorf("expected %s, got %s", service.Group, serviceStatus.Group)
+	}
+	if serviceStatus.Key != "group_name" {
+		t.Errorf("expected %s, got %s", "group_name", serviceStatus.Key)
+	}
+}

core/service_test.go

@@ -1,19 +1,49 @@
 package core
 
 import (
+	"io/ioutil"
+	"strings"
 	"testing"
 	"time"
+
+	"github.com/TwiN/gatus/v3/alerting/alert"
+	"github.com/TwiN/gatus/v3/client"
 )
 
+func TestService_IsEnabled(t *testing.T) {
+	if !(Service{Enabled: nil}).IsEnabled() {
+		t.Error("service.IsEnabled() should've returned true, because Enabled was set to nil")
+	}
+	if value := false; (Service{Enabled: &value}).IsEnabled() {
+		t.Error("service.IsEnabled() should've returned false, because Enabled was set to false")
+	}
+	if value := true; !(Service{Enabled: &value}).IsEnabled() {
+		t.Error("Service.IsEnabled() should've returned true, because Enabled was set to true")
+	}
+}
+
 func TestService_ValidateAndSetDefaults(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	service := Service{
-		Name:       "TwiNNatioN",
-		URL:        "https://twinnation.org/health",
+		Name:       "website-health",
+		URL:        "https://twin.sh/health",
 		Conditions: []*Condition{&condition},
-		Alerts:     []*Alert{{Type: PagerDutyAlert}},
+		Alerts:     []*alert.Alert{{Type: alert.TypePagerDuty}},
 	}
 	service.ValidateAndSetDefaults()
+	if service.ClientConfig == nil {
+		t.Error("client configuration should've been set to the default configuration")
+	} else {
+		if service.ClientConfig.Insecure != client.GetDefaultConfig().Insecure {
+			t.Errorf("Default client configuration should've set Insecure to %v, got %v", client.GetDefaultConfig().Insecure, service.ClientConfig.Insecure)
+		}
+		if service.ClientConfig.IgnoreRedirect != client.GetDefaultConfig().IgnoreRedirect {
+			t.Errorf("Default client configuration should've set IgnoreRedirect to %v, got %v", client.GetDefaultConfig().IgnoreRedirect, service.ClientConfig.IgnoreRedirect)
+		}
+		if service.ClientConfig.Timeout != client.GetDefaultConfig().Timeout {
+			t.Errorf("Default client configuration should've set Timeout to %v, got %v", client.GetDefaultConfig().Timeout, service.ClientConfig.Timeout)
+		}
+	}
 	if service.Method != "GET" {
 		t.Error("Service method should've defaulted to GET")
 	}
@@ -26,7 +56,7 @@ func TestService_ValidateAndSetDefaults(t *testing.T) {
 	if len(service.Alerts) != 1 {
 		t.Error("Service should've had 1 alert")
 	}
-	if service.Alerts[0].Enabled {
+	if service.Alerts[0].IsEnabled() {
 		t.Error("Service alert should've defaulted to disabled")
 	}
 	if service.Alerts[0].SuccessThreshold != 2 {
@@ -37,6 +67,34 @@ func TestService_ValidateAndSetDefaults(t *testing.T) {
 	}
 }
 
+func TestService_ValidateAndSetDefaultsWithClientConfig(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "website-health",
+		URL:        "https://twin.sh/health",
+		Conditions: []*Condition{&condition},
+		ClientConfig: &client.Config{
+			Insecure:       true,
+			IgnoreRedirect: true,
+			Timeout:        0,
+		},
+	}
+	service.ValidateAndSetDefaults()
+	if service.ClientConfig == nil {
+		t.Error("client configuration should've been set to the default configuration")
+	} else {
+		if !service.ClientConfig.Insecure {
+			t.Error("service.ClientConfig.Insecure should've been set to true")
+		}
+		if !service.ClientConfig.IgnoreRedirect {
+			t.Error("service.ClientConfig.IgnoreRedirect should've been set to true")
+		}
+		if service.ClientConfig.Timeout != client.GetDefaultConfig().Timeout {
+			t.Error("service.ClientConfig.Timeout should've been set to 10s, because the timeout value entered is not set or invalid")
+		}
+	}
+}
+
 func TestService_ValidateAndSetDefaultsWithNoName(t *testing.T) {
 	defer func() { recover() }()
 	condition := Condition("[STATUS] == 200")
@@ -45,8 +103,10 @@ func TestService_ValidateAndSetDefaultsWithNoName(t *testing.T) {
 		URL:        "http://example.com",
 		Conditions: []*Condition{&condition},
 	}
-	service.ValidateAndSetDefaults()
-	t.Fatal("Should've panicked because service didn't have a name, which is a mandatory field")
+	err := service.ValidateAndSetDefaults()
+	if err == nil {
+		t.Fatal("Should've returned an error because service didn't have a name, which is a mandatory field")
+	}
 }
 
 func TestService_ValidateAndSetDefaultsWithNoUrl(t *testing.T) {
@@ -57,8 +117,10 @@ func TestService_ValidateAndSetDefaultsWithNoUrl(t *testing.T) {
 		URL:        "",
 		Conditions: []*Condition{&condition},
 	}
-	service.ValidateAndSetDefaults()
-	t.Fatal("Should've panicked because service didn't have an url, which is a mandatory field")
+	err := service.ValidateAndSetDefaults()
+	if err == nil {
+		t.Fatal("Should've returned an error because service didn't have an url, which is a mandatory field")
+	}
 }
 
 func TestService_ValidateAndSetDefaultsWithNoConditions(t *testing.T) {
@@ -68,8 +130,10 @@ func TestService_ValidateAndSetDefaultsWithNoConditions(t *testing.T) {
 		URL:        "http://example.com",
 		Conditions: nil,
 	}
-	service.ValidateAndSetDefaults()
-	t.Fatal("Should've panicked because service didn't have at least 1 condition")
+	err := service.ValidateAndSetDefaults()
+	if err == nil {
+		t.Fatal("Should've returned an error because service didn't have at least 1 condition")
+	}
 }
 
 func TestService_ValidateAndSetDefaultsWithDNS(t *testing.T) {
@@ -83,43 +147,119 @@ func TestService_ValidateAndSetDefaultsWithDNS(t *testing.T) {
 		},
 		Conditions: []*Condition{&conditionSuccess},
 	}
-	service.ValidateAndSetDefaults()
+	err := service.ValidateAndSetDefaults()
+	if err != nil {
+
+	}
 	if service.DNS.QueryName != "example.com." {
 		t.Error("Service.dns.query-name should be formatted with . suffix")
 	}
 }
 
-func TestService_GetAlertsTriggered(t *testing.T) {
+func TestService_buildHTTPRequest(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	service := Service{
-		Name:       "TwiNNatioN",
-		URL:        "https://twinnation.org/health",
+		Name:       "website-health",
+		URL:        "https://twin.sh/health",
 		Conditions: []*Condition{&condition},
-		Alerts:     []*Alert{{Type: PagerDutyAlert, Enabled: true}},
 	}
 	service.ValidateAndSetDefaults()
-	if service.NumberOfFailuresInARow != 0 {
-		t.Error("Service.NumberOfFailuresInARow should start with 0")
+	request := service.buildHTTPRequest()
+	if request.Method != "GET" {
+		t.Error("request.Method should've been GET, but was", request.Method)
 	}
-	if service.NumberOfSuccessesInARow != 0 {
-		t.Error("Service.NumberOfSuccessesInARow should start with 0")
+	if request.Host != "twin.sh" {
+		t.Error("request.Host should've been twin.sh, but was", request.Host)
 	}
-	if len(service.GetAlertsTriggered()) > 0 {
-		t.Error("No alerts should've been triggered, because service.NumberOfFailuresInARow is 0, which is below the failure threshold")
+	if userAgent := request.Header.Get("User-Agent"); userAgent != GatusUserAgent {
+		t.Errorf("request.Header.Get(User-Agent) should've been %s, but was %s", GatusUserAgent, userAgent)
 	}
-	service.NumberOfFailuresInARow = service.Alerts[0].FailureThreshold
-	if len(service.GetAlertsTriggered()) != 1 {
-		t.Error("Alert should've been triggered")
+}
+
+func TestService_buildHTTPRequestWithCustomUserAgent(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "website-health",
+		URL:        "https://twin.sh/health",
+		Conditions: []*Condition{&condition},
+		Headers: map[string]string{
+			"User-Agent": "Test/2.0",
+		},
+	}
+	service.ValidateAndSetDefaults()
+	request := service.buildHTTPRequest()
+	if request.Method != "GET" {
+		t.Error("request.Method should've been GET, but was", request.Method)
+	}
+	if request.Host != "twin.sh" {
+		t.Error("request.Host should've been twin.sh, but was", request.Host)
+	}
+	if userAgent := request.Header.Get("User-Agent"); userAgent != "Test/2.0" {
+		t.Errorf("request.Header.Get(User-Agent) should've been %s, but was %s", "Test/2.0", userAgent)
+	}
+}
+
+func TestService_buildHTTPRequestWithHostHeader(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "website-health",
+		URL:        "https://twin.sh/health",
+		Method:     "POST",
+		Conditions: []*Condition{&condition},
+		Headers: map[string]string{
+			"Host": "example.com",
+		},
+	}
+	service.ValidateAndSetDefaults()
+	request := service.buildHTTPRequest()
+	if request.Method != "POST" {
+		t.Error("request.Method should've been POST, but was", request.Method)
+	}
+	if request.Host != "example.com" {
+		t.Error("request.Host should've been example.com, but was", request.Host)
+	}
+}
+
+func TestService_buildHTTPRequestWithGraphQLEnabled(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "website-graphql",
+		URL:        "https://twin.sh/graphql",
+		Method:     "POST",
+		Conditions: []*Condition{&condition},
+		GraphQL:    true,
+		Body: `{
+  users(gender: "female") {
+    id
+    name
+    gender
+    avatar
+  }
+}`,
+	}
+	service.ValidateAndSetDefaults()
+	request := service.buildHTTPRequest()
+	if request.Method != "POST" {
+		t.Error("request.Method should've been POST, but was", request.Method)
+	}
+	if contentType := request.Header.Get(ContentTypeHeader); contentType != "application/json" {
+		t.Error("request.Header.Content-Type should've been application/json, but was", contentType)
+	}
+	body, _ := ioutil.ReadAll(request.Body)
+	if !strings.HasPrefix(string(body), "{\"query\":") {
+		t.Error("request.body should've started with '{\"query\":', but it didn't:", string(body))
 	}
 }
 
 func TestIntegrationEvaluateHealth(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
+	bodyCondition := Condition("[BODY].status == UP")
 	service := Service{
-		Name:       "TwiNNatioN",
-		URL:        "https://twinnation.org/health",
-		Conditions: []*Condition{&condition},
+		Name:       "website-health",
+		URL:        "https://twin.sh/health",
+		Conditions: []*Condition{&condition, &bodyCondition},
 	}
+	service.ValidateAndSetDefaults()
 	result := service.EvaluateHealth()
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
@@ -132,11 +272,31 @@ func TestIntegrationEvaluateHealth(t *testing.T) {
 	}
 }
 
+func TestIntegrationEvaluateHealthWithFailure(t *testing.T) {
+	condition := Condition("[STATUS] == 500")
+	service := Service{
+		Name:       "website-health",
+		URL:        "https://twin.sh/health",
+		Conditions: []*Condition{&condition},
+	}
+	service.ValidateAndSetDefaults()
+	result := service.EvaluateHealth()
+	if result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a failure", condition)
+	}
+	if !result.Connected {
+		t.Error("Because the connection has been established, result.Connected should've been true")
+	}
+	if result.Success {
+		t.Error("Because one of the conditions failed, success should have been false")
+	}
+}
+
 func TestIntegrationEvaluateHealthForDNS(t *testing.T) {
 	conditionSuccess := Condition("[DNS_RCODE] == NOERROR")
 	conditionBody := Condition("[BODY] == 93.184.216.34")
 	service := Service{
-		Name: "TwiNNatioN",
+		Name: "example",
 		URL:  "8.8.8.8",
 		DNS: &DNS{
 			QueryType: "A",
@@ -144,6 +304,7 @@ func TestIntegrationEvaluateHealthForDNS(t *testing.T) {
 		},
 		Conditions: []*Condition{&conditionSuccess, &conditionBody},
 	}
+	service.ValidateAndSetDefaults()
 	result := service.EvaluateHealth()
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Conditions '%s' and %s should have been a success", conditionSuccess, conditionBody)
@@ -156,21 +317,60 @@ func TestIntegrationEvaluateHealthForDNS(t *testing.T) {
 	}
 }
 
-func TestIntegrationEvaluateHealthWithFailure(t *testing.T) {
-	condition := Condition("[STATUS] == 500")
+func TestIntegrationEvaluateHealthForICMP(t *testing.T) {
+	conditionSuccess := Condition("[CONNECTED] == true")
 	service := Service{
-		Name:       "TwiNNatioN",
-		URL:        "https://twinnation.org/health",
-		Conditions: []*Condition{&condition},
+		Name:       "icmp-test",
+		URL:        "icmp://127.0.0.1",
+		Conditions: []*Condition{&conditionSuccess},
 	}
+	service.ValidateAndSetDefaults()
 	result := service.EvaluateHealth()
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Conditions '%s' should have been a success", conditionSuccess)
 	}
 	if !result.Connected {
 		t.Error("Because the connection has been established, result.Connected should've been true")
 	}
-	if result.Success {
-		t.Error("Because one of the conditions failed, success should have been false")
+	if !result.Success {
+		t.Error("Because all conditions passed, this should have been a success")
+	}
+}
+
+func TestService_getIP(t *testing.T) {
+	conditionSuccess := Condition("[CONNECTED] == true")
+	service := Service{
+		Name:       "invalid-url-test",
+		URL:        "",
+		Conditions: []*Condition{&conditionSuccess},
+	}
+	result := &Result{}
+	service.getIP(result)
+	if len(result.Errors) == 0 {
+		t.Error("service.getIP(result) should've thrown an error because the URL is invalid, thus cannot be parsed")
+	}
+}
+
+func TestService_NeedsToReadBody(t *testing.T) {
+	statusCondition := Condition("[STATUS] == 200")
+	bodyCondition := Condition("[BODY].status == UP")
+	bodyConditionWithLength := Condition("len([BODY].tags) > 0")
+	if (&Service{Conditions: []*Condition{&statusCondition}}).needsToReadBody() {
+		t.Error("expected false, got true")
+	}
+	if !(&Service{Conditions: []*Condition{&bodyCondition}}).needsToReadBody() {
+		t.Error("expected true, got false")
+	}
+	if !(&Service{Conditions: []*Condition{&bodyConditionWithLength}}).needsToReadBody() {
+		t.Error("expected true, got false")
+	}
+	if !(&Service{Conditions: []*Condition{&statusCondition, &bodyCondition}}).needsToReadBody() {
+		t.Error("expected true, got false")
+	}
+	if !(&Service{Conditions: []*Condition{&bodyCondition, &statusCondition}}).needsToReadBody() {
+		t.Error("expected true, got false")
+	}
+	if !(&Service{Conditions: []*Condition{&bodyConditionWithLength, &statusCondition}}).needsToReadBody() {
+		t.Error("expected true, got false")
 	}
 }

core/types.go

@@ -1,63 +0,0 @@
-package core
-
-import (
-	"time"
-)
-
-// HealthStatus is the status of Gatus
-type HealthStatus struct {
-	// Status is the state of Gatus (UP/DOWN)
-	Status string `json:"status"`
-
-	// Message is an accompanying description of why the status is as reported.
-	// If the Status is UP, no message will be provided
-	Message string `json:"message,omitempty"`
-}
-
-// Result of the evaluation of a Service
-type Result struct {
-	// HTTPStatus is the HTTP response status code
-	HTTPStatus int `json:"status"`
-
-	// DNSRCode is the response code of DNS query in human readable version
-	DNSRCode string `json:"dns-rcode"`
-
-	// Body is the response body
-	Body []byte `json:"-"`
-
-	// Hostname extracted from the Service URL
-	Hostname string `json:"hostname"`
-
-	// IP resolved from the Service URL
-	IP string `json:"-"`
-
-	// Connected whether a connection to the host was established successfully
-	Connected bool `json:"-"`
-
-	// Duration time that the request took
-	Duration time.Duration `json:"duration"`
-
-	// Errors encountered during the evaluation of the service's health
-	Errors []string `json:"errors"`
-
-	// ConditionResults results of the service's conditions
-	ConditionResults []*ConditionResult `json:"condition-results"`
-
-	// Success whether the result signifies a success or not
-	Success bool `json:"success"`
-
-	// Timestamp when the request was sent
-	Timestamp time.Time `json:"timestamp"`
-
-	// CertificateExpiration is the duration before the certificate expires
-	CertificateExpiration time.Duration `json:"certificate-expiration,omitempty"`
-}
-
-// ConditionResult result of a Condition
-type ConditionResult struct {
-	// Condition that was evaluated
-	Condition string `json:"condition"`
-
-	// Success whether the condition was met (successful) or not (failed)
-	Success bool `json:"success"`
-}

core/ui/ui.go

@@ -0,0 +1,17 @@
+package ui
+
+// Config is the UI configuration for services
+type Config struct {
+	// HideHostname whether to hide the hostname in the Result
+	HideHostname bool `yaml:"hide-hostname"`
+	// DontResolveFailedConditions whether to resolve failed conditions in the Result for display in the UI
+	DontResolveFailedConditions bool `yaml:"dont-resolve-failed-conditions"`
+}
+
+// GetDefaultConfig retrieves the default UI configuration
+func GetDefaultConfig() *Config {
+	return &Config{
+		HideHostname:                false,
+		DontResolveFailedConditions: false,
+	}
+}

core/uptime.go

@@ -0,0 +1,24 @@
+package core
+
+// Uptime is the struct that contains the relevant data for calculating the uptime as well as the uptime itself
+// and some other statistics
+type Uptime struct {
+	// HourlyStatistics is a map containing metrics collected (value) for every hourly unix timestamps (key)
+	//
+	// Used only if the storage type is memory
+	HourlyStatistics map[int64]*HourlyUptimeStatistics `json:"-"`
+}
+
+// HourlyUptimeStatistics is a struct containing all metrics collected over the course of an hour
+type HourlyUptimeStatistics struct {
+	TotalExecutions             uint64 // Total number of checks
+	SuccessfulExecutions        uint64 // Number of successful executions
+	TotalExecutionsResponseTime uint64 // Total response time for all executions in milliseconds
+}
+
+// NewUptime creates a new Uptime
+func NewUptime() *Uptime {
+	return &Uptime{
+		HourlyStatistics: make(map[int64]*HourlyUptimeStatistics),
+	}
+}

docs/pagerduty-integration-guide.md

@@ -13,7 +13,7 @@
 
 
 # Support
-If you need help with this integration, please create an issue at https://github.com/TwinProduction/gatus/issues
+If you need help with this integration, please create an issue at https://github.com/TwiN/gatus/issues
 
 
 # Integration Walkthrough
@@ -26,7 +26,7 @@ If you need help with this integration, please create an issue at https://github
 3. Enter an **Integration Name** in the format `gatus-service-name` (e.g. `Gatus-Shopping-Cart`) and select **Gatus** from the Integration Type menu.
 4. Click the **Add Integration** button to save your new integration. You will be redirected to the Integrations tab for your service.
 5. An **Integration Key** will be generated on this screen. Keep this key saved in a safe place, as it will be used when you configure the integration with **Gatus** in the next section.
-![PagerDuty Integration Key](https://raw.githubusercontent.com/TwinProduction/gatus/master/.github/assets/pagerduty-integration-key.png)
+![PagerDuty Integration Key](https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/pagerduty-integration-key.png)
 
 
 ## In Gatus
@@ -39,9 +39,9 @@ alerting:
 You can now add alerts of type `pagerduty` in the services you've defined, like so:
 ```yaml
 services:
-  - name: twinnation
+  - name: website
     interval: 30s
-    url: "https://twinnation.org/health"
+    url: "https://twin.sh/health"
     alerts:
       - type: pagerduty
         enabled: true
@@ -56,7 +56,7 @@ services:
 ```
 
 The sample above will do the following:
-- Send a request to the `https://twinnation.org/health` (`services[].url`) specified every **30s** (`services[].interval`)
+- Send a request to the `https://twin.sh/health` (`services[].url`) specified every **30s** (`services[].interval`)
 - Evaluate the conditions to determine whether the service is "healthy" or not
 - **If all conditions are not met 3 (`services[].alerts[].failure-threshold`) times in a row**: Gatus will create a new incident
 - **If, after an incident has been triggered, all conditions are met 5 (`services[].alerts[].success-threshold`) times in a row _AND_ `services[].alerts[].send-on-resolved` is set to `true`**: Gatus will resolve the triggered incident

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

@@ -1,16 +0,0 @@
-metrics: true
-services:
-  - name: TwiNNatioN
-    url: https://twinnation.org/health
-    interval: 30s
-    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"

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

@@ -1,43 +0,0 @@
-version: '3.7'
-
-services:
-  gatus:
-    container_name: gatus
-    image: twinproduction/gatus
-    restart: always
-    ports:
-      - 8080:8080
-    volumes:
-      - ./config.yaml:/config/config.yaml
-    networks:
-      - metrics
-
-  prometheus:
-    container_name: prometheus
-    image: prom/prometheus:v2.14.0
-    restart: always
-    command: --config.file=/etc/prometheus/prometheus.yml
-    ports:
-      - 9090:9090
-    volumes:
-      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
-    networks:
-      - metrics
-
-  grafana:
-    container_name: grafana
-    image: grafana/grafana:6.4.4
-    restart: always
-    environment:
-      GF_SECURITY_ADMIN_PASSWORD: secret
-    ports:
-      - 3000:3000
-    volumes:
-      - ./grafana/grafana.ini/:/etc/grafana/grafana.ini:ro
-      - ./grafana/provisioning/:/etc/grafana/provisioning/:ro
-    networks:
-      - metrics
-
-networks:
-  metrics:
-    driver: bridge

example/docker-compose-mattermost/docker-compose.yml

@@ -1,13 +0,0 @@
-version: "3.8"
-services:
-    gatus:
-        image: twinproduction/gatus:latest
-        ports:
-          - 8080:8080
-        volumes:
-          - ./config.yaml:/config/config.yaml
-
-    mattermost-preview:
-        image: mattermost/mattermost-preview:latest
-        ports:
-          - 8065:8065

example/docker-compose/docker-compose.yml

@@ -1,8 +0,0 @@
-version: "3.8"
-services:
-    gatus:
-        image: twinproduction/gatus:latest
-        ports:
-          - 8080:8080
-        volumes:
-          - ./config.yaml:/config/config.yaml