Fix typo

#29: Automatically reload on configuration file update

.github/workflows/build.yml

@@ -14,10 +14,10 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
-      - name: Set up Go 1.15
+      - name: Set up Go
         uses: actions/setup-go@v2
         with:
-          go-version: 1.15
+          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

.github/workflows/publish.yml

@@ -6,6 +6,7 @@ jobs:
   build:
     name: Publish
     runs-on: ubuntu-latest
+    timeout-minutes: 30
     steps:
       - name: Check out code
         uses: actions/checkout@v2

.gitignore

@@ -1,4 +1,5 @@
 .idea
 .vscode
 gatus
-db.db
+db.db
+config/config.yml

LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 TwinProduction
+Copyright (c) 2021 TwinProduction
 
 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:
 

README.md

@@ -18,6 +18,7 @@ core applications: https://status.twinnation.org/
 
 ## Table of Contents
 
+- [Why Gatus?](#why-gatus)
 - [Features](#features)
 - [Usage](#usage)
 - [Configuration](#configuration)
@@ -31,6 +32,7 @@ core applications: https://status.twinnation.org/
     - [Configuring Twilio alerts](#configuring-twilio-alerts)
     - [Configuring Mattermost alerts](#configuring-mattermost-alerts)
     - [Configuring Messagebird alerts](#configuring-messagebird-alerts)    
+    - [Configuring Telegram alerts](#configuring-telegram-alerts)
     - [Configuring custom alerts](#configuring-custom-alerts)
   - [Kubernetes (ALPHA)](#kubernetes-alpha)
     - [Auto Discovery](#auto-discovery)
@@ -47,9 +49,30 @@ core applications: https://status.twinnation.org/
   - [Monitoring a service using DNS queries](#monitoring-a-service-using-dns-queries)
   - [Basic authentication](#basic-authentication)
   - [disable-monitoring-lock](#disable-monitoring-lock)
+  - [Reloading configuration on the fly](#reloading-configuration-on-the-fly)
   - [Service groups](#service-groups)
   - [Exposing Gatus on a custom port](#exposing-gatus-on-a-custom-port)
   - [Uptime Badges (ALPHA)](#uptime-badges)
+  - [API](#API)
+
+
+## Why Gatus?
+
+Before getting into the specifics, I want to address the most common question:
+> Why would I use Gatus when I can just use Prometheus’ Alertmanager, Cloudwatch or even Splunk?
+
+Neither of these can tell you that there’s a problem if there are no clients actively calling the endpoint.
+In other words, it's because monitoring metrics mostly rely on existing traffic, which effectively means that unless
+your clients are already experiencing a problem, you won't be notified.
+
+Gatus, on the other hand, allows you to configure health checks for each of your features, which in turn allows it to
+monitor these features and potentially alert you before any clients are impacted.
+
+A sign you may want to look into Gatus is by simply asking yourself whether you'd receive an alert if your load balancer
+was to go down right now. Will any of your existing alerts by triggered? Your metrics won’t report an increase in errors
+if there’s no traffic that makes it to your applications. This puts you in a situation where your clients are the ones
+that will notify you about the degradation of your services rather than you reassuring them that you're working on
+fixing the issue before they even know about it.
 
 
 ## Features
@@ -94,7 +117,7 @@ This example would look like this:
 
 ![Simple example](.github/assets/example.png)
 
-Note that you can also add environment variables in the configuration file (e.g. `$DOMAIN`, `${DOMAIN}`)
+Note that you can also use environment variables in the configuration file (e.g. `$DOMAIN`, `${DOMAIN}`)
 
 
 ## Configuration
@@ -111,7 +134,7 @@ Note that you can also add environment variables in the configuration file (e.g.
 | `services[].url`                         | URL to send the request to                                                    | Required `""`  |
 | `services[].method`                      | Request method                                                                | `GET`          |
 | `services[].insecure`                    | Whether to skip verifying the server's certificate chain and host name        | `false`        |
-| `services[].conditions`                  | Conditions used to determine the health of the service. See [Conditions](#conditions) | `[]`           |
+| `services[].conditions`                  | Conditions used to determine the health of the service. See [Conditions](#conditions). | `[]`           |
 | `services[].interval`                    | Duration to wait between every status check                                   | `60s`          |
 | `services[].graphql`                     | Whether to wrap the body in a query param (`{"query":"$body"}`)               | `false`        |
 | `services[].body`                        | Request body                                                                  | `""`           |
@@ -119,18 +142,19 @@ Note that you can also add environment variables in the configuration file (e.g.
 | `services[].dns`                         | Configuration for a service of type DNS. See [Monitoring a service using DNS queries](#monitoring-a-service-using-dns-queries). | `""`           |
 | `services[].dns.query-type`              | Query type for DNS service                                                    | `""`           |
 | `services[].dns.query-name`              | Query name for DNS service                                                    | `""`           |
-| `services[].alerts[].type`               | Type of alert. Valid types: `slack`, `discord`m `pagerduty`, `twilio`, `mattermost`, `messagebird`, `custom` | Required `""`  |
+| `services[].alerts[].type`               | Type of alert. Valid types: `slack`, `discord`, `pagerduty`, `twilio`, `mattermost`, `messagebird`, `custom` | Required `""`  |
 | `services[].alerts[].enabled`            | Whether to enable the alert                                                   | `false`        |
 | `services[].alerts[].failure-threshold`  | Number of failures in a row needed before triggering the alert                | `3`            |
 | `services[].alerts[].success-threshold`  | Number of successes in a row before an ongoing incident is marked as resolved | `2`            |
 | `services[].alerts[].send-on-resolved`   | Whether to send a notification once a triggered alert is marked as resolved   | `false`        |
 | `services[].alerts[].description`        | Description of the alert. Will be included in the alert sent                  | `""`           |
-| `alerting`                               | Configuration for alerting. See [Alerting](#alerting)                         | `{}`           |
+| `alerting`                               | Configuration for alerting. See [Alerting](#alerting).                        | `{}`           |
 | `security`                               | Security configuration                                                        | `{}`           |
 | `security.basic`                         | Basic authentication security configuration                                   | `{}`           |
 | `security.basic.username`                | Username for Basic authentication                                             | Required `""`  |
 | `security.basic.password-sha512`         | Password's SHA512 hash for Basic authentication                               | Required `""`  |
 | `disable-monitoring-lock`                | Whether to [disable the monitoring lock](#disable-monitoring-lock)            | `false`        |
+| `skip-invalid-config-update`             | Whether to ignore invalid configuration update. See [Reloading configuration on the fly](#reloading-configuration-on-the-fly).
 | `web`                                    | Web configuration                                                             | `{}`           |
 | `web.address`                            | Address to listen on                                                          | `0.0.0.0`      |
 | `web.port`                               | Port to listen on                                                             | `8080`         |
@@ -219,12 +243,20 @@ ignored.
 | `alerting.messagebird.access-key`        | Messagebird access key                                                        | Required `""`  |
 | `alerting.messagebird.originator`        | The sender of the message                                                     | Required `""`  |
 | `alerting.messagebird.recipients`        | The recipients of the message                                                 | Required `""`  |
+| `alerting.telegram`                      | Configuration for alerts of type `telegram`                                   | `{}`           |
+| `alerting.telegram.token`                | Telegram Bot Token                                                            | Required `""`  |
+| `alerting.telegram.id`                   | Telegram User ID                                                              | Required `""`  |
 | `alerting.custom`                        | Configuration for custom actions on failure or alerts                         | `{}`           |
 | `alerting.custom.url`                    | Custom alerting request url                                                   | Required `""`  |
 | `alerting.custom.method`                 | Request method                                                                | `GET`          |
 | `alerting.custom.insecure`               | Whether to skip verifying the server's certificate chain and host name        | `false`        |
 | `alerting.custom.body`                   | Custom alerting request body.                                                 | `""`           |
 | `alerting.custom.headers`                | Custom alerting request headers                                               | `{}`           |
+| `alerting.*.default-alert.enabled`            | Whether to enable the alert                                                   | N/A       |
+| `alerting.*.default-alert.failure-threshold`  | Number of failures in a row needed before triggering the alert                | N/A       |
+| `alerting.*.default-alert.success-threshold`  | Number of successes in a row before an ongoing incident is marked as resolved | N/A       |
+| `alerting.*.default-alert.send-on-resolved`   | Whether to send a notification once a triggered alert is marked as resolved   | N/A       |
+| `alerting.*.default-alert.description`        | Description of the alert. Will be included in the alert sent                  | N/A       |
 
 
 #### Configuring Slack alerts
@@ -394,6 +426,32 @@ services:
 ```
 
 
+#### Configuring Telegram alerts
+
+```yaml
+alerting:
+  telegram: 
+    token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"
+    id: "0123456789"
+
+services:
+  - name: twinnation
+    url: "https://twinnation.org/health"
+    interval: 30s
+    alerts:
+      - type: telegram
+        enabled: true
+        send-on-resolved: true
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+```
+
+Here's an example of what the notifications look like:
+
+![Telegram notifications](.github/assets/telegram-alerts.png)
+
+
 #### Configuring custom alerts
 
 While they're called alerts, you can use this feature to call anything. 
@@ -452,6 +510,59 @@ As a result, the `[ALERT_TRIGGERED_OR_RESOLVED]` in the body of first example of
 `partial_outage` when an alert is triggered and `operational` when an alert is resolved.
 
 
+#### Setting a default provider alert
+
+While you can specify the alert configuration directly in the service definition, it's tedious and may lead to a very
+long configuration file.
+
+To avoid such problem, you can use the `default-alert` parameter present in each provider configuration:
+```yaml
+alerting:
+  slack: 
+    webhook-url: "https://hooks.slack.com/services/**********/**********/**********"
+    default-alert:
+      enabled: true
+      description: "healthcheck failed"
+      send-on-resolved: true
+      failure-threshold: 5
+      success-threshold: 5
+```
+
+As a result, your service configuration looks a lot tidier:
+```yaml
+services:
+  - name: example
+    url: "https://example.org"
+    alerts:
+      - type: slack
+    conditions:
+      - "[STATUS] == 200"
+
+  - name: other-example
+    url: "https://example.com"
+    alerts:
+      - type: slack
+    conditions:
+      - "[STATUS] == 200"
+```
+
+It also allows you to do things like this:
+```yaml
+services:
+  - name: twinnation
+    url: "https://twinnation.org/health"
+    alerts:
+      - type: slack
+        failure-threshold: 5
+      - type: slack
+        failure-threshold: 10
+      - type: slack
+        failure-threshold: 15
+    conditions:
+      - "[STATUS] == 200"
+```
+
+
 ### Kubernetes (ALPHA)
 
 > **WARNING**: This feature is in ALPHA. This means that it is very likely to change in the near future, which means that
@@ -530,6 +641,11 @@ If you're on Windows, replace `"$(pwd)"` by the absolute path to your current di
 docker run -p 8080:8080 --mount type=bind,source=C:/Users/Chris/Desktop/config.yaml,target=/config/config.yaml --name gatus twinproduction/gatus
 ```
 
+To build the image locally:
+```
+docker build . -t twinproduction/gatus
+```
+
 
 ## Running the tests
 
@@ -704,6 +820,30 @@ technically, if you create 100 services with a 1 seconds interval, Gatus will se
 - You want to test multiple services at very short interval (< 5s)
 
 
+### Reloading configuration on the fly
+
+For the sake on convenience, Gatus automatically reloads the configuration on the fly if the loaded configuration file
+is updated while Gatus is running.
+
+By default, the application will exit if the updating configuration is invalid, but you can configure
+Gatus to continue running if the configuration file is updated with an invalid configuration by
+setting `skip-invalid-config-update` to `true`.
+
+Keep in mind that it is in your best interest to ensure the validity of the configuration file after each update you
+apply to the configuration file while Gatus is running by looking at the log and making sure that you do not see the
+following message:
+```
+The configuration file was updated, but it is not valid. The old configuration will continue being used.
+```
+Failure to do so may result in Gatus being unable to start if the application is restarted for whatever reason.
+
+I recommend not setting `skip-invalid-config-update` to `true` to avoid a situation like this, but the choice is yours
+to make.
+
+Note that if you are not using a file storage, updating the configuration while Gatus is running is effectively
+the same as restarting the application.
+
+
 ### Service groups
 
 Service groups are used for grouping multiple services together on the dashboard.
@@ -799,3 +939,25 @@ Example: ![Uptime 24h](https://status.twinnation.org/api/v1/badges/uptime/24h/co
 ```
 
 If you'd like to see a visual example of each badges available, you can simply navigate to the service's detail page.
+
+### API
+Gatus provides a simple read-only API which can be queried in order to programmatically determine service status and history.
+
+All services are available via a GET request to the following endpoint:
+```
+/api/v1/statuses
+````
+
+Example: https://status.twinnation.org/api/v1/statuses
+
+Specific services can also be queried by using the following pattern:
+```
+/api/v1/statuses/{group}_{service}
+```
+
+Example: https://status.twinnation.org/api/v1/statuses/core_twinnation-home
+
+Gzip compression will be used if the `Accept-Encoding` HTTP header contains `gzip`.
+
+The API will return a JSON payload with the `Content-Type` response header set to `application/json`. 
+No such header is required to query the API.

alerting/alert/alert.go

@@ -1,21 +1,30 @@
-package core
+package alert
 
 // Alert is the service's alert configuration
 type Alert struct {
-	// Type of alert
-	Type AlertType `yaml:"type"`
+	// Type of alert (required)
+	Type Type `yaml:"type"`
 
 	// Enabled defines whether or not the alert is enabled
-	Enabled bool `yaml:"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.
-	Description string `yaml:"description"`
+	//
+	// 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
-	SendOnResolved bool `yaml:"send-on-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"`
@@ -35,29 +44,26 @@ type Alert struct {
 	Triggered bool
 }
 
-// AlertType is the type of the alert.
-// The value will generally be the name of the alert provider
-type AlertType string
+// GetDescription retrieves the description of the alert
+func (alert Alert) GetDescription() string {
+	if alert.Description == nil {
+		return ""
+	}
+	return *alert.Description
+}
 
-const (
-	// CustomAlert is the AlertType for the custom alerting provider
-	CustomAlert AlertType = "custom"
+// IsEnabled returns whether an alert is enabled or not
+func (alert Alert) IsEnabled() bool {
+	if alert.Enabled == nil {
+		return false
+	}
+	return *alert.Enabled
+}
 
-	// DiscordAlert is the AlertType for the discord alerting provider
-	DiscordAlert AlertType = "discord"
-
-	// 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"
-
-	// SlackAlert is the AlertType for the slack alerting provider
-	SlackAlert AlertType = "slack"
-
-	// TwilioAlert is the AlertType for the twilio alerting provider
-	TwilioAlert AlertType = "twilio"
-)
+// 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,31 @@
+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"
+
+	// 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,12 +1,15 @@
 package alerting
 
 import (
+	"github.com/TwinProduction/gatus/alerting/alert"
+	"github.com/TwinProduction/gatus/alerting/provider"
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/alerting/provider/discord"
 	"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/telegram"
 	"github.com/TwinProduction/gatus/alerting/provider/twilio"
 )
 
@@ -30,6 +33,64 @@ type Config struct {
 	// Slack is the configuration for the slack alerting provider
 	Slack *slack.AlertProvider `yaml:"slack"`
 
+	// 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"`
 }
+
+// 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.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

@@ -9,6 +9,7 @@ import (
 	"os"
 	"strings"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/client"
 	"github.com/TwinProduction/gatus/core"
 )
@@ -22,6 +23,9 @@ type AlertProvider struct {
 	Body         string                       `yaml:"body,omitempty"`
 	Headers      map[string]string            `yaml:"headers,omitempty"`
 	Placeholders map[string]map[string]string `yaml:"placeholders,omitempty"`
+
+	// 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
@@ -30,7 +34,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) *AlertProvider {
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *alert.Alert, result *core.Result, resolved bool) *AlertProvider {
 	return provider
 }
 
@@ -112,3 +116,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

@@ -4,6 +4,7 @@ import (
 	"io/ioutil"
 	"testing"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/core"
 )
 
@@ -60,7 +61,7 @@ func TestAlertProvider_buildHTTPRequestWhenTriggered(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.Fatal("customAlertProvider shouldn't have been nil")
 	}

alerting/provider/discord/discord.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"net/http"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
 )
@@ -11,6 +12,9 @@ import (
 // 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
@@ -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, results string
 	var colorCode int
 	if resolved {
@@ -57,7 +61,12 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
       ]
     }
   ]
-}`, message, alert.Description, colorCode, results),
+}`, message, alert.GetDescription(), 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

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/core"
 )
 
@@ -22,7 +23,7 @@ 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)
+	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")
 	}
@@ -44,7 +45,7 @@ func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 
 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.Fatal("customAlertProvider shouldn't have been nil")
 	}

alerting/provider/mattermost/mattermost.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"net/http"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
 )
@@ -12,6 +13,9 @@ import (
 type AlertProvider struct {
 	WebhookURL string `yaml:"webhook-url"`
 	Insecure   bool   `yaml:"insecure,omitempty"`
+
+	// 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
@@ -20,7 +24,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 string
 	var color string
 	if resolved {
@@ -69,7 +73,12 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
       ]
     }
   ]
-}`, message, message, alert.Description, color, service.URL, results),
+}`, message, message, alert.GetDescription(), 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

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/core"
 )
 
@@ -22,7 +23,7 @@ func TestAlertProvider_IsValid(t *testing.T) {
 
 func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	provider := AlertProvider{WebhookURL: "http://example.org"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	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")
 	}
@@ -44,7 +45,7 @@ func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 
 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
 	provider := AlertProvider{WebhookURL: "http://example.org"}
-	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.Fatal("customAlertProvider shouldn't have been nil")
 	}

alerting/provider/messagebird/messagebird.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"net/http"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
 )
@@ -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,12 +30,12 @@ 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{
@@ -48,3 +52,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

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/core"
 )
 
@@ -30,7 +31,7 @@ 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.Fatal("customAlertProvider shouldn't have been nil")
 	}
@@ -56,7 +57,7 @@ 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.Fatal("customAlertProvider shouldn't have been nil")
 	}

alerting/provider/pagerduty/pagerduty.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"net/http"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
 )
@@ -11,6 +12,9 @@ import (
 // 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"`
 }
 
 // IsValid returns whether the provider's configuration is valid
@@ -21,14 +25,14 @@ func (provider *AlertProvider) IsValid() bool {
 // 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 = ""
 	}
@@ -50,3 +54,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/pagerduty/pagerduty_test.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/core"
 )
 
@@ -22,7 +23,7 @@ func TestAlertProvider_IsValid(t *testing.T) {
 
 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.Fatal("customAlertProvider shouldn't have been nil")
 	}
@@ -44,7 +45,7 @@ func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 
 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.Fatal("customAlertProvider shouldn't have been nil")
 	}

alerting/provider/provider.go

@@ -1,12 +1,14 @@
 package provider
 
 import (
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/alerting/provider/discord"
 	"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/telegram"
 	"github.com/TwinProduction/gatus/alerting/provider/twilio"
 	"github.com/TwinProduction/gatus/core"
 )
@@ -17,7 +19,32 @@ 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 (
@@ -28,5 +55,6 @@ var (
 	_ AlertProvider = (*messagebird.AlertProvider)(nil)
 	_ AlertProvider = (*pagerduty.AlertProvider)(nil)
 	_ AlertProvider = (*slack.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/TwinProduction/gatus/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/alert"
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/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)
@@ -57,7 +61,12 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
       ]
     }
   ]
-}`, message, alert.Description, color, results),
+}`, message, alert.GetDescription(), 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

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/core"
 )
 
@@ -22,7 +23,7 @@ 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)
+	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")
 	}
@@ -44,7 +45,7 @@ func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 
 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.Fatal("customAlertProvider shouldn't have been nil")
 	}

alerting/provider/telegram/telegram.go

@@ -0,0 +1,60 @@
+package telegram
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwinProduction/gatus/alerting/alert"
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/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/TwinProduction/gatus/alerting/alert"
+	"github.com/TwinProduction/gatus/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,6 +6,7 @@ import (
 	"net/http"
 	"net/url"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
 )
@@ -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

@@ -5,6 +5,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/core"
 )
 
@@ -31,7 +32,8 @@ func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 		From:  "3",
 		To:    "4",
 	}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "service-name"}, &core.Alert{Description: "alert-description"}, &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.Fatal("customAlertProvider shouldn't have been nil")
 	}
@@ -56,7 +58,8 @@ func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
 		From:  "2",
 		To:    "1",
 	}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "service-name"}, &core.Alert{Description: "alert-description"}, &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.Fatal("customAlertProvider shouldn't have been nil")
 	}

client/client.go

@@ -4,6 +4,8 @@ import (
 	"crypto/tls"
 	"net"
 	"net/http"
+	"os"
+	"strconv"
 	"time"
 
 	"github.com/go-ping/ping"
@@ -16,14 +18,27 @@ var (
 	// pingTimeout is the timeout for the Ping function
 	// This is mainly exposed for testing purposes
 	pingTimeout = 5 * time.Second
+
+	// httpTimeout is the timeout for secureHTTPClient and insecureHTTPClient
+	httpTimeout = 10 * time.Second
 )
 
+func init() {
+	// XXX: This is an undocumented feature. See https://github.com/TwinProduction/gatus/issues/104.
+	httpTimeoutInSecondsFromEnvironmentVariable := os.Getenv("HTTP_CLIENT_TIMEOUT_IN_SECONDS")
+	if len(httpTimeoutInSecondsFromEnvironmentVariable) > 0 {
+		if httpTimeoutInSeconds, err := strconv.Atoi(httpTimeoutInSecondsFromEnvironmentVariable); err == nil {
+			httpTimeout = time.Duration(httpTimeoutInSeconds) * time.Second
+		}
+	}
+}
+
 // GetHTTPClient returns the shared HTTP client
 func GetHTTPClient(insecure bool) *http.Client {
 	if insecure {
 		if insecureHTTPClient == nil {
 			insecureHTTPClient = &http.Client{
-				Timeout: 10 * time.Second,
+				Timeout: httpTimeout,
 				Transport: &http.Transport{
 					MaxIdleConns:        100,
 					MaxIdleConnsPerHost: 20,
@@ -38,7 +53,7 @@ func GetHTTPClient(insecure bool) *http.Client {
 	}
 	if secureHTTPClient == nil {
 		secureHTTPClient = &http.Client{
-			Timeout: 10 * time.Second,
+			Timeout: httpTimeout,
 			Transport: &http.Transport{
 				MaxIdleConns:        100,
 				MaxIdleConnsPerHost: 20,
@@ -69,7 +84,6 @@ func Ping(address string) (bool, time.Duration) {
 	}
 	pinger.Count = 1
 	pinger.Timeout = pingTimeout
-	pinger.SetNetwork("ip4")
 	pinger.SetPrivileged(true)
 	err = pinger.Run()
 	if err != nil {

config.yaml

@@ -36,3 +36,19 @@ services:
       - "[STATUS] == 200"
       - "[BODY].deleted == false"
       - "len([BODY].text) > 0"
+
+  - 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,8 +5,10 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
+	"time"
 
 	"github.com/TwinProduction/gatus/alerting"
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/alerting/provider"
 	"github.com/TwinProduction/gatus/core"
 	"github.com/TwinProduction/gatus/k8s"
@@ -39,13 +41,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
@@ -56,6 +53,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
@@ -78,47 +79,57 @@ type Config struct {
 
 	// Web is the configuration for the web listener
 	Web *WebConfig `yaml:"web"`
+
+	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 config
+	return false
 }
 
-// Set sets the configuration
-// Used only for testing
-func Set(cfg *Config) {
-	config = cfg
+// 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()
+		}
+	}
 }
 
 // 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) {
@@ -144,23 +155,33 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 	} 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)
-		validateStorageConfig(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 := validateKubernetesConfig(config); err != nil {
+			return nil, err
+		}
+		if err := validateWebConfig(config); err != nil {
+			return nil, err
+		}
+		if err := validateStorageConfig(config); err != nil {
+			return nil, err
+		}
 	}
 	return
 }
 
-func validateStorageConfig(config *Config) {
+func validateStorageConfig(config *Config) error {
 	if config.Storage == nil {
 		config.Storage = &storage.Config{}
 	}
 	err := storage.Initialize(config.Storage)
 	if err != nil {
-		panic(err)
+		return err
 	}
 	// Remove all ServiceStatus that represent services which no longer exist in the configuration
 	var keys []string
@@ -171,44 +192,52 @@ func validateStorageConfig(config *Config) {
 	if numberOfServiceStatusesDeleted > 0 {
 		log.Printf("[config][validateStorageConfig] Deleted %d service statuses because their matching services no longer existed", numberOfServiceStatusesDeleted)
 	}
+	return nil
 }
 
-func validateWebConfig(config *Config) {
+func validateWebConfig(config *Config) error {
 	if config.Web == nil {
 		config.Web = &WebConfig{Address: DefaultAddress, Port: DefaultPort}
 	} else {
-		config.Web.validateAndSetDefaults()
+		return config.Web.validateAndSetDefaults()
 	}
+	return nil
 }
 
-func validateKubernetesConfig(config *Config) {
+// deprecated
+// I don't like the current implementation.
+func validateKubernetesConfig(config *Config) error {
 	if config.Kubernetes != nil && config.Kubernetes.AutoDiscover {
 		if config.Kubernetes.ServiceTemplate == nil {
-			panic("kubernetes.service-template cannot be nil")
+			return errors.New("kubernetes.service-template cannot be nil")
 		}
 		if config.Debug {
 			log.Println("[config][validateKubernetesConfig] Automatically discovering Kubernetes services...")
 		}
 		discoveredServices, err := k8s.DiscoverServices(config.Kubernetes)
 		if err != nil {
-			panic(err)
+			return err
 		}
 		config.Services = append(config.Services, discoveredServices...)
 		log.Printf("[config][validateKubernetesConfig] Discovered %d Kubernetes services", len(discoveredServices))
 	}
+	return nil
 }
 
-func validateServicesConfig(config *Config) {
+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 {
@@ -217,30 +246,49 @@ 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.CustomAlert,
-		core.DiscordAlert,
-		core.MattermostAlert,
-		core.MessagebirdAlert,
-		core.PagerDutyAlert,
-		core.SlackAlert,
-		core.TwilioAlert,
+	alertTypes := []alert.Type{
+		alert.TypeCustom,
+		alert.TypeDiscord,
+		alert.TypeMattermost,
+		alert.TypeMessagebird,
+		alert.TypePagerDuty,
+		alert.TypeSlack,
+		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)
@@ -252,52 +300,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.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
-	case core.DiscordAlert:
-		if config.Alerting.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.Alerting.Discord
-	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.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.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.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
-	}
-	return nil
-}

config/config_test.go

@@ -7,43 +7,29 @@ import (
 	"time"
 
 	"github.com/TwinProduction/gatus/alerting"
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/alerting/provider/discord"
 	"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/telegram"
 	"github.com/TwinProduction/gatus/alerting/provider/twilio"
 	"github.com/TwinProduction/gatus/core"
 	"github.com/TwinProduction/gatus/k8stest"
 	v1 "k8s.io/api/core/v1"
 )
 
-func TestGetBeforeConfigIsLoaded(t *testing.T) {
-	defer func() { recover() }()
-	Get()
-	t.Fatal("Should've panicked because the configuration hasn't been loaded yet")
-}
-
-func TestSet(t *testing.T) {
-	if config != nil {
-		t.Fatal("config should've been nil")
-	}
-	Set(&Config{})
-	if config == nil {
-		t.Fatal("config shouldn't have been nil")
-	}
-}
-
 func TestLoadFileThatDoesNotExist(t *testing.T) {
-	err := Load("file-that-does-not-exist.yaml")
+	_, err := Load("file-that-does-not-exist.yaml")
 	if err == nil {
 		t.Error("Should've returned an error, because the file specified doesn't exist")
 	}
 }
 
 func TestLoadDefaultConfigurationFile(t *testing.T) {
-	err := LoadDefaultConfiguration()
+	_, err := LoadDefaultConfiguration()
 	if err == nil {
 		t.Error("Should've returned an error, because there's no configuration files at the default path nor the default fallback path")
 	}
@@ -235,8 +221,7 @@ services:
 }
 
 func TestParseAndValidateConfigBytesWithInvalidPort(t *testing.T) {
-	defer func() { recover() }()
-	_, _ = parseAndValidateConfigBytes([]byte(`
+	_, err := parseAndValidateConfigBytes([]byte(`
 web:
   port: 65536
   address: 127.0.0.1
@@ -246,7 +231,9 @@ services:
     conditions:
       - "[STATUS] == 200"
 `))
-	t.Fatal("Should've panicked because the configuration specifies an invalid port value")
+	if err == nil {
+		t.Fatal("Should've returned an error because the configuration specifies an invalid port value")
+	}
 }
 
 func TestParseAndValidateConfigBytesWithMetricsAndCustomUserAgentHeader(t *testing.T) {
@@ -350,10 +337,21 @@ alerting:
     webhook-url: "http://example.org"
   pagerduty:
     integration-key: "00000000000000000000000000000000"
+  mattermost:
+    webhook-url: "http://example.com"
   messagebird:
     access-key: "1"
     originator: "31619191918"
     recipients: "31619191919"
+  telegram:
+    token: 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11
+    id: 0123456789
+  twilio:
+    sid: "1234"
+    token: "5678"
+    from: "+1-234-567-8901"
+    to: "+1-234-567-8901"
+
 services:
   - name: twinnation
     url: https://twinnation.org/health
@@ -365,12 +363,196 @@ services:
         failure-threshold: 7
         success-threshold: 5
         description: "Healthcheck failed 7 times in a row"
+      - type: mattermost
+        enabled: true
       - type: messagebird
       - type: discord
         enabled: true
         failure-threshold: 10
+      - type: telegram
+        enabled: true
+      - type: twilio
+        enabled: true
+        failure-threshold: 12
+        success-threshold: 15
     conditions:
       - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	// Alerting providers
+	if config.Alerting == nil {
+		t.Fatal("config.Alerting shouldn't have been nil")
+	}
+	if config.Alerting.Slack == nil || !config.Alerting.Slack.IsValid() {
+		t.Fatal("Slack alerting config should've been valid")
+	}
+	// Services
+	if len(config.Services) != 1 {
+		t.Error("There should've been 1 service")
+	}
+	if config.Services[0].URL != "https://twinnation.org/health" {
+		t.Errorf("URL should have been %s", "https://twinnation.org/health")
+	}
+	if config.Services[0].Interval != 60*time.Second {
+		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
+	}
+	if len(config.Services[0].Alerts) != 7 {
+		t.Fatal("There should've been 7 alerts configured")
+	}
+
+	if config.Services[0].Alerts[0].Type != alert.TypeSlack {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeSlack, config.Services[0].Alerts[0].Type)
+	}
+	if !config.Services[0].Alerts[0].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[0].FailureThreshold != 3 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 3, config.Services[0].Alerts[0].FailureThreshold)
+	}
+	if config.Services[0].Alerts[0].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[0].SuccessThreshold)
+	}
+
+	if config.Services[0].Alerts[1].Type != alert.TypePagerDuty {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypePagerDuty, config.Services[0].Alerts[1].Type)
+	}
+	if config.Services[0].Alerts[1].GetDescription() != "Healthcheck failed 7 times in a row" {
+		t.Errorf("The description of the alert should've been %s, but it was %s", "Healthcheck failed 7 times in a row", config.Services[0].Alerts[1].GetDescription())
+	}
+	if config.Services[0].Alerts[1].FailureThreshold != 7 {
+		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 7, config.Services[0].Alerts[1].FailureThreshold)
+	}
+	if config.Services[0].Alerts[1].SuccessThreshold != 5 {
+		t.Errorf("The success threshold of the alert should've been %d, but it was %d", 5, config.Services[0].Alerts[1].SuccessThreshold)
+	}
+
+	if config.Services[0].Alerts[2].Type != alert.TypeMattermost {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeMattermost, config.Services[0].Alerts[2].Type)
+	}
+	if !config.Services[0].Alerts[2].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[2].FailureThreshold != 3 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 3, config.Services[0].Alerts[2].FailureThreshold)
+	}
+	if config.Services[0].Alerts[2].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[2].SuccessThreshold)
+	}
+
+	if config.Services[0].Alerts[3].Type != alert.TypeMessagebird {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeMessagebird, config.Services[0].Alerts[3].Type)
+	}
+	if config.Services[0].Alerts[3].IsEnabled() {
+		t.Error("The alert should've been disabled")
+	}
+
+	if config.Services[0].Alerts[4].Type != alert.TypeDiscord {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeDiscord, config.Services[0].Alerts[4].Type)
+	}
+	if !config.Services[0].Alerts[4].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[4].FailureThreshold != 10 {
+		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 10, config.Services[0].Alerts[4].FailureThreshold)
+	}
+	if config.Services[0].Alerts[4].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[4].SuccessThreshold)
+	}
+
+	if config.Services[0].Alerts[5].Type != alert.TypeTelegram {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeTelegram, config.Services[0].Alerts[5].Type)
+	}
+	if !config.Services[0].Alerts[5].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[5].FailureThreshold != 3 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 3, config.Services[0].Alerts[5].FailureThreshold)
+	}
+	if config.Services[0].Alerts[5].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[5].SuccessThreshold)
+	}
+
+	if config.Services[0].Alerts[6].Type != alert.TypeTwilio {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeTwilio, config.Services[0].Alerts[6].Type)
+	}
+	if !config.Services[0].Alerts[6].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[6].FailureThreshold != 12 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 12, config.Services[0].Alerts[6].FailureThreshold)
+	}
+	if config.Services[0].Alerts[6].SuccessThreshold != 15 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 15, config.Services[0].Alerts[6].SuccessThreshold)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithAlertingAndDefaultAlert(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+debug: true
+
+alerting:
+  slack:
+    webhook-url: "http://example.com"
+    default-alert:
+      enabled: true
+  discord:
+    webhook-url: "http://example.org"
+    default-alert:
+      enabled: true
+      failure-threshold: 10
+      success-threshold: 1
+  pagerduty:
+    integration-key: "00000000000000000000000000000000"
+    default-alert:
+      enabled: true
+      description: default description
+      failure-threshold: 7
+      success-threshold: 5
+  mattermost:
+    webhook-url: "http://example.com"
+    default-alert:
+      enabled: true
+  messagebird:
+    access-key: "1"
+    originator: "31619191918"
+    recipients: "31619191919"
+    default-alert:
+      enabled: false
+      send-on-resolved: true
+  telegram:
+    token: 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11
+    id: 0123456789
+    default-alert:
+      enabled: true
+  twilio:
+    sid: "1234"
+    token: "5678"
+    from: "+1-234-567-8901"
+    to: "+1-234-567-8901"
+    default-alert:
+      enabled: true
+      failure-threshold: 12
+      success-threshold: 15
+
+services:
+ - name: twinnation
+   url: https://twinnation.org/health
+   alerts:
+     - type: slack
+     - type: pagerduty
+     - type: mattermost
+     - type: messagebird
+     - type: discord
+       success-threshold: 2 # test service alert override
+     - type: telegram
+     - type: twilio
+   conditions:
+     - "[STATUS] == 200"
 `))
 	if err != nil {
 		t.Error("expected no error, got", err.Error())
@@ -388,18 +570,36 @@ services:
 	if config.Alerting.Slack == nil || !config.Alerting.Slack.IsValid() {
 		t.Fatal("Slack alerting config should've been valid")
 	}
+	if config.Alerting.Slack.GetDefaultAlert() == nil {
+		t.Fatal("Slack.GetDefaultAlert() shouldn't have returned nil")
+	}
 	if config.Alerting.Slack.WebhookURL != "http://example.com" {
 		t.Errorf("Slack webhook should've been %s, but was %s", "http://example.com", config.Alerting.Slack.WebhookURL)
 	}
+
 	if config.Alerting.PagerDuty == nil || !config.Alerting.PagerDuty.IsValid() {
 		t.Fatal("PagerDuty alerting config should've been valid")
 	}
-	if config.Alerting.Messagebird == nil || !config.Alerting.Messagebird.IsValid() {
-		t.Fatal("Messagebird alerting config should've been valid")
+	if config.Alerting.PagerDuty.GetDefaultAlert() == nil {
+		t.Fatal("PagerDuty.GetDefaultAlert() shouldn't have returned nil")
 	}
 	if config.Alerting.PagerDuty.IntegrationKey != "00000000000000000000000000000000" {
 		t.Errorf("PagerDuty integration key should've been %s, but was %s", "00000000000000000000000000000000", config.Alerting.PagerDuty.IntegrationKey)
 	}
+
+	if config.Alerting.Mattermost == nil || !config.Alerting.Mattermost.IsValid() {
+		t.Fatal("Mattermost alerting config should've been valid")
+	}
+	if config.Alerting.Mattermost.GetDefaultAlert() == nil {
+		t.Fatal("Mattermost.GetDefaultAlert() shouldn't have returned nil")
+	}
+
+	if config.Alerting.Messagebird == nil || !config.Alerting.Messagebird.IsValid() {
+		t.Fatal("Messagebird alerting config should've been valid")
+	}
+	if config.Alerting.Messagebird.GetDefaultAlert() == nil {
+		t.Fatal("Messagebird.GetDefaultAlert() shouldn't have returned nil")
+	}
 	if config.Alerting.Messagebird.AccessKey != "1" {
 		t.Errorf("Messagebird access key should've been %s, but was %s", "1", config.Alerting.Messagebird.AccessKey)
 	}
@@ -409,15 +609,39 @@ services:
 	if config.Alerting.Messagebird.Recipients != "31619191919" {
 		t.Errorf("Messagebird to recipients should've been %s, but was %s", "31619191919", config.Alerting.Messagebird.Recipients)
 	}
+
 	if config.Alerting.Discord == nil || !config.Alerting.Discord.IsValid() {
 		t.Fatal("Discord alerting config should've been valid")
 	}
+	if config.Alerting.Discord.GetDefaultAlert() == nil {
+		t.Fatal("Discord.GetDefaultAlert() shouldn't have returned nil")
+	}
 	if config.Alerting.Discord.WebhookURL != "http://example.org" {
 		t.Errorf("Discord webhook should've been %s, but was %s", "http://example.org", config.Alerting.Discord.WebhookURL)
 	}
-	if GetAlertingProviderByAlertType(config, core.DiscordAlert) != config.Alerting.Discord {
+	if config.Alerting.GetAlertingProviderByAlertType(alert.TypeDiscord) != config.Alerting.Discord {
 		t.Error("expected discord configuration")
 	}
+
+	if config.Alerting.Telegram == nil || !config.Alerting.Telegram.IsValid() {
+		t.Fatal("Telegram alerting config should've been valid")
+	}
+	if config.Alerting.Telegram.GetDefaultAlert() == nil {
+		t.Fatal("Telegram.GetDefaultAlert() shouldn't have returned nil")
+	}
+	if config.Alerting.Telegram.Token != "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11" {
+		t.Errorf("Telegram token should've been %s, but was %s", "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", config.Alerting.Telegram.Token)
+	}
+	if config.Alerting.Telegram.ID != "0123456789" {
+		t.Errorf("Telegram ID should've been %s, but was %s", "012345689", config.Alerting.Telegram.ID)
+	}
+
+	if config.Alerting.Twilio == nil || !config.Alerting.Twilio.IsValid() {
+		t.Fatal("Twilio alerting config should've been valid")
+	}
+	if config.Alerting.Twilio.GetDefaultAlert() == nil {
+		t.Fatal("Twilio.GetDefaultAlert() shouldn't have returned nil")
+	}
 	// Services
 	if len(config.Services) != 1 {
 		t.Error("There should've been 1 service")
@@ -428,14 +652,14 @@ services:
 	if config.Services[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
 	}
-	if len(config.Services[0].Alerts) != 4 {
-		t.Fatal("There should've been 4 alerts configured")
+	if len(config.Services[0].Alerts) != 7 {
+		t.Fatal("There should've been 7 alerts configured")
 	}
 
-	if config.Services[0].Alerts[0].Type != core.SlackAlert {
-		t.Errorf("The type of the alert should've been %s, but it was %s", core.SlackAlert, config.Services[0].Alerts[0].Type)
+	if config.Services[0].Alerts[0].Type != alert.TypeSlack {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeSlack, config.Services[0].Alerts[0].Type)
 	}
-	if !config.Services[0].Alerts[0].Enabled {
+	if !config.Services[0].Alerts[0].IsEnabled() {
 		t.Error("The alert should've been enabled")
 	}
 	if config.Services[0].Alerts[0].FailureThreshold != 3 {
@@ -445,11 +669,11 @@ services:
 		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[0].SuccessThreshold)
 	}
 
-	if config.Services[0].Alerts[1].Type != core.PagerDutyAlert {
-		t.Errorf("The type of the alert should've been %s, but it was %s", core.PagerDutyAlert, config.Services[0].Alerts[1].Type)
+	if config.Services[0].Alerts[1].Type != alert.TypePagerDuty {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypePagerDuty, config.Services[0].Alerts[1].Type)
 	}
-	if config.Services[0].Alerts[1].Description != "Healthcheck failed 7 times in a row" {
-		t.Errorf("The description of the alert should've been %s, but it was %s", "Healthcheck failed 7 times in a row", config.Services[0].Alerts[1].Description)
+	if config.Services[0].Alerts[1].GetDescription() != "default description" {
+		t.Errorf("The description of the alert should've been %s, but it was %s", "default description", config.Services[0].Alerts[1].GetDescription())
 	}
 	if config.Services[0].Alerts[1].FailureThreshold != 7 {
 		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 7, config.Services[0].Alerts[1].FailureThreshold)
@@ -458,21 +682,145 @@ services:
 		t.Errorf("The success threshold of the alert should've been %d, but it was %d", 5, config.Services[0].Alerts[1].SuccessThreshold)
 	}
 
-	if config.Services[0].Alerts[2].Type != core.MessagebirdAlert {
-		t.Errorf("The type of the alert should've been %s, but it was %s", core.MessagebirdAlert, config.Services[0].Alerts[2].Type)
+	if config.Services[0].Alerts[2].Type != alert.TypeMattermost {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeMattermost, config.Services[0].Alerts[2].Type)
 	}
-	if config.Services[0].Alerts[2].Enabled {
-		t.Error("The alert should've been disabled")
+	if !config.Services[0].Alerts[2].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[2].FailureThreshold != 3 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 3, config.Services[0].Alerts[2].FailureThreshold)
+	}
+	if config.Services[0].Alerts[2].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[2].SuccessThreshold)
 	}
 
-	if config.Services[0].Alerts[3].Type != core.DiscordAlert {
-		t.Errorf("The type of the alert should've been %s, but it was %s", core.DiscordAlert, config.Services[0].Alerts[3].Type)
+	if config.Services[0].Alerts[3].Type != alert.TypeMessagebird {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeMessagebird, config.Services[0].Alerts[3].Type)
 	}
-	if config.Services[0].Alerts[3].FailureThreshold != 10 {
-		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 10, config.Services[0].Alerts[3].FailureThreshold)
+	if config.Services[0].Alerts[3].IsEnabled() {
+		t.Error("The alert should've been disabled")
 	}
-	if config.Services[0].Alerts[3].SuccessThreshold != 2 {
-		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[3].SuccessThreshold)
+	if !config.Services[0].Alerts[3].IsSendingOnResolved() {
+		t.Error("The alert should be sending on resolve")
+	}
+
+	if config.Services[0].Alerts[4].Type != alert.TypeDiscord {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeDiscord, config.Services[0].Alerts[4].Type)
+	}
+	if !config.Services[0].Alerts[4].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[4].FailureThreshold != 10 {
+		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 10, config.Services[0].Alerts[4].FailureThreshold)
+	}
+	if config.Services[0].Alerts[4].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[4].SuccessThreshold)
+	}
+
+	if config.Services[0].Alerts[5].Type != alert.TypeTelegram {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeTelegram, config.Services[0].Alerts[5].Type)
+	}
+	if !config.Services[0].Alerts[5].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[5].FailureThreshold != 3 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 3, config.Services[0].Alerts[5].FailureThreshold)
+	}
+	if config.Services[0].Alerts[5].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[5].SuccessThreshold)
+	}
+
+	if config.Services[0].Alerts[6].Type != alert.TypeTwilio {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeTwilio, config.Services[0].Alerts[6].Type)
+	}
+	if !config.Services[0].Alerts[6].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[6].FailureThreshold != 12 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 12, config.Services[0].Alerts[6].FailureThreshold)
+	}
+	if config.Services[0].Alerts[6].SuccessThreshold != 15 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 15, config.Services[0].Alerts[6].SuccessThreshold)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithAlertingAndDefaultAlertAndMultipleAlertsOfSameTypeWithOverriddenParameters(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+alerting:
+  slack:
+    webhook-url: "http://example.com"
+    default-alert:
+      enabled: true
+      description: "description"
+
+services:
+ - name: twinnation
+   url: https://twinnation.org/health
+   alerts:
+     - type: slack
+       failure-threshold: 10
+     - type: slack
+       failure-threshold: 20
+       description: "wow"
+     - type: slack
+       enabled: false
+       failure-threshold: 30
+   conditions:
+     - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	// Alerting providers
+	if config.Alerting == nil {
+		t.Fatal("config.Alerting shouldn't have been nil")
+	}
+	if config.Alerting.Slack == nil || !config.Alerting.Slack.IsValid() {
+		t.Fatal("Slack alerting config should've been valid")
+	}
+	// Services
+	if len(config.Services) != 1 {
+		t.Error("There should've been 2 services")
+	}
+	if config.Services[0].Alerts[0].Type != alert.TypeSlack {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeSlack, config.Services[0].Alerts[0].Type)
+	}
+	if config.Services[0].Alerts[1].Type != alert.TypeSlack {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeSlack, config.Services[0].Alerts[1].Type)
+	}
+	if config.Services[0].Alerts[2].Type != alert.TypeSlack {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeSlack, config.Services[0].Alerts[2].Type)
+	}
+	if !config.Services[0].Alerts[0].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if !config.Services[0].Alerts[1].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[2].IsEnabled() {
+		t.Error("The alert should've been disabled")
+	}
+	if config.Services[0].Alerts[0].GetDescription() != "description" {
+		t.Errorf("The description of the alert should've been %s, but it was %s", "description", config.Services[0].Alerts[0].GetDescription())
+	}
+	if config.Services[0].Alerts[1].GetDescription() != "wow" {
+		t.Errorf("The description of the alert should've been %s, but it was %s", "description", config.Services[0].Alerts[1].GetDescription())
+	}
+	if config.Services[0].Alerts[2].GetDescription() != "description" {
+		t.Errorf("The description of the alert should've been %s, but it was %s", "description", config.Services[0].Alerts[2].GetDescription())
+	}
+	if config.Services[0].Alerts[0].FailureThreshold != 10 {
+		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 10, config.Services[0].Alerts[0].FailureThreshold)
+	}
+	if config.Services[0].Alerts[1].FailureThreshold != 20 {
+		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 20, config.Services[0].Alerts[1].FailureThreshold)
+	}
+	if config.Services[0].Alerts[2].FailureThreshold != 30 {
+		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 30, config.Services[0].Alerts[2].FailureThreshold)
 	}
 }
 
@@ -681,8 +1029,7 @@ services:
 }
 
 func TestParseAndValidateConfigBytesWithInvalidSecurityConfig(t *testing.T) {
-	defer func() { recover() }()
-	_, _ = parseAndValidateConfigBytes([]byte(`
+	_, err := parseAndValidateConfigBytes([]byte(`
 security:
   basic:
     username: "admin"
@@ -693,13 +1040,15 @@ services:
     conditions:
       - "[STATUS] == 200"
 `))
-	t.Error("Function should've panicked")
+	if err == nil {
+		t.Error("Function should've returned an error")
+	}
 }
 
 func TestParseAndValidateConfigBytesWithValidSecurityConfig(t *testing.T) {
 	const expectedUsername = "admin"
 	const expectedPasswordHash = "6b97ed68d14eb3f1aa959ce5d49c7dc612e1eb1dafd73b1e705847483fd6a6c809f2ceb4e8df6ff9984c6298ff0285cace6614bf8daa9f0070101b6c89899e22"
-	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
+	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`debug: true
 security:
   basic:
     username: "%s"
@@ -814,8 +1163,7 @@ kubernetes:
 }
 
 func TestParseAndValidateConfigBytesWithKubernetesAutoDiscoveryButNoServiceTemplate(t *testing.T) {
-	defer func() { recover() }()
-	_, _ = parseAndValidateConfigBytes([]byte(`
+	_, err := parseAndValidateConfigBytes([]byte(`
 kubernetes:
   cluster-mode: "mock"
   auto-discover: true
@@ -824,12 +1172,13 @@ kubernetes:
       hostname-suffix: ".default.svc.cluster.local"
       target-path: "/health"
 `))
-	t.Error("Function should've panicked because providing a service-template is mandatory")
+	if err == nil {
+		t.Error("Function should've returned an error because providing a service-template is mandatory")
+	}
 }
 
 func TestParseAndValidateConfigBytesWithKubernetesAutoDiscoveryUsingClusterModeIn(t *testing.T) {
-	defer func() { recover() }()
-	_, _ = parseAndValidateConfigBytes([]byte(`
+	_, err := parseAndValidateConfigBytes([]byte(`
 kubernetes:
   cluster-mode: "in"
   auto-discover: true
@@ -842,41 +1191,44 @@ kubernetes:
       hostname-suffix: ".default.svc.cluster.local"
       target-path: "/health"
 `))
-	// TODO: find a way to test this?
-	t.Error("Function should've panicked because testing with ClusterModeIn isn't supported")
+	if err == nil {
+		t.Error("Function should've returned an error because testing with ClusterModeIn isn't supported")
+	}
 }
 
 func TestGetAlertingProviderByAlertType(t *testing.T) {
-	cfg := &Config{
-		Alerting: &alerting.Config{
-			Custom:      &custom.AlertProvider{},
-			Discord:     &discord.AlertProvider{},
-			Mattermost:  &mattermost.AlertProvider{},
-			Messagebird: &messagebird.AlertProvider{},
-			PagerDuty:   &pagerduty.AlertProvider{},
-			Slack:       &slack.AlertProvider{},
-			Twilio:      &twilio.AlertProvider{},
-		},
+	alertingConfig := &alerting.Config{
+		Custom:      &custom.AlertProvider{},
+		Discord:     &discord.AlertProvider{},
+		Mattermost:  &mattermost.AlertProvider{},
+		Messagebird: &messagebird.AlertProvider{},
+		PagerDuty:   &pagerduty.AlertProvider{},
+		Slack:       &slack.AlertProvider{},
+		Telegram:    &telegram.AlertProvider{},
+		Twilio:      &twilio.AlertProvider{},
 	}
-	if GetAlertingProviderByAlertType(cfg, core.CustomAlert) != cfg.Alerting.Custom {
+	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeCustom) != alertingConfig.Custom {
 		t.Error("expected Custom configuration")
 	}
-	if GetAlertingProviderByAlertType(cfg, core.DiscordAlert) != cfg.Alerting.Discord {
+	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeDiscord) != alertingConfig.Discord {
 		t.Error("expected Discord configuration")
 	}
-	if GetAlertingProviderByAlertType(cfg, core.MattermostAlert) != cfg.Alerting.Mattermost {
+	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeMattermost) != alertingConfig.Mattermost {
 		t.Error("expected Mattermost configuration")
 	}
-	if GetAlertingProviderByAlertType(cfg, core.MessagebirdAlert) != cfg.Alerting.Messagebird {
+	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeMessagebird) != alertingConfig.Messagebird {
 		t.Error("expected Messagebird configuration")
 	}
-	if GetAlertingProviderByAlertType(cfg, core.PagerDutyAlert) != cfg.Alerting.PagerDuty {
+	if alertingConfig.GetAlertingProviderByAlertType(alert.TypePagerDuty) != alertingConfig.PagerDuty {
 		t.Error("expected PagerDuty configuration")
 	}
-	if GetAlertingProviderByAlertType(cfg, core.SlackAlert) != cfg.Alerting.Slack {
+	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeSlack) != alertingConfig.Slack {
 		t.Error("expected Slack configuration")
 	}
-	if GetAlertingProviderByAlertType(cfg, core.TwilioAlert) != cfg.Alerting.Twilio {
+	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeTelegram) != alertingConfig.Telegram {
+		t.Error("expected Telegram configuration")
+	}
+	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeTwilio) != alertingConfig.Twilio {
 		t.Error("expected Twilio configuration")
 	}
 }

config/web.go

@@ -16,7 +16,7 @@ type WebConfig struct {
 }
 
 // validateAndSetDefaults checks and sets the default values for fields that are not set
-func (web *WebConfig) validateAndSetDefaults() {
+func (web *WebConfig) validateAndSetDefaults() error {
 	// Validate the Address
 	if len(web.Address) == 0 {
 		web.Address = DefaultAddress
@@ -25,8 +25,9 @@ func (web *WebConfig) validateAndSetDefaults() {
 	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))
+		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

controller/controller.go

@@ -44,20 +44,19 @@ func init() {
 }
 
 // Handle creates the router and starts the server
-func Handle() {
-	cfg := config.Get()
-	var router http.Handler = CreateRouter(cfg)
+func Handle(securityConfig *security.Config, webConfig *config.WebConfig, enableMetrics bool) {
+	var router http.Handler = CreateRouter(securityConfig, enableMetrics)
 	if os.Getenv("ENVIRONMENT") == "dev" {
 		router = developmentCorsHandler(router)
 	}
 	server = &http.Server{
-		Addr:         fmt.Sprintf("%s:%d", cfg.Web.Address, cfg.Web.Port),
+		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 " + cfg.Web.SocketAddress())
+	log.Println("[controller][Handle] Listening on " + webConfig.SocketAddress())
 	if os.Getenv("ROUTER_TEST") == "true" {
 		return
 	}
@@ -73,15 +72,15 @@ func Shutdown() {
 }
 
 // CreateRouter creates the router for the http server
-func CreateRouter(cfg *config.Config) *mux.Router {
+func CreateRouter(securityConfig *security.Config, enabledMetrics bool) *mux.Router {
 	router := mux.NewRouter()
-	if cfg.Metrics {
+	if enabledMetrics {
 		router.Handle("/metrics", promhttp.Handler()).Methods("GET")
 	}
 	router.Handle("/health", health.Handler().WithJSON(true)).Methods("GET")
 	router.HandleFunc("/favicon.ico", favIconHandler).Methods("GET")
-	router.HandleFunc("/api/v1/statuses", secureIfNecessary(cfg, serviceStatusesHandler)).Methods("GET") // No GzipHandler for this one, because we cache the content
-	router.HandleFunc("/api/v1/statuses/{key}", secureIfNecessary(cfg, GzipHandlerFunc(serviceStatusHandler))).Methods("GET")
+	router.HandleFunc("/api/v1/statuses", secureIfNecessary(securityConfig, serviceStatusesHandler)).Methods("GET") // No GzipHandler for this one, because we cache the content
+	router.HandleFunc("/api/v1/statuses/{key}", secureIfNecessary(securityConfig, GzipHandlerFunc(serviceStatusHandler))).Methods("GET")
 	router.HandleFunc("/api/v1/badges/uptime/{duration}/{identifier}", badgeHandler).Methods("GET")
 	// SPA
 	router.HandleFunc("/services/{service}", spaHandler).Methods("GET")
@@ -90,9 +89,9 @@ func CreateRouter(cfg *config.Config) *mux.Router {
 	return router
 }
 
-func secureIfNecessary(cfg *config.Config, handler http.HandlerFunc) http.HandlerFunc {
-	if cfg.Security != nil && cfg.Security.IsValid() {
-		return security.Handler(handler, cfg.Security)
+func secureIfNecessary(securityConfig *security.Config, handler http.HandlerFunc) http.HandlerFunc {
+	if securityConfig != nil && securityConfig.IsValid() {
+		return security.Handler(handler, securityConfig)
 	}
 	return handler
 }

controller/controller_test.go

@@ -105,7 +105,7 @@ func TestCreateRouter(t *testing.T) {
 	}
 	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(cfg)
+	router := CreateRouter(cfg.Security, cfg.Metrics)
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -235,12 +235,10 @@ func TestHandle(t *testing.T) {
 			},
 		},
 	}
-	config.Set(cfg)
-	defer config.Set(nil)
 	_ = os.Setenv("ROUTER_TEST", "true")
 	_ = os.Setenv("ENVIRONMENT", "dev")
 	defer os.Clearenv()
-	Handle()
+	Handle(cfg.Security, cfg.Web, cfg.Metrics)
 	defer Shutdown()
 	request, _ := http.NewRequest("GET", "/health", nil)
 	responseRecorder := httptest.NewRecorder()
@@ -273,7 +271,7 @@ func TestServiceStatusesHandler(t *testing.T) {
 	// Can't be bothered dealing with timezone issues on the worker that runs the automated tests
 	firstResult.Timestamp = time.Time{}
 	secondResult.Timestamp = time.Time{}
-	router := CreateRouter(&config.Config{})
+	router := CreateRouter(nil, false)
 
 	type Scenario struct {
 		Name         string

core/condition.go

@@ -71,12 +71,20 @@ const (
 
 	// 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
+// TODO: Add a mandatory space between each operators (e.g. " == " instead of "==") (BREAKING CHANGE)
 func (c Condition) evaluate(result *Result) bool {
 	condition := string(c)
 	success := false
@@ -224,7 +232,7 @@ func sanitizeAndResolve(elements []string, result *Result) ([]string, []string)
 					checkingForExistence = true
 					element = strings.TrimSuffix(strings.TrimPrefix(element, HasFunctionPrefix), FunctionSuffix)
 				}
-				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.TrimPrefix(element, BodyPlaceholder+"."), result.body)
+				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.TrimPrefix(strings.TrimPrefix(element, BodyPlaceholder), "."), result.body)
 				if checkingForExistence {
 					if err != nil {
 						element = "false"
@@ -282,6 +290,13 @@ func prettify(parameters []string, resolvedParameters []string, operator string)
 	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]

core/condition_test.go

@@ -183,6 +183,13 @@ func TestCondition_evaluate(t *testing.T) {
 			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"),
@@ -274,6 +281,20 @@ func TestCondition_evaluate(t *testing.T) {
 			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.*)"),

core/dns.go

@@ -29,16 +29,17 @@ type DNS struct {
 	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) {

core/dns_test.go

@@ -109,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) {
@@ -119,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/service.go

@@ -11,6 +11,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/client"
 )
 
@@ -72,7 +73,7 @@ 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"`
@@ -85,7 +86,7 @@ type Service struct {
 }
 
 // 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.Interval == 0 {
 		service.Interval = 1 * time.Minute
@@ -105,32 +106,32 @@ func (service *Service) ValidateAndSetDefaults() {
 	if _, contentTypeHeaderExists := service.Headers[ContentTypeHeader]; !contentTypeHeaderExists && service.GraphQL {
 		service.Headers[ContentTypeHeader] = "application/json"
 	}
-	for _, alert := range service.Alerts {
-		if alert.FailureThreshold <= 0 {
-			alert.FailureThreshold = 3
+	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
 }
 
 // EvaluateHealth sends a request to the service's URL and evaluates the conditions of the service.
@@ -155,13 +156,13 @@ func (service *Service) EvaluateHealth() *Result {
 }
 
 // GetAlertsTriggered returns a slice of alerts that have been triggered
-func (service *Service) GetAlertsTriggered() []Alert {
-	var alerts []Alert
+func (service *Service) GetAlertsTriggered() []alert.Alert {
+	var alerts []alert.Alert
 	if service.NumberOfFailuresInARow == 0 {
 		return alerts
 	}
 	for _, alert := range service.Alerts {
-		if alert.Enabled && alert.FailureThreshold == service.NumberOfFailuresInARow {
+		if alert.IsEnabled() && alert.FailureThreshold == service.NumberOfFailuresInARow {
 			alerts = append(alerts, *alert)
 			continue
 		}

core/service_test.go

@@ -5,6 +5,8 @@ import (
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/TwinProduction/gatus/alerting/alert"
 )
 
 func TestService_ValidateAndSetDefaults(t *testing.T) {
@@ -13,7 +15,7 @@ func TestService_ValidateAndSetDefaults(t *testing.T) {
 		Name:       "twinnation-health",
 		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition},
-		Alerts:     []*Alert{{Type: PagerDutyAlert}},
+		Alerts:     []*alert.Alert{{Type: alert.TypePagerDuty}},
 	}
 	service.ValidateAndSetDefaults()
 	if service.Method != "GET" {
@@ -28,7 +30,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 {
@@ -47,8 +49,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) {
@@ -59,8 +63,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) {
@@ -70,8 +76,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) {
@@ -85,7 +93,10 @@ 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")
 	}
@@ -93,11 +104,12 @@ func TestService_ValidateAndSetDefaultsWithDNS(t *testing.T) {
 
 func TestService_GetAlertsTriggered(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
+	enabled := true
 	service := Service{
 		Name:       "twinnation-health",
 		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition},
-		Alerts:     []*Alert{{Type: PagerDutyAlert, Enabled: true}},
+		Alerts:     []*alert.Alert{{Type: alert.TypePagerDuty, Enabled: &enabled}},
 	}
 	service.ValidateAndSetDefaults()
 	if service.NumberOfFailuresInARow != 0 {

core/uptime.go

@@ -1,6 +1,7 @@
 package core
 
 import (
+	"log"
 	"time"
 )
 
@@ -10,55 +11,70 @@ const (
 )
 
 // 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 {
-	// LastSevenDays is the uptime percentage over the past 7 days
-	LastSevenDays float64 `json:"7d"`
-
-	// LastTwentyFourHours is the uptime percentage over the past 24 hours
-	LastTwentyFourHours float64 `json:"24h"`
-
-	// LastHour is the uptime percentage over the past hour
-	LastHour float64 `json:"1h"`
+	LastSevenDays       float64 `json:"7d"`  // Uptime percentage over the past 7 days
+	LastTwentyFourHours float64 `json:"24h"` // Uptime percentage over the past 24 hours
+	LastHour            float64 `json:"1h"`  // Uptime percentage over the past hour
 
 	// SuccessfulExecutionsPerHour is a map containing the number of successes (value)
 	// for every hourly unix timestamps (key)
+	// Deprecated
 	SuccessfulExecutionsPerHour map[int64]uint64 `json:"-"`
 
 	// TotalExecutionsPerHour is a map containing the total number of checks (value)
 	// for every hourly unix timestamps (key)
+	// Deprecated
 	TotalExecutionsPerHour map[int64]uint64 `json:"-"`
+
+	// HourlyStatistics is a map containing metrics collected (value) for every hourly unix timestamps (key)
+	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
 }
 
 // NewUptime creates a new Uptime
 func NewUptime() *Uptime {
 	return &Uptime{
-		SuccessfulExecutionsPerHour: make(map[int64]uint64),
-		TotalExecutionsPerHour:      make(map[int64]uint64),
+		HourlyStatistics: make(map[int64]*HourlyUptimeStatistics),
 	}
 }
 
 // ProcessResult processes the result by extracting the relevant from the result and recalculating the uptime
 // if necessary
 func (uptime *Uptime) ProcessResult(result *Result) {
-	if uptime.SuccessfulExecutionsPerHour == nil || uptime.TotalExecutionsPerHour == nil {
-		uptime.SuccessfulExecutionsPerHour = make(map[int64]uint64)
-		uptime.TotalExecutionsPerHour = make(map[int64]uint64)
+	// XXX: Remove this on v3.0.0
+	if len(uptime.SuccessfulExecutionsPerHour) != 0 || len(uptime.TotalExecutionsPerHour) != 0 {
+		uptime.migrateToHourlyStatistics()
+	}
+	if uptime.HourlyStatistics == nil {
+		uptime.HourlyStatistics = make(map[int64]*HourlyUptimeStatistics)
 	}
 	unixTimestampFlooredAtHour := result.Timestamp.Unix() - (result.Timestamp.Unix() % 3600)
-	if result.Success {
-		uptime.SuccessfulExecutionsPerHour[unixTimestampFlooredAtHour]++
+	hourlyStats, _ := uptime.HourlyStatistics[unixTimestampFlooredAtHour]
+	if hourlyStats == nil {
+		hourlyStats = &HourlyUptimeStatistics{}
+		uptime.HourlyStatistics[unixTimestampFlooredAtHour] = hourlyStats
 	}
-	uptime.TotalExecutionsPerHour[unixTimestampFlooredAtHour]++
+	if result.Success {
+		hourlyStats.SuccessfulExecutions++
+	}
+	hourlyStats.TotalExecutions++
+	hourlyStats.TotalExecutionsResponseTime += uint64(result.Duration.Milliseconds())
 	// Clean up only when we're starting to have too many useless keys
 	// Note that this is only triggered when there are more entries than there should be after
 	// 10 days, despite the fact that we are deleting everything that's older than 7 days.
 	// This is to prevent re-iterating on every `ProcessResult` as soon as the uptime has been logged for 7 days.
-	if len(uptime.TotalExecutionsPerHour) > numberOfHoursInTenDays {
+	if len(uptime.HourlyStatistics) > numberOfHoursInTenDays {
 		sevenDaysAgo := time.Now().Add(-(sevenDays + time.Hour)).Unix()
-		for hourlyUnixTimestamp := range uptime.TotalExecutionsPerHour {
+		for hourlyUnixTimestamp := range uptime.HourlyStatistics {
 			if sevenDaysAgo > hourlyUnixTimestamp {
-				delete(uptime.TotalExecutionsPerHour, hourlyUnixTimestamp)
-				delete(uptime.SuccessfulExecutionsPerHour, hourlyUnixTimestamp)
+				delete(uptime.HourlyStatistics, hourlyUnixTimestamp)
 			}
 		}
 	}
@@ -86,17 +102,20 @@ func (uptime *Uptime) recalculate() {
 	timestamp := now.Add(-sevenDays)
 	for now.Sub(timestamp) >= 0 {
 		hourlyUnixTimestamp := timestamp.Unix() - (timestamp.Unix() % 3600)
-		successCountForTimestamp := uptime.SuccessfulExecutionsPerHour[hourlyUnixTimestamp]
-		totalCountForTimestamp := uptime.TotalExecutionsPerHour[hourlyUnixTimestamp]
-		uptimeBrackets["7d_success"] += successCountForTimestamp
-		uptimeBrackets["7d_total"] += totalCountForTimestamp
+		hourlyStats := uptime.HourlyStatistics[hourlyUnixTimestamp]
+		if hourlyStats == nil || hourlyStats.TotalExecutions == 0 {
+			timestamp = timestamp.Add(time.Hour)
+			continue
+		}
+		uptimeBrackets["7d_success"] += hourlyStats.SuccessfulExecutions
+		uptimeBrackets["7d_total"] += hourlyStats.TotalExecutions
 		if now.Sub(timestamp) <= 24*time.Hour {
-			uptimeBrackets["24h_success"] += successCountForTimestamp
-			uptimeBrackets["24h_total"] += totalCountForTimestamp
+			uptimeBrackets["24h_success"] += hourlyStats.SuccessfulExecutions
+			uptimeBrackets["24h_total"] += hourlyStats.TotalExecutions
 		}
 		if now.Sub(timestamp) <= time.Hour {
-			uptimeBrackets["1h_success"] += successCountForTimestamp
-			uptimeBrackets["1h_total"] += totalCountForTimestamp
+			uptimeBrackets["1h_success"] += hourlyStats.SuccessfulExecutions
+			uptimeBrackets["1h_total"] += hourlyStats.TotalExecutions
 		}
 		timestamp = timestamp.Add(time.Hour)
 	}
@@ -110,3 +129,24 @@ func (uptime *Uptime) recalculate() {
 		uptime.LastHour = float64(uptimeBrackets["1h_success"]) / float64(uptimeBrackets["1h_total"])
 	}
 }
+
+// XXX: Remove this on v3.0.0
+// Deprecated
+func (uptime *Uptime) migrateToHourlyStatistics() {
+	log.Println("[migrateToHourlyStatistics] Got", len(uptime.SuccessfulExecutionsPerHour), "entries for successful executions and", len(uptime.TotalExecutionsPerHour), "entries for total executions")
+	uptime.HourlyStatistics = make(map[int64]*HourlyUptimeStatistics)
+	for hourlyUnixTimestamp, totalExecutions := range uptime.TotalExecutionsPerHour {
+		if totalExecutions == 0 {
+			log.Println("[migrateToHourlyStatistics] Skipping entry at", hourlyUnixTimestamp, "because total number of executions is 0")
+			continue
+		}
+		uptime.HourlyStatistics[hourlyUnixTimestamp] = &HourlyUptimeStatistics{
+			TotalExecutions:             totalExecutions,
+			SuccessfulExecutions:        uptime.SuccessfulExecutionsPerHour[hourlyUnixTimestamp],
+			TotalExecutionsResponseTime: 0,
+		}
+	}
+	log.Println("[migrateToHourlyStatistics] Migrated", len(uptime.HourlyStatistics), "entries")
+	uptime.SuccessfulExecutionsPerHour = nil
+	uptime.TotalExecutionsPerHour = nil
+}

core/uptime_bench_test.go

@@ -0,0 +1,24 @@
+package core
+
+import (
+	"testing"
+	"time"
+)
+
+func BenchmarkUptime_ProcessResult(b *testing.B) {
+	uptime := NewUptime()
+	now := time.Now()
+	now = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), 0, 0, 0, now.Location())
+	// Start 12000 days ago
+	timestamp := now.Add(-12000 * 24 * time.Hour)
+	for n := 0; n < b.N; n++ {
+		uptime.ProcessResult(&Result{
+			Duration:  18 * time.Millisecond,
+			Success:   n%15 == 0,
+			Timestamp: timestamp,
+		})
+		// Simulate service with an interval of 3 minutes
+		timestamp = timestamp.Add(3 * time.Minute)
+	}
+	b.ReportAllocs()
+}

core/uptime_test.go

@@ -12,33 +12,39 @@ func TestUptime_ProcessResult(t *testing.T) {
 
 	checkUptimes(t, serviceStatus, 0.00, 0.00, 0.00)
 
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-7 * 24 * time.Hour), Success: true})
+	now := time.Now()
+	now = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), 0, 0, 0, now.Location())
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-7 * 24 * time.Hour), Success: true})
 	checkUptimes(t, serviceStatus, 1.00, 0.00, 0.00)
 
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-6 * 24 * time.Hour), Success: false})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-6 * 24 * time.Hour), Success: false})
 	checkUptimes(t, serviceStatus, 0.50, 0.00, 0.00)
 
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-8 * 24 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-8 * 24 * time.Hour), Success: true})
 	checkUptimes(t, serviceStatus, 0.50, 0.00, 0.00)
 
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-24 * time.Hour), Success: true})
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-12 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-24 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-12 * time.Hour), Success: true})
 	checkUptimes(t, serviceStatus, 0.75, 1.00, 0.00)
 
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-1 * time.Hour), Success: true})
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-30 * time.Minute), Success: false})
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-15 * time.Minute), Success: false})
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-10 * time.Minute), Success: false})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-1 * time.Hour), Success: true, Duration: 10 * time.Millisecond})
+	checkHourlyStatistics(t, uptime.HourlyStatistics[now.Unix()-now.Unix()%3600-3600], 10, 1, 1)
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-30 * time.Minute), Success: false, Duration: 500 * time.Millisecond})
+	checkHourlyStatistics(t, uptime.HourlyStatistics[now.Unix()-now.Unix()%3600-3600], 510, 2, 1)
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-15 * time.Minute), Success: false, Duration: 25 * time.Millisecond})
+	checkHourlyStatistics(t, uptime.HourlyStatistics[now.Unix()-now.Unix()%3600-3600], 535, 3, 1)
+
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-10 * time.Minute), Success: false})
 	checkUptimes(t, serviceStatus, 0.50, 0.50, 0.25)
 
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-120 * time.Hour), Success: true})
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-119 * time.Hour), Success: true})
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-118 * time.Hour), Success: true})
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-117 * time.Hour), Success: true})
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-10 * time.Hour), Success: true})
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-8 * time.Hour), Success: true})
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-30 * time.Minute), Success: true})
-	uptime.ProcessResult(&Result{Timestamp: time.Now().Add(-25 * time.Minute), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-120 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-119 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-118 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-117 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-10 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-8 * time.Hour), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-30 * time.Minute), Success: true})
+	uptime.ProcessResult(&Result{Timestamp: now.Add(-25 * time.Minute), Success: true})
 	checkUptimes(t, serviceStatus, 0.75, 0.70, 0.50)
 }
 
@@ -51,8 +57,8 @@ func TestServiceStatus_AddResultUptimeIsCleaningUpAfterItself(t *testing.T) {
 	timestamp := now.Add(-12 * 24 * time.Hour)
 	for timestamp.Unix() <= now.Unix() {
 		serviceStatus.AddResult(&Result{Timestamp: timestamp, Success: true})
-		if len(serviceStatus.Uptime.SuccessfulExecutionsPerHour) > numberOfHoursInTenDays {
-			t.Errorf("At no point in time should there be more than %d entries in serviceStatus.SuccessfulExecutionsPerHour, but there are %d", numberOfHoursInTenDays, len(serviceStatus.Uptime.SuccessfulExecutionsPerHour))
+		if len(serviceStatus.Uptime.HourlyStatistics) > numberOfHoursInTenDays {
+			t.Errorf("At no point in time should there be more than %d entries in serviceStatus.SuccessfulExecutionsPerHour, but there are %d", numberOfHoursInTenDays, len(serviceStatus.Uptime.HourlyStatistics))
 		}
 		if now.Sub(timestamp) > time.Hour && serviceStatus.Uptime.LastHour != 0 {
 			t.Error("most recent timestamp > 1h ago, expected serviceStatus.Uptime.LastHour to be 0, got", serviceStatus.Uptime.LastHour)
@@ -60,7 +66,7 @@ func TestServiceStatus_AddResultUptimeIsCleaningUpAfterItself(t *testing.T) {
 		if now.Sub(timestamp) < time.Hour && serviceStatus.Uptime.LastHour == 0 {
 			t.Error("most recent timestamp < 1h ago, expected serviceStatus.Uptime.LastHour to NOT be 0, got", serviceStatus.Uptime.LastHour)
 		}
-		// Simulate service with an interval of 1 minute
+		// Simulate service with an interval of 3 minutes
 		timestamp = timestamp.Add(3 * time.Minute)
 	}
 }
@@ -76,3 +82,15 @@ func checkUptimes(t *testing.T, status *ServiceStatus, expectedUptimeDuringLastS
 		t.Errorf("expected status.Uptime.LastHour to be %f, got %f", expectedUptimeDuringLastHour, status.Uptime.LastHour)
 	}
 }
+
+func checkHourlyStatistics(t *testing.T, hourlyUptimeStatistics *HourlyUptimeStatistics, expectedTotalExecutionsResponseTime uint64, expectedTotalExecutions uint64, expectedSuccessfulExecutions uint64) {
+	if hourlyUptimeStatistics.TotalExecutionsResponseTime != expectedTotalExecutionsResponseTime {
+		t.Error("TotalExecutionsResponseTime should've been", expectedTotalExecutionsResponseTime, "got", hourlyUptimeStatistics.TotalExecutionsResponseTime)
+	}
+	if hourlyUptimeStatistics.TotalExecutions != expectedTotalExecutions {
+		t.Error("TotalExecutions should've been", expectedTotalExecutions, "got", hourlyUptimeStatistics.TotalExecutions)
+	}
+	if hourlyUptimeStatistics.SuccessfulExecutions != expectedSuccessfulExecutions {
+		t.Error("SuccessfulExecutions should've been", expectedSuccessfulExecutions, "got", hourlyUptimeStatistics.SuccessfulExecutions)
+	}
+}

go.mod

@@ -1,6 +1,6 @@
 module github.com/TwinProduction/gatus
 
-go 1.15
+go 1.16
 
 require (
 	cloud.google.com/go v0.74.0 // indirect

go.sum

@@ -1,5 +1,4 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0 h1:eOI3/cP2VTU6uZLDYAoic+eyzzB9YyGmJ7eIjl8rOPg=
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
 cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
@@ -142,7 +141,6 @@ github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/me
 github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/gogo/protobuf v1.2.1 h1:/s5zKNz0uPFCZ5hddgPdo2TK2TVrUNMn0OOX8/aZMTE=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls=
 github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
@@ -161,7 +159,6 @@ github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71
 github.com/golang/protobuf v0.0.0-20161109072736-4bd1920723d7/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
 github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
@@ -172,7 +169,6 @@ github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrU
 github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
 github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
 github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
@@ -184,13 +180,11 @@ github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0 h1:/QaMHBdZ26BB3SSst0Iwl10Epc+xhTquomWX0oZEB6w=
 github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.4 h1:L8R9j+yAqZuZjsqh/z+F1NCffTKKLShY6zXTItVIZ8M=
 github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/gofuzz v1.0.0 h1:A8PeW59pxE9IoFRqBp37U+mSNaQoZ46F1f0f863XSXw=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
@@ -220,7 +214,6 @@ github.com/gophercloud/gophercloud v0.1.0/go.mod h1:vxM41WHh5uqHVBMZHzuwNOHh8XEo
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
 github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
-github.com/gorilla/mux v1.7.3 h1:gnP5JzjVOuiZD07fKKToCAOjS0yOpj/qPETTXCCS6hw=
 github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
 github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
 github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
@@ -362,21 +355,18 @@ github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXP
 github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
 github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og=
-github.com/prometheus/client_golang v1.7.1 h1:NTGy1Ja9pByO+xAeH/qiWnLrKtr3hJPNjaVUwnjpdpA=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
 github.com/prometheus/client_golang v1.9.0 h1:Rrch9mh17XcxvEu9D9DEpb4isxjGBtcevQjKvxPRQIU=
 github.com/prometheus/client_golang v1.9.0/go.mod h1:FqZLKOZnGdFAhOK4nqGHa7D66IdsO+O441Eve7ptJDU=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4 h1:gQz4mCbXsO+nc9n1hCxHcGA3Zx3Eo+UHZoInFGUIXNM=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
 github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/common v0.7.0 h1:L+1lyG48J1zAQXA3RBX/nG/B3gjlHq0zTt2tlbJLyCY=
 github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
 github.com/prometheus/common v0.15.0 h1:4fgOnadei3EZvgRwxJ7RMpG1k1pOZth5Pc13tyspaKM=
@@ -385,7 +375,6 @@ github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R
 github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
-github.com/prometheus/procfs v0.1.3 h1:F0+tqvhOksq22sc6iCHF5WGlWjdwj92p0udFh1VFBS8=
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.2.0 h1:wH4vA7pcjKuZzjF7lM8awk4fnuJO6idemZXoKnULUx4=
 github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
@@ -407,7 +396,6 @@ github.com/sony/gobreaker v0.4.1/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJ
 github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
 github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
 github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.1 h1:aCvUg6QPl3ibpQUxyLkrEkCHtPqYJL4x9AuhqVqFis4=
 github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
@@ -418,7 +406,6 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
@@ -459,7 +446,6 @@ golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad h1:DN0cp81fZ3njFcrLCytUHRSUkqBjfTo4Tx9RJTWs0EY=
 golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
@@ -481,7 +467,6 @@ golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTk
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
 golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
@@ -531,7 +516,6 @@ golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/
 golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344 h1:vGXIOMxbNfDTk/aXCmfdLgkrSV+Z2tcbze+pEc3v5W4=
 golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
@@ -542,7 +526,6 @@ golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20201224014010-6772e930b67b h1:iFwSg7t5GZmB/Q5TjiEAsdoLDrdJRC1RiF2WhuV29Qw=
 golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421 h1:Wo7BWFiOk0QRFMLYMqJGFMd9CgUAcGx7V+qEg/h5IBI=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -556,7 +539,6 @@ golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -610,7 +592,6 @@ golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f h1:+Nyd8tzPX9R7BWHguqsrbFdRx3WQ/1ib8I44HXV5yTA=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -618,7 +599,6 @@ golang.org/x/sys v0.0.0-20201214210602-f9fddec55a1e/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20201223074533-0d417f636930 h1:vRgIt+nup/B/BwIS0g2oC0haq0iqbV3ZA+u6+0TlNCo=
 golang.org/x/sys v0.0.0-20201223074533-0d417f636930/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf h1:MZ2shdL+ZM/XzY3ZGOnh4Nlpnxz5GSOhOmtHo3iPU6M=
 golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
@@ -626,7 +606,6 @@ golang.org/x/text v0.0.0-20160726164857-2910a502d2bf/go.mod h1:NqM8EUOU14njkJ3fq
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.4 h1:0YWbFKbhXG/wIiuHDSKpS0Iy7FSA+u45VtBMfQcFTTc=
@@ -634,7 +613,6 @@ golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20191024005414-555d28b269f0 h1:/5xXl8Y5W96D+TtHSlonuFqGHIWVuyCkGJLwGh9JJFs=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 h1:Hir2P/De0WpUhtrKGGjvSb2YxUgyZ7EFOSLIcSSpiwE=
 golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -668,7 +646,6 @@ golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200103221440-774c71fcf114 h1:DnSr2mCsxyCE6ZgIkmcWUQY2R5cH/6wL7eIxEmQOMSE=
 golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
@@ -694,7 +671,6 @@ golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4f
 golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -719,7 +695,6 @@ google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ
 google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.4.0 h1:/wp5JvzpHIxhs/dumFmF7BXTf3Z+dd4uXta4kVyO508=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
@@ -787,14 +762,12 @@ google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQ
 google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
 google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
 google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
 google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
@@ -810,12 +783,10 @@ gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWD
 gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
 gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
@@ -847,7 +818,6 @@ rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
 sigs.k8s.io/structured-merge-diff/v3 v3.0.0-20200116222232-67a7b8c61874/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw=
 sigs.k8s.io/structured-merge-diff/v3 v3.0.0 h1:dOmIZBMfhcHS09XZkMyUgkq5trg3/jRyJYFZUiaOp8E=
 sigs.k8s.io/structured-merge-diff/v3 v3.0.0/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw=
-sigs.k8s.io/yaml v1.1.0 h1:4A07+ZFc2wgJwo8YNlQpr1rVlgUDlxXHhPJciaPY5gs=
 sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
 sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q=
 sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=

jsonpath/jsonpath.go

@@ -41,7 +41,7 @@ func extractValue(currentKey string, value interface{}) interface{} {
 		tmp := strings.SplitN(currentKey, "[", 3)
 		arrayIndex, err := strconv.Atoi(strings.Replace(tmp[1], "]", "", 1))
 		if err != nil {
-			return value
+			return nil
 		}
 		currentKey := tmp[0]
 		// if currentKey contains only an index (i.e. [0] or 0)

jsonpath/jsonpath_test.go

@@ -20,6 +20,15 @@ func TestEval(t *testing.T) {
 	}
 }
 
+func TestEvalWithInvalidData(t *testing.T) {
+	path := "simple"
+	data := `invalid data`
+	_, _, err := Eval(path, []byte(data))
+	if err == nil {
+		t.Error("expected an error")
+	}
+}
+
 func TestEvalWithInvalidPath(t *testing.T) {
 	path := "errors"
 	data := `{}`
@@ -75,6 +84,16 @@ func TestEvalWithArrayOfValues(t *testing.T) {
 	}
 }
 
+func TestEvalWithArrayOfValuesAndInvalidIndex(t *testing.T) {
+	path := "ids[wat]"
+	data := `{"ids": [1, 2]}`
+
+	_, _, err := Eval(path, []byte(data))
+	if err == nil {
+		t.Error("Expected an error")
+	}
+}
+
 func TestEvalWithRootArrayOfValues(t *testing.T) {
 	path := "[1]"
 	data := `[1, 2]`

main.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"os/signal"
 	"syscall"
+	"time"
 
 	"github.com/TwinProduction/gatus/config"
 	"github.com/TwinProduction/gatus/controller"
@@ -13,37 +14,75 @@ import (
 )
 
 func main() {
-	cfg := loadConfiguration()
-	go watchdog.Monitor(cfg)
-	go controller.Handle()
+	cfg, err := loadConfiguration()
+	if err != nil {
+		panic(err)
+	}
+	start(cfg)
 	// Wait for termination signal
-	sig := make(chan os.Signal, 1)
+	signalChannel := make(chan os.Signal, 1)
 	done := make(chan bool, 1)
-	signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
+	signal.Notify(signalChannel, os.Interrupt, syscall.SIGTERM)
 	go func() {
-		<-sig
+		<-signalChannel
 		log.Println("Received termination signal, attempting to gracefully shut down")
-		controller.Shutdown()
-		err := storage.Get().Save()
-		if err != nil {
-			log.Println("Failed to save storage provider:", err.Error())
-		}
+		stop()
+		save()
 		done <- true
 	}()
 	<-done
 	log.Println("Shutting down")
 }
 
-func loadConfiguration() *config.Config {
-	var err error
+func stop() {
+	watchdog.Shutdown()
+	controller.Shutdown()
+}
+
+func save() {
+	err := storage.Get().Save()
+	if err != nil {
+		log.Println("Failed to save storage provider:", err.Error())
+	}
+}
+
+func start(cfg *config.Config) {
+	go controller.Handle(cfg.Security, cfg.Web, cfg.Metrics)
+	watchdog.Monitor(cfg)
+	go listenToConfigurationFileChanges(cfg)
+}
+
+func loadConfiguration() (cfg *config.Config, err error) {
 	customConfigFile := os.Getenv("GATUS_CONFIG_FILE")
 	if len(customConfigFile) > 0 {
-		err = config.Load(customConfigFile)
+		cfg, err = config.Load(customConfigFile)
 	} else {
-		err = config.LoadDefaultConfiguration()
+		cfg, err = config.LoadDefaultConfiguration()
+	}
+	return
+}
+
+func listenToConfigurationFileChanges(cfg *config.Config) {
+	for {
+		time.Sleep(30 * time.Second)
+		if cfg.HasLoadedConfigurationFileBeenModified() {
+			log.Println("[main][listenToConfigurationFileChanges] Configuration file has been modified")
+			save()
+			updatedConfig, err := loadConfiguration()
+			if err != nil {
+				if cfg.SkipInvalidConfigUpdate {
+					log.Println("[main][listenToConfigurationFileChanges] Failed to load new configuration:", err.Error())
+					log.Println("[main][listenToConfigurationFileChanges] The configuration file was updated, but it is not valid. The old configuration will continue being used.")
+					// Update the last file modification time to avoid trying to process the same invalid configuration again
+					cfg.UpdateLastFileModTime()
+					continue
+				} else {
+					panic(err)
+				}
+			}
+			stop()
+			start(updatedConfig)
+			return
+		}
 	}
-	if err != nil {
-		panic(err)
-	}
-	return config.Get()
 }

metric/metric.go

@@ -5,7 +5,6 @@ import (
 	"strconv"
 	"sync"
 
-	"github.com/TwinProduction/gatus/config"
 	"github.com/TwinProduction/gatus/core"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
@@ -19,18 +18,16 @@ var (
 // PublishMetricsForService publishes metrics for the given service and its result.
 // These metrics will be exposed at /metrics if the metrics are enabled
 func PublishMetricsForService(service *core.Service, result *core.Result) {
-	if config.Get().Metrics {
-		rwLock.Lock()
-		gauge, exists := gauges[fmt.Sprintf("%s_%s", service.Name, service.URL)]
-		if !exists {
-			gauge = promauto.NewGaugeVec(prometheus.GaugeOpts{
-				Subsystem:   "gatus",
-				Name:        "tasks",
-				ConstLabels: prometheus.Labels{"service": service.Name, "url": service.URL},
-			}, []string{"status", "success"})
-			gauges[fmt.Sprintf("%s_%s", service.Name, service.URL)] = gauge
-		}
-		rwLock.Unlock()
-		gauge.WithLabelValues(strconv.Itoa(result.HTTPStatus), strconv.FormatBool(result.Success)).Inc()
+	rwLock.Lock()
+	gauge, exists := gauges[fmt.Sprintf("%s_%s", service.Name, service.URL)]
+	if !exists {
+		gauge = promauto.NewGaugeVec(prometheus.GaugeOpts{
+			Subsystem:   "gatus",
+			Name:        "tasks",
+			ConstLabels: prometheus.Labels{"service": service.Name, "url": service.URL},
+		}, []string{"status", "success"})
+		gauges[fmt.Sprintf("%s_%s", service.Name, service.URL)] = gauge
 	}
+	rwLock.Unlock()
+	gauge.WithLabelValues(strconv.Itoa(result.HTTPStatus), strconv.FormatBool(result.Success)).Inc()
 }

security/handler.go

@@ -5,7 +5,7 @@ import (
 	"strings"
 )
 
-// Handler takes care of security for a given handler with the given security configuratioon
+// Handler takes care of security for a given handler with the given security configuration
 func Handler(handler http.HandlerFunc, security *Config) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		usernameEntered, passwordEntered, ok := r.BasicAuth()

storage/storage.go

@@ -1,6 +1,7 @@
 package storage
 
 import (
+	"context"
 	"log"
 	"time"
 
@@ -15,6 +16,9 @@ var (
 	// Because store.Store is an interface, a nil check wouldn't be sufficient, so instead of doing reflection
 	// every single time Get is called, we'll just lazily keep track of its existence through this variable
 	initialized bool
+
+	ctx        context.Context
+	cancelFunc context.CancelFunc
 )
 
 // Get retrieves the storage provider
@@ -33,31 +37,38 @@ func Get() store.Store {
 func Initialize(cfg *Config) error {
 	initialized = true
 	var err error
+	if cancelFunc != nil {
+		// Stop the active autoSave task
+		cancelFunc()
+	}
 	if cfg == nil || len(cfg.File) == 0 {
 		log.Println("[storage][Initialize] Creating storage provider")
-		provider, err = memory.NewStore("")
-		if err != nil {
-			return err
-		}
+		provider, _ = memory.NewStore("")
 	} else {
+		ctx, cancelFunc = context.WithCancel(context.Background())
 		log.Printf("[storage][Initialize] Creating storage provider with file=%s", cfg.File)
 		provider, err = memory.NewStore(cfg.File)
 		if err != nil {
 			return err
 		}
-		go autoSave(7 * time.Minute)
+		go autoSave(7*time.Minute, ctx)
 	}
 	return nil
 }
 
-// autoSave automatically calls the Save function of the provider at every interval
-func autoSave(interval time.Duration) {
+// autoSave automatically calls the SaveFunc function of the provider at every interval
+func autoSave(interval time.Duration, ctx context.Context) {
 	for {
-		time.Sleep(interval)
-		log.Printf("[storage][autoSave] Saving")
-		err := provider.Save()
-		if err != nil {
-			log.Println("[storage][autoSave] Save failed:", err.Error())
+		select {
+		case <-ctx.Done():
+			log.Printf("[storage][autoSave] Stopping active job")
+			return
+		case <-time.After(interval):
+			log.Printf("[storage][autoSave] Saving")
+			err := provider.Save()
+			if err != nil {
+				log.Println("[storage][autoSave] Save failed:", err.Error())
+			}
 		}
 	}
 }

storage/storage_test.go

@@ -0,0 +1,37 @@
+package storage
+
+import (
+	"testing"
+	"time"
+)
+
+func TestInitialize(t *testing.T) {
+	file := t.TempDir() + "/test.db"
+	err := Initialize(&Config{File: file})
+	if err != nil {
+		t.Fatal("shouldn't have returned an error")
+	}
+	if cancelFunc == nil {
+		t.Error("cancelFunc shouldn't have been nil")
+	}
+	if ctx == nil {
+		t.Error("ctx shouldn't have been nil")
+	}
+	// Try to initialize it again
+	err = Initialize(&Config{File: file})
+	if err != nil {
+		t.Fatal("shouldn't have returned an error")
+	}
+	cancelFunc()
+}
+
+func TestAutoSave(t *testing.T) {
+	file := t.TempDir() + "/test.db"
+	if err := Initialize(&Config{File: file}); err != nil {
+		t.Fatal("shouldn't have returned an error")
+	}
+	go autoSave(3*time.Millisecond, ctx)
+	time.Sleep(15 * time.Millisecond)
+	cancelFunc()
+	time.Sleep(5 * time.Millisecond)
+}

storage/store/store.go

@@ -7,7 +7,7 @@ import (
 
 // Store is the interface that each stores should implement
 type Store interface {
-	// GetAllAsJSON returns the JSON encoding of all monitored core.ServiceStatus
+	// GetAllServiceStatusesWithResultPagination returns the JSON encoding of all monitored core.ServiceStatus
 	// with a subset of core.Result defined by the page and pageSize parameters
 	GetAllServiceStatusesWithResultPagination(page, pageSize int) map[string]*core.ServiceStatus
 

watchdog/alerting.go

@@ -4,96 +4,96 @@ import (
 	"encoding/json"
 	"log"
 
-	"github.com/TwinProduction/gatus/config"
+	"github.com/TwinProduction/gatus/alerting"
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/core"
 )
 
 // HandleAlerting takes care of alerts to resolve and alerts to trigger based on result success or failure
-func HandleAlerting(service *core.Service, result *core.Result) {
-	cfg := config.Get()
-	if cfg.Alerting == nil {
+func HandleAlerting(service *core.Service, result *core.Result, alertingConfig *alerting.Config, debug bool) {
+	if alertingConfig == nil {
 		return
 	}
 	if result.Success {
-		handleAlertsToResolve(service, result, cfg)
+		handleAlertsToResolve(service, result, alertingConfig, debug)
 	} else {
-		handleAlertsToTrigger(service, result, cfg)
+		handleAlertsToTrigger(service, result, alertingConfig, debug)
 	}
 }
 
-func handleAlertsToTrigger(service *core.Service, result *core.Result, cfg *config.Config) {
+func handleAlertsToTrigger(service *core.Service, result *core.Result, alertingConfig *alerting.Config, debug bool) {
 	service.NumberOfSuccessesInARow = 0
 	service.NumberOfFailuresInARow++
-	for _, alert := range service.Alerts {
-		// If the alert hasn't been triggered, move to the next one
-		if !alert.Enabled || alert.FailureThreshold > service.NumberOfFailuresInARow {
+	for _, serviceAlert := range service.Alerts {
+		// If the serviceAlert hasn't been triggered, move to the next one
+		if !serviceAlert.IsEnabled() || serviceAlert.FailureThreshold > service.NumberOfFailuresInARow {
 			continue
 		}
-		if alert.Triggered {
-			if cfg.Debug {
-				log.Printf("[watchdog][handleAlertsToTrigger] Alert for service=%s with description='%s' has already been TRIGGERED, skipping", service.Name, alert.Description)
+		if serviceAlert.Triggered {
+			if debug {
+				log.Printf("[watchdog][handleAlertsToTrigger] Alert for service=%s with description='%s' has already been TRIGGERED, skipping", service.Name, serviceAlert.GetDescription())
 			}
 			continue
 		}
-		alertProvider := config.GetAlertingProviderByAlertType(cfg, alert.Type)
+		alertProvider := alertingConfig.GetAlertingProviderByAlertType(serviceAlert.Type)
 		if alertProvider != nil && alertProvider.IsValid() {
-			log.Printf("[watchdog][handleAlertsToTrigger] Sending %s alert because alert for service=%s with description='%s' has been TRIGGERED", alert.Type, service.Name, alert.Description)
-			customAlertProvider := alertProvider.ToCustomAlertProvider(service, alert, result, false)
+			log.Printf("[watchdog][handleAlertsToTrigger] Sending %s serviceAlert because serviceAlert for service=%s with description='%s' has been TRIGGERED", serviceAlert.Type, service.Name, serviceAlert.GetDescription())
+			customAlertProvider := alertProvider.ToCustomAlertProvider(service, serviceAlert, result, false)
 			// TODO: retry on error
 			var err error
 			// We need to extract the DedupKey from PagerDuty's response
-			if alert.Type == core.PagerDutyAlert {
+			if serviceAlert.Type == alert.TypePagerDuty {
 				var body []byte
-				if body, err = customAlertProvider.Send(service.Name, alert.Description, false); err == nil {
+				if body, err = customAlertProvider.Send(service.Name, serviceAlert.GetDescription(), false); err == nil {
 					var response pagerDutyResponse
 					if err = json.Unmarshal(body, &response); err != nil {
 						log.Printf("[watchdog][handleAlertsToTrigger] Ran into error unmarshaling pagerduty response: %s", err.Error())
 					} else {
-						alert.ResolveKey = response.DedupKey
+						serviceAlert.ResolveKey = response.DedupKey
 					}
 				}
 			} else {
-				// All other alert types don't need to extract anything from the body, so we can just send the request right away
-				_, err = customAlertProvider.Send(service.Name, alert.Description, false)
+				// All other serviceAlert types don't need to extract anything from the body, so we can just send the request right away
+				_, err = customAlertProvider.Send(service.Name, serviceAlert.GetDescription(), false)
 			}
 			if err != nil {
-				log.Printf("[watchdog][handleAlertsToTrigger] Failed to send an alert for service=%s: %s", service.Name, err.Error())
+				log.Printf("[watchdog][handleAlertsToTrigger] Failed to send an serviceAlert for service=%s: %s", service.Name, err.Error())
 			} else {
-				alert.Triggered = true
+				serviceAlert.Triggered = true
 			}
 		} else {
-			log.Printf("[watchdog][handleAlertsToResolve] Not sending alert of type=%s despite being TRIGGERED, because the provider wasn't configured properly", alert.Type)
+			log.Printf("[watchdog][handleAlertsToResolve] Not sending serviceAlert of type=%s despite being TRIGGERED, because the provider wasn't configured properly", serviceAlert.Type)
 		}
 	}
 }
 
-func handleAlertsToResolve(service *core.Service, result *core.Result, cfg *config.Config) {
+func handleAlertsToResolve(service *core.Service, result *core.Result, alertingConfig *alerting.Config, debug bool) {
 	service.NumberOfSuccessesInARow++
-	for _, alert := range service.Alerts {
-		if !alert.Enabled || !alert.Triggered || alert.SuccessThreshold > service.NumberOfSuccessesInARow {
+	for _, serviceAlert := range service.Alerts {
+		if !serviceAlert.IsEnabled() || !serviceAlert.Triggered || serviceAlert.SuccessThreshold > service.NumberOfSuccessesInARow {
 			continue
 		}
-		// Even if the alert provider returns an error, we still set the alert's Triggered variable to false.
+		// Even if the serviceAlert provider returns an error, we still set the serviceAlert's Triggered variable to false.
 		// Further explanation can be found on Alert's Triggered field.
-		alert.Triggered = false
-		if !alert.SendOnResolved {
+		serviceAlert.Triggered = false
+		if !serviceAlert.IsSendingOnResolved() {
 			continue
 		}
-		alertProvider := config.GetAlertingProviderByAlertType(cfg, alert.Type)
+		alertProvider := alertingConfig.GetAlertingProviderByAlertType(serviceAlert.Type)
 		if alertProvider != nil && alertProvider.IsValid() {
-			log.Printf("[watchdog][handleAlertsToResolve] Sending %s alert because alert for service=%s with description='%s' has been RESOLVED", alert.Type, service.Name, alert.Description)
-			customAlertProvider := alertProvider.ToCustomAlertProvider(service, alert, result, true)
+			log.Printf("[watchdog][handleAlertsToResolve] Sending %s serviceAlert because serviceAlert for service=%s with description='%s' has been RESOLVED", serviceAlert.Type, service.Name, serviceAlert.GetDescription())
+			customAlertProvider := alertProvider.ToCustomAlertProvider(service, serviceAlert, result, true)
 			// TODO: retry on error
-			_, err := customAlertProvider.Send(service.Name, alert.Description, true)
+			_, err := customAlertProvider.Send(service.Name, serviceAlert.GetDescription(), true)
 			if err != nil {
-				log.Printf("[watchdog][handleAlertsToResolve] Failed to send an alert for service=%s: %s", service.Name, err.Error())
+				log.Printf("[watchdog][handleAlertsToResolve] Failed to send an serviceAlert for service=%s: %s", service.Name, err.Error())
 			} else {
-				if alert.Type == core.PagerDutyAlert {
-					alert.ResolveKey = ""
+				if serviceAlert.Type == alert.TypePagerDuty {
+					serviceAlert.ResolveKey = ""
 				}
 			}
 		} else {
-			log.Printf("[watchdog][handleAlertsToResolve] Not sending alert of type=%s despite being RESOLVED, because the provider wasn't configured properly", alert.Type)
+			log.Printf("[watchdog][handleAlertsToResolve] Not sending serviceAlert of type=%s despite being RESOLVED, because the provider wasn't configured properly", serviceAlert.Type)
 		}
 	}
 	service.NumberOfFailuresInARow = 0

watchdog/alerting_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/TwinProduction/gatus/alerting"
+	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/alerting/provider/pagerduty"
 	"github.com/TwinProduction/gatus/config"
@@ -24,78 +25,69 @@ func TestHandleAlerting(t *testing.T) {
 			},
 		},
 	}
-	config.Set(cfg)
+	enabled := true
 	service := &core.Service{
 		URL: "http://example.com",
-		Alerts: []*core.Alert{
+		Alerts: []*alert.Alert{
 			{
-				Type:             core.CustomAlert,
-				Enabled:          true,
+				Type:             alert.TypeCustom,
+				Enabled:          &enabled,
 				FailureThreshold: 2,
 				SuccessThreshold: 3,
-				SendOnResolved:   true,
+				SendOnResolved:   &enabled,
 				Triggered:        false,
 			},
 		},
 	}
 
 	verify(t, service, 0, 0, false, "The alert shouldn't start triggered")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 1, 0, false, "The alert shouldn't have triggered")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 2, 0, true, "The alert should've triggered")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 3, 0, true, "The alert should still be triggered")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 4, 0, true, "The alert should still be triggered")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 1, true, "The alert should still be triggered (because service.Alerts[0].SuccessThreshold is 3)")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 2, true, "The alert should still be triggered (because service.Alerts[0].SuccessThreshold is 3)")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 3, false, "The alert should've been resolved")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 4, false, "The alert should no longer be triggered")
 }
 
 func TestHandleAlertingWhenAlertingConfigIsNil(t *testing.T) {
 	_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
 	defer os.Clearenv()
-
-	cfg := &config.Config{
-		Debug:    true,
-		Alerting: nil,
-	}
-	config.Set(cfg)
-	HandleAlerting(nil, nil)
+	HandleAlerting(nil, nil, nil, true)
 }
 
 func TestHandleAlertingWithBadAlertProvider(t *testing.T) {
 	_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
 	defer os.Clearenv()
 
-	cfg := &config.Config{
-		Alerting: &alerting.Config{},
-	}
-	config.Set(cfg)
+	enabled := true
 	service := &core.Service{
 		URL: "http://example.com",
-		Alerts: []*core.Alert{
+		Alerts: []*alert.Alert{
 			{
-				Type:             core.CustomAlert,
-				Enabled:          true,
+				Type:             alert.TypeCustom,
+				Enabled:          &enabled,
 				FailureThreshold: 1,
 				SuccessThreshold: 1,
-				SendOnResolved:   true,
+				SendOnResolved:   &enabled,
 				Triggered:        false,
 			},
 		},
 	}
 
 	verify(t, service, 0, 0, false, "The alert shouldn't start triggered")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, &alerting.Config{}, false)
 	verify(t, service, 1, 0, false, "The alert shouldn't have triggered")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, &alerting.Config{}, false)
 	verify(t, service, 2, 0, false, "The alert shouldn't have triggered, because the provider wasn't configured properly")
 }
 
@@ -112,16 +104,16 @@ func TestHandleAlertingWhenTriggeredAlertIsAlmostResolvedButServiceStartFailingA
 			},
 		},
 	}
-	config.Set(cfg)
+	enabled := true
 	service := &core.Service{
 		URL: "http://example.com",
-		Alerts: []*core.Alert{
+		Alerts: []*alert.Alert{
 			{
-				Type:             core.CustomAlert,
-				Enabled:          true,
+				Type:             alert.TypeCustom,
+				Enabled:          &enabled,
 				FailureThreshold: 2,
 				SuccessThreshold: 3,
-				SendOnResolved:   true,
+				SendOnResolved:   &enabled,
 				Triggered:        true,
 			},
 		},
@@ -129,7 +121,7 @@ func TestHandleAlertingWhenTriggeredAlertIsAlmostResolvedButServiceStartFailingA
 	}
 
 	// This test simulate an alert that was already triggered
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 2, 0, true, "The alert was already triggered at the beginning of this test")
 }
 
@@ -146,23 +138,24 @@ func TestHandleAlertingWhenTriggeredAlertIsResolvedButSendOnResolvedIsFalse(t *t
 			},
 		},
 	}
-	config.Set(cfg)
+	enabled := true
+	disabled := false
 	service := &core.Service{
 		URL: "http://example.com",
-		Alerts: []*core.Alert{
+		Alerts: []*alert.Alert{
 			{
-				Type:             core.CustomAlert,
-				Enabled:          true,
+				Type:             alert.TypeCustom,
+				Enabled:          &enabled,
 				FailureThreshold: 1,
 				SuccessThreshold: 1,
-				SendOnResolved:   false,
+				SendOnResolved:   &disabled,
 				Triggered:        true,
 			},
 		},
 		NumberOfFailuresInARow: 1,
 	}
 
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 1, false, "The alert should've been resolved")
 }
 
@@ -178,26 +171,26 @@ func TestHandleAlertingWhenTriggeredAlertIsResolvedPagerDuty(t *testing.T) {
 			},
 		},
 	}
-	config.Set(cfg)
+	enabled := true
 	service := &core.Service{
 		URL: "http://example.com",
-		Alerts: []*core.Alert{
+		Alerts: []*alert.Alert{
 			{
-				Type:             core.PagerDutyAlert,
-				Enabled:          true,
+				Type:             alert.TypePagerDuty,
+				Enabled:          &enabled,
 				FailureThreshold: 1,
 				SuccessThreshold: 1,
-				SendOnResolved:   true,
+				SendOnResolved:   &enabled,
 				Triggered:        false,
 			},
 		},
 		NumberOfFailuresInARow: 0,
 	}
 
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 1, 0, true, "")
 
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 1, false, "The alert should've been resolved")
 }
 
@@ -214,48 +207,48 @@ func TestHandleAlertingWithProviderThatReturnsAnError(t *testing.T) {
 			},
 		},
 	}
-	config.Set(cfg)
+	enabled := true
 	service := &core.Service{
 		URL: "http://example.com",
-		Alerts: []*core.Alert{
+		Alerts: []*alert.Alert{
 			{
-				Type:             core.CustomAlert,
-				Enabled:          true,
+				Type:             alert.TypeCustom,
+				Enabled:          &enabled,
 				FailureThreshold: 2,
 				SuccessThreshold: 2,
-				SendOnResolved:   true,
+				SendOnResolved:   &enabled,
 				Triggered:        false,
 			},
 		},
 	}
 
 	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "true")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 1, 0, false, "")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 2, 0, false, "The alert should have failed to trigger, because the alert provider is returning an error")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 3, 0, false, "The alert should still not be triggered, because the alert provider is still returning an error")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 4, 0, false, "The alert should still not be triggered, because the alert provider is still returning an error")
 	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "false")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 5, 0, true, "The alert should've been triggered because the alert provider is no longer returning an error")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 1, true, "The alert should've still been triggered")
 	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "true")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 2, false, "The alert should've been resolved DESPITE THE ALERT PROVIDER RETURNING AN ERROR. See Alert.Triggered for further explanation.")
 	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "false")
 
 	// Make sure that everything's working as expected after a rough patch
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 1, 0, false, "")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 2, 0, true, "The alert should have triggered")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 1, true, "The alert should still be triggered")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 2, false, "The alert should have been resolved")
 }
 
@@ -272,42 +265,42 @@ func TestHandleAlertingWithProviderThatOnlyReturnsErrorOnResolve(t *testing.T) {
 			},
 		},
 	}
-	config.Set(cfg)
+	enabled := true
 	service := &core.Service{
 		URL: "http://example.com",
-		Alerts: []*core.Alert{
+		Alerts: []*alert.Alert{
 			{
-				Type:             core.CustomAlert,
-				Enabled:          true,
+				Type:             alert.TypeCustom,
+				Enabled:          &enabled,
 				FailureThreshold: 1,
 				SuccessThreshold: 1,
-				SendOnResolved:   true,
+				SendOnResolved:   &enabled,
 				Triggered:        false,
 			},
 		},
 	}
 
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 1, 0, true, "")
 	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "true")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 1, false, "")
 	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "false")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 1, 0, true, "")
 	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "true")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 1, false, "")
 	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "false")
 
 	// Make sure that everything's working as expected after a rough patch
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 1, 0, true, "")
-	HandleAlerting(service, &core.Result{Success: false})
+	HandleAlerting(service, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 2, 0, true, "")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 1, false, "")
-	HandleAlerting(service, &core.Result{Success: true})
+	HandleAlerting(service, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
 	verify(t, service, 0, 2, false, "")
 }
 

watchdog/watchdog.go

@@ -1,10 +1,12 @@
 package watchdog
 
 import (
+	"context"
 	"log"
 	"sync"
 	"time"
 
+	"github.com/TwinProduction/gatus/alerting"
 	"github.com/TwinProduction/gatus/config"
 	"github.com/TwinProduction/gatus/core"
 	"github.com/TwinProduction/gatus/metric"
@@ -15,48 +17,65 @@ var (
 	// monitoringMutex is used to prevent multiple services from being evaluated at the same time.
 	// Without this, conditions using response time may become inaccurate.
 	monitoringMutex sync.Mutex
+
+	ctx        context.Context
+	cancelFunc context.CancelFunc
 )
 
 // Monitor loops over each services and starts a goroutine to monitor each services separately
 func Monitor(cfg *config.Config) {
+	ctx, cancelFunc = context.WithCancel(context.Background())
 	for _, service := range cfg.Services {
 		// To prevent multiple requests from running at the same time, we'll wait for a little bit before each iteration
 		time.Sleep(1111 * time.Millisecond)
-		go monitor(service)
+		go monitor(service, cfg.Alerting, cfg.DisableMonitoringLock, cfg.Metrics, cfg.Debug, ctx)
 	}
 }
 
 // monitor monitors a single service in a loop
-func monitor(service *core.Service) {
-	cfg := config.Get()
+func monitor(service *core.Service, alertingConfig *alerting.Config, disableMonitoringLock, enabledMetrics, debug bool, ctx context.Context) {
+	// Run it immediately on start
+	execute(service, alertingConfig, disableMonitoringLock, enabledMetrics, debug)
+	// Loop for the next executions
 	for {
-		if !cfg.DisableMonitoringLock {
-			// By placing the lock here, we prevent multiple services from being monitored at the exact same time, which
-			// could cause performance issues and return inaccurate results
-			monitoringMutex.Lock()
+		select {
+		case <-ctx.Done():
+			log.Printf("[watchdog][monitor] Canceling current execution of group=%s; service=%s", service.Group, service.Name)
+			return
+		case <-time.After(service.Interval):
+			execute(service, alertingConfig, disableMonitoringLock, enabledMetrics, debug)
 		}
-		if cfg.Debug {
-			log.Printf("[watchdog][monitor] Monitoring group=%s; service=%s", service.Group, service.Name)
-		}
-		result := service.EvaluateHealth()
+	}
+}
+
+func execute(service *core.Service, alertingConfig *alerting.Config, disableMonitoringLock, enabledMetrics, debug bool) {
+	if !disableMonitoringLock {
+		// By placing the lock here, we prevent multiple services from being monitored at the exact same time, which
+		// could cause performance issues and return inaccurate results
+		monitoringMutex.Lock()
+	}
+	if debug {
+		log.Printf("[watchdog][execute] Monitoring group=%s; service=%s", service.Group, service.Name)
+	}
+	result := service.EvaluateHealth()
+	if enabledMetrics {
 		metric.PublishMetricsForService(service, result)
-		UpdateServiceStatuses(service, result)
-		log.Printf(
-			"[watchdog][monitor] Monitored group=%s; service=%s; success=%v; errors=%d; duration=%s",
-			service.Group,
-			service.Name,
-			result.Success,
-			len(result.Errors),
-			result.Duration.Round(time.Millisecond),
-		)
-		HandleAlerting(service, result)
-		if cfg.Debug {
-			log.Printf("[watchdog][monitor] Waiting for interval=%s before monitoring group=%s service=%s again", service.Interval, service.Group, service.Name)
-		}
-		if !cfg.DisableMonitoringLock {
-			monitoringMutex.Unlock()
-		}
-		time.Sleep(service.Interval)
+	}
+	UpdateServiceStatuses(service, result)
+	log.Printf(
+		"[watchdog][execute] Monitored group=%s; service=%s; success=%v; errors=%d; duration=%s",
+		service.Group,
+		service.Name,
+		result.Success,
+		len(result.Errors),
+		result.Duration.Round(time.Millisecond),
+	)
+	HandleAlerting(service, result, alertingConfig, debug)
+	if debug {
+		log.Printf("[watchdog][execute] Waiting for interval=%s before monitoring group=%s service=%s again", service.Interval, service.Group, service.Name)
+	}
+	if !disableMonitoringLock {
+		monitoringMutex.Unlock()
 	}
 }
 
@@ -64,3 +83,8 @@ func monitor(service *core.Service) {
 func UpdateServiceStatuses(service *core.Service, result *core.Result) {
 	storage.Get().Insert(service, result)
 }
+
+// Shutdown stops monitoring all services
+func Shutdown() {
+	cancelFunc()
+}

web/app/package.json

@@ -1,30 +1,29 @@
 {
-  "name": "app",
-  "version": "0.1.0",
+  "name": "gatus",
+  "version": "2.0.0",
   "private": true,
   "scripts": {
     "serve": "vue-cli-service serve --mode development",
-    "build": "vue-cli-service build --mode production",
+    "build": "vue-cli-service build --modern --mode production",
     "lint": "vue-cli-service lint"
   },
   "dependencies": {
-    "@tailwindcss/postcss7-compat": "^2.0.2",
-    "autoprefixer": "^9.8.6",
-    "core-js": "^3.6.5",
-    "postcss": "^7.0.35",
-    "tailwindcss": "npm:@tailwindcss/postcss7-compat@^2.0.2",
-    "vue": "^3.0.0",
-    "vue-router": "^4.0.0-0"
+    "core-js": "^3.12.1",
+    "vue": "^3.0.11",
+    "vue-router": "^4.0.6"
   },
   "devDependencies": {
-    "@vue/cli-plugin-babel": "~4.5.0",
-    "@vue/cli-plugin-eslint": "~4.5.0",
-    "@vue/cli-plugin-router": "~4.5.0",
-    "@vue/cli-service": "~4.5.0",
-    "@vue/compiler-sfc": "^3.0.0",
+    "@vue/cli-plugin-babel": "^5.0.0-beta.0",
+    "@vue/cli-plugin-eslint": "^5.0.0-beta.0",
+    "@vue/cli-plugin-router": "^5.0.0-beta.0",
+    "@vue/cli-service": "^5.0.0-beta.0",
+    "@vue/compiler-sfc": "^3.0.11",
+    "autoprefixer": "^10.2.5",
     "babel-eslint": "^10.1.0",
-    "eslint": "^6.7.2",
-    "eslint-plugin-vue": "^7.0.0-0"
+    "eslint": "^7.26.0",
+    "eslint-plugin-vue": "^7.8.0",
+    "postcss": "^8.2.15",
+    "tailwindcss": "^2.1.2"
   },
   "eslintConfig": {
     "root": true,

web/app/postcss.config.js

@@ -1,5 +1,8 @@
+const tailwindcss = require('tailwindcss');
+
 module.exports = {
 	plugins: [
-		require('tailwindcss')
+		tailwindcss('./tailwind.config.js'),
+		require('autoprefixer'),
 	],
 };

web/app/public/index.html

@@ -1,16 +1,14 @@
 <!DOCTYPE html>
 <html lang="en">
   <head>
-    <meta charset="utf-8">
+    <meta charset="utf-8" />
+    <title>Health Dashboard | Gatus</title>
     <meta http-equiv="X-UA-Compatible" content="IE=edge">
     <meta name="viewport" content="width=device-width,initial-scale=1.0">
     <link rel="icon" href="<%= BASE_URL %>favicon.ico">
-    <title>Health Dashboard | Gatus</title>
   </head>
-  <body>
-    <noscript>
-      <strong>Enable JavaScript to view this page.</strong>
-    </noscript>
+  <body class="dark:bg-gray-900">
+    <noscript><strong>Enable JavaScript to view this page.</strong></noscript>
     <div id="app"></div>
   </body>
 </html>

web/app/src/App.vue

@@ -1,5 +1,5 @@
 <template>
-  <div class="container container-xs relative mx-auto xl:rounded xl:border xl:shadow-xl xl:my-5 p-5 pb-12 xl:pb-5 text-left" id="global">
+  <div class="container container-xs relative mx-auto xl:rounded xl:border xl:shadow-xl xl:my-5 p-5 pb-12 xl:pb-5 text-left dark:bg-gray-800 dark:text-gray-200 dark:border-gray-500" id="global">
     <div class="mb-2">
       <div class="flex flex-wrap">
         <div class="w-3/4 text-left my-auto">
@@ -39,18 +39,3 @@ export default {
   },
 }
 </script>
-
-
-<style>
-html {
-  height: 100%;
-}
-
-html, body {
-  background-color: #f7f9fb;
-}
-
-#global, #results {
-  max-width: 1200px;
-}
-</style>

web/app/src/components/Pagination.vue

@@ -1,10 +1,10 @@
 <template>
   <div class="mt-3 flex">
     <div class="flex-1">
-      <button v-if="currentPage < 5" @click="nextPage" class="bg-gray-100 hover:bg-gray-200 px-2 rounded border-gray-200 border text-monospace text-gray-500">&lt;</button>
+      <button v-if="currentPage < 5" @click="nextPage" class="bg-gray-100 hover:bg-gray-200 text-gray-500 border border-gray-200 px-2 rounded font-mono dark:bg-gray-700 dark:text-gray-200 dark:border-gray-500 dark:hover:bg-gray-600">&lt;</button>
     </div>
     <div class="flex-1 text-right">
-      <button v-if="currentPage > 1" @click="previousPage" class="bg-gray-100 hover:bg-gray-200 px-2 rounded border-gray-200 border text-monospace text-gray-500">&gt;</button>
+      <button v-if="currentPage > 1" @click="previousPage" class="bg-gray-100 hover:bg-gray-200 text-gray-500 border border-gray-200 px-2 rounded font-mono dark:bg-gray-700 dark:text-gray-200 dark:border-gray-500 dark:hover:bg-gray-600">&gt;</button>
     </div>
   </div>
 </template>

web/app/src/components/Service.vue

@@ -1,15 +1,20 @@
 <template>
-  <div class='service px-3 py-3 border-l border-r border-t rounded-none hover:bg-gray-100' v-if="data">
+  <div class='service px-3 py-3 border-l border-r border-t rounded-none hover:bg-gray-100 dark:hover:bg-gray-700 dark:border-gray-500' v-if="data">
     <div class='flex flex-wrap mb-2'>
       <div class='w-3/4'>
-        <router-link :to="generatePath()" class="font-bold hover:text-blue-800 hover:underline" title="View detailed service health">
+        <router-link :to="generatePath()" class="font-bold hover:text-blue-800 hover:underline dark:hover:text-blue-400" title="View detailed service health">
           {{ data.name }}
         </router-link>
         <span v-if="data.results && data.results.length" class='text-gray-500 font-light'> | {{ data.results[data.results.length - 1].hostname }}</span>
       </div>
       <div class='w-1/4 text-right'>
-        <span class='font-light status-min-max-ms' v-if="data.results && data.results.length">
-          {{ (minResponseTime === maxResponseTime ? minResponseTime : (minResponseTime + '-' + maxResponseTime)) }}ms
+        <span class='font-light overflow-x-hidden cursor-pointer select-none' v-if="data.results && data.results.length" @click="toggleShowAverageResponseTime" :title="showAverageResponseTime ? 'Average response time' : 'Minimum and maximum response time'">
+          <slot v-if="showAverageResponseTime">
+            ~{{ averageResponseTime }}ms
+          </slot>
+          <slot v-else>
+            {{ (minResponseTime === maxResponseTime ? minResponseTime : (minResponseTime + '-' + maxResponseTime)) }}ms
+          </slot>
         </span>
       </div>
     </div>
@@ -17,7 +22,7 @@
       <div class='status-over-time flex flex-row'>
         <slot v-if="data.results && data.results.length">
           <slot v-if="data.results.length < maximumNumberOfResults">
-            <span v-for="filler in maximumNumberOfResults - data.results.length" :key="filler" class="status rounded border border-dashed">&nbsp;</span>
+            <span v-for="filler in maximumNumberOfResults - data.results.length" :key="filler" class="status rounded border border-dashed border-gray-400">&nbsp;</span>
           </slot>
           <slot v-for="result in data.results" :key="result">
             <span v-if="result.success" class="status status-success rounded bg-success" @mouseenter="showTooltip(result, $event)" @mouseleave="showTooltip(null, $event)"></span>
@@ -25,7 +30,7 @@
           </slot>
         </slot>
         <slot v-else>
-          <span v-for="filler in maximumNumberOfResults" :key="filler" class="status rounded border border-dashed">&nbsp;</span>
+          <span v-for="filler in maximumNumberOfResults" :key="filler" class="status rounded border border-dashed border-gray-400">&nbsp;</span>
         </slot>
       </div>
     </div>
@@ -56,15 +61,18 @@ export default {
   props: {
     maximumNumberOfResults: Number,
     data: Object,
+    showAverageResponseTime: Boolean
   },
-  emits: ['showTooltip'],
+  emits: ['showTooltip', 'toggleShowAverageResponseTime'],
   mixins: [helper],
   methods: {
     updateMinAndMaxResponseTimes() {
       let minResponseTime = null;
       let maxResponseTime = null;
+      let totalResponseTime = 0;
       for (let i in this.data.results) {
         const responseTime = parseInt((this.data.results[i].duration/1000000).toFixed(0));
+        totalResponseTime += responseTime;
         if (minResponseTime == null || minResponseTime > responseTime) {
           minResponseTime = responseTime;
         }
@@ -78,6 +86,9 @@ export default {
       if (this.maxResponseTime !== maxResponseTime) {
         this.maxResponseTime = maxResponseTime;
       }
+      if (this.data.results && this.data.results.length) {
+        this.averageResponseTime = (totalResponseTime/this.data.results.length).toFixed(0);
+      }
     },
     generatePath() {
       if (!this.data) {
@@ -87,6 +98,9 @@ export default {
     },
     showTooltip(result, event) {
       this.$emit('showTooltip', result, event);
+    },
+    toggleShowAverageResponseTime() {
+      this.$emit('toggleShowAverageResponseTime');
     }
   },
   watch: {
@@ -100,7 +114,8 @@ export default {
   data() {
     return {
       minResponseTime: 0,
-      maxResponseTime: 0
+      maxResponseTime: 0,
+      averageResponseTime: 0
     }
   }
 }
@@ -117,8 +132,6 @@ export default {
   border-bottom-left-radius: 3px;
   border-bottom-right-radius: 3px;
   border-bottom-width: 3px;
-  border-color: #dee2e6;
-  border-style: solid;
 }
 
 .status-over-time {
@@ -152,10 +165,6 @@ export default {
   margin-top: 5px;
 }
 
-.status-min-max-ms {
-  overflow-x: hidden;
-}
-
 .status.status-success::after {
   content: "✓";
 }

web/app/src/components/ServiceGroup.vue

@@ -1,8 +1,8 @@
 <template>
   <div :class="services.length === 0 ? 'mt-3' : 'mt-4'">
     <slot v-if="name !== 'undefined'">
-      <div class="service-group pt-2 border" @click="toggleGroup">
-        <h5 class='text-monospace text-gray-400 text-xl font-medium pb-2 px-3'>
+      <div class="service-group pt-2 border dark:bg-gray-800 dark:border-gray-500" @click="toggleGroup">
+        <h5 class='font-mono text-gray-400 text-xl font-medium pb-2 px-3 dark:text-gray-200 dark:hover:text-gray-500 dark:border-gray-500'>
           <span v-if="healthy" class='text-green-600'>&#10003;</span>
           <span v-else class='text-yellow-400'>~</span>
           {{ name }}
@@ -14,7 +14,12 @@
     </slot>
     <div v-if="!collapsed" :class="name === 'undefined' ? '' : 'service-group-content'">
       <slot v-for="service in services" :key="service">
-        <Service :data="service" @showTooltip="showTooltip" :maximumNumberOfResults="20"/>
+        <Service
+            :data="service"
+            :maximumNumberOfResults="20"
+            @showTooltip="showTooltip"
+            @toggleShowAverageResponseTime="toggleShowAverageResponseTime" :showAverageResponseTime="showAverageResponseTime"
+        />
       </slot>
     </div>
   </div>
@@ -31,9 +36,10 @@ export default {
   },
   props: {
     name: String,
-    services: Array
+    services: Array,
+    showAverageResponseTime: Boolean
   },
-  emits: ['showTooltip'],
+  emits: ['showTooltip', 'toggleShowAverageResponseTime'],
   methods: {
     healthCheck() {
       if (this.services) {
@@ -56,10 +62,13 @@ export default {
     },
     toggleGroup() {
       this.collapsed = !this.collapsed;
-      sessionStorage.setItem(`service-group:${this.name}:collapsed`, this.collapsed);
+      sessionStorage.setItem(`gatus:service-group:${this.name}:collapsed`, this.collapsed);
     },
     showTooltip(result, event) {
       this.$emit('showTooltip', result, event);
+    },
+    toggleShowAverageResponseTime() {
+      this.$emit('toggleShowAverageResponseTime');
     }
   },
   watch: {
@@ -73,7 +82,7 @@ export default {
   data() {
     return {
       healthy: true,
-      collapsed: sessionStorage.getItem(`service-group:${this.name}:collapsed`) === "true"
+      collapsed: sessionStorage.getItem(`gatus:service-group:${this.name}:collapsed`) === "true"
     }
   }
 }
@@ -87,6 +96,6 @@ export default {
 }
 
 .service-group h5:hover {
-  color: #1b1e21 !important;
+  color: #1b1e21;
 }
 </style>

web/app/src/components/Services.vue

@@ -1,7 +1,7 @@
 <template>
   <div id="results">
     <slot v-for="serviceGroup in serviceGroups" :key="serviceGroup">
-      <ServiceGroup :services="serviceGroup.services" :name="serviceGroup.name" @showTooltip="showTooltip"/>
+      <ServiceGroup :services="serviceGroup.services" :name="serviceGroup.name" @showTooltip="showTooltip" @toggleShowAverageResponseTime="toggleShowAverageResponseTime" :showAverageResponseTime="showAverageResponseTime" />
     </slot>
   </div>
 </template>
@@ -17,9 +17,10 @@ export default {
   },
   props: {
     showStatusOnHover: Boolean,
-    serviceStatuses: Object
+    serviceStatuses: Object,
+    showAverageResponseTime: Boolean
   },
-  emits: ['showTooltip'],
+  emits: ['showTooltip', 'toggleShowAverageResponseTime'],
   methods: {
     process() {
       let outputByGroup = {};
@@ -45,6 +46,9 @@ export default {
     },
     showTooltip(result, event) {
       this.$emit('showTooltip', result, event);
+    },
+    toggleShowAverageResponseTime() {
+      this.$emit('toggleShowAverageResponseTime');
     }
   },
   watch: {

web/app/src/components/Settings.vue

@@ -1,17 +1,23 @@
 <template>
   <div id="settings">
-    <div class="flex bg-gray-200 rounded border border-gray-300 shadow">
-      <div class="text-sm text-gray-600 rounded-xl py-1 px-2">
-        &#x21bb;
+    <div class="flex">
+      <div class="flex bg-gray-200 border-gray-300 rounded border shadow dark:text-gray-200 dark:bg-gray-800 dark:border-gray-500">
+        <div class="text-xs text-gray-600 rounded-xl py-1 px-2 dark:text-gray-200">
+          &#x21bb;
+        </div>
+        <select class="text-center text-gray-500 text-xs dark:text-gray-200 dark:bg-gray-800 border-r border-l border-gray-300 dark:border-gray-500" id="refresh-rate" ref="refreshInterval" @change="handleChangeRefreshInterval">
+          <option value="10" :selected="refreshInterval === 10">10s</option>
+          <option value="30" :selected="refreshInterval === 30">30s</option>
+          <option value="60" :selected="refreshInterval === 60">1m</option>
+          <option value="120" :selected="refreshInterval === 120">2m</option>
+          <option value="300" :selected="refreshInterval === 300">5m</option>
+          <option value="600" :selected="refreshInterval === 600">10m</option>
+        </select>
+        <button @click="toggleDarkMode" class="text-xs p-1">
+          <slot v-if="darkMode">☀</slot>
+          <slot v-else>🌙</slot>
+        </button>
       </div>
-      <select class="text-center text-gray-500 text-sm" id="refresh-rate" ref="refreshInterval" @change="handleChangeRefreshInterval">
-        <option value="10">10s</option>
-        <option value="30" selected>30s</option>
-        <option value="60">1m</option>
-        <option value="120">2m</option>
-        <option value="300">5m</option>
-        <option value="600">10m</option>
-      </select>
     </div>
   </div>
 </template>
@@ -23,6 +29,7 @@ export default {
   props: {},
   methods: {
     setRefreshInterval(seconds) {
+      sessionStorage.setItem('gatus:refresh-interval', seconds);
       let that = this;
       this.refreshIntervalHandler = setInterval(function () {
         that.refreshData();
@@ -35,24 +42,44 @@ export default {
       this.refreshData();
       clearInterval(this.refreshIntervalHandler);
       this.setRefreshInterval(this.$refs.refreshInterval.value);
+    },
+    toggleDarkMode() {
+      if (localStorage.theme === 'dark') {
+        localStorage.theme = 'light';
+      } else {
+        localStorage.theme = 'dark';
+      }
+      this.applyTheme();
+    },
+    applyTheme() {
+      if (localStorage.theme === 'dark' || (!('theme' in localStorage) && window.matchMedia('(prefers-color-scheme: dark)').matches)) {
+        this.darkMode = true;
+        document.documentElement.classList.add('dark');
+      } else {
+        this.darkMode = false;
+        document.documentElement.classList.remove('dark');
+      }
     }
   },
   created() {
+    if (this.refreshInterval !== 10 && this.refreshInterval !== 30 && this.refreshInterval !== 60 && this.refreshInterval !== 120 && this.refreshInterval !== 300 && this.refreshInterval !== 600) {
+      this.refreshInterval = 60;
+    }
     this.setRefreshInterval(this.refreshInterval);
+    // dark mode
+    this.applyTheme();
   },
   unmounted() {
     clearInterval(this.refreshIntervalHandler);
   },
   data() {
     return {
-      refreshInterval: 30,
+      refreshInterval: sessionStorage.getItem('gatus:refresh-interval') < 10 ? 60 : parseInt(sessionStorage.getItem('gatus:refresh-interval')),
       refreshIntervalHandler: 0,
+      darkMode: false
     }
   },
 }
-
-// props.refreshInterval = 30
-//$("#refresh-rate").val(30);
 </script>
 
 

web/app/src/index.css

@@ -6,6 +6,34 @@
     background-color: #28a745;
 }
 
-.text-monospace {
-    font-family: Consolas, monospace;
-}
+html {
+    height: 100%;
+}
+
+body {
+    padding-top: 20px;
+    padding-bottom: 20px;
+    min-height: 100vh;
+}
+
+html, body {
+    background-color: #f7f9fb;
+}
+
+#global {
+    margin-top: 0 !important;
+}
+
+#global, #results {
+    max-width: 1280px;
+}
+
+@media screen and (max-width: 1279px) {
+    body {
+        padding-top: 0;
+        padding-bottom: 0;
+    }
+    #global {
+        min-height: 100vh;
+    }
+}

web/app/src/views/Details.vue

@@ -1,16 +1,21 @@
 <template>
-  <router-link to="../" class="absolute top-2 left-2 inline-block px-2 py-0 text-lg text-black transition bg-gray-100 rounded shadow ripple hover:shadow-lg hover:bg-gray-200 focus:outline-none">
+  <router-link to="../" class="absolute top-2 left-2 inline-block px-2 pb-0.5 text-lg text-black bg-gray-100 rounded hover:bg-gray-200 focus:outline-none border border-gray-200 dark:bg-gray-700 dark:text-gray-200 dark:border-gray-500 dark:hover:bg-gray-600">
     &larr;
   </router-link>
   <div>
     <slot v-if="serviceStatus">
-      <h1 class="text-xl xl:text-3xl text-monospace text-gray-400">RECENT CHECKS</h1>
+      <h1 class="text-xl xl:text-3xl font-mono text-gray-400">RECENT CHECKS</h1>
       <hr class="mb-4" />
-      <Service :data="serviceStatus" :maximumNumberOfResults="20" @showTooltip="showTooltip" />
+      <Service
+          :data="serviceStatus"
+          :maximumNumberOfResults="20"
+          @showTooltip="showTooltip"
+          @toggleShowAverageResponseTime="toggleShowAverageResponseTime" :showAverageResponseTime="showAverageResponseTime"
+      />
       <Pagination @page="changePage"/>
     </slot>
     <div v-if="uptime" class="mt-12">
-      <h1 class="text-xl xl:text-3xl text-monospace text-gray-400">UPTIME</h1>
+      <h1 class="text-xl xl:text-3xl font-mono text-gray-400">UPTIME</h1>
       <hr />
       <div class="flex space-x-4 text-center text-xl xl:text-2xl mt-3">
         <div class="flex-1">
@@ -27,7 +32,7 @@
         </div>
       </div>
       <hr class="mt-1"/>
-      <h3 class="text-xl text-monospace text-gray-400 mt-1 text-right">BADGES</h3>
+      <h3 class="text-xl font-mono text-gray-400 mt-1 text-right">BADGES</h3>
       <div v-if="serviceStatus && serviceStatus.key" class="flex space-x-4 text-center text-2xl mt-6 relative bottom-12">
         <div class="flex-1">
           <img :src="generateBadgeImageURL('7d')" alt="7d uptime badge" class="mx-auto" />
@@ -41,7 +46,7 @@
       </div>
     </div>
     <div>
-      <h1 class="text-xl xl:text-3xl text-monospace text-gray-400 mt-4">EVENTS</h1>
+      <h1 class="text-xl xl:text-3xl font-mono text-gray-400 mt-4">EVENTS</h1>
       <hr class="mb-4" />
       <div>
         <slot v-for="event in events" :key="event">
@@ -139,13 +144,16 @@ export default {
       let minutes = Math.ceil((new Date(start) - new Date(end))/1000/60);
       return minutes + (minutes === 1 ? ' minute' : ' minutes');
     },
-    showTooltip(result, event) {
-      this.$emit('showTooltip', result, event);
-    },
     changePage(page) {
       this.currentPage = page;
       this.fetchData();
     },
+    showTooltip(result, event) {
+      this.$emit('showTooltip', result, event);
+    },
+    toggleShowAverageResponseTime() {
+      this.showAverageResponseTime = !this.showAverageResponseTime;
+    },
   },
   data() {
     return {
@@ -155,6 +163,7 @@ export default {
       // Since this page isn't at the root, we need to modify the server URL a bit
       serverUrl: SERVER_URL === '.' ? '..' : SERVER_URL,
       currentPage: 1,
+      showAverageResponseTime: true,
     }
   },
   created() {
@@ -167,7 +176,5 @@ export default {
 .service {
   border-radius: 3px;
   border-bottom-width: 3px;
-  border-color: #dee2e6;
-  border-style: solid;
 }
 </style>

web/app/src/views/Home.vue

@@ -1,5 +1,10 @@
 <template>
-  <Services :serviceStatuses="serviceStatuses" :showStatusOnHover="true" @showTooltip="showTooltip"/>
+  <Services
+      :serviceStatuses="serviceStatuses"
+      :showStatusOnHover="true"
+      @showTooltip="showTooltip"
+      @toggleShowAverageResponseTime="toggleShowAverageResponseTime" :showAverageResponseTime="showAverageResponseTime"
+  />
   <Pagination @page="changePage"/>
   <Settings @refreshData="fetchData"/>
 </template>
@@ -17,7 +22,7 @@ export default {
     Services,
     Settings,
   },
-  emits: ['showTooltip'],
+  emits: ['showTooltip', 'toggleShowAverageResponseTime'],
   methods: {
     fetchData() {
       //console.log("[Home][fetchData] Fetching data");
@@ -29,18 +34,22 @@ export default {
             }
           });
     },
-    showTooltip(result, event) {
-      this.$emit('showTooltip', result, event);
-    },
     changePage(page) {
       this.currentPage = page;
       this.fetchData();
     },
+    showTooltip(result, event) {
+      this.$emit('showTooltip', result, event);
+    },
+    toggleShowAverageResponseTime() {
+      this.showAverageResponseTime = !this.showAverageResponseTime;
+    },
   },
   data() {
     return {
       serviceStatuses: {},
-      currentPage: 1
+      currentPage: 1,
+      showAverageResponseTime: true
     }
   },
   created() {

web/app/tailwind.config.js

@@ -1,7 +1,10 @@
 module.exports = {
-  purge: ['./index.html', './src/**/*.{vue,js,ts,jsx,tsx}'],
-  darkMode: false, // or 'media' or 'class'
+  purge: ['./public/index.html', './src/**/*.{vue,js,ts,jsx,tsx}'],
+  darkMode: 'class', // or 'media' or 'class'
   theme: {
+    fontFamily: {
+      'mono': ['Consolas', 'Monaco', '"Courier New"', 'monospace']
+    },
     extend: {},
   },
   variants: {

web/static/index.html

@@ -1 +1 @@
-<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width,initial-scale=1"><link rel="icon" href="/favicon.ico"><title>Health Dashboard | Gatus</title><link href="/css/app.css" rel="preload" as="style"><link href="/js/app.js" rel="preload" as="script"><link href="/js/chunk-vendors.js" rel="preload" as="script"><link href="/css/app.css" rel="stylesheet"></head><body><noscript><strong>Enable JavaScript to view this page.</strong></noscript><div id="app"></div><script src="/js/chunk-vendors.js"></script><script src="/js/app.js"></script></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width,initial-scale=1"><link rel="icon" href="/favicon.ico"><title>Health Dashboard | Gatus</title><script defer="defer" src="/js/chunk-vendors.js" type="module"></script><script defer="defer" src="/js/app.js" type="module"></script><link href="/css/app.css" rel="stylesheet"><script defer="defer" src="/js/chunk-vendors-legacy.js" nomodule></script><script defer="defer" src="/js/app-legacy.js" nomodule></script></head><body class="dark:bg-gray-900"><noscript><strong>Enable JavaScript to view this page.</strong></noscript><div id="app"></div></body></html>