Minor update

Add Messagebird alerting

README.md

@@ -27,6 +27,7 @@ core applications: https://status.twinnation.org/
     - [Configuring PagerDuty alerts](#configuring-pagerduty-alerts)
     - [Configuring Twilio alerts](#configuring-twilio-alerts)
     - [Configuring Mattermost alerts](#configuring-mattermost-alerts)
+    - [Configuring Messagebird alerts](#configuring-messagebird-alerts)    
     - [Configuring custom alerts](#configuring-custom-alerts)
   - [Kubernetes (ALPHA)](#kubernetes-alpha)
     - [Auto Discovery](#auto-discovery)
@@ -50,7 +51,7 @@ The main features of Gatus are:
 - **Highly flexible health check conditions**: While checking the response status may be enough for some use cases, Gatus goes much further and allows you to add conditions on the response time, the response body and even the IP address.
 - **Ability to use Gatus for user acceptance tests**: Thanks to the point above, you can leverage this application to create automated user acceptance tests.
 - **Very easy to configure**: Not only is the configuration designed to be as readable as possible, it's also extremely easy to add a new service or a new endpoint to monitor.
-- **Alerting**: While having a pretty visual dashboard is useful to keep track of the state of your application(s), you probably don't want to stare at it all day. Thus, notifications via Slack, Mattermost, PagerDuty and Twilio are supported out of the box with the ability to configure a custom alerting provider for any needs you might have, whether it be a different provider or a custom application that manages automated rollbacks. 
+- **Alerting**: While having a pretty visual dashboard is useful to keep track of the state of your application(s), you probably don't want to stare at it all day. Thus, notifications via Slack, Mattermost, Messagebird, PagerDuty and Twilio are supported out of the box with the ability to configure a custom alerting provider for any needs you might have, whether it be a different provider or a custom application that manages automated rollbacks. 
 - **Metrics**
 - **Low resource consumption**: As with most Go applications, the resource footprint that this application requires is negligibly small.
 - **Service auto discovery in Kubernetes** (ALPHA)
@@ -107,7 +108,7 @@ Note that you can also add environment variables in the configuration file (i.e.
 | `services[].dns`                         | Configuration for a service of type DNS. See [Monitoring using DNS queries](#monitoring-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`, `pagerduty`, `twilio`, `mattermost`, `custom` | Required `""`  |
+| `services[].alerts[].type`               | Type of alert. Valid types: `slack`, `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`            |
@@ -126,6 +127,10 @@ Note that you can also add environment variables in the configuration file (i.e.
 | `alerting.mattermost`                    | Configuration for alerts of type `mattermost`                                 | `{}`           |
 | `alerting.mattermost.webhook-url`        | Mattermost Webhook URL                                                        | Required `""`  |
 | `alerting.mattermost.insecure`           | Whether to skip verifying the server's certificate chain and host name        | `false`        |
+| `alerting.messagebird`                   | Settings for alerts of type `messagebird`                                     | `{}`           |
+| `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.custom`                        | Configuration for custom actions on failure or alerts                         | `{}`           |
 | `alerting.custom.url`                    | Custom alerting request url                                                   | Required `""`  |
 | `alerting.custom.method`                 | Request method                                                                | `GET`          |
@@ -139,6 +144,7 @@ Note that you can also add environment variables in the configuration file (i.e.
 | `disable-monitoring-lock`                | Whether to [disable the monitoring lock](#disable-monitoring-lock)            | `false`        |
 | `web.address`                            | Address to listen on                                                          | `0.0.0.0`      |
 | `web.port`                               | Port to listen on                                                             | `8080`         |
+| `web.context-root`                       | Context root which should be used by the web frontent                         | `/`            |
 
 For Kubernetes configuration, see [Kubernetes](#kubernetes-alpha)
 
@@ -305,6 +311,33 @@ Here's an example of what the notifications look like:
 ![Mattermost notifications](.github/assets/mattermost-alerts.png)
 
 
+#### Configuring Messagebird alerts
+
+Example of sending **SMS** text message alert using Messagebird:
+
+```yaml
+alerting:
+  messagebird:
+    access-key: "..."
+    originator: "31619191918"
+    recipients: "31619191919,31619191920"
+services:
+  - name: twinnation
+    interval: 30s
+    url: "https://twinnation.org/health"
+    alerts:
+      - type: messagebird
+        enabled: true
+        failure-threshold: 3
+        send-on-resolved: true
+        description: "healthcheck failed 3 times in a row"
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 300"
+```
+
+
 #### Configuring custom alerts
 
 While they're called alerts, you can use this feature to call anything. 

alerting/config.go

@@ -2,9 +2,10 @@ package alerting
 
 import (
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/alerting/provider/mattermost"
+	"github.com/TwinProduction/gatus/alerting/provider/messagebird"
 	"github.com/TwinProduction/gatus/alerting/provider/pagerduty"
 	"github.com/TwinProduction/gatus/alerting/provider/slack"
-	"github.com/TwinProduction/gatus/alerting/provider/mattermost"
 	"github.com/TwinProduction/gatus/alerting/provider/twilio"
 )
 
@@ -16,6 +17,9 @@ type Config struct {
 	// Mattermost is the configuration for the mattermost alerting provider
 	Mattermost *mattermost.AlertProvider `yaml:"mattermost"`
 
+	// Messagebird is the configuration for the messagebird alerting provider
+	Messagebird *messagebird.AlertProvider `yaml:"messagebird"`
+
 	// Pagerduty is the configuration for the pagerduty alerting provider
 	PagerDuty *pagerduty.AlertProvider `yaml:"pagerduty"`
 

alerting/provider/custom/custom.go

@@ -62,7 +62,7 @@ func (provider *AlertProvider) buildRequest(serviceName, alertDescription string
 		}
 	}
 	if len(method) == 0 {
-		method = "GET"
+		method = http.MethodGet
 	}
 	bodyBuffer := bytes.NewBuffer([]byte(body))
 	request, _ := http.NewRequest(method, providerURL, bodyBuffer)

alerting/provider/mattermost/mattermost.go

@@ -2,6 +2,8 @@ package mattermost
 
 import (
 	"fmt"
+	"net/http"
+
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
 )
@@ -39,8 +41,8 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
 	}
 	return &custom.AlertProvider{
-		URL:    provider.WebhookURL,
-		Method: "POST",
+		URL:      provider.WebhookURL,
+		Method:   http.MethodPost,
 		Insecure: provider.Insecure,
 		Body: fmt.Sprintf(`{
   "text": "",

alerting/provider/messagebird/messagebird.go

@@ -0,0 +1,50 @@
+package messagebird
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/core"
+)
+
+const (
+	restAPIURL = "https://rest.messagebird.com/messages"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Messagebird
+type AlertProvider struct {
+	AccessKey  string `yaml:"access-key"`
+	Originator string `yaml:"originator"`
+	Recipients string `yaml:"recipients"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.AccessKey) > 0 && len(provider.Originator) > 0 && len(provider.Recipients) > 0
+}
+
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+// Reference doc for messagebird https://developers.messagebird.com/api/sms-messaging/#send-outbound-sms
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
+	var message string
+	if resolved {
+		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.Description)
+	} else {
+		message = fmt.Sprintf("TRIGGERED: %s - %s", service.Name, alert.Description)
+	}
+
+	return &custom.AlertProvider{
+		URL:    restAPIURL,
+		Method: http.MethodPost,
+		Body: fmt.Sprintf(`{
+  "originator": "%s",
+  "recipients": "%s",
+  "body": "%s"
+}`, provider.Originator, provider.Recipients, message),
+		Headers: map[string]string{
+			"Content-Type":  "application/json",
+			"Authorization": fmt.Sprintf("AccessKey %s", provider.AccessKey),
+		},
+	}
+}

alerting/provider/messagebird/messagebird_test.go

@@ -0,0 +1,53 @@
+package messagebird
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+)
+
+func TestMessagebirdAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{
+		AccessKey:  "1",
+		Originator: "1",
+		Recipients: "1",
+	}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{
+		AccessKey:  "1",
+		Originator: "1",
+		Recipients: "1",
+	}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
+		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{
+		AccessKey:  "1",
+		Originator: "1",
+		Recipients: "1",
+	}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, false)
+	if customAlertProvider == nil {
+		t.Error("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
+		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
+	}
+}

alerting/provider/pagerduty/pagerduty.go

@@ -2,6 +2,8 @@ package pagerduty
 
 import (
 	"fmt"
+	"net/http"
+
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
 )
@@ -19,7 +21,7 @@ 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, result *core.Result, resolved bool) *custom.AlertProvider {
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
 	var message, eventAction, resolveKey string
 	if resolved {
 		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.Description)
@@ -32,7 +34,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 	}
 	return &custom.AlertProvider{
 		URL:    "https://events.pagerduty.com/v2/enqueue",
-		Method: "POST",
+		Method: http.MethodPost,
 		Body: fmt.Sprintf(`{
   "routing_key": "%s",
   "dedup_key": "%s",

alerting/provider/provider.go

@@ -2,9 +2,10 @@ package provider
 
 import (
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/alerting/provider/mattermost"
+	"github.com/TwinProduction/gatus/alerting/provider/messagebird"
 	"github.com/TwinProduction/gatus/alerting/provider/pagerduty"
 	"github.com/TwinProduction/gatus/alerting/provider/slack"
-	"github.com/TwinProduction/gatus/alerting/provider/mattermost"
 	"github.com/TwinProduction/gatus/alerting/provider/twilio"
 	"github.com/TwinProduction/gatus/core"
 )
@@ -24,5 +25,6 @@ var (
 	_ AlertProvider = (*twilio.AlertProvider)(nil)
 	_ AlertProvider = (*slack.AlertProvider)(nil)
 	_ AlertProvider = (*mattermost.AlertProvider)(nil)
+	_ AlertProvider = (*messagebird.AlertProvider)(nil)
 	_ AlertProvider = (*pagerduty.AlertProvider)(nil)
 )

alerting/provider/slack/slack.go

@@ -2,6 +2,7 @@ package slack
 
 import (
 	"fmt"
+	"net/http"
 
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
@@ -38,7 +39,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 	}
 	return &custom.AlertProvider{
 		URL:    provider.WebhookURL,
-		Method: "POST",
+		Method: http.MethodPost,
 		Body: fmt.Sprintf(`{
   "text": "",
   "attachments": [

alerting/provider/twilio/twilio.go

@@ -3,9 +3,11 @@ package twilio
 import (
 	"encoding/base64"
 	"fmt"
+	"net/http"
+	"net/url"
+
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
 	"github.com/TwinProduction/gatus/core"
-	"net/url"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Twilio
@@ -22,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 *core.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
 	var message string
 	if resolved {
 		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.Description)
@@ -31,7 +33,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 	}
 	return &custom.AlertProvider{
 		URL:    fmt.Sprintf("https://api.twilio.com/2010-04-01/Accounts/%s/Messages.json", provider.SID),
-		Method: "POST",
+		Method: http.MethodPost,
 		Body: url.Values{
 			"To":   {provider.To},
 			"From": {provider.From},

config/config.go

@@ -28,6 +28,9 @@ const (
 
 	// DefaultPort is the default port the service will listen on
 	DefaultPort = 8080
+
+	// DefaultContextRoot is the default context root of the web application
+	DefaultContextRoot = "/"
 )
 
 var (
@@ -84,6 +87,7 @@ func Get() *Config {
 }
 
 // Load loads a custom configuration file
+// Note that the misconfiguration of some fields may lead to panics. This is on purpose.
 func Load(configFile string) error {
 	log.Printf("[config][Load] Reading configuration from configFile=%s", configFile)
 	cfg, err := readConfigurationFile(configFile)
@@ -143,7 +147,7 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 
 func validateWebConfig(config *Config) {
 	if config.Web == nil {
-		config.Web = &webConfig{Address: DefaultAddress, Port: DefaultPort}
+		config.Web = &webConfig{Address: DefaultAddress, Port: DefaultPort, ContextRoot: DefaultContextRoot}
 	} else {
 		config.Web.validateAndSetDefaults()
 	}
@@ -198,6 +202,7 @@ func validateAlertingConfig(config *Config) {
 	alertTypes := []core.AlertType{
 		core.SlackAlert,
 		core.MattermostAlert,
+		core.MessagebirdAlert,
 		core.TwilioAlert,
 		core.PagerDutyAlert,
 		core.CustomAlert,
@@ -234,6 +239,12 @@ func GetAlertingProviderByAlertType(config *Config, alertType core.AlertType) pr
 			return nil
 		}
 		return config.Alerting.Mattermost
+	case core.MessagebirdAlert:
+		if config.Alerting.Messagebird == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Alerting.Messagebird
 	case core.TwilioAlert:
 		if config.Alerting.Twilio == nil {
 			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil

config/config_test.go

@@ -109,6 +109,9 @@ services:
 	if config.Web.Port != DefaultPort {
 		t.Errorf("Port should have been %d, because it is the default value", DefaultPort)
 	}
+	if config.Web.ContextRoot != DefaultContextRoot {
+		t.Errorf("ContextRoot should have been %s, because it is the default value", DefaultContextRoot)
+	}
 }
 
 func TestParseAndValidateConfigBytesWithAddress(t *testing.T) {
@@ -215,6 +218,44 @@ services:
 	}
 }
 
+func TestParseAndValidateConfigBytesWithPortAndHostAndContextRoot(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+web:
+  port: 12345
+  address: 127.0.0.1
+  context-root: /deeply/nested/down=/their
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("No error should've been returned")
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Metrics {
+		t.Error("Metrics should've been false by default")
+	}
+	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 config.Web.Address != "127.0.0.1" {
+		t.Errorf("Bind address should have been %s, because it is specified in config", "127.0.0.1")
+	}
+	if config.Web.Port != 12345 {
+		t.Errorf("Port should have been %d, because it is specified in config", 12345)
+	}
+	if config.Web.ContextRoot != "/deeply/nested/down=/their/" {
+		t.Errorf("Port should have been %s, because it is specified in config", "/deeply/nested/down=/their/")
+	}
+}
+
 func TestParseAndValidateConfigBytesWithInvalidPort(t *testing.T) {
 	defer func() { recover() }()
 	_, _ = parseAndValidateConfigBytes([]byte(`
@@ -260,6 +301,9 @@ services:
 	if config.Web.Port != DefaultPort {
 		t.Errorf("Port should have been %d, because it is the default value", DefaultPort)
 	}
+	if config.Web.ContextRoot != DefaultContextRoot {
+		t.Errorf("ContextRoot should have been %s, because it is the default value", DefaultContextRoot)
+	}
 }
 
 func TestParseAndValidateConfigBytesWithMetricsAndHostAndPort(t *testing.T) {
@@ -322,6 +366,10 @@ alerting:
     webhook-url: "http://example.com"
   pagerduty:
     integration-key: "00000000000000000000000000000000"
+  messagebird:
+    access-key: "1"
+    originator: "31619191918"
+    recipients: "31619191919"
 services:
   - name: twinnation
     url: https://twinnation.org/health
@@ -333,6 +381,8 @@ services:
         failure-threshold: 7
         success-threshold: 5
         description: "Healthcheck failed 7 times in a row"
+      - type: messagebird
+        enabled: true
     conditions:
       - "[STATUS] == 200"
 `))
@@ -357,9 +407,21 @@ services:
 	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.IntegrationKey != "00000000000000000000000000000000" {
 		t.Errorf("PagerDuty integration key should've been %s, but was %s", "00000000000000000000000000000000", config.Alerting.PagerDuty.IntegrationKey)
 	}
+	if config.Alerting.Messagebird.AccessKey != "1" {
+		t.Errorf("Messagebird access key should've been %s, but was %s", "1", config.Alerting.Messagebird.AccessKey)
+	}
+	if config.Alerting.Messagebird.Originator != "31619191918" {
+		t.Errorf("Messagebird originator field should've been %s, but was %s", "31619191918", config.Alerting.Messagebird.Originator)
+	}
+	if config.Alerting.Messagebird.Recipients != "31619191919" {
+		t.Errorf("Messagebird to recipients should've been %s, but was %s", "31619191919", config.Alerting.Messagebird.Recipients)
+	}
 	if len(config.Services) != 1 {
 		t.Error("There should've been 1 service")
 	}
@@ -372,8 +434,8 @@ services:
 	if config.Services[0].Alerts == nil {
 		t.Fatal("The service alerts shouldn't have been nil")
 	}
-	if len(config.Services[0].Alerts) != 2 {
-		t.Fatal("There should've been 2 alert configured")
+	if len(config.Services[0].Alerts) != 3 {
+		t.Fatal("There should've been 3 alert configured")
 	}
 	if !config.Services[0].Alerts[0].Enabled {
 		t.Error("The alert should've been enabled")
@@ -399,6 +461,9 @@ services:
 	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[0].Description)
 	}
+	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[1].Type)
+	}
 }
 
 func TestParseAndValidateConfigBytesWithInvalidPagerDutyAlertingConfig(t *testing.T) {

config/web.go

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

config/web_test.go

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

core/alert.go

@@ -40,6 +40,9 @@ const (
 	// 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"
 

main.go

@@ -29,13 +29,15 @@ func main() {
 	if cfg.Security != nil && cfg.Security.IsValid() {
 		resultsHandler = security.Handler(serviceResultsHandler, cfg.Security)
 	}
-	http.HandleFunc("/api/v1/results", resultsHandler)
-	http.HandleFunc("/health", healthHandler)
-	http.Handle("/", GzipHandler(http.FileServer(http.Dir("./static"))))
+	http.HandleFunc("/favicon.ico", favIconHandler) // favicon needs to be always served from the root
+	http.HandleFunc(cfg.Web.PrependWithContextRoot("/api/v1/results"), resultsHandler)
+	http.HandleFunc(cfg.Web.PrependWithContextRoot("/health"), healthHandler)
+	http.Handle(cfg.Web.ContextRoot, GzipHandler(http.StripPrefix(cfg.Web.ContextRoot, http.FileServer(http.Dir("./static")))))
+
 	if cfg.Metrics {
-		http.Handle("/metrics", promhttp.Handler())
+		http.Handle(cfg.Web.PrependWithContextRoot("/metrics"), promhttp.Handler())
 	}
-	log.Printf("[main][main] Listening on %s\n", cfg.Web.SocketAddress())
+	log.Printf("[main][main] Listening on %s%s\n", cfg.Web.SocketAddress(), cfg.Web.ContextRoot)
 	go watchdog.Monitor(cfg)
 	log.Fatal(http.ListenAndServe(cfg.Web.SocketAddress(), nil))
 }
@@ -88,3 +90,8 @@ func healthHandler(writer http.ResponseWriter, _ *http.Request) {
 	writer.WriteHeader(http.StatusOK)
 	_, _ = writer.Write([]byte("{\"status\":\"UP\"}"))
 }
+
+// favIconHandler handles requests for /favicon.ico
+func favIconHandler(writer http.ResponseWriter, request *http.Request) {
+	http.ServeFile(writer, request, "./static/favicon.ico")
+}

static/index.html

@@ -3,7 +3,7 @@
 <head>
 	<title>Health Dashboard</title>
 	<meta name="viewport" content="width=device-width, initial-scale=1" />
-	<link rel="stylesheet" href="/bootstrap.min.css" />
+	<link rel="stylesheet" href="./bootstrap.min.css" />
 	<style>
 		html, body {
 			background-color: #f7f9fb;
@@ -129,11 +129,11 @@
 		</div>
 	</div>
 
-	<script src="/jquery.min.js"></script>
+	<script src="./jquery.min.js"></script>
 
 	<div id="social">
 		<a href="https://github.com/TwinProduction/gatus" target="_blank" title="Gatus on GitHub">
-			<img src="/github.png" alt="GitHub" width="32" height="auto" />
+			<img src="./github.png" alt="GitHub" width="32" height="auto" />
 		</a>
 	</div>
 
@@ -220,7 +220,7 @@
 		}
 
 		function refreshResults() {
-			$.getJSON("/api/v1/results", function (data) {
+			$.getJSON("./api/v1/results", function (data) {
 				// Update the table only if there's a change
 				if (JSON.stringify(serviceStatuses) !== JSON.stringify(data)) {
 					serviceStatuses = data;