Merge pull request #83 from TwinProduction/persistence

Implement persistence

.dockerignore

@@ -3,3 +3,4 @@ Dockerfile
 .github
 .idea
 .git
+web/app

.github/codecov.yml

@@ -0,0 +1,6 @@
+ignore:
+  - "watchdog/watchdog.go"
+
+coverage:
+  status:
+    patch: off

.github/workflows/build.yml

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

.gitignore

@@ -1,4 +1,3 @@
-bin
 .idea
 .vscode
 gatus

Dockerfile

@@ -13,7 +13,7 @@ RUN CGO_ENABLED=0 GOOS=linux go build -mod vendor -a -installsuffix cgo -o gatus
 FROM scratch
 COPY --from=builder /app/gatus .
 COPY --from=builder /app/config.yaml ./config/config.yaml
-COPY --from=builder /app/static static/
+COPY --from=builder /app/web/static ./web/static
 COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
 ENV PORT=8080
 EXPOSE ${PORT}

Makefile

@@ -0,0 +1,14 @@
+docker-build:
+	docker build -t twinproduction/gatus:latest .
+
+docker-build-and-run:
+	docker build -t twinproduction/gatus:latest . && docker run -p 8080:8080 --name gatus twinproduction/gatus:latest
+
+build-frontend:
+	npm --prefix web/app run build
+
+run-frontend:
+	npm --prefix web/app run serve
+
+test:
+	go test -mod=vendor ./... -cover

alerting/provider/custom/custom.go

@@ -2,9 +2,11 @@ package custom
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"os"
 	"strings"
 
 	"github.com/TwinProduction/gatus/client"
@@ -74,6 +76,12 @@ func (provider *AlertProvider) buildHTTPRequest(serviceName, alertDescription st
 
 // Send a request to the alert provider and return the body
 func (provider *AlertProvider) Send(serviceName, alertDescription string, resolved bool) ([]byte, error) {
+	if os.Getenv("MOCK_ALERT_PROVIDER") == "true" {
+		if os.Getenv("MOCK_ALERT_PROVIDER_ERROR") == "true" {
+			return nil, errors.New("error")
+		}
+		return []byte("{}"), nil
+	}
 	request := provider.buildHTTPRequest(serviceName, alertDescription, resolved)
 	response, err := client.GetHTTPClient(provider.Insecure).Do(request)
 	if err != nil {

alerting/provider/slack/slack.go

@@ -31,7 +31,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 	for _, conditionResult := range result.ConditionResults {
 		var prefix string
 		if conditionResult.Success {
-			prefix = ":heavy_check_mark:"
+			prefix = ":white_check_mark:"
 		} else {
 			prefix = ":x:"
 		}

client/client.go

@@ -12,6 +12,10 @@ import (
 var (
 	secureHTTPClient   *http.Client
 	insecureHTTPClient *http.Client
+
+	// pingTimeout is the timeout for the Ping function
+	// This is mainly exposed for testing purposes
+	pingTimeout = 5 * time.Second
 )
 
 // GetHTTPClient returns the shared HTTP client
@@ -19,7 +23,7 @@ func GetHTTPClient(insecure bool) *http.Client {
 	if insecure {
 		if insecureHTTPClient == nil {
 			insecureHTTPClient = &http.Client{
-				Timeout: time.Second * 10,
+				Timeout: 10 * time.Second,
 				Transport: &http.Transport{
 					MaxIdleConns:        100,
 					MaxIdleConnsPerHost: 20,
@@ -62,7 +66,7 @@ func Ping(address string) (bool, time.Duration) {
 		return false, 0
 	}
 	pinger.Count = 1
-	pinger.Timeout = 5 * time.Second
+	pinger.Timeout = pingTimeout
 	pinger.SetNetwork("ip4")
 	pinger.SetPrivileged(true)
 	err = pinger.Run()
@@ -70,6 +74,10 @@ func Ping(address string) (bool, time.Duration) {
 		return false, 0
 	}
 	if pinger.Statistics() != nil {
+		// If the packet loss is 100, it means that the packet didn't reach the host
+		if pinger.Statistics().PacketLoss == 100 {
+			return false, pinger.Timeout
+		}
 		return true, pinger.Statistics().MaxRtt
 	}
 	return true, 0

client/client_test.go

@@ -2,6 +2,7 @@ package client
 
 import (
 	"testing"
+	"time"
 )
 
 func TestGetHTTPClient(t *testing.T) {
@@ -28,6 +29,7 @@ func TestGetHTTPClient(t *testing.T) {
 }
 
 func TestPing(t *testing.T) {
+	pingTimeout = 500 * time.Millisecond
 	if success, rtt := Ping("127.0.0.1"); !success {
 		t.Error("expected true")
 		if rtt == 0 {
@@ -35,7 +37,13 @@ func TestPing(t *testing.T) {
 		}
 	}
 	if success, rtt := Ping("256.256.256.256"); success {
-		t.Error("expected false")
+		t.Error("expected false, because the IP is invalid")
+		if rtt != 0 {
+			t.Error("Round-trip time returned on failure should've been 0")
+		}
+	}
+	if success, rtt := Ping("192.168.152.153"); success {
+		t.Error("expected false, because the IP is valid but the host should be unreachable")
 		if rtt != 0 {
 			t.Error("Round-trip time returned on failure should've been 0")
 		}

config.yaml

@@ -1,14 +1,14 @@
 services:
-  - name: frontend
+  - name: front-end
     group: core
     url: "https://twinnation.org/health"
     interval: 1m
     conditions:
       - "[STATUS] == 200"
       - "[BODY].status == UP"
-      - "[RESPONSE_TIME] < 70"
+      - "[RESPONSE_TIME] < 150"
 
-  - name: backend
+  - name: back-end
     group: core
     url: "http://example.org/"
     interval: 5m

config/config.go

@@ -11,6 +11,8 @@ import (
 	"github.com/TwinProduction/gatus/core"
 	"github.com/TwinProduction/gatus/k8s"
 	"github.com/TwinProduction/gatus/security"
+	"github.com/TwinProduction/gatus/storage"
+	"github.com/TwinProduction/gatus/util"
 	"gopkg.in/yaml.v2"
 )
 
@@ -28,9 +30,6 @@ 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 (
@@ -74,8 +73,11 @@ type Config struct {
 	// Kubernetes is the Kubernetes configuration
 	Kubernetes *k8s.Config `yaml:"kubernetes"`
 
+	// Storage is the configuration for how the data is stored
+	Storage *storage.Config `yaml:"storage"`
+
 	// Web is the configuration for the web listener
-	Web *webConfig `yaml:"web"`
+	Web *WebConfig `yaml:"web"`
 }
 
 // Get returns the configuration, or panics if the configuration hasn't loaded yet
@@ -86,6 +88,12 @@ func Get() *Config {
 	return config
 }
 
+// Set sets the configuration
+// Used only for testing
+func Set(cfg *Config) {
+	config = cfg
+}
+
 // 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 {
@@ -141,13 +149,33 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 		validateServicesConfig(config)
 		validateKubernetesConfig(config)
 		validateWebConfig(config)
+		validateStorageConfig(config)
 	}
 	return
 }
 
+func validateStorageConfig(config *Config) {
+	if config.Storage == nil {
+		config.Storage = &storage.Config{}
+	}
+	err := storage.Initialize(config.Storage)
+	if err != nil {
+		panic(err)
+	}
+	// Remove all ServiceStatus that represent services which no longer exist in the configuration
+	var keys []string
+	for _, service := range config.Services {
+		keys = append(keys, util.ConvertGroupAndServiceToKey(service.Group, service.Name))
+	}
+	numberOfServiceStatusesDeleted := storage.Get().DeleteAllServiceStatusesNotInKeys(keys)
+	if numberOfServiceStatusesDeleted > 0 {
+		log.Printf("[config][validateStorageConfig] Deleted %d service statuses because their matching services no longer existed", numberOfServiceStatusesDeleted)
+	}
+}
+
 func validateWebConfig(config *Config) {
 	if config.Web == nil {
-		config.Web = &webConfig{Address: DefaultAddress, Port: DefaultPort, ContextRoot: DefaultContextRoot}
+		config.Web = &WebConfig{Address: DefaultAddress, Port: DefaultPort}
 	} else {
 		config.Web.validateAndSetDefaults()
 	}

config/config_test.go

@@ -17,6 +17,16 @@ func TestGetBeforeConfigIsLoaded(t *testing.T) {
 	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")
 	if err == nil {
@@ -32,7 +42,10 @@ func TestLoadDefaultConfigurationFile(t *testing.T) {
 }
 
 func TestParseAndValidateConfigBytes(t *testing.T) {
-	config, err := parseAndValidateConfigBytes([]byte(`
+	file := t.TempDir() + "/test.db"
+	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
+storage:
+  file: %s
 services:
   - name: twinnation
     url: https://twinnation.org/health
@@ -44,9 +57,9 @@ services:
     conditions:
       - "[STATUS] != 400"
       - "[STATUS] != 500"
-`))
+`, file)))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -89,7 +102,7 @@ services:
       - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -109,9 +122,6 @@ 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) {
@@ -125,7 +135,7 @@ services:
       - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -155,12 +165,12 @@ web:
   port: 12345
 services:
   - name: twinnation
-    url: https://twinnation.org/actuator/health
+    url: https://twinnation.org/health
     conditions:
       - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -168,17 +178,15 @@ services:
 	if config.Metrics {
 		t.Error("Metrics should've been false by default")
 	}
-	if config.Services[0].URL != "https://twinnation.org/actuator/health" {
-		t.Errorf("URL should have been %s", "https://twinnation.org/actuator/health")
+	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 != DefaultAddress {
 		t.Errorf("Bind address should have been %s, because it is the default value", DefaultAddress)
 	}
-
 	if config.Web.Port != 12345 {
 		t.Errorf("Port should have been %d, because it is specified in config", 12345)
 	}
@@ -196,7 +204,7 @@ services:
       - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -218,44 +226,6 @@ 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(`
@@ -283,7 +253,7 @@ services:
       - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -303,9 +273,6 @@ 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)
-	}
 	if userAgent := config.Services[0].Headers["User-Agent"]; userAgent != "Test/2.0" {
 		t.Errorf("User-Agent should've been %s, got %s", "Test/2.0", userAgent)
 	}
@@ -324,7 +291,7 @@ services:
       - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -368,7 +335,6 @@ badconfig:
 func TestParseAndValidateConfigBytesWithAlerting(t *testing.T) {
 	config, err := parseAndValidateConfigBytes([]byte(`
 debug: true
-
 alerting:
   slack:
     webhook-url: "http://example.com"
@@ -395,7 +361,7 @@ services:
       - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -488,7 +454,7 @@ services:
       - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -522,7 +488,7 @@ services:
       - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -561,7 +527,7 @@ services:
       - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -614,7 +580,7 @@ services:
       - "[STATUS] == 200"
 `, expectedUsername, expectedPasswordHash)))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -681,7 +647,7 @@ kubernetes:
       target-path: "/health"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")

config/web.go

@@ -3,25 +3,20 @@ package config
 import (
 	"fmt"
 	"math"
-	"net/url"
-	"strings"
 )
 
-// webConfig is the structure which supports the configuration of the endpoint
+// WebConfig is the structure which supports the configuration of the endpoint
 // which provides access to the web frontend
-type webConfig struct {
+type WebConfig struct {
 	// Address to listen on (defaults to 0.0.0.0 specified by DefaultAddress)
 	Address string `yaml:"address"`
 
 	// Port to listen on (default to 8080 specified by DefaultPort)
 	Port int `yaml:"port"`
-
-	// ContextRoot set the root context for the web application
-	ContextRoot string `yaml:"context-root"`
 }
 
 // validateAndSetDefaults checks and sets the default values for fields that are not set
-func (web *webConfig) validateAndSetDefaults() {
+func (web *WebConfig) validateAndSetDefaults() {
 	// Validate the Address
 	if len(web.Address) == 0 {
 		web.Address = DefaultAddress
@@ -32,32 +27,9 @@ func (web *webConfig) validateAndSetDefaults() {
 	} else if web.Port < 0 || web.Port > math.MaxUint16 {
 		panic(fmt.Sprintf("invalid port: value should be between %d and %d", 0, math.MaxUint16))
 	}
-	// Validate the ContextRoot
-	if len(web.ContextRoot) == 0 {
-		web.ContextRoot = DefaultContextRoot
-	} else {
-		trimmedContextRoot := strings.Trim(web.ContextRoot, "/")
-		if len(trimmedContextRoot) == 0 {
-			web.ContextRoot = DefaultContextRoot
-			return
-		}
-		rootContextURL, err := url.Parse(trimmedContextRoot)
-		if err != nil {
-			panic("invalid context root:" + err.Error())
-		}
-		if rootContextURL.Path != trimmedContextRoot {
-			panic("invalid context root: too complex")
-		}
-		web.ContextRoot = "/" + strings.Trim(rootContextURL.Path, "/") + "/"
-	}
 }
 
 // SocketAddress returns the combination of the Address and the Port
-func (web *webConfig) SocketAddress() string {
+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,12 +1,11 @@
 package config
 
 import (
-	"fmt"
 	"testing"
 )
 
 func TestWebConfig_SocketAddress(t *testing.T) {
-	web := &webConfig{
+	web := &WebConfig{
 		Address: "0.0.0.0",
 		Port:    8081,
 	}
@@ -14,86 +13,3 @@ 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/"},
-	{"Multiple 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)
-		})
-	}
-}
-
-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)
-	}
-}
-
-// 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))
-}

controller/badge.go

@@ -14,26 +14,18 @@ import (
 // badgeHandler handles the automatic generation of badge based on the group name and service name passed.
 //
 // Valid values for {duration}: 7d, 24h, 1h
-// Pattern for {identifier}: group-<GROUP_NAME>-service-<SERVICE_NAME>.svg
+// Pattern for {identifier}: <KEY>.svg
 func badgeHandler(writer http.ResponseWriter, request *http.Request) {
 	variables := mux.Vars(request)
 	duration := variables["duration"]
-	// group-<GROUP_NAME>-service-<SERVICE_NAME>.svg
-	identifier := variables["identifier"]
 	if duration != "7d" && duration != "24h" && duration != "1h" {
 		writer.WriteHeader(http.StatusBadRequest)
 		_, _ = writer.Write([]byte("Durations supported: 7d, 24h, 1h"))
 		return
 	}
-	parts := strings.Split(identifier, "-service-")
-	if len(parts) != 2 || !strings.HasPrefix(identifier, "group-") || !strings.HasSuffix(identifier, ".svg") {
-		writer.WriteHeader(http.StatusBadRequest)
-		_, _ = writer.Write([]byte("Invalid path: Pattern should look like /group-<GROUP_NAME>-service-<SERVICE_NAME>.svg"))
-		return
-	}
-	groupName := strings.TrimPrefix(parts[0], "group-")
-	serviceName := strings.TrimSuffix(parts[1], ".svg")
-	uptime := watchdog.GetUptimeByServiceGroupAndName(groupName, serviceName)
+	identifier := variables["identifier"]
+	key := strings.TrimSuffix(identifier, ".svg")
+	uptime := watchdog.GetUptimeByKey(key)
 	if uptime == nil {
 		writer.WriteHeader(http.StatusNotFound)
 		_, _ = writer.Write([]byte("Requested service not found"))

controller/controller.go

@@ -3,9 +3,11 @@ package controller
 import (
 	"bytes"
 	"compress/gzip"
+	"encoding/json"
 	"fmt"
 	"log"
 	"net/http"
+	"os"
 	"strings"
 	"time"
 
@@ -23,6 +25,14 @@ const (
 
 var (
 	cache = gocache.NewCache().WithMaxSize(100).WithEvictionPolicy(gocache.LeastRecentlyUsed)
+
+	// staticFolder is the path to the location of the static folder from the root path of the project
+	// The only reason this is exposed is to allow running tests from a different path than the root path of the project
+	staticFolder = "./web/static"
+
+	// server is the http.Server created by Handle.
+	// The only reason it exists is for testing purposes.
+	server *http.Server
 )
 
 func init() {
@@ -34,36 +44,52 @@ func init() {
 // Handle creates the router and starts the server
 func Handle() {
 	cfg := config.Get()
-	router := CreateRouter(cfg)
-	server := &http.Server{
+	var router http.Handler = CreateRouter(cfg)
+	if os.Getenv("ENVIRONMENT") == "dev" {
+		router = developmentCorsHandler(router)
+	}
+	server = &http.Server{
 		Addr:         fmt.Sprintf("%s:%d", cfg.Web.Address, cfg.Web.Port),
 		Handler:      router,
 		ReadTimeout:  15 * time.Second,
 		WriteTimeout: 15 * time.Second,
 		IdleTimeout:  15 * time.Second,
 	}
-	log.Printf("[controller][Handle] Listening on %s%s\n", cfg.Web.SocketAddress(), cfg.Web.ContextRoot)
+	log.Println("[controller][Handle] Listening on " + cfg.Web.SocketAddress())
+	if os.Getenv("ROUTER_TEST") == "true" {
+		return
+	}
 	log.Fatal(server.ListenAndServe())
 }
 
 // CreateRouter creates the router for the http server
 func CreateRouter(cfg *config.Config) *mux.Router {
 	router := mux.NewRouter()
-	statusesHandler := serviceStatusesHandler
-	if cfg.Security != nil && cfg.Security.IsValid() {
-		statusesHandler = security.Handler(serviceStatusesHandler, cfg.Security)
-	}
-	router.HandleFunc("/favicon.ico", favIconHandler).Methods("GET") // favicon needs to be always served from the root
-	router.HandleFunc(cfg.Web.PrependWithContextRoot("/api/v1/statuses"), statusesHandler).Methods("GET")
-	router.HandleFunc(cfg.Web.PrependWithContextRoot("/api/v1/badges/uptime/{duration}/{identifier}"), badgeHandler).Methods("GET")
-	router.HandleFunc(cfg.Web.PrependWithContextRoot("/health"), healthHandler).Methods("GET")
-	router.PathPrefix(cfg.Web.ContextRoot).Handler(GzipHandler(http.StripPrefix(cfg.Web.ContextRoot, http.FileServer(http.Dir("./static")))))
 	if cfg.Metrics {
-		router.Handle(cfg.Web.PrependWithContextRoot("/metrics"), promhttp.Handler()).Methods("GET")
+		router.Handle("/metrics", promhttp.Handler()).Methods("GET")
 	}
+	router.HandleFunc("/favicon.ico", favIconHandler).Methods("GET")
+	router.HandleFunc("/health", healthHandler).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/badges/uptime/{duration}/{identifier}", badgeHandler).Methods("GET")
+	// SPA
+	router.HandleFunc("/services/{service}", spaHandler).Methods("GET")
+	// Everything else falls back on static content
+	router.PathPrefix("/").Handler(GzipHandler(http.FileServer(http.Dir(staticFolder))))
 	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)
+	}
+	return handler
+}
+
+// serviceStatusesHandler handles requests to retrieve all service statuses
+// Due to the size of the response, this function leverages a cache.
+// Must not be wrapped by GzipHandler
 func serviceStatusesHandler(writer http.ResponseWriter, r *http.Request) {
 	gzipped := strings.Contains(r.Header.Get("Accept-Encoding"), "gzip")
 	var exists bool
@@ -81,7 +107,7 @@ func serviceStatusesHandler(writer http.ResponseWriter, r *http.Request) {
 		gzipWriter := gzip.NewWriter(buffer)
 		data, err = watchdog.GetServiceStatusesAsJSON()
 		if err != nil {
-			log.Printf("[main][serviceStatusesHandler] Unable to marshal object to JSON: %s", err.Error())
+			log.Printf("[controller][serviceStatusesHandler] Unable to marshal object to JSON: %s", err.Error())
 			writer.WriteHeader(http.StatusInternalServerError)
 			_, _ = writer.Write([]byte("Unable to marshal object to JSON"))
 			return
@@ -102,6 +128,36 @@ func serviceStatusesHandler(writer http.ResponseWriter, r *http.Request) {
 	_, _ = writer.Write(data)
 }
 
+// serviceStatusHandler retrieves a single ServiceStatus by group name and service name
+func serviceStatusHandler(writer http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	serviceStatus := watchdog.GetServiceStatusByKey(vars["key"])
+	if serviceStatus == nil {
+		log.Printf("[controller][serviceStatusHandler] Service with key=%s not found", vars["key"])
+		writer.WriteHeader(http.StatusNotFound)
+		_, _ = writer.Write([]byte("not found"))
+		return
+	}
+	data := map[string]interface{}{
+		"serviceStatus": serviceStatus,
+		// The following fields, while present on core.ServiceStatus, are annotated to remain hidden so that we can
+		// expose only the necessary data on /api/v1/statuses.
+		// Since the /api/v1/statuses/{key} endpoint does need this data, however, we explicitly expose it here
+		"events": serviceStatus.Events,
+		"uptime": serviceStatus.Uptime,
+	}
+	output, err := json.Marshal(data)
+	if err != nil {
+		log.Printf("[controller][serviceStatusHandler] Unable to marshal object to JSON: %s", err.Error())
+		writer.WriteHeader(http.StatusInternalServerError)
+		_, _ = writer.Write([]byte("Unable to marshal object to JSON"))
+		return
+	}
+	writer.Header().Add("Content-Type", "application/json")
+	writer.WriteHeader(http.StatusOK)
+	_, _ = writer.Write(output)
+}
+
 func healthHandler(writer http.ResponseWriter, _ *http.Request) {
 	writer.Header().Add("Content-Type", "application/json")
 	writer.WriteHeader(http.StatusOK)
@@ -110,5 +166,10 @@ func healthHandler(writer http.ResponseWriter, _ *http.Request) {
 
 // favIconHandler handles requests for /favicon.ico
 func favIconHandler(writer http.ResponseWriter, request *http.Request) {
-	http.ServeFile(writer, request, "./static/favicon.ico")
+	http.ServeFile(writer, request, staticFolder+"/favicon.ico")
+}
+
+// spaHandler handles requests for /favicon.ico
+func spaHandler(writer http.ResponseWriter, request *http.Request) {
+	http.ServeFile(writer, request, staticFolder+"/index.html")
 }

controller/controller_test.go

@@ -0,0 +1,169 @@
+package controller
+
+import (
+	"math/rand"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/TwinProduction/gatus/config"
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/watchdog"
+)
+
+func TestCreateRouter(t *testing.T) {
+	staticFolder = "../web/static"
+	cfg := &config.Config{
+		Metrics: true,
+		Services: []*core.Service{
+			{
+				Name:  "frontend",
+				Group: "core",
+			},
+			{
+				Name:  "backend",
+				Group: "core",
+			},
+		},
+	}
+	watchdog.UpdateServiceStatuses(cfg.Services[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
+	watchdog.UpdateServiceStatuses(cfg.Services[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
+	router := CreateRouter(cfg)
+	type Scenario struct {
+		Name         string
+		Path         string
+		ExpectedCode int
+		Gzip         bool
+	}
+	scenarios := []Scenario{
+		{
+			Name:         "health",
+			Path:         "/health",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "metrics",
+			Path:         "/metrics",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badges-1h",
+			Path:         "/api/v1/badges/uptime/1h/core_frontend.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badges-24h",
+			Path:         "/api/v1/badges/uptime/24h/core_backend.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badges-7d",
+			Path:         "/api/v1/badges/uptime/7d/core_frontend.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "badges-with-invalid-duration",
+			Path:         "/api/v1/badges/uptime/3d/core_backend.svg",
+			ExpectedCode: http.StatusBadRequest,
+		},
+		{
+			Name:         "badges-for-invalid-key",
+			Path:         "/api/v1/badges/uptime/7d/invalid_key.svg",
+			ExpectedCode: http.StatusNotFound,
+		},
+		{
+			Name:         "service-statuses",
+			Path:         "/api/v1/statuses",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "service-statuses-gzip",
+			Path:         "/api/v1/statuses",
+			ExpectedCode: http.StatusOK,
+			Gzip:         true,
+		},
+		{
+			Name:         "service-status",
+			Path:         "/api/v1/statuses/core_frontend",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "service-status-gzip",
+			Path:         "/api/v1/statuses/core_frontend",
+			ExpectedCode: http.StatusOK,
+			Gzip:         true,
+		},
+		{
+			Name:         "service-status-for-invalid-key",
+			Path:         "/api/v1/statuses/invalid_key",
+			ExpectedCode: http.StatusNotFound,
+		},
+		{
+			Name:         "favicon",
+			Path:         "/favicon.ico",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "frontend-home",
+			Path:         "/",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "frontend-assets",
+			Path:         "/js/app.js",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "frontend-service",
+			Path:         "/services/core_frontend",
+			ExpectedCode: http.StatusOK,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			if scenario.Gzip {
+				request.Header.Set("Accept-Encoding", "gzip")
+			}
+			responseRecorder := httptest.NewRecorder()
+			router.ServeHTTP(responseRecorder, request)
+			if responseRecorder.Code != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			}
+		})
+	}
+}
+
+func TestHandle(t *testing.T) {
+	cfg := &config.Config{
+		Web: &config.WebConfig{
+			Address: "0.0.0.0",
+			Port:    rand.Intn(65534),
+		},
+		Services: []*core.Service{
+			{
+				Name:  "frontend",
+				Group: "core",
+			},
+			{
+				Name:  "backend",
+				Group: "core",
+			},
+		},
+	}
+	config.Set(cfg)
+	_ = os.Setenv("ROUTER_TEST", "true")
+	_ = os.Setenv("ENVIRONMENT", "dev")
+	Handle()
+	request, _ := http.NewRequest("GET", "/health", nil)
+	responseRecorder := httptest.NewRecorder()
+	server.Handler.ServeHTTP(responseRecorder, request)
+	if responseRecorder.Code != http.StatusOK {
+		t.Error("expected GET /health to return status code 200")
+	}
+	if server == nil {
+		t.Fatal("server should've been set (but because we set ROUTER_TEST, it shouldn't have been started)")
+	}
+}

controller/cors.go

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

controller/gzip.go

@@ -32,10 +32,18 @@ func (w *gzipResponseWriter) Write(b []byte) (int, error) {
 	return w.Writer.Write(b)
 }
 
-// GzipHandler compresses the response of a given handler if the request's headers specify that the client
+// GzipHandler compresses the response of a given http.Handler if the request's headers specify that the client
 // supports gzip encoding
 func GzipHandler(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(writer http.ResponseWriter, r *http.Request) {
+	return GzipHandlerFunc(func(writer http.ResponseWriter, r *http.Request) {
+		next.ServeHTTP(writer, r)
+	})
+}
+
+// GzipHandlerFunc compresses the response of a given http.HandlerFunc if the request's headers specify that the client
+// supports gzip encoding
+func GzipHandlerFunc(next http.HandlerFunc) http.HandlerFunc {
+	return func(writer http.ResponseWriter, r *http.Request) {
 		// If the request doesn't specify that it supports gzip, then don't compress it
 		if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
 			next.ServeHTTP(writer, r)
@@ -47,5 +55,5 @@ func GzipHandler(next http.Handler) http.Handler {
 		gz.Reset(writer)
 		defer gz.Close()
 		next.ServeHTTP(&gzipResponseWriter{ResponseWriter: writer, Writer: gz}, r)
-	})
+	}
 }

core/alert.go

@@ -26,6 +26,12 @@ type Alert struct {
 
 	// Triggered is used to determine whether an alert has been triggered. When an alert is resolved, this value
 	// should be set back to false. It is used to prevent the same alert from going out twice.
+	//
+	// This value should only be modified if the provider.AlertProvider's Send function does not return an error for an
+	// alert that hasn't been triggered yet. This doubles as a lazy retry. The reason why this behavior isn't also
+	// applied for alerts that are already triggered and has become "healthy" again is to prevent a case where, for
+	// some reason, the alert provider always returns errors when trying to send the resolved notification
+	// (SendOnResolved).
 	Triggered bool
 }
 

core/condition.go

@@ -2,7 +2,6 @@ package core
 
 import (
 	"fmt"
-	"log"
 	"strconv"
 	"strings"
 	"time"
@@ -48,11 +47,20 @@ const (
 	CertificateExpirationPlaceholder = "[CERTIFICATE_EXPIRATION]"
 
 	// LengthFunctionPrefix is the prefix for the length function
+	//
+	// Usage: len([BODY].articles) == 10, len([BODY].name) > 5
 	LengthFunctionPrefix = "len("
 
 	// PatternFunctionPrefix is the prefix for the pattern function
+	//
+	// Usage: pat(192.168.*.*)
 	PatternFunctionPrefix = "pat("
 
+	// AnyFunctionPrefix is the prefix for the any function
+	//
+	// Usage: any(1.1.1.1, 1.0.0.1)
+	AnyFunctionPrefix = "any("
+
 	// FunctionSuffix is the suffix for all functions
 	FunctionSuffix = ")"
 
@@ -64,51 +72,52 @@ const (
 type Condition string
 
 // evaluate the Condition with the Result of the health check
-func (c *Condition) evaluate(result *Result) bool {
-	condition := string(*c)
+func (c Condition) evaluate(result *Result) bool {
+	condition := string(c)
 	success := false
-	var resolvedCondition string
+	conditionToDisplay := condition
 	if strings.Contains(condition, "==") {
-		parts := sanitizeAndResolve(strings.Split(condition, "=="), result)
-		success = isEqual(parts[0], parts[1])
-		resolvedCondition = fmt.Sprintf("%v == %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolve(strings.Split(condition, "=="), result)
+		success = isEqual(resolvedParameters[0], resolvedParameters[1])
+		if !success {
+			conditionToDisplay = prettify(parameters, resolvedParameters, "==")
+		}
 	} else if strings.Contains(condition, "!=") {
-		parts := sanitizeAndResolve(strings.Split(condition, "!="), result)
-		success = !isEqual(parts[0], parts[1])
-		resolvedCondition = fmt.Sprintf("%v != %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolve(strings.Split(condition, "!="), result)
+		success = !isEqual(resolvedParameters[0], resolvedParameters[1])
+		if !success {
+			conditionToDisplay = prettify(parameters, resolvedParameters, "!=")
+		}
 	} else if strings.Contains(condition, "<=") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, "<="), result)
-		success = parts[0] <= parts[1]
-		resolvedCondition = fmt.Sprintf("%v <= %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, "<="), result)
+		success = resolvedParameters[0] <= resolvedParameters[1]
+		if !success {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, "<=")
+		}
 	} else if strings.Contains(condition, ">=") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, ">="), result)
-		success = parts[0] >= parts[1]
-		resolvedCondition = fmt.Sprintf("%v >= %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, ">="), result)
+		success = resolvedParameters[0] >= resolvedParameters[1]
+		if !success {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, ">=")
+		}
 	} else if strings.Contains(condition, ">") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, ">"), result)
-		success = parts[0] > parts[1]
-		resolvedCondition = fmt.Sprintf("%v > %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, ">"), result)
+		success = resolvedParameters[0] > resolvedParameters[1]
+		if !success {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, ">")
+		}
 	} else if strings.Contains(condition, "<") {
-		parts := sanitizeAndResolveNumerical(strings.Split(condition, "<"), result)
-		success = parts[0] < parts[1]
-		resolvedCondition = fmt.Sprintf("%v < %v", parts[0], parts[1])
+		parameters, resolvedParameters := sanitizeAndResolveNumerical(strings.Split(condition, "<"), result)
+		success = resolvedParameters[0] < resolvedParameters[1]
+		if !success {
+			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, "<")
+		}
 	} else {
 		result.Errors = append(result.Errors, fmt.Sprintf("invalid condition '%s' has been provided", condition))
 		return false
 	}
-	conditionToDisplay := condition
-	// If the condition isn't a success, return what the resolved condition was too
 	if !success {
-		log.Printf("[Condition][evaluate] Condition '%s' did not succeed because '%s' is false", condition, resolvedCondition)
-		// Check if the resolved condition was an invalid path
-		isResolvedConditionInvalidPath := strings.ReplaceAll(resolvedCondition, fmt.Sprintf("%s ", InvalidConditionElementSuffix), "") == condition
-		if isResolvedConditionInvalidPath {
-			// Since, in the event of an invalid path, the resolvedCondition contains the condition itself,
-			// we'll only display the resolvedCondition
-			conditionToDisplay = resolvedCondition
-		} else {
-			conditionToDisplay = fmt.Sprintf("%s (%s)", condition, resolvedCondition)
-		}
+		//log.Printf("[Condition][evaluate] Condition '%s' did not succeed because '%s' is false", condition, condition)
 	}
 	result.ConditionResults = append(result.ConditionResults, &ConditionResult{Condition: conditionToDisplay, Success: success})
 	return success
@@ -116,33 +125,66 @@ func (c *Condition) evaluate(result *Result) bool {
 
 // isEqual compares two strings.
 //
-// It also supports the pattern function. That is to say, if one of the strings starts with PatternFunctionPrefix
-// and ends with FunctionSuffix, it will be treated like a pattern.
+// Supports the pattern and the any functions.
+// i.e. if one of the parameters starts with PatternFunctionPrefix and ends with FunctionSuffix, it will be treated like
+// a pattern.
 func isEqual(first, second string) bool {
-	var isFirstPattern, isSecondPattern bool
-	if strings.HasPrefix(first, PatternFunctionPrefix) && strings.HasSuffix(first, FunctionSuffix) {
-		isFirstPattern = true
-		first = strings.TrimSuffix(strings.TrimPrefix(first, PatternFunctionPrefix), FunctionSuffix)
-	}
-	if strings.HasPrefix(second, PatternFunctionPrefix) && strings.HasSuffix(second, FunctionSuffix) {
-		isSecondPattern = true
-		second = strings.TrimSuffix(strings.TrimPrefix(second, PatternFunctionPrefix), FunctionSuffix)
-	}
-	if isFirstPattern && !isSecondPattern {
-		return pattern.Match(first, second)
-	} else if !isFirstPattern && isSecondPattern {
-		return pattern.Match(second, first)
-	} else {
-		return first == second
+	firstHasFunctionSuffix := strings.HasSuffix(first, FunctionSuffix)
+	secondHasFunctionSuffix := strings.HasSuffix(second, FunctionSuffix)
+	if firstHasFunctionSuffix || secondHasFunctionSuffix {
+		var isFirstPattern, isSecondPattern bool
+		if strings.HasPrefix(first, PatternFunctionPrefix) && firstHasFunctionSuffix {
+			isFirstPattern = true
+			first = strings.TrimSuffix(strings.TrimPrefix(first, PatternFunctionPrefix), FunctionSuffix)
+		}
+		if strings.HasPrefix(second, PatternFunctionPrefix) && secondHasFunctionSuffix {
+			isSecondPattern = true
+			second = strings.TrimSuffix(strings.TrimPrefix(second, PatternFunctionPrefix), FunctionSuffix)
+		}
+		if isFirstPattern && !isSecondPattern {
+			return pattern.Match(first, second)
+		} else if !isFirstPattern && isSecondPattern {
+			return pattern.Match(second, first)
+		}
+		var isFirstAny, isSecondAny bool
+		if strings.HasPrefix(first, AnyFunctionPrefix) && firstHasFunctionSuffix {
+			isFirstAny = true
+			first = strings.TrimSuffix(strings.TrimPrefix(first, AnyFunctionPrefix), FunctionSuffix)
+		}
+		if strings.HasPrefix(second, AnyFunctionPrefix) && secondHasFunctionSuffix {
+			isSecondAny = true
+			second = strings.TrimSuffix(strings.TrimPrefix(second, AnyFunctionPrefix), FunctionSuffix)
+		}
+		if isFirstAny && !isSecondAny {
+			options := strings.Split(first, ",")
+			for _, option := range options {
+				if strings.TrimSpace(option) == second {
+					return true
+				}
+			}
+			return false
+		} else if !isFirstAny && isSecondAny {
+			options := strings.Split(second, ",")
+			for _, option := range options {
+				if strings.TrimSpace(option) == first {
+					return true
+				}
+			}
+			return false
+		}
 	}
+	return first == second
 }
 
-// sanitizeAndResolve sanitizes and resolves a list of element and returns the list of resolved elements
-func sanitizeAndResolve(list []string, result *Result) []string {
-	var sanitizedList []string
+// sanitizeAndResolve sanitizes and resolves a list of elements and returns the list of parameters as well as a list
+// of resolved parameters
+func sanitizeAndResolve(elements []string, result *Result) ([]string, []string) {
+	parameters := make([]string, len(elements))
+	resolvedParameters := make([]string, len(elements))
 	body := strings.TrimSpace(string(result.Body))
-	for _, element := range list {
+	for i, element := range elements {
 		element = strings.TrimSpace(element)
+		parameters[i] = element
 		switch strings.ToUpper(element) {
 		case StatusPlaceholder:
 			element = strconv.Itoa(result.HTTPStatus)
@@ -166,42 +208,68 @@ func sanitizeAndResolve(list []string, result *Result) []string {
 					wantLength = true
 					element = strings.TrimSuffix(strings.TrimPrefix(element, LengthFunctionPrefix), FunctionSuffix)
 				}
-				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.Replace(element, fmt.Sprintf("%s.", BodyPlaceholder), "", 1), result.Body)
+				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.TrimPrefix(element, BodyPlaceholder+"."), result.Body)
 				if err != nil {
 					if err.Error() != "unexpected end of JSON input" {
 						result.Errors = append(result.Errors, err.Error())
 					}
 					if wantLength {
-						element = fmt.Sprintf("%s%s%s %s", LengthFunctionPrefix, element, FunctionSuffix, InvalidConditionElementSuffix)
+						element = LengthFunctionPrefix + element + FunctionSuffix + " " + InvalidConditionElementSuffix
 					} else {
-						element = fmt.Sprintf("%s %s", element, InvalidConditionElementSuffix)
+						element = element + " " + InvalidConditionElementSuffix
 					}
 				} else {
 					if wantLength {
-						element = fmt.Sprintf("%d", resolvedElementLength)
+						element = strconv.Itoa(resolvedElementLength)
 					} else {
 						element = resolvedElement
 					}
 				}
 			}
 		}
-		sanitizedList = append(sanitizedList, element)
+		resolvedParameters[i] = element
 	}
-	return sanitizedList
+	return parameters, resolvedParameters
 }
 
-func sanitizeAndResolveNumerical(list []string, result *Result) []int64 {
-	var sanitizedNumbers []int64
-	sanitizedList := sanitizeAndResolve(list, result)
-	for _, element := range sanitizedList {
+func sanitizeAndResolveNumerical(list []string, result *Result) (parameters []string, resolvedNumericalParameters []int64) {
+	parameters, resolvedParameters := sanitizeAndResolve(list, result)
+	for _, element := range resolvedParameters {
 		if duration, err := time.ParseDuration(element); duration != 0 && err == nil {
-			sanitizedNumbers = append(sanitizedNumbers, duration.Milliseconds())
+			resolvedNumericalParameters = append(resolvedNumericalParameters, duration.Milliseconds())
 		} else if number, err := strconv.ParseInt(element, 10, 64); err != nil {
 			// Default to 0 if the string couldn't be converted to an integer
-			sanitizedNumbers = append(sanitizedNumbers, 0)
+			resolvedNumericalParameters = append(resolvedNumericalParameters, 0)
 		} else {
-			sanitizedNumbers = append(sanitizedNumbers, number)
+			resolvedNumericalParameters = append(resolvedNumericalParameters, number)
 		}
 	}
-	return sanitizedNumbers
+	return parameters, resolvedNumericalParameters
+}
+
+func prettifyNumericalParameters(parameters []string, resolvedParameters []int64, operator string) string {
+	return prettify(parameters, []string{strconv.Itoa(int(resolvedParameters[0])), strconv.Itoa(int(resolvedParameters[1]))}, operator)
+}
+
+// XXX: make this configurable? i.e. show-resolved-conditions-on-failure
+func prettify(parameters []string, resolvedParameters []string, operator string) string {
+	// Since, in the event of an invalid path, the resolvedParameters also contain the condition itself,
+	// we'll return the resolvedParameters as-is.
+	if strings.HasSuffix(resolvedParameters[0], InvalidConditionElementSuffix) || strings.HasSuffix(resolvedParameters[1], InvalidConditionElementSuffix) {
+		return resolvedParameters[0] + " " + operator + " " + resolvedParameters[1]
+	}
+	// First element is a placeholder
+	if parameters[0] != resolvedParameters[0] && parameters[1] == resolvedParameters[1] {
+		return parameters[0] + " (" + resolvedParameters[0] + ") " + operator + " " + parameters[1]
+	}
+	// Second element is a placeholder
+	if parameters[0] == resolvedParameters[0] && parameters[1] != resolvedParameters[1] {
+		return parameters[0] + " " + operator + " " + parameters[1] + " (" + resolvedParameters[1] + ")"
+	}
+	// Both elements are placeholders...?
+	if parameters[0] != resolvedParameters[0] && parameters[1] != resolvedParameters[1] {
+		return parameters[0] + " (" + resolvedParameters[0] + ") " + operator + " " + parameters[1] + " (" + resolvedParameters[1] + ")"
+	}
+	// Neither elements are placeholders
+	return parameters[0] + " " + operator + " " + parameters[1]
 }

core/condition_bench_test.go

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

core/condition_test.go

@@ -1,6 +1,7 @@
 package core
 
 import (
+	"fmt"
 	"strconv"
 	"testing"
 	"time"
@@ -22,6 +23,9 @@ func TestCondition_evaluateWithStatus(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	if result.ConditionResults[0].Condition != string(condition) {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, condition, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithStatusFailure(t *testing.T) {
@@ -31,6 +35,10 @@ func TestCondition_evaluateWithStatusFailure(t *testing.T) {
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[STATUS] (500) == 200"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithStatusUsingLessThan(t *testing.T) {
@@ -40,6 +48,10 @@ func TestCondition_evaluateWithStatusUsingLessThan(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[STATUS] < 300"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithStatusFailureUsingLessThan(t *testing.T) {
@@ -49,6 +61,10 @@ func TestCondition_evaluateWithStatusFailureUsingLessThan(t *testing.T) {
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[STATUS] (404) < 300"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithResponseTimeUsingLessThan(t *testing.T) {
@@ -58,6 +74,10 @@ func TestCondition_evaluateWithResponseTimeUsingLessThan(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] < 500"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithResponseTimeUsingLessThanDuration(t *testing.T) {
@@ -67,6 +87,10 @@ func TestCondition_evaluateWithResponseTimeUsingLessThanDuration(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] < 1s"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithResponseTimeUsingLessThanInvalid(t *testing.T) {
@@ -76,6 +100,10 @@ func TestCondition_evaluateWithResponseTimeUsingLessThanInvalid(t *testing.T) {
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have failed because the condition has an invalid numerical value that should've automatically resolved to 0", condition)
 	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] (50) < potato (0)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithResponseTimeUsingGreaterThan(t *testing.T) {
@@ -87,6 +115,10 @@ func TestCondition_evaluateWithResponseTimeUsingGreaterThan(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] > 500"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithResponseTimeUsingGreaterThanDuration(t *testing.T) {
@@ -96,6 +128,10 @@ func TestCondition_evaluateWithResponseTimeUsingGreaterThanDuration(t *testing.T
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] > 1s"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithResponseTimeUsingGreaterThanOrEqualTo(t *testing.T) {
@@ -105,6 +141,10 @@ func TestCondition_evaluateWithResponseTimeUsingGreaterThanOrEqualTo(t *testing.
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] >= 500"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithResponseTimeUsingLessThanOrEqualTo(t *testing.T) {
@@ -114,6 +154,10 @@ func TestCondition_evaluateWithResponseTimeUsingLessThanOrEqualTo(t *testing.T)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[RESPONSE_TIME] <= 500"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBody(t *testing.T) {
@@ -123,6 +167,10 @@ func TestCondition_evaluateWithBody(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY] == test"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyJSONPath(t *testing.T) {
@@ -132,6 +180,10 @@ func TestCondition_evaluateWithBodyJSONPath(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].status == UP"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyJSONPathComplex(t *testing.T) {
@@ -141,31 +193,35 @@ func TestCondition_evaluateWithBodyJSONPathComplex(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.name == john"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithInvalidBodyJSONPathComplex(t *testing.T) {
-	expectedResolvedCondition := "[BODY].data.name (INVALID) == john"
 	condition := Condition("[BODY].data.name == john")
 	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
 	condition.evaluate(result)
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure, because the path was invalid", condition)
 	}
-	if result.ConditionResults[0].Condition != expectedResolvedCondition {
-		t.Errorf("Condition '%s' should have resolved to '%s', but resolved to '%s' instead", condition, expectedResolvedCondition, result.ConditionResults[0].Condition)
+	expectedConditionDisplayed := "[BODY].data.name (INVALID) == john"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
 	}
 }
 
 func TestCondition_evaluateWithInvalidBodyJSONPathComplexWithLengthFunction(t *testing.T) {
-	expectedResolvedCondition := "len([BODY].data.name) (INVALID) == john"
 	condition := Condition("len([BODY].data.name) == john")
 	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
 	condition.evaluate(result)
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure, because the path was invalid", condition)
 	}
-	if result.ConditionResults[0].Condition != expectedResolvedCondition {
-		t.Errorf("Condition '%s' should have resolved to '%s', but resolved to '%s' instead", condition, expectedResolvedCondition, result.ConditionResults[0].Condition)
+	expectedConditionDisplayed := "len([BODY].data.name) (INVALID) == john"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
 	}
 }
 
@@ -176,6 +232,10 @@ func TestCondition_evaluateWithBodyJSONPathDoublePlaceholders(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].user.firstName != [BODY].user.lastName"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyJSONPathDoublePlaceholdersFailure(t *testing.T) {
@@ -185,6 +245,10 @@ func TestCondition_evaluateWithBodyJSONPathDoublePlaceholdersFailure(t *testing.
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[BODY].user.firstName (john) == [BODY].user.lastName (doe)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyJSONPathLongInt(t *testing.T) {
@@ -194,6 +258,10 @@ func TestCondition_evaluateWithBodyJSONPathLongInt(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.id == 1"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyJSONPathComplexInt(t *testing.T) {
@@ -203,6 +271,10 @@ func TestCondition_evaluateWithBodyJSONPathComplexInt(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data[1].id == 2"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyJSONPathComplexIntUsingGreaterThan(t *testing.T) {
@@ -212,6 +284,10 @@ func TestCondition_evaluateWithBodyJSONPathComplexIntUsingGreaterThan(t *testing
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.id > 0"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyJSONPathComplexIntFailureUsingGreaterThan(t *testing.T) {
@@ -221,6 +297,10 @@ func TestCondition_evaluateWithBodyJSONPathComplexIntFailureUsingGreaterThan(t *
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.id (1) > 5"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyJSONPathComplexIntUsingLessThan(t *testing.T) {
@@ -230,6 +310,10 @@ func TestCondition_evaluateWithBodyJSONPathComplexIntUsingLessThan(t *testing.T)
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.id < 5"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyJSONPathComplexIntFailureUsingLessThan(t *testing.T) {
@@ -239,6 +323,10 @@ func TestCondition_evaluateWithBodyJSONPathComplexIntFailureUsingLessThan(t *tes
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[BODY].data.id (10) < 5"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodySliceLength(t *testing.T) {
@@ -248,6 +336,10 @@ func TestCondition_evaluateWithBodySliceLength(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "len([BODY].data) == 3"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyStringLength(t *testing.T) {
@@ -257,6 +349,36 @@ func TestCondition_evaluateWithBodyStringLength(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "len([BODY].name) == 8"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithBodyPattern(t *testing.T) {
+	condition := Condition("[BODY] == pat(*john*)")
+	result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "[BODY] == pat(*john*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithReverseBodyPattern(t *testing.T) {
+	condition := Condition("pat(*john*) == [BODY]")
+	result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "pat(*john*) == [BODY]"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyStringPattern(t *testing.T) {
@@ -266,6 +388,24 @@ func TestCondition_evaluateWithBodyStringPattern(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[BODY].name == pat(*ohn*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithBodyHTMLPattern(t *testing.T) {
+	var html = `<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">john.doe</div></body></html>`
+	condition := Condition("[BODY] == pat(*<div id=\"user\">john.doe</div>*)")
+	result := &Result{Body: []byte(html)}
+	condition.evaluate(result)
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a success", condition)
+	}
+	expectedConditionDisplayed := "[BODY] == pat(*<div id=\"user\">john.doe</div>*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithBodyStringPatternFailure(t *testing.T) {
@@ -275,14 +415,9 @@ func TestCondition_evaluateWithBodyStringPatternFailure(t *testing.T) {
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
-}
-
-func TestCondition_evaluateWithBodyPatternFailure(t *testing.T) {
-	condition := Condition("[BODY] == pat(*john*)")
-	result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
+	expectedConditionDisplayed := "[BODY].name (john.doe) == pat(bob*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
 	}
 }
 
@@ -293,6 +428,10 @@ func TestCondition_evaluateWithIPPattern(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[IP] == pat(10.*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithIPPatternFailure(t *testing.T) {
@@ -302,6 +441,10 @@ func TestCondition_evaluateWithIPPatternFailure(t *testing.T) {
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[IP] (255.255.255.255) == pat(10.*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithStatusPattern(t *testing.T) {
@@ -311,6 +454,10 @@ func TestCondition_evaluateWithStatusPattern(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[STATUS] == pat(4*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithStatusPatternFailure(t *testing.T) {
@@ -320,6 +467,105 @@ func TestCondition_evaluateWithStatusPatternFailure(t *testing.T) {
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[STATUS] (404) != pat(4*)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithBodyStringAny(t *testing.T) {
+	condition := Condition("[BODY].name == any(john.doe, jane.doe)")
+	expectedConditionDisplayed := "[BODY].name == any(john.doe, jane.doe)"
+	results := []*Result{
+		{Body: []byte("{\"name\": \"john.doe\"}")},
+		{Body: []byte("{\"name\": \"jane.doe\"}")},
+	}
+	for _, result := range results {
+		success := condition.evaluate(result)
+		if !success || !result.ConditionResults[0].Success {
+			t.Errorf("Condition '%s' should have been a success", condition)
+		}
+		if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+			t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+		}
+	}
+}
+
+func TestCondition_evaluateWithBodyStringAnyFailure(t *testing.T) {
+	condition := Condition("[BODY].name == any(john.doe, jane.doe)")
+	result := &Result{Body: []byte("{\"name\": \"bob.doe\"}")}
+	condition.evaluate(result)
+	if result.ConditionResults[0].Success {
+		t.Errorf("Condition '%s' should have been a failure", condition)
+	}
+	expectedConditionDisplayed := "[BODY].name (bob.doe) == any(john.doe, jane.doe)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
+}
+
+func TestCondition_evaluateWithStatusAny(t *testing.T) {
+	condition := Condition("[STATUS] == any(200, 429)")
+	statuses := []int{200, 429}
+	for _, status := range statuses {
+		result := &Result{HTTPStatus: status}
+		condition.evaluate(result)
+		if !result.ConditionResults[0].Success {
+			t.Errorf("Condition '%s' should have been a success", condition)
+		}
+		expectedConditionDisplayed := "[STATUS] == any(200, 429)"
+		if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+			t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+		}
+	}
+}
+
+func TestCondition_evaluateWithReverseStatusAny(t *testing.T) {
+	condition := Condition("any(200, 429) == [STATUS]")
+	statuses := []int{200, 429}
+	for _, status := range statuses {
+		result := &Result{HTTPStatus: status}
+		condition.evaluate(result)
+		if !result.ConditionResults[0].Success {
+			t.Errorf("Condition '%s' should have been a success", condition)
+		}
+		expectedConditionDisplayed := "any(200, 429) == [STATUS]"
+		if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+			t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+		}
+	}
+}
+
+func TestCondition_evaluateWithStatusAnyFailure(t *testing.T) {
+	condition := Condition("[STATUS] == any(200, 429)")
+	statuses := []int{201, 400, 404, 500}
+	for _, status := range statuses {
+		result := &Result{HTTPStatus: status}
+		condition.evaluate(result)
+		if result.ConditionResults[0].Success {
+			t.Errorf("Condition '%s' should have been a failure", condition)
+		}
+		expectedConditionDisplayed := fmt.Sprintf("[STATUS] (%d) == any(200, 429)", status)
+		if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+			t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+		}
+	}
+}
+
+func TestCondition_evaluateWithReverseStatusAnyFailure(t *testing.T) {
+	condition := Condition("any(200, 429) == [STATUS]")
+	statuses := []int{201, 400, 404, 500}
+	for _, status := range statuses {
+		result := &Result{HTTPStatus: status}
+		condition.evaluate(result)
+		if result.ConditionResults[0].Success {
+			t.Errorf("Condition '%s' should have been a failure", condition)
+		}
+		expectedConditionDisplayed := fmt.Sprintf("any(200, 429) == [STATUS] (%d)", status)
+		if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+			t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+		}
+	}
 }
 
 func TestCondition_evaluateWithConnected(t *testing.T) {
@@ -329,6 +575,10 @@ func TestCondition_evaluateWithConnected(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[CONNECTED] == true"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithConnectedFailure(t *testing.T) {
@@ -338,6 +588,10 @@ func TestCondition_evaluateWithConnectedFailure(t *testing.T) {
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[CONNECTED] (false) == true"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithUnsetCertificateExpiration(t *testing.T) {
@@ -347,6 +601,10 @@ func TestCondition_evaluateWithUnsetCertificateExpiration(t *testing.T) {
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[CERTIFICATE_EXPIRATION] == 0"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithCertificateExpirationGreaterThanNumerical(t *testing.T) {
@@ -357,6 +615,10 @@ func TestCondition_evaluateWithCertificateExpirationGreaterThanNumerical(t *test
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[CERTIFICATE_EXPIRATION] > 2419200000"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithCertificateExpirationGreaterThanNumericalFailure(t *testing.T) {
@@ -367,6 +629,10 @@ func TestCondition_evaluateWithCertificateExpirationGreaterThanNumericalFailure(
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[CERTIFICATE_EXPIRATION] (1209600000) > 2419200000"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithCertificateExpirationGreaterThanDuration(t *testing.T) {
@@ -376,6 +642,10 @@ func TestCondition_evaluateWithCertificateExpirationGreaterThanDuration(t *testi
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	expectedConditionDisplayed := "[CERTIFICATE_EXPIRATION] > 12h"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }
 
 func TestCondition_evaluateWithCertificateExpirationGreaterThanDurationFailure(t *testing.T) {
@@ -385,4 +655,8 @@ func TestCondition_evaluateWithCertificateExpirationGreaterThanDurationFailure(t
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	expectedConditionDisplayed := "[CERTIFICATE_EXPIRATION] (86400000) > 48h (172800000)"
+	if result.ConditionResults[0].Condition != expectedConditionDisplayed {
+		t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", condition, expectedConditionDisplayed, result.ConditionResults[0].Condition)
+	}
 }

core/event.go

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

core/result.go

@@ -31,7 +31,7 @@ type Result struct {
 	Errors []string `json:"errors"`
 
 	// ConditionResults results of the service's conditions
-	ConditionResults []*ConditionResult `json:"condition-results"`
+	ConditionResults []*ConditionResult `json:"conditionResults"`
 
 	// Success whether the result signifies a success or not
 	Success bool `json:"success"`

core/service-status.go

@@ -1,5 +1,11 @@
 package core
 
+import (
+	"time"
+
+	"github.com/TwinProduction/gatus/util"
+)
+
 // ServiceStatus contains the evaluation Results of a Service
 type ServiceStatus struct {
 	// Name of the service
@@ -8,11 +14,25 @@ type ServiceStatus struct {
 	// Group the service is a part of. Used for grouping multiple services together on the front end.
 	Group string `json:"group,omitempty"`
 
+	// Key is the key representing the ServiceStatus
+	Key string `json:"key"`
+
 	// Results is the list of service evaluation results
 	Results []*Result `json:"results"`
 
+	// Events is a list of events
+	//
+	// We don't expose this through JSON, because the main dashboard doesn't need to have this data.
+	// However, the detailed service page does leverage this by including it to a map that will be
+	// marshalled alongside the ServiceStatus.
+	Events []*Event `json:"-"`
+
 	// Uptime information on the service's uptime
-	Uptime *Uptime `json:"uptime"`
+	//
+	// We don't expose this through JSON, because the main dashboard doesn't need to have this data.
+	// However, the detailed service page does leverage this by including it to a map that will be
+	// marshalled alongside the ServiceStatus.
+	Uptime *Uptime `json:"-"`
 }
 
 // NewServiceStatus creates a new ServiceStatus
@@ -20,14 +40,35 @@ func NewServiceStatus(service *Service) *ServiceStatus {
 	return &ServiceStatus{
 		Name:    service.Name,
 		Group:   service.Group,
+		Key:     util.ConvertGroupAndServiceToKey(service.Group, service.Name),
 		Results: make([]*Result, 0),
-		Uptime:  NewUptime(),
+		Events: []*Event{{
+			Type:      EventStart,
+			Timestamp: time.Now(),
+		}},
+		Uptime: NewUptime(),
 	}
 }
 
 // AddResult adds a Result to ServiceStatus.Results and makes sure that there are
 // no more than 20 results in the Results slice
 func (ss *ServiceStatus) AddResult(result *Result) {
+	if len(ss.Results) > 0 {
+		// Check if there's any change since the last result
+		// OR there's only 1 event, which only happens when there's a start event
+		if ss.Results[len(ss.Results)-1].Success != result.Success || len(ss.Events) == 1 {
+			event := &Event{Timestamp: result.Timestamp}
+			if result.Success {
+				event.Type = EventHealthy
+			} else {
+				event.Type = EventUnhealthy
+			}
+			ss.Events = append(ss.Events, event)
+			if len(ss.Events) > 20 {
+				ss.Events = ss.Events[1:]
+			}
+		}
+	}
 	ss.Results = append(ss.Results, result)
 	if len(ss.Results) > 20 {
 		ss.Results = ss.Results[1:]

core/service-status_test.go

@@ -14,6 +14,9 @@ func TestNewServiceStatus(t *testing.T) {
 	if serviceStatus.Group != service.Group {
 		t.Errorf("expected %s, got %s", service.Group, serviceStatus.Group)
 	}
+	if serviceStatus.Key != "group_name" {
+		t.Errorf("expected %s, got %s", "group_name", serviceStatus.Key)
+	}
 }
 
 func TestServiceStatus_AddResult(t *testing.T) {

core/uptime.go

@@ -25,15 +25,20 @@ type Uptime struct {
 	// LastHour is the uptime percentage over the past hour
 	LastHour float64 `json:"1h"`
 
-	successCountPerHour map[string]uint64
-	totalCountPerHour   map[string]uint64
+	// SuccessCountPerHour is a map containing the number of successes per hour, per timestamp following the
+	// custom RFC3339WithoutMinutesAndSeconds format
+	SuccessCountPerHour map[string]uint64 `json:"-"`
+
+	// TotalCountPerHour is a map containing the total number of checks per hour, per timestamp following the
+	// custom RFC3339WithoutMinutesAndSeconds format
+	TotalCountPerHour map[string]uint64 `json:"-"`
 }
 
 // NewUptime creates a new Uptime
 func NewUptime() *Uptime {
 	return &Uptime{
-		successCountPerHour: make(map[string]uint64),
-		totalCountPerHour:   make(map[string]uint64),
+		SuccessCountPerHour: make(map[string]uint64),
+		TotalCountPerHour:   make(map[string]uint64),
 	}
 }
 
@@ -42,16 +47,16 @@ func NewUptime() *Uptime {
 func (uptime *Uptime) ProcessResult(result *Result) {
 	timestampDateWithHour := result.Timestamp.Format(RFC3339WithoutMinutesAndSeconds)
 	if result.Success {
-		uptime.successCountPerHour[timestampDateWithHour]++
+		uptime.SuccessCountPerHour[timestampDateWithHour]++
 	}
-	uptime.totalCountPerHour[timestampDateWithHour]++
+	uptime.TotalCountPerHour[timestampDateWithHour]++
 	// 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.totalCountPerHour) > numberOfHoursInTenDays {
+	if len(uptime.TotalCountPerHour) > numberOfHoursInTenDays {
 		sevenDaysAgo := time.Now().Add(-(sevenDays + time.Hour))
-		for k := range uptime.totalCountPerHour {
+		for k := range uptime.TotalCountPerHour {
 			dateWithHour, err := time.Parse(time.RFC3339, k)
 			if err != nil {
 				// This shouldn't happen, but we'll log it in case it does happen
@@ -59,8 +64,8 @@ func (uptime *Uptime) ProcessResult(result *Result) {
 				continue
 			}
 			if sevenDaysAgo.Unix() > dateWithHour.Unix() {
-				delete(uptime.totalCountPerHour, k)
-				delete(uptime.successCountPerHour, k)
+				delete(uptime.TotalCountPerHour, k)
+				delete(uptime.SuccessCountPerHour, k)
 			}
 		}
 	}
@@ -88,8 +93,8 @@ func (uptime *Uptime) recalculate() {
 	timestamp := now.Add(-sevenDays)
 	for now.Sub(timestamp) >= 0 {
 		timestampDateWithHour := timestamp.Format(RFC3339WithoutMinutesAndSeconds)
-		successCountForTimestamp := uptime.successCountPerHour[timestampDateWithHour]
-		totalCountForTimestamp := uptime.totalCountPerHour[timestampDateWithHour]
+		successCountForTimestamp := uptime.SuccessCountPerHour[timestampDateWithHour]
+		totalCountForTimestamp := uptime.TotalCountPerHour[timestampDateWithHour]
 		uptimeBrackets["7d_success"] += successCountForTimestamp
 		uptimeBrackets["7d_total"] += totalCountForTimestamp
 		if now.Sub(timestamp) <= 24*time.Hour {

core/uptime_test.go

@@ -51,8 +51,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.successCountPerHour) > numberOfHoursInTenDays {
-			t.Errorf("At no point in time should there be more than %d entries in serviceStatus.successCountPerHour", numberOfHoursInTenDays)
+		if len(serviceStatus.Uptime.SuccessCountPerHour) > numberOfHoursInTenDays {
+			t.Errorf("At no point in time should there be more than %d entries in serviceStatus.SuccessCountPerHour", numberOfHoursInTenDays)
 		}
 		//fmt.Printf("timestamp=%s; uptimeDuringLastHour=%f; timeAgo=%s\n", timestamp.Format(time.RFC3339), serviceStatus.UptimeDuringLastHour, time.Since(timestamp))
 		if now.Sub(timestamp) > time.Hour && serviceStatus.Uptime.LastHour != 0 {

example/docker-compose-mattermost/config.yaml

@@ -1,6 +1,16 @@
+alerting:
+  mattermost:
+    webhook-url: "http://mattermost:8065/hooks/tokengoeshere"
+    insecure: true
+
 services:
   - name: example
     url: http://example.org
-    interval: 30s
+    interval: 1m
+    alerts:
+      - type: mattermost
+        enabled: true
+        description: "healthcheck failed 3 times in a row"
+        send-on-resolved: true
     conditions:
       - "[STATUS] == 200"

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

@@ -1,13 +1,24 @@
 version: "3.8"
-services:
-    gatus:
-        image: twinproduction/gatus:latest
-        ports:
-          - 8080:8080
-        volumes:
-          - ./config.yaml:/config/config.yaml
 
-    mattermost-preview:
-        image: mattermost/mattermost-preview:latest
-        ports:
-          - 8065:8065
+services:
+  gatus:
+    container_name: gatus
+    image: twinproduction/gatus:latest
+    ports:
+      - 8080:8080
+    volumes:
+      - ./config.yaml:/config/config.yaml
+    networks:
+      - default
+
+  mattermost:
+    container_name: mattermost
+    image: mattermost/mattermost-preview:5.26.0
+    ports:
+      - 8065:8065
+    networks:
+      - default
+
+networks:
+  default:
+    driver: bridge

go.mod

@@ -4,7 +4,7 @@ go 1.15
 
 require (
 	cloud.google.com/go v0.74.0 // indirect
-	github.com/TwinProduction/gocache v0.3.0
+	github.com/TwinProduction/gocache v1.2.0
 	github.com/go-ping/ping v0.0.0-20201115131931-3300c582a663
 	github.com/google/gofuzz v1.2.0 // indirect
 	github.com/gorilla/mux v1.8.0

go.sum

@@ -50,8 +50,8 @@ github.com/PuerkitoBio/purell v1.0.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbt
 github.com/PuerkitoBio/urlesc v0.0.0-20160726150825-5bd2802263f2/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
 github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
 github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
-github.com/TwinProduction/gocache v0.3.0 h1:nC02PSOyGLiXGrOJ6eskGc5chBq5GW6m3pA2g341VEM=
-github.com/TwinProduction/gocache v0.3.0/go.mod h1:+qH57V/K4oAcX9C7CvgJTwUX4lzfIUXQC/6XaRSOS1Y=
+github.com/TwinProduction/gocache v1.2.0 h1:iZBUuri5VydxYhNkWEOZm/JzX/X2b3OZzfLrPaRWKjk=
+github.com/TwinProduction/gocache v1.2.0/go.mod h1:+qH57V/K4oAcX9C7CvgJTwUX4lzfIUXQC/6XaRSOS1Y=
 github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
 github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=

pattern/pattern.go

@@ -10,10 +10,11 @@ func Match(pattern, s string) bool {
 	if pattern == "*" {
 		return true
 	}
-	// Backslashes break filepath.Match, so we'll remove all of them.
-	// This has a pretty significant impact on performance when there
-	// are backslashes, but at least it doesn't break filepath.Match.
-	s = strings.ReplaceAll(s, "\\", "")
+	// Separators found in the string break filepath.Match, so we'll remove all of them.
+	// This has a pretty significant impact on performance when there are separators in
+	// the strings, but at least it doesn't break filepath.Match.
+	s = strings.ReplaceAll(s, string(filepath.Separator), "")
+	pattern = strings.ReplaceAll(pattern, string(filepath.Separator), "")
 	matched, _ := filepath.Match(pattern, s)
 	return matched
 }

static/index.html

@@ -1,414 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-	<title>Health Dashboard</title>
-	<meta name="viewport" content="width=device-width, initial-scale=1" />
-	<link rel="stylesheet" href="./bootstrap.min.css" />
-	<style>
-        html, body {
-            background-color: #f7f9fb;
-        }
-        html {
-            height: 100%;
-        }
-        #results div.container:first-child {
-            border-top-left-radius: 3px;
-            border-top-right-radius: 3px;
-        }
-        #results div.container:last-child {
-            border-bottom-left-radius: 3px;
-            border-bottom-right-radius: 3px;
-            border-bottom-width: 1px;
-            border-color: #dee2e6;
-            border-style: solid;
-        }
-        .status {
-            cursor: pointer;
-            transition: all 500ms ease-in-out;
-            overflow-x: hidden;
-            padding: .25em 0;
-            color: white;
-        }
-        .title {
-            font-size: 2.5rem;
-        }
-        .status:hover {
-            opacity: 0.7;
-            transition: opacity 100ms ease-in-out;
-            color: black;
-        }
-        .status-over-time {
-            overflow: auto;
-        }
-        .status-over-time>span:not(:last-child) {
-            margin-left: 2px;
-        }
-        .status-time-ago {
-            color: #6a737d;
-            opacity: 0.5;
-            margin-top: 5px;
-        }
-        .status-min-max-ms {
-            overflow-x: hidden;
-        }
-        #tooltip {
-            position: fixed;
-            top: 0;
-            left: 0;
-            background-color: white;
-            border: 1px solid lightgray;
-            border-radius: 4px;
-            padding: 6px;
-            font-size: 13px;
-        }
-        #tooltip code {
-            color: #212529;
-            line-height: 1;
-        }
-        #tooltip .tooltip-title {
-            font-weight: bold;
-            margin-bottom: 0;
-            display: block;
-        }
-        #tooltip .tooltip-title {
-            margin-top: 8px;
-        }
-        #tooltip>.tooltip-title:first-child {
-            margin-top: 0;
-        }
-        #social {
-            position: fixed;
-            right: 5px;
-            bottom: 5px;
-            padding: 5px;
-            margin: 0;
-            z-index: 100;
-        }
-        #social img {
-            opacity: 0.3;
-        }
-        #social img:hover {
-            opacity: 1;
-        }
-        #settings {
-            position: fixed;
-            left: 5px;
-            bottom: 5px;
-            padding: 5px;
-        }
-        #settings select:focus {
-            box-shadow: none;
-        }
-        .service-group {
-            cursor: pointer;
-            user-select: none;
-        }
-        .service-group h5:hover {
-            color: #1b1e21 !important;
-        }
-	</style>
-</head>
-<body>
-<div class="container my-3 rounded p-3 border shadow">
-	<div class="mb-2">
-		<div class="row">
-			<div class="col-8 text-left my-auto">
-				<div class="title display-4">Health Status</div>
-			</div>
-			<div class="col-4 text-right">
-				<img src="logo.png" alt="Gatus" style="position: relative; min-width: 50px; max-width: 200px; width: 20%;"/>
-			</div>
-		</div>
-	</div>
-	<div id="results"></div>
-</div>
-
-<div id="tooltip" style="display: none">
-	<div class="tooltip-title">Timestamp:</div>
-	<code id="tooltip-timestamp">...</code>
-	<div class="tooltip-title">Response time:</div>
-	<code id="tooltip-response-time">...</code>
-	<div class="tooltip-title">Conditions:</div>
-	<code id="tooltip-conditions">...</code>
-	<div id="tooltip-errors-container">
-		<div class="tooltip-title">Errors:</div>
-		<code id="tooltip-errors">...</code>
-	</div>
-</div>
-
-<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" />
-	</a>
-</div>
-
-<div id="settings">
-	<div class="input-group input-group-sm">
-		<div class="input-group-prepend">
-			<div class="input-group-text">&#x21bb;</div>
-		</div>
-		<select class="form-control form-control-sm" id="refresh-rate">
-			<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>
-
-<script>
-	let serviceStatuses = {};
-	let timerHandler = 0;
-	let refreshIntervalHandler = 0;
-	let userClickedStatus = false;
-
-	// TODO: make this variable configurable and persist the choice in localStorage
-	let showStatusOnHover = true;
-
-	function showTooltip(serviceName, index, element) {
-		//userClickedStatus = false;
-		clearTimeout(timerHandler);
-		let serviceResult = serviceStatuses[serviceName].results[index];
-		$("#tooltip-timestamp").text(prettifyTimestamp(serviceResult.timestamp));
-		$("#tooltip-response-time").text(parseInt(serviceResult.duration/1000000) + "ms");
-		// Populate the condition section
-		let conditions = "";
-		for (let i in serviceResult['condition-results']) {
-			let conditionResult = serviceResult['condition-results'][i];
-			conditions += (conditionResult.success ? "&#10003;" : "X") + " ~ " + htmlEntities(conditionResult.condition) + "<br />";
-		}
-		$("#tooltip-conditions").html(conditions);
-		// Populate the error section only if there are errors
-		if (serviceResult.errors && serviceResult.errors.length > 0) {
-			let errors = "";
-			for (let i in serviceResult.errors) {
-				errors += "- " + htmlEntities(serviceResult.errors[i]) + "<br />";
-			}
-			$("#tooltip-errors").html(errors);
-			$("#tooltip-errors-container").show();
-		} else {
-			$("#tooltip-errors-container").hide();
-		}
-		// Position tooltip
-		$("#tooltip").css({top: "0px", left: "0px"}).show();
-		let targetTopPosition = element.getBoundingClientRect().y + 30;
-		let targetLeftPosition = element.getBoundingClientRect().x;
-		// Make adjustments if necessary
-		let tooltipBoundingClientRect = document.querySelector('#tooltip').getBoundingClientRect();
-		if (targetLeftPosition + window.scrollX + tooltipBoundingClientRect.width + 50 > document.body.getBoundingClientRect().width) {
-			targetLeftPosition = element.getBoundingClientRect().x - tooltipBoundingClientRect.width + element.getBoundingClientRect().width;
-			if (targetLeftPosition < 0) {
-				targetLeftPosition += -targetLeftPosition;
-			}
-		}
-		if (targetTopPosition + window.scrollY + tooltipBoundingClientRect.height + 50 > document.body.getBoundingClientRect().height && targetTopPosition >= 0) {
-			targetTopPosition = element.getBoundingClientRect().y - (tooltipBoundingClientRect.height + 10);
-			if (targetTopPosition < 0) {
-				targetTopPosition = element.getBoundingClientRect().y + 30;
-			}
-		}
-		$("#tooltip").css({top: targetTopPosition + "px", left: targetLeftPosition + "px"});
-	}
-
-	function fadeTooltip() {
-		if (!userClickedStatus) {
-			timerHandler = setTimeout(function () {
-				$("#tooltip").hide();
-			}, 500);
-		}
-	}
-
-	function toggleTooltip(serviceName, index, element) {
-		console.log("userClickedStatus="+userClickedStatus);
-		if (!userClickedStatus) {
-			showTooltip(serviceName, index, element);
-			userClickedStatus = true;
-		} else {
-			$("#tooltip").hide();
-			userClickedStatus = false;
-		}
-	}
-
-	function createStatusBadge(serviceStatusIndex, index, success) {
-		if (success) {
-			if (showStatusOnHover) {
-				return "<span class='status badge badge-success' style='width: 5%' onmouseenter='showTooltip(\"" + serviceStatusIndex + "\", " + index + ", this)' onmouseleave='fadeTooltip()' onclick='userClickedStatus = !userClickedStatus;'>&#10003;</span>";
-			} else {
-				return "<span class='status badge badge-success' style='width: 5%' onclick='toggleTooltip(\"" + serviceStatusIndex + "\", " + index + ", this)'>&#10003;</span>";
-			}
-		}
-		if (showStatusOnHover) {
-			return "<span class='status badge badge-danger' style='width: 5%' onmouseenter='showTooltip(\"" + serviceStatusIndex + "\", " + index + ", this)' onmouseleave='fadeTooltip()' onclick='userClickedStatus = !userClickedStatus;'>X</span>";
-		} else {
-			return "<span class='status badge badge-danger' style='width: 5%' onclick='toggleTooltip(\"" + serviceStatusIndex + "\", " + index + ", this)'>X</span>";
-		}
-	}
-
-	function refreshStatuses() {
-		$.getJSON("./api/v1/statuses", function (data) {
-			// Update the table only if there's a change
-			if (JSON.stringify(serviceStatuses) !== JSON.stringify(data)) {
-				serviceStatuses = data;
-				buildTable();
-			}
-		});
-	}
-
-	function buildTable() {
-		let outputByGroup = {};
-		for (let serviceStatusIndex in serviceStatuses) {
-			let serviceStatusOverTime = "";
-			let serviceStatus = serviceStatuses[serviceStatusIndex];
-			let hostname = serviceStatus.results[serviceStatus.results.length-1].hostname;
-			let minResponseTime = null;
-			let maxResponseTime = null;
-			let newestTimestamp = null;
-			let oldestTimestamp = null;
-			for (let resultIndex in serviceStatus.results) {
-				let serviceResult = serviceStatus.results[resultIndex];
-				serviceStatusOverTime = createStatusBadge(serviceStatusIndex, resultIndex, serviceResult.success) + serviceStatusOverTime;
-				const responseTime = parseInt(serviceResult.duration/1000000);
-				if (minResponseTime == null || minResponseTime > responseTime) {
-					minResponseTime = responseTime;
-				}
-				if (maxResponseTime == null || maxResponseTime < responseTime) {
-					maxResponseTime = responseTime;
-				}
-				const timestamp = new Date(serviceResult.timestamp);
-				if (newestTimestamp == null || newestTimestamp < timestamp) {
-					newestTimestamp = timestamp;
-				}
-				if (oldestTimestamp == null || oldestTimestamp > timestamp) {
-					oldestTimestamp = timestamp;
-				}
-			}
-			let output = ""
-				+ "<div class='container py-3 border-left border-right border-top border-black rounded-0'>"
-				+ "  <div class='row mb-2'>"
-				+ "    <div class='col-md-10'>"
-				+ "      <span class='font-weight-bold'>" + serviceStatus.name + "</span> <span class='text-secondary font-weight-lighter'>- " + hostname + "</span>"
-				+ "    </div>"
-				+ "    <div class='col-md-2 text-right'>"
-				+ "      <span class='font-weight-lighter status-min-max-ms'>" + (minResponseTime === maxResponseTime ? minResponseTime : (minResponseTime + "-" + maxResponseTime)) + "ms</span>"
-				+ "    </div>"
-				+ "  </div>"
-				+ "  <div class='row'>"
-				+ "    <div class='col-12 d-flex flex-row-reverse status-over-time'>"
-				+ "      " + serviceStatusOverTime
-				+ "    </div>"
-				+ "  </div>"
-				+ "  <div class='row status-time-ago'>"
-				+ "    <div class='col-6'>"
-				+ "      " + generatePrettyTimeAgo(oldestTimestamp)
-				+ "    </div>"
-				+ "    <div class='col-6 text-right'>"
-				+ "      " + generatePrettyTimeAgo(newestTimestamp)
-				+ "    </div>"
-				+ "  </div>"
-				+ "</div>";
-			// create an empty entry if this group is new
-			if (!outputByGroup[serviceStatus.group]) {
-				outputByGroup[serviceStatus.group] = "";
-			}
-			outputByGroup[serviceStatus.group] += output;
-		}
-		let output = "";
-		for (let group in outputByGroup) {
-			// Services that don't have a group should be skipped and left for last
-			if (group === 'undefined') {
-				continue
-			}
-			let key = group.replace(/[^a-zA-Z0-9]/g, '');
-			let existingGroupContentSelector = $("#service-group-" + key + "-content");
-			let isCurrentlyHidden = existingGroupContentSelector.length && existingGroupContentSelector[0].style.display === 'none';
-			let groupStatus = "<span class='text-success'>&#10003;</span>";
-			if (outputByGroup[group].includes("badge badge-danger")) {
-				groupStatus = "<span class='text-warning'>~</span>";
-			}
-			output += ""
-				+ "<div class='mt-" + (output.length ? '4' : '3') + "'>"
-				+ "  <div class='container pt-2 border-left border-right border-top border-black border-bottom service-group' id='service-group-" + key + "' data-group='" + key + "' onclick='toggleGroup(this)'>"
-				+ "    <h5 class='text-secondary text-monospace pb-0'>"
-				+ "      " + groupStatus + " " + group
-				+ "      <span class='float-right service-group-arrow' id='service-group-" + key + "-arrow'>" + (isCurrentlyHidden ? "&#9660;" : "&#9650;") + "</span>"
-				+ "    </h5>"
-				+ "  </div>"
-				+ "  <div class='service-group-content' id='service-group-" + key + "-content' style='" + (isCurrentlyHidden ? "display: none;" : "") + "'>"
-				+ "    " + outputByGroup[group]
-				+ "  </div>"
-				+ "</div>";
-		}
-		// Add all services that don't have a group at the end
-		if (outputByGroup['undefined']) {
-			output += ""
-				+ "<div class='mt-" + (output.length ? '4' : '3') + "'>"
-				+ "  " + outputByGroup['undefined']
-				+ "</div>"
-		}
-		$("#results").html(output);
-	}
-
-	function toggleGroup(element) {
-		let selector = $("#service-group-" + element.dataset.group + "-content");
-		selector.toggle("fast", function() {
-			if (selector.length && selector[0].style.display === 'none') {
-				$("#service-group-" + element.dataset.group + "-arrow").html("&#9660;");
-			} else {
-				$("#service-group-" + element.dataset.group + "-arrow").html("&#9650;");
-			}
-		});
-	}
-
-	function prettifyTimestamp(timestamp) {
-		let date = new Date(timestamp);
-		let YYYY = date.getFullYear();
-		let MM = ((date.getMonth()+1)<10?"0":"")+""+(date.getMonth()+1);
-		let DD = ((date.getDate())<10?"0":"")+""+(date.getDate());
-		let hh = ((date.getHours())<10?"0":"")+""+(date.getHours());
-		let mm = ((date.getMinutes())<10?"0":"")+""+(date.getMinutes());
-		let ss = ((date.getSeconds())<10?"0":"")+""+(date.getSeconds());
-		return YYYY + "-" + MM + "-" + DD + " " + hh + ":" + mm + ":" + ss;
-	}
-
-	function generatePrettyTimeAgo(t) {
-		let differenceInMs = new Date().getTime() - new Date(t).getTime();
-		if (differenceInMs > 3600000) {
-			let hours = (differenceInMs/3600000).toFixed(0);
-			return hours + " hour" + (hours !== "1" ? "s" : "") + " ago";
-		}
-		if (differenceInMs > 60000) {
-			let minutes = (differenceInMs/60000).toFixed(0);
-			return minutes + " minute" + (minutes !== "1" ? "s" : "") + " ago";
-		}
-		return (differenceInMs/1000).toFixed(0) + " seconds ago";
-	}
-
-	function htmlEntities(s) {
-		return String(s)
-			.replace(/&/g, '&amp;')
-			.replace(/</g, '&lt;')
-			.replace(/>/g, '&gt;')
-			.replace(/"/g, '&quot;')
-			.replace(/'/g, '&apos;');
-	}
-
-	function setRefreshInterval(seconds) {
-		refreshStatuses();
-		refreshIntervalHandler = setInterval(function() {
-			refreshStatuses();
-		}, seconds * 1000);
-	}
-
-	$("#refresh-rate").change(function() {
-		clearInterval(refreshIntervalHandler);
-		setRefreshInterval($(this).val());
-	});
-	setRefreshInterval(30);
-	$("#refresh-rate").val(30);
-</script>
-</body>
-</html>

storage/config.go

@@ -0,0 +1,7 @@
+package storage
+
+// Config is the configuration for alerting providers
+type Config struct {
+	// File is the path of the file to use when using file.Store
+	File string `yaml:"file"`
+}

storage/memory.go

@@ -1,107 +0,0 @@
-package storage
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/TwinProduction/gatus/core"
-)
-
-// InMemoryStore implements an in-memory store
-type InMemoryStore struct {
-	serviceStatuses     map[string]*core.ServiceStatus
-	serviceResultsMutex sync.RWMutex
-}
-
-// NewInMemoryStore returns an in-memory store. Note that the store acts as a singleton, so although new-ing
-// up in-memory stores will give you a unique reference to a struct each time, all structs returned
-// by this function will act on the same in-memory store.
-func NewInMemoryStore() *InMemoryStore {
-	return &InMemoryStore{
-		serviceStatuses: make(map[string]*core.ServiceStatus),
-	}
-}
-
-// GetAll returns all the observed results for all services from the in memory store
-func (ims *InMemoryStore) GetAll() map[string]*core.ServiceStatus {
-	results := make(map[string]*core.ServiceStatus, len(ims.serviceStatuses))
-	ims.serviceResultsMutex.RLock()
-	for key, serviceStatus := range ims.serviceStatuses {
-		results[key] = &core.ServiceStatus{
-			Name:    serviceStatus.Name,
-			Group:   serviceStatus.Group,
-			Results: copyResults(serviceStatus.Results),
-		}
-	}
-	ims.serviceResultsMutex.RUnlock()
-	return results
-}
-
-// GetServiceStatus returns the service status for a given service name in the given group
-func (ims *InMemoryStore) GetServiceStatus(group, name string) *core.ServiceStatus {
-	key := fmt.Sprintf("%s_%s", group, name)
-	ims.serviceResultsMutex.RLock()
-	serviceStatus := ims.serviceStatuses[key]
-	ims.serviceResultsMutex.RUnlock()
-	return serviceStatus
-}
-
-// Insert inserts the observed result for the specified service into the in memory store
-func (ims *InMemoryStore) Insert(service *core.Service, result *core.Result) {
-	key := fmt.Sprintf("%s_%s", service.Group, service.Name)
-	ims.serviceResultsMutex.Lock()
-	serviceStatus, exists := ims.serviceStatuses[key]
-	if !exists {
-		serviceStatus = core.NewServiceStatus(service)
-		ims.serviceStatuses[key] = serviceStatus
-	}
-	serviceStatus.AddResult(result)
-	ims.serviceResultsMutex.Unlock()
-}
-
-func copyResults(results []*core.Result) []*core.Result {
-	var copiedResults []*core.Result
-	for _, result := range results {
-		copiedResults = append(copiedResults, &core.Result{
-			HTTPStatus:            result.HTTPStatus,
-			DNSRCode:              result.DNSRCode,
-			Body:                  result.Body,
-			Hostname:              result.Hostname,
-			IP:                    result.IP,
-			Connected:             result.Connected,
-			Duration:              result.Duration,
-			Errors:                copyErrors(result.Errors),
-			ConditionResults:      copyConditionResults(result.ConditionResults),
-			Success:               result.Connected,
-			Timestamp:             result.Timestamp,
-			CertificateExpiration: result.CertificateExpiration,
-		})
-	}
-	return copiedResults
-}
-
-func copyConditionResults(conditionResults []*core.ConditionResult) []*core.ConditionResult {
-	var copiedConditionResults []*core.ConditionResult
-	for _, conditionResult := range conditionResults {
-		copiedConditionResults = append(copiedConditionResults, &core.ConditionResult{
-			Condition: conditionResult.Condition,
-			Success:   conditionResult.Success,
-		})
-	}
-	return copiedConditionResults
-}
-
-func copyErrors(errors []string) []string {
-	var copiedErrors []string
-	for _, err := range errors {
-		copiedErrors = append(copiedErrors, err)
-	}
-	return copiedErrors
-}
-
-// Clear will empty all the results from the in memory store
-func (ims *InMemoryStore) Clear() {
-	ims.serviceResultsMutex.Lock()
-	ims.serviceStatuses = make(map[string]*core.ServiceStatus)
-	ims.serviceResultsMutex.Unlock()
-}

storage/memory_test.go

@@ -1,436 +0,0 @@
-package storage
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/TwinProduction/gatus/core"
-)
-
-var testService = core.Service{
-	Name:                    "Name",
-	Group:                   "Group",
-	URL:                     "URL",
-	DNS:                     &core.DNS{QueryType: "QueryType", QueryName: "QueryName"},
-	Method:                  "Method",
-	Body:                    "Body",
-	GraphQL:                 false,
-	Headers:                 nil,
-	Interval:                time.Second * 2,
-	Conditions:              nil,
-	Alerts:                  nil,
-	Insecure:                false,
-	NumberOfFailuresInARow:  0,
-	NumberOfSuccessesInARow: 0,
-}
-
-var memoryStore = NewInMemoryStore()
-
-func TestStorage_GetAllFromEmptyMemoryStoreReturnsNothing(t *testing.T) {
-	memoryStore.Clear()
-	results := memoryStore.GetAll()
-	if len(results) != 0 {
-		t.Errorf("MemoryStore should've returned 0 results, but actually returned %d", len(results))
-	}
-}
-
-func TestStorage_InsertIntoEmptyMemoryStoreThenGetAllReturnsOneResult(t *testing.T) {
-	memoryStore.Clear()
-	result := core.Result{
-		HTTPStatus:            200,
-		DNSRCode:              "DNSRCode",
-		Body:                  nil,
-		Hostname:              "Hostname",
-		IP:                    "IP",
-		Connected:             false,
-		Duration:              time.Second * 2,
-		Errors:                nil,
-		ConditionResults:      nil,
-		Success:               false,
-		Timestamp:             time.Now(),
-		CertificateExpiration: time.Second * 2,
-	}
-
-	memoryStore.Insert(&testService, &result)
-
-	results := memoryStore.GetAll()
-	if len(results) != 1 {
-		t.Errorf("MemoryStore should've returned 0 results, but actually returned %d", len(results))
-	}
-
-	key := fmt.Sprintf("%s_%s", testService.Group, testService.Name)
-	storedResult, exists := results[key]
-	if !exists {
-		t.Fatalf("In Memory Store should've contained key '%s', but didn't", key)
-	}
-
-	if storedResult.Name != testService.Name {
-		t.Errorf("Stored Results Name should've been %s, but was %s", testService.Name, storedResult.Name)
-	}
-	if storedResult.Group != testService.Group {
-		t.Errorf("Stored Results Group should've been %s, but was %s", testService.Group, storedResult.Group)
-	}
-	if len(storedResult.Results) != 1 {
-		t.Errorf("Stored Results for service %s should've had 1 result, but actually had %d", storedResult.Name, len(storedResult.Results))
-	}
-	if storedResult.Results[0] == &result {
-		t.Errorf("Returned result is the same reference as result passed to insert. Returned result should be copies only")
-	}
-}
-
-func TestStorage_InsertTwoResultsForSingleServiceIntoEmptyMemoryStore_ThenGetAllReturnsTwoResults(t *testing.T) {
-	memoryStore.Clear()
-	result1 := core.Result{
-		HTTPStatus:            404,
-		DNSRCode:              "DNSRCode",
-		Body:                  nil,
-		Hostname:              "Hostname",
-		IP:                    "IP",
-		Connected:             false,
-		Duration:              time.Second * 2,
-		Errors:                nil,
-		ConditionResults:      nil,
-		Success:               false,
-		Timestamp:             time.Now(),
-		CertificateExpiration: time.Second * 2,
-	}
-	result2 := core.Result{
-		HTTPStatus:            200,
-		DNSRCode:              "DNSRCode",
-		Body:                  nil,
-		Hostname:              "Hostname",
-		IP:                    "IP",
-		Connected:             true,
-		Duration:              time.Second * 2,
-		Errors:                nil,
-		ConditionResults:      nil,
-		Success:               true,
-		Timestamp:             time.Now(),
-		CertificateExpiration: time.Second * 2,
-	}
-
-	resultsToInsert := []core.Result{result1, result2}
-
-	memoryStore.Insert(&testService, &result1)
-	memoryStore.Insert(&testService, &result2)
-
-	results := memoryStore.GetAll()
-	if len(results) != 1 {
-		t.Fatalf("MemoryStore should've returned 1 results, but actually returned %d", len(results))
-	}
-
-	key := fmt.Sprintf("%s_%s", testService.Group, testService.Name)
-	serviceResults, exists := results[key]
-	if !exists {
-		t.Fatalf("In Memory Store should've contained key '%s', but didn't", key)
-	}
-
-	if len(serviceResults.Results) != 2 {
-		t.Fatalf("Service '%s' should've had 2 results, but actually returned %d", serviceResults.Name, len(serviceResults.Results))
-	}
-
-	for i, r := range serviceResults.Results {
-		expectedResult := resultsToInsert[i]
-
-		if r.HTTPStatus != expectedResult.HTTPStatus {
-			t.Errorf("Result at index %d should've had a HTTPStatus of %d, but was actually %d", i, expectedResult.HTTPStatus, r.HTTPStatus)
-		}
-		if r.DNSRCode != expectedResult.DNSRCode {
-			t.Errorf("Result at index %d should've had a DNSRCode of %s, but was actually %s", i, expectedResult.DNSRCode, r.DNSRCode)
-		}
-		if len(r.Body) != len(expectedResult.Body) {
-			t.Errorf("Result at index %d should've had a body of length %d, but was actually %d", i, len(expectedResult.Body), len(r.Body))
-		}
-		if r.Hostname != expectedResult.Hostname {
-			t.Errorf("Result at index %d should've had a Hostname of %s, but was actually %s", i, expectedResult.Hostname, r.Hostname)
-		}
-		if r.IP != expectedResult.IP {
-			t.Errorf("Result at index %d should've had a IP of %s, but was actually %s", i, expectedResult.IP, r.IP)
-		}
-		if r.Connected != expectedResult.Connected {
-			t.Errorf("Result at index %d should've had a Connected value of %t, but was actually %t", i, expectedResult.Connected, r.Connected)
-		}
-		if r.Duration != expectedResult.Duration {
-			t.Errorf("Result at index %d should've had a Duration of %s, but was actually %s", i, expectedResult.Duration.String(), r.Duration.String())
-		}
-		if len(r.Errors) != len(expectedResult.Errors) {
-			t.Errorf("Result at index %d should've had %d errors, but actually had %d errors", i, len(expectedResult.Errors), len(r.Errors))
-		}
-		if len(r.ConditionResults) != len(expectedResult.ConditionResults) {
-			t.Errorf("Result at index %d should've had %d ConditionResults, but actually had %d ConditionResults", i, len(expectedResult.ConditionResults), len(r.ConditionResults))
-		}
-		if r.Success != expectedResult.Success {
-			t.Errorf("Result at index %d should've had a Success of %t, but was actually %t", i, expectedResult.Success, r.Success)
-		}
-		if r.Timestamp != expectedResult.Timestamp {
-			t.Errorf("Result at index %d should've had a Timestamp of %s, but was actually %s", i, expectedResult.Timestamp.String(), r.Timestamp.String())
-		}
-		if r.CertificateExpiration != expectedResult.CertificateExpiration {
-			t.Errorf("Result at index %d should've had a CertificateExpiration of %s, but was actually %s", i, expectedResult.CertificateExpiration.String(), r.CertificateExpiration.String())
-		}
-	}
-}
-
-func TestStorage_InsertTwoResultsTwoServicesIntoEmptyMemoryStore_ThenGetAllReturnsTwoServicesWithOneResultEach(t *testing.T) {
-	memoryStore.Clear()
-	result1 := core.Result{
-		HTTPStatus:            404,
-		DNSRCode:              "DNSRCode",
-		Body:                  nil,
-		Hostname:              "Hostname",
-		IP:                    "IP",
-		Connected:             false,
-		Duration:              time.Second * 2,
-		Errors:                nil,
-		ConditionResults:      nil,
-		Success:               false,
-		Timestamp:             time.Now(),
-		CertificateExpiration: time.Second * 2,
-	}
-	result2 := core.Result{
-		HTTPStatus:            200,
-		DNSRCode:              "DNSRCode",
-		Body:                  nil,
-		Hostname:              "Hostname",
-		IP:                    "IP",
-		Connected:             true,
-		Duration:              time.Second * 2,
-		Errors:                nil,
-		ConditionResults:      nil,
-		Success:               true,
-		Timestamp:             time.Now(),
-		CertificateExpiration: time.Second * 2,
-	}
-
-	testService2 := core.Service{
-		Name:                    "Name2",
-		Group:                   "Group",
-		URL:                     "URL",
-		DNS:                     &core.DNS{QueryType: "QueryType", QueryName: "QueryName"},
-		Method:                  "Method",
-		Body:                    "Body",
-		GraphQL:                 false,
-		Headers:                 nil,
-		Interval:                time.Second * 2,
-		Conditions:              nil,
-		Alerts:                  nil,
-		Insecure:                false,
-		NumberOfFailuresInARow:  0,
-		NumberOfSuccessesInARow: 0,
-	}
-
-	memoryStore.Insert(&testService, &result1)
-	memoryStore.Insert(&testService2, &result2)
-
-	results := memoryStore.GetAll()
-	if len(results) != 2 {
-		t.Fatalf("MemoryStore should've returned 2 results, but actually returned %d", len(results))
-	}
-
-	key := fmt.Sprintf("%s_%s", testService.Group, testService.Name)
-	serviceResults1, exists := results[key]
-	if !exists {
-		t.Fatalf("In Memory Store should've contained key '%s', but didn't", key)
-	}
-
-	if len(serviceResults1.Results) != 1 {
-		t.Fatalf("Service '%s' should've had 1 results, but actually returned %d", serviceResults1.Name, len(serviceResults1.Results))
-	}
-
-	key = fmt.Sprintf("%s_%s", testService2.Group, testService2.Name)
-	serviceResults2, exists := results[key]
-	if !exists {
-		t.Fatalf("In Memory Store should've contained key '%s', but didn't", key)
-	}
-
-	if len(serviceResults2.Results) != 1 {
-		t.Fatalf("Service '%s' should've had 1 results, but actually returned %d", serviceResults1.Name, len(serviceResults1.Results))
-	}
-}
-
-func TestStorage_InsertResultForServiceWithErrorsIntoEmptyMemoryStore_ThenGetAllReturnsOneResultWithErrors(t *testing.T) {
-	memoryStore.Clear()
-	errors := []string{
-		"error1",
-		"error2",
-	}
-	result1 := core.Result{
-		HTTPStatus:            404,
-		DNSRCode:              "DNSRCode",
-		Body:                  nil,
-		Hostname:              "Hostname",
-		IP:                    "IP",
-		Connected:             false,
-		Duration:              time.Second * 2,
-		Errors:                errors,
-		ConditionResults:      nil,
-		Success:               false,
-		Timestamp:             time.Now(),
-		CertificateExpiration: time.Second * 2,
-	}
-
-	memoryStore.Insert(&testService, &result1)
-
-	results := memoryStore.GetAll()
-	if len(results) != 1 {
-		t.Fatalf("MemoryStore should've returned 1 results, but actually returned %d", len(results))
-	}
-
-	key := fmt.Sprintf("%s_%s", testService.Group, testService.Name)
-	serviceResults, exists := results[key]
-	if !exists {
-		t.Fatalf("In Memory Store should've contained key '%s', but didn't", key)
-	}
-
-	if len(serviceResults.Results) != 1 {
-		t.Fatalf("Service '%s' should've had 2 results, but actually returned %d", serviceResults.Name, len(serviceResults.Results))
-	}
-
-	actualResult := serviceResults.Results[0]
-
-	if len(actualResult.Errors) != len(errors) {
-		t.Errorf("Service result should've had 2 errors, but actually had %d errors", len(actualResult.Errors))
-	}
-
-	for i, err := range actualResult.Errors {
-		if err != errors[i] {
-			t.Errorf("Error at index %d should've been %s, but was actually %s", i, errors[i], err)
-		}
-	}
-}
-
-func TestStorage_InsertResultForServiceWithConditionResultsIntoEmptyMemoryStore_ThenGetAllReturnsOneResultWithConditionResults(t *testing.T) {
-	memoryStore.Clear()
-	crs := []*core.ConditionResult{
-		{
-			Condition: "condition1",
-			Success:   true,
-		},
-		{
-			Condition: "condition2",
-			Success:   false,
-		},
-	}
-	result := core.Result{
-		HTTPStatus:            404,
-		DNSRCode:              "DNSRCode",
-		Body:                  nil,
-		Hostname:              "Hostname",
-		IP:                    "IP",
-		Connected:             false,
-		Duration:              time.Second * 2,
-		Errors:                nil,
-		ConditionResults:      crs,
-		Success:               false,
-		Timestamp:             time.Now(),
-		CertificateExpiration: time.Second * 2,
-	}
-
-	memoryStore.Insert(&testService, &result)
-
-	results := memoryStore.GetAll()
-	if len(results) != 1 {
-		t.Fatalf("MemoryStore should've returned 1 results, but actually returned %d", len(results))
-	}
-
-	key := fmt.Sprintf("%s_%s", testService.Group, testService.Name)
-	serviceResults, exists := results[key]
-	if !exists {
-		t.Fatalf("In Memory Store should've contained key '%s', but didn't", key)
-	}
-
-	if len(serviceResults.Results) != 1 {
-		t.Fatalf("Service '%s' should've had 2 results, but actually returned %d", serviceResults.Name, len(serviceResults.Results))
-	}
-
-	actualResult := serviceResults.Results[0]
-
-	if len(actualResult.ConditionResults) != len(crs) {
-		t.Errorf("Service result should've had 2 ConditionResults, but actually had %d ConditionResults", len(actualResult.Errors))
-	}
-
-	for i, cr := range actualResult.ConditionResults {
-		if cr.Condition != crs[i].Condition {
-			t.Errorf("ConditionResult at index %d should've had condition %s, but was actually %s", i, crs[i].Condition, cr.Condition)
-		}
-		if cr.Success != crs[i].Success {
-			t.Errorf("ConditionResult at index %d should've had success value of %t, but was actually %t", i, crs[i].Success, cr.Success)
-		}
-	}
-}
-
-func TestStorage_MultipleMemoryStoreInstancesReferToDifferentInternalMaps(t *testing.T) {
-	memoryStore.Clear()
-	currentMap := memoryStore.GetAll()
-
-	otherMemoryStore := NewInMemoryStore()
-	otherMemoryStoresMap := otherMemoryStore.GetAll()
-
-	if len(currentMap) != len(otherMemoryStoresMap) {
-		t.Errorf("Multiple memory stores should refer to the different internal maps, but 'memoryStore' returned %d results, and 'otherMemoryStore' returned %d results", len(currentMap), len(otherMemoryStoresMap))
-	}
-
-	memoryStore.Insert(&testService, &core.Result{})
-	currentMap = memoryStore.GetAll()
-	otherMemoryStoresMap = otherMemoryStore.GetAll()
-
-	if len(currentMap) == len(otherMemoryStoresMap) {
-		t.Errorf("Multiple memory stores should refer to different internal maps, but 'memoryStore' returned %d results after inserting, and 'otherMemoryStore' returned %d results after inserting", len(currentMap), len(otherMemoryStoresMap))
-	}
-
-	otherMemoryStore.Clear()
-	currentMap = memoryStore.GetAll()
-	otherMemoryStoresMap = otherMemoryStore.GetAll()
-
-	if len(currentMap) == len(otherMemoryStoresMap) {
-		t.Errorf("Multiple memory stores should refer to different internal maps, but 'memoryStore' returned %d results after clearing, and 'otherMemoryStore' returned %d results after clearing", len(currentMap), len(otherMemoryStoresMap))
-	}
-}
-
-func TestStorage_ModificationsToReturnedMapDoNotAffectInternalMap(t *testing.T) {
-	memoryStore.Clear()
-
-	memoryStore.Insert(&testService, &core.Result{})
-	modifiedResults := memoryStore.GetAll()
-	for k := range modifiedResults {
-		delete(modifiedResults, k)
-	}
-	results := memoryStore.GetAll()
-
-	if len(modifiedResults) == len(results) {
-		t.Errorf("Returned map from GetAll should be free to modify by the caller without affecting internal in-memory map, but length of results from in-memory map (%d) was equal to the length of results in modified map (%d)", len(results), len(modifiedResults))
-	}
-}
-
-func TestStorage_GetServiceStatusForExistingStatusReturnsThatServiceStatus(t *testing.T) {
-	memoryStore.Clear()
-
-	memoryStore.Insert(&testService, &core.Result{})
-	serviceStatus := memoryStore.GetServiceStatus(testService.Group, testService.Name)
-
-	if serviceStatus == nil {
-		t.Errorf("Returned service status for group '%s' and name '%s' was nil after inserting the service into the store", testService.Group, testService.Name)
-	}
-}
-
-func TestStorage_GetServiceStatusForMissingStatusReturnsNil(t *testing.T) {
-	memoryStore.Clear()
-
-	memoryStore.Insert(&testService, &core.Result{})
-
-	serviceStatus := memoryStore.GetServiceStatus("nonexistantgroup", "nonexistantname")
-	if serviceStatus != nil {
-		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", testService.Group, testService.Name)
-	}
-
-	serviceStatus = memoryStore.GetServiceStatus(testService.Group, "nonexistantname")
-	if serviceStatus != nil {
-		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", testService.Group, "nonexistantname")
-	}
-
-	serviceStatus = memoryStore.GetServiceStatus("nonexistantgroup", testService.Name)
-	if serviceStatus != nil {
-		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", "nonexistantgroup", testService.Name)
-	}
-}

storage/storage.go

@@ -0,0 +1,48 @@
+package storage
+
+import (
+	"log"
+	"time"
+
+	"github.com/TwinProduction/gatus/storage/store"
+	"github.com/TwinProduction/gatus/storage/store/memory"
+)
+
+var (
+	provider store.Store
+
+	// initialized keeps track of whether the storage provider was initialized
+	// 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
+)
+
+// Get retrieves the storage provider
+func Get() store.Store {
+	if !initialized {
+		log.Println("[storage][Get] Provider requested before it was initialized, automatically initializing")
+		err := Initialize(nil)
+		if err != nil {
+			panic("failed to automatically initialize store: " + err.Error())
+		}
+	}
+	return provider
+}
+
+// Initialize instantiates the storage provider based on the Config provider
+func Initialize(cfg *Config) error {
+	initialized = true
+	var err error
+	if cfg == nil || len(cfg.File) == 0 {
+		log.Println("[storage][Initialize] Creating storage provider")
+		provider, err = memory.NewStore("")
+	} else {
+		log.Printf("[storage][Initialize] Creating storage provider with file=%s", cfg.File)
+		provider, err = memory.NewStore(cfg.File)
+		if err != nil {
+			return err
+		}
+		go provider.(*memory.Store).AutoSave(7 * time.Minute)
+	}
+	return nil
+}

storage/store/memory/memory.go

@@ -0,0 +1,110 @@
+package memory
+
+import (
+	"encoding/gob"
+	"encoding/json"
+	"log"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/util"
+	"github.com/TwinProduction/gocache"
+)
+
+func init() {
+	gob.Register(&core.ServiceStatus{})
+	gob.Register(&core.Uptime{})
+	gob.Register(&core.Result{})
+	gob.Register(&core.Event{})
+}
+
+// Store that leverages gocache
+type Store struct {
+	file  string
+	cache *gocache.Cache
+}
+
+// NewStore creates a new store
+func NewStore(file string) (*Store, error) {
+	store := &Store{
+		file:  file,
+		cache: gocache.NewCache().WithMaxSize(gocache.NoMaxSize),
+	}
+	if len(file) > 0 {
+		_, err := store.cache.ReadFromFile(file)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return store, nil
+}
+
+// GetAllAsJSON returns the JSON encoding of all monitored core.ServiceStatus
+func (s *Store) GetAllAsJSON() ([]byte, error) {
+	return json.Marshal(s.cache.GetAll())
+}
+
+// GetServiceStatus returns the service status for a given service name in the given group
+func (s *Store) GetServiceStatus(groupName, serviceName string) *core.ServiceStatus {
+	return s.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(groupName, serviceName))
+}
+
+// GetServiceStatusByKey returns the service status for a given key
+func (s *Store) GetServiceStatusByKey(key string) *core.ServiceStatus {
+	serviceStatus := s.cache.GetValue(key)
+	if serviceStatus == nil {
+		return nil
+	}
+	return serviceStatus.(*core.ServiceStatus)
+}
+
+// Insert adds the observed result for the specified service into the store
+func (s *Store) Insert(service *core.Service, result *core.Result) {
+	key := util.ConvertGroupAndServiceToKey(service.Group, service.Name)
+	serviceStatus, exists := s.cache.Get(key)
+	if !exists {
+		serviceStatus = core.NewServiceStatus(service)
+	}
+	serviceStatus.(*core.ServiceStatus).AddResult(result)
+	s.cache.Set(key, serviceStatus)
+}
+
+// DeleteAllServiceStatusesNotInKeys removes all ServiceStatus that are not within the keys provided
+func (s *Store) DeleteAllServiceStatusesNotInKeys(keys []string) int {
+	var keysToDelete []string
+	for _, existingKey := range s.cache.GetKeysByPattern("*", 0) {
+		shouldDelete := true
+		for _, key := range keys {
+			if existingKey == key {
+				shouldDelete = false
+				break
+			}
+		}
+		if shouldDelete {
+			keysToDelete = append(keysToDelete, existingKey)
+		}
+	}
+	return s.cache.DeleteAll(keysToDelete)
+}
+
+// Clear deletes everything from the store
+func (s *Store) Clear() {
+	s.cache.Clear()
+}
+
+// Save persists the cache to the store file
+func (s *Store) Save() error {
+	return s.cache.SaveToFile(s.file)
+}
+
+// AutoSave automatically calls the Save function at every interval
+func (s *Store) AutoSave(interval time.Duration) {
+	for {
+		time.Sleep(interval)
+		log.Printf("[memory][AutoSave] Persisting data to file")
+		err := s.Save()
+		if err != nil {
+			log.Printf("[memory][AutoSave] failed to save to file=%s: %s", s.file, err.Error())
+		}
+	}
+}

storage/store/memory/memory_test.go

@@ -0,0 +1,252 @@
+package memory
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/util"
+)
+
+var (
+	firstCondition  = core.Condition("[STATUS] == 200")
+	secondCondition = core.Condition("[RESPONSE_TIME] < 500")
+	thirdCondition  = core.Condition("[CERTIFICATE_EXPIRATION] < 72h")
+
+	timestamp = time.Now()
+
+	testService = core.Service{
+		Name:                    "name",
+		Group:                   "group",
+		URL:                     "https://example.org/what/ever",
+		Method:                  "GET",
+		Body:                    "body",
+		Interval:                30 * time.Second,
+		Conditions:              []*core.Condition{&firstCondition, &secondCondition, &thirdCondition},
+		Alerts:                  nil,
+		Insecure:                false,
+		NumberOfFailuresInARow:  0,
+		NumberOfSuccessesInARow: 0,
+	}
+	testSuccessfulResult = core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Body:                  []byte("body"),
+		Errors:                nil,
+		Connected:             true,
+		Success:               true,
+		Timestamp:             timestamp,
+		Duration:              150 * time.Millisecond,
+		CertificateExpiration: 10 * time.Hour,
+		ConditionResults: []*core.ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   true,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   true,
+			},
+		},
+	}
+	testUnsuccessfulResult = core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Body:                  []byte("body"),
+		Errors:                []string{"error-1", "error-2"},
+		Connected:             true,
+		Success:               false,
+		Timestamp:             timestamp,
+		Duration:              750 * time.Millisecond,
+		CertificateExpiration: 10 * time.Hour,
+		ConditionResults: []*core.ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   false,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   false,
+			},
+		},
+	}
+)
+
+func TestStore_Insert(t *testing.T) {
+	store, _ := NewStore("")
+	store.Insert(&testService, &testSuccessfulResult)
+	store.Insert(&testService, &testUnsuccessfulResult)
+
+	if store.cache.Count() != 1 {
+		t.Fatalf("expected 1 ServiceStatus, got %d", store.cache.Count())
+	}
+	key := fmt.Sprintf("%s_%s", testService.Group, testService.Name)
+	serviceStatus := store.GetServiceStatusByKey(key)
+	if serviceStatus == nil {
+		t.Fatalf("Store should've had key '%s', but didn't", key)
+	}
+	if len(serviceStatus.Results) != 2 {
+		t.Fatalf("Service '%s' should've had 2 results, but actually returned %d", serviceStatus.Name, len(serviceStatus.Results))
+	}
+	for i, r := range serviceStatus.Results {
+		expectedResult := store.GetServiceStatus(testService.Group, testService.Name).Results[i]
+		if r.HTTPStatus != expectedResult.HTTPStatus {
+			t.Errorf("Result at index %d should've had a HTTPStatus of %d, but was actually %d", i, expectedResult.HTTPStatus, r.HTTPStatus)
+		}
+		if r.DNSRCode != expectedResult.DNSRCode {
+			t.Errorf("Result at index %d should've had a DNSRCode of %s, but was actually %s", i, expectedResult.DNSRCode, r.DNSRCode)
+		}
+		if len(r.Body) != len(expectedResult.Body) {
+			t.Errorf("Result at index %d should've had a body of length %d, but was actually %d", i, len(expectedResult.Body), len(r.Body))
+		}
+		if r.Hostname != expectedResult.Hostname {
+			t.Errorf("Result at index %d should've had a Hostname of %s, but was actually %s", i, expectedResult.Hostname, r.Hostname)
+		}
+		if r.IP != expectedResult.IP {
+			t.Errorf("Result at index %d should've had a IP of %s, but was actually %s", i, expectedResult.IP, r.IP)
+		}
+		if r.Connected != expectedResult.Connected {
+			t.Errorf("Result at index %d should've had a Connected value of %t, but was actually %t", i, expectedResult.Connected, r.Connected)
+		}
+		if r.Duration != expectedResult.Duration {
+			t.Errorf("Result at index %d should've had a Duration of %s, but was actually %s", i, expectedResult.Duration.String(), r.Duration.String())
+		}
+		if len(r.Errors) != len(expectedResult.Errors) {
+			t.Errorf("Result at index %d should've had %d errors, but actually had %d errors", i, len(expectedResult.Errors), len(r.Errors))
+		}
+		if len(r.ConditionResults) != len(expectedResult.ConditionResults) {
+			t.Errorf("Result at index %d should've had %d ConditionResults, but actually had %d ConditionResults", i, len(expectedResult.ConditionResults), len(r.ConditionResults))
+		}
+		if r.Success != expectedResult.Success {
+			t.Errorf("Result at index %d should've had a Success of %t, but was actually %t", i, expectedResult.Success, r.Success)
+		}
+		if r.Timestamp != expectedResult.Timestamp {
+			t.Errorf("Result at index %d should've had a Timestamp of %s, but was actually %s", i, expectedResult.Timestamp.String(), r.Timestamp.String())
+		}
+		if r.CertificateExpiration != expectedResult.CertificateExpiration {
+			t.Errorf("Result at index %d should've had a CertificateExpiration of %s, but was actually %s", i, expectedResult.CertificateExpiration.String(), r.CertificateExpiration.String())
+		}
+	}
+}
+
+func TestStore_GetServiceStatus(t *testing.T) {
+	store, _ := NewStore("")
+	store.Insert(&testService, &testSuccessfulResult)
+	store.Insert(&testService, &testUnsuccessfulResult)
+
+	serviceStatus := store.GetServiceStatus(testService.Group, testService.Name)
+	if serviceStatus == nil {
+		t.Fatalf("serviceStatus shouldn't have been nil")
+	}
+	if serviceStatus.Uptime == nil {
+		t.Fatalf("serviceStatus.Uptime shouldn't have been nil")
+	}
+	if serviceStatus.Uptime.LastHour != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastHour should've been 0.5")
+	}
+	if serviceStatus.Uptime.LastTwentyFourHours != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastTwentyFourHours should've been 0.5")
+	}
+	if serviceStatus.Uptime.LastSevenDays != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastSevenDays should've been 0.5")
+	}
+}
+
+func TestStore_GetServiceStatusForMissingStatusReturnsNil(t *testing.T) {
+	store, _ := NewStore("")
+	store.Insert(&testService, &testSuccessfulResult)
+
+	serviceStatus := store.GetServiceStatus("nonexistantgroup", "nonexistantname")
+	if serviceStatus != nil {
+		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", testService.Group, testService.Name)
+	}
+	serviceStatus = store.GetServiceStatus(testService.Group, "nonexistantname")
+	if serviceStatus != nil {
+		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", testService.Group, "nonexistantname")
+	}
+	serviceStatus = store.GetServiceStatus("nonexistantgroup", testService.Name)
+	if serviceStatus != nil {
+		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", "nonexistantgroup", testService.Name)
+	}
+}
+
+func TestStore_GetServiceStatusByKey(t *testing.T) {
+	store, _ := NewStore("")
+	store.Insert(&testService, &testSuccessfulResult)
+	store.Insert(&testService, &testUnsuccessfulResult)
+
+	serviceStatus := store.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(testService.Group, testService.Name))
+	if serviceStatus == nil {
+		t.Fatalf("serviceStatus shouldn't have been nil")
+	}
+	if serviceStatus.Uptime == nil {
+		t.Fatalf("serviceStatus.Uptime shouldn't have been nil")
+	}
+	if serviceStatus.Uptime.LastHour != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastHour should've been 0.5")
+	}
+	if serviceStatus.Uptime.LastTwentyFourHours != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastTwentyFourHours should've been 0.5")
+	}
+	if serviceStatus.Uptime.LastSevenDays != 0.5 {
+		t.Errorf("serviceStatus.Uptime.LastSevenDays should've been 0.5")
+	}
+}
+
+func TestStore_GetAllAsJSON(t *testing.T) {
+	store, _ := NewStore("")
+	firstResult := &testSuccessfulResult
+	secondResult := &testUnsuccessfulResult
+	store.Insert(&testService, firstResult)
+	store.Insert(&testService, secondResult)
+	// Can't be bothered dealing with timezone issues on the worker that runs the automated tests
+	firstResult.Timestamp = time.Time{}
+	secondResult.Timestamp = time.Time{}
+	output, err := store.GetAllAsJSON()
+	if err != nil {
+		t.Fatal("shouldn't have returned an error, got", err.Error())
+	}
+	expectedOutput := `{"group_name":{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"errors":null,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}]}}`
+	if string(output) != expectedOutput {
+		t.Errorf("expected:\n %s\n\ngot:\n %s", expectedOutput, string(output))
+	}
+}
+
+func TestStore_DeleteAllServiceStatusesNotInKeys(t *testing.T) {
+	store, _ := NewStore("")
+	firstService := core.Service{Name: "service-1", Group: "group"}
+	secondService := core.Service{Name: "service-2", Group: "group"}
+	result := &testSuccessfulResult
+	store.Insert(&firstService, result)
+	store.Insert(&secondService, result)
+	if store.cache.Count() != 2 {
+		t.Errorf("expected cache to have 2 keys, got %d", store.cache.Count())
+	}
+	if store.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(firstService.Group, firstService.Name)) == nil {
+		t.Fatal("firstService should exist")
+	}
+	if store.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(secondService.Group, secondService.Name)) == nil {
+		t.Fatal("secondService should exist")
+	}
+	store.DeleteAllServiceStatusesNotInKeys([]string{util.ConvertGroupAndServiceToKey(firstService.Group, firstService.Name)})
+	if store.cache.Count() != 1 {
+		t.Fatalf("expected cache to have 1 keys, got %d", store.cache.Count())
+	}
+	if store.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(firstService.Group, firstService.Name)) == nil {
+		t.Error("secondService should've been deleted")
+	}
+	if store.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(secondService.Group, secondService.Name)) != nil {
+		t.Error("firstService should still exist")
+	}
+}

storage/store/store.go

@@ -0,0 +1,34 @@
+package store
+
+import (
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage/store/memory"
+)
+
+// Store is the interface that each stores should implement
+type Store interface {
+	// GetAllAsJSON returns the JSON encoding of all monitored core.ServiceStatus
+	GetAllAsJSON() ([]byte, error)
+
+	// GetServiceStatus returns the service status for a given service name in the given group
+	GetServiceStatus(groupName, serviceName string) *core.ServiceStatus
+
+	// GetServiceStatusByKey returns the service status for a given key
+	GetServiceStatusByKey(key string) *core.ServiceStatus
+
+	// Insert adds the observed result for the specified service into the store
+	Insert(service *core.Service, result *core.Result)
+
+	// DeleteAllServiceStatusesNotInKeys removes all ServiceStatus that are not within the keys provided
+	//
+	// Used to delete services that have been persisted but are no longer part of the configured services
+	DeleteAllServiceStatusesNotInKeys(keys []string) int
+
+	// Clear deletes everything from the store
+	Clear()
+}
+
+var (
+	// Validate interface implementation on compile
+	_ Store = (*memory.Store)(nil)
+)

storage/store/store_bench_test.go

@@ -0,0 +1,136 @@
+package store
+
+import (
+	"testing"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage/store/memory"
+)
+
+var (
+	firstCondition  = core.Condition("[STATUS] == 200")
+	secondCondition = core.Condition("[RESPONSE_TIME] < 500")
+	thirdCondition  = core.Condition("[CERTIFICATE_EXPIRATION] < 72h")
+
+	timestamp = time.Now()
+
+	testService = core.Service{
+		Name:                    "name",
+		Group:                   "group",
+		URL:                     "https://example.org/what/ever",
+		Method:                  "GET",
+		Body:                    "body",
+		Interval:                30 * time.Second,
+		Conditions:              []*core.Condition{&firstCondition, &secondCondition, &thirdCondition},
+		Alerts:                  nil,
+		Insecure:                false,
+		NumberOfFailuresInARow:  0,
+		NumberOfSuccessesInARow: 0,
+	}
+	testSuccessfulResult = core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Body:                  []byte("body"),
+		Errors:                nil,
+		Connected:             true,
+		Success:               true,
+		Timestamp:             timestamp,
+		Duration:              150 * time.Millisecond,
+		CertificateExpiration: 10 * time.Hour,
+		ConditionResults: []*core.ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   true,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   true,
+			},
+		},
+	}
+	testUnsuccessfulResult = core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Body:                  []byte("body"),
+		Errors:                []string{"error-1", "error-2"},
+		Connected:             true,
+		Success:               false,
+		Timestamp:             timestamp,
+		Duration:              750 * time.Millisecond,
+		CertificateExpiration: 10 * time.Hour,
+		ConditionResults: []*core.ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   false,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   false,
+			},
+		},
+	}
+)
+
+func BenchmarkStore_GetAllAsJSON(b *testing.B) {
+	memoryStore, err := memory.NewStore("")
+	if err != nil {
+		b.Fatal("failed to create store:", err.Error())
+	}
+	type Scenario struct {
+		Name  string
+		Store Store
+	}
+	scenarios := []Scenario{
+		{
+			Name:  "memory",
+			Store: memoryStore,
+		},
+	}
+	for _, scenario := range scenarios {
+		scenario.Store.Insert(&testService, &testSuccessfulResult)
+		scenario.Store.Insert(&testService, &testUnsuccessfulResult)
+		b.Run(scenario.Name, func(b *testing.B) {
+			for n := 0; n < b.N; n++ {
+				scenario.Store.GetAllAsJSON()
+			}
+			b.ReportAllocs()
+		})
+	}
+}
+
+func BenchmarkStore_Insert(b *testing.B) {
+	memoryStore, err := memory.NewStore("")
+	if err != nil {
+		b.Fatal("failed to create store:", err.Error())
+	}
+	type Scenario struct {
+		Name  string
+		Store Store
+	}
+	scenarios := []Scenario{
+		{
+			Name:  "memory",
+			Store: memoryStore,
+		},
+	}
+	for _, scenario := range scenarios {
+		b.Run(scenario.Name, func(b *testing.B) {
+			for n := 0; n < b.N; n++ {
+				scenario.Store.Insert(&testService, &testSuccessfulResult)
+				scenario.Store.Insert(&testService, &testUnsuccessfulResult)
+			}
+			b.ReportAllocs()
+		})
+	}
+}

util/key.go

@@ -0,0 +1,18 @@
+package util
+
+import "strings"
+
+// ConvertGroupAndServiceToKey converts a group and a service to a key
+func ConvertGroupAndServiceToKey(group, service string) string {
+	return sanitize(group) + "_" + sanitize(service)
+}
+
+func sanitize(s string) string {
+	s = strings.TrimSpace(strings.ToLower(s))
+	s = strings.ReplaceAll(s, "/", "-")
+	s = strings.ReplaceAll(s, "_", "-")
+	s = strings.ReplaceAll(s, ".", "-")
+	s = strings.ReplaceAll(s, ",", "-")
+	s = strings.ReplaceAll(s, " ", "-")
+	return s
+}

util/key_test.go

@@ -0,0 +1,36 @@
+package util
+
+import "testing"
+
+func TestConvertGroupAndServiceToKey(t *testing.T) {
+	type Scenario struct {
+		GroupName      string
+		ServiceName    string
+		ExpectedOutput string
+	}
+	scenarios := []Scenario{
+		{
+			GroupName:      "Core",
+			ServiceName:    "Front End",
+			ExpectedOutput: "core_front-end",
+		},
+		{
+			GroupName:      "Load balancers",
+			ServiceName:    "us-west-2",
+			ExpectedOutput: "load-balancers_us-west-2",
+		},
+		{
+			GroupName:      "a/b test",
+			ServiceName:    "a",
+			ExpectedOutput: "a-b-test_a",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.ExpectedOutput, func(t *testing.T) {
+			output := ConvertGroupAndServiceToKey(scenario.GroupName, scenario.ServiceName)
+			if output != scenario.ExpectedOutput {
+				t.Errorf("Expected '%s', got '%s'", scenario.ExpectedOutput, output)
+			}
+		})
+	}
+}

vendor/github.com/TwinProduction/gocache/README.md

@@ -4,8 +4,7 @@
 [![Go Report Card](https://goreportcard.com/badge/github.com/TwinProduction/gocache)](https://goreportcard.com/report/github.com/TwinProduction/gocache)
 [![codecov](https://codecov.io/gh/TwinProduction/gocache/branch/master/graph/badge.svg)](https://codecov.io/gh/TwinProduction/gocache)
 [![Go version](https://img.shields.io/github/go-mod/go-version/TwinProduction/gocache.svg)](https://github.com/TwinProduction/gocache)
-[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](https://godoc.org/github.com/TwinProduction/gocache)
-[![Docker pulls](https://img.shields.io/docker/pulls/twinproduction/gocache-server.svg)](https://cloud.docker.com/repository/docker/twinproduction/gocache-server)
+[![Go Reference](https://pkg.go.dev/badge/github.com/TwinProduction/gocache.svg)](https://pkg.go.dev/github.com/TwinProduction/gocache)
 
 gocache is an easy-to-use, high-performance, lightweight and thread-safe (goroutine-safe) in-memory key-value cache 
 with support for LRU and FIFO eviction policies as well as expiration, bulk operations and even persistence to file.
@@ -27,6 +26,7 @@ with support for LRU and FIFO eviction policies as well as expiration, bulk oper
 - [Eviction](#eviction)
   - [MaxSize](#maxsize)
   - [MaxMemoryUsage](#maxmemoryusage)
+- [Expiration](#expiration)
 - [Server](#server)
 - [Running the server with Docker](#running-the-server-with-docker)
 - [Performance](#performance)
@@ -71,28 +71,31 @@ cache.StartJanitor()
 ```
 
 ### Functions
+| Function                          | Description |
+| --------------------------------- | ----------- |
+| WithMaxSize                       | Sets the max size of the cache. `gocache.NoMaxSize` means there is no limit. If not set, the default max size is `gocache.DefaultMaxSize`.
+| WithMaxMemoryUsage                | Sets the max memory usage of the cache. `gocache.NoMaxMemoryUsage` means there is no limit. The default behavior is to not evict based on memory usage.
+| WithEvictionPolicy                | Sets the eviction algorithm to be used when the cache reaches the max size. If not set, the default eviction policy is `gocache.FirstInFirstOut` (FIFO).
+| WithForceNilInterfaceOnNilPointer | Configures whether values with a nil pointer passed to write functions should be forcefully set to nil. Defaults to true.
+| StartJanitor                      | Starts the janitor, which is in charge of deleting expired cache entries in the background.
+| StopJanitor                       | Stops the janitor.
+| Set                               | Same as `SetWithTTL`, but with no expiration (`gocache.NoExpiration`)
+| SetAll                            | Same as `Set`, but in bulk
+| SetWithTTL                        | Creates or updates a cache entry with the given key, value and expiration time. If the max size after the aforementioned operation is above the configured max size, the tail will be evicted. Depending on the eviction policy, the tail is defined as the oldest 
+| Get                               | Gets a cache entry by its key.
+| GetByKeys                         | Gets a map of entries by their keys. The resulting map will contain all keys, even if some of the keys in the slice passed as parameter were not present in the cache.  
+| GetAll                            | Gets all cache entries.
+| GetKeysByPattern                  | Retrieves a slice of keys that matches a given pattern.
+| Delete                            | Removes a key from the cache.
+| DeleteAll                         | Removes multiple keys from the cache.
+| Count                             | Gets the size of the cache. This includes cache keys which may have already expired, but have not been removed yet.
+| Clear                             | Wipes the cache.
+| TTL                               | Gets the time until a cache key expires. 
+| Expire                            | Sets the expiration time of an existing cache key.
+| SaveToFile                        | Stores the content of the cache to a file so that it can be read using `ReadFromFile`. See [persistence](#persistence).
+| ReadFromFile                      | Populates the cache using a file created using `SaveToFile`. See [persistence](#persistence).
 
-| Function           | Description |
-| ------------------ | ----------- |
-| WithMaxSize        | Sets the max size of the cache. `gocache.NoMaxSize` means there is no limit. If not set, the default max size is `gocache.DefaultMaxSize`.
-| WithMaxMemoryUsage | Sets the max memory usage of the cache. `gocache.NoMaxMemoryUsage` means there is no limit. The default behavior is to not evict based on memory usage.
-| WithEvictionPolicy | Sets the eviction algorithm to be used when the cache reaches the max size. If not set, the default eviction policy is `gocache.FirstInFirstOut` (FIFO).
-| StartJanitor       | Starts the janitor, which is in charge of deleting expired cache entries in the background.
-| StopJanitor        | Stops the janitor.
-| Set                | Same as `SetWithTTL`, but with no expiration (`gocache.NoExpiration`)
-| SetAll             | Same as `Set`, but in bulk
-| SetWithTTL         | Creates or updates a cache entry with the given key, value and expiration time. If the max size after the aforementioned operation is above the configured max size, the tail will be evicted. Depending on the eviction policy, the tail is defined as the oldest 
-| Get                | Gets a cache entry by its key.
-| GetAll             | Gets a map of entries by their keys. The resulting map will contain all keys, even if some of the keys in the slice passed as parameter were not present in the cache.  
-| GetKeysByPattern   | Retrieves a slice of keys that matches a given pattern.
-| Delete             | Removes a key from the cache.
-| DeleteAll          | Removes multiple keys from the cache.
-| Count              | Gets the size of the cache. This includes cache keys which may have already expired, but have not been removed yet.
-| Clear              | Wipes the cache.
-| TTL                | Gets the time until a cache key expires. 
-| Expire             | Sets the expiration time of an existing cache key.
-| SaveToFile         | Stores the content of the cache to a file so that it can be read using `ReadFromFile`. See [persistence](#persistence).
-| ReadFromFile       | Populates the cache using a file created using `SaveToFile`. See [persistence](#persistence).
+For further documentation, please refer to [Go Reference](https://pkg.go.dev/github.com/TwinProduction/gocache)
 
 
 ### Examples
@@ -102,13 +105,14 @@ cache.StartJanitor()
 cache.Set("key", "value") 
 cache.Set("key", 1)
 cache.Set("key", struct{ Text string }{Test: "value"})
+cache.SetWithTTL("key", []byte("value"), 24*time.Hour)
 ```
 
 #### Getting an entry
 ```go
-value, ok := cache.Get("key")
+value, exists := cache.Get("key")
 ```
-You can also get multiple entries by using `cache.GetAll([]string{"key1", "key2"})`
+You can also get multiple entries by using `cache.GetByKeys([]string{"key1", "key2"})`
 
 #### Deleting an entry
 ```go
@@ -122,8 +126,9 @@ package main
 
 import (
 	"fmt"
-	"github.com/TwinProduction/gocache"
 	"time"
+
+    "github.com/TwinProduction/gocache"
 )
 
 func main() {
@@ -136,8 +141,8 @@ func main() {
 
 	value, exists := cache.Get("key")
 	fmt.Printf("[Get] key=key; value=%s; exists=%v\n", value, exists)
-	for key, value := range cache.GetAll([]string{"k1", "k2", "k3"}) {
-		fmt.Printf("[GetAll] key=%s; value=%s\n", key, value)
+	for key, value := range cache.GetByKeys([]string{"k1", "k2", "k3"}) {
+		fmt.Printf("[GetByKeys] key=%s; value=%s\n", key, value)
 	}
 	for _, key := range cache.GetKeysByPattern("key*", 0) {
 		fmt.Printf("[GetKeysByPattern] key=%s\n", key)
@@ -174,9 +179,9 @@ func main() {
 
 ```
 [Get] key=key; value=value; exists=true
-[GetAll] key=k2; value=v2
-[GetAll] key=k3; value=v3
-[GetAll] key=k1; value=v1
+[GetByKeys] key=k2; value=v2
+[GetByKeys] key=k3; value=v3
+[GetByKeys] key=k1; value=v1
 [GetKeysByPattern] key=key
 [GetKeysByPattern] key=key-with-ttl
 Cache size before persisting cache to file: 5
@@ -248,6 +253,7 @@ you'll be fine.
 
 
 ## Eviction
+
 ### MaxSize
 Eviction by MaxSize is the default behavior, and is also the most efficient.
 
@@ -258,7 +264,7 @@ cache := gocache.NewCache().WithMaxSize(1000)
 This means that whenever an operation causes the total size of the cache to go above 1000, the tail will be evicted.
 
 ### MaxMemoryUsage
-Eviction by MaxMemoryUsage is **disabled by default**, and is still a work in progress.
+Eviction by MaxMemoryUsage is **disabled by default**, and is in alpha.
 
 The code below will create a cache that has a maximum memory usage of 50MB:
 ```go
@@ -268,7 +274,7 @@ This means that whenever an operation causes the total memory usage of the cache
 will be evicted.
 
 Unlike evictions caused by reaching the MaxSize, evictions triggered by MaxMemoryUsage may lead to multiple entries
-being evicted in a row. The reason for this is that if, for instance, you had 500 entries of 0.1MB each and you suddenly added 
+being evicted in a row. The reason for this is that if, for instance, you had 100 entries of 0.1MB each and you suddenly added 
 a single entry of 10MB, 100 entries would need to be evicted to make enough space for that new big entry.
 
 It's very important to keep in mind that eviction by MaxMemoryUsage is approximate.
@@ -284,13 +290,25 @@ As previously mentioned, this is a work in progress, and here's a list of the th
 - Adding an entry bigger than the configured MaxMemoryUsage will work, but it will evict all other entries.
 
 
+## Expiration
+There are two ways that the deletion of expired keys can take place:
+- Active
+- Passive
+
+**Active deletion of expired keys** happens when an attempt is made to access the value of a cache entry that expired. 
+`Get`, `GetByKeys` and `GetAll` are the only functions that can trigger active deletion of expired keys.
+
+**Passive deletion of expired keys** runs in the background and is managed by the janitor. 
+If you do not start the janitor, there will be no passive deletion of expired keys.
+
+
 ## Server
 For the sake of convenience, a ready-to-go cache server is available 
 through the `gocacheserver` package. 
 
-The reason why the server is in a different package is because `gocache` does not use 
-any external dependencies, but rather than re-inventing the wheel, the server 
-implementation uses redcon, which is a Redis server framework for Go.
+The reason why the server is in a different package is because `gocache` limit its external dependencies to the strict 
+minimum (e.g. boltdb for persistence), however, rather than re-inventing the wheel, the server implementation uses
+redcon, which is a very good Redis server framework for Go.
 
 That way, those who desire to use gocache without the server will not add any extra dependencies
 as long as they don't import the `gocacheserver` package. 
@@ -305,7 +323,7 @@ import (
 
 func main() {
 	cache := gocache.NewCache().WithEvictionPolicy(gocache.LeastRecentlyUsed).WithMaxSize(100000)
-	server := gocacheserver.NewServer(cache)
+	server := gocacheserver.NewServer(cache).WithPort(6379)
 	server.Start()
 }
 ```
@@ -330,12 +348,14 @@ Any Redis client should be able to interact with the server, though only the fol
 
 
 ## Running the server with Docker
+[![Docker pulls](https://img.shields.io/docker/pulls/twinproduction/gocache-server.svg)](https://cloud.docker.com/repository/docker/twinproduction/gocache-server)
+
 To build it locally, refer to the Makefile's `docker-build` and `docker-run` steps.
 
 Note that the server version of gocache is still under development.
 
 ```
-docker run --name gocache-server -p 6379:6379 twinproduction/gocache-server:v0.1.0
+docker run --name gocache-server -p 6379:6379 twinproduction/gocache-server
 ```
 
 
@@ -362,45 +382,76 @@ but if you're looking into using a library like gocache, odds are, you want more
 | mem    | 32G DDR4 |
 
 ```
-BenchmarkMap_Get-8                                                         	47943618	       26.6 ns/op
-BenchmarkMap_SetSmallValue-8                                               	 3800810	       394 ns/op
-BenchmarkMap_SetMediumValue-8                                              	 3904794	       400 ns/op
-BenchmarkMap_SetLargeValue-8                                               	 3934033	       383 ns/op
-BenchmarkCache_Get-8                                                       	27254640	       45.0 ns/op
-BenchmarkCache_SetSmallValue-8                                             	 2991620	       401 ns/op
-BenchmarkCache_SetMediumValue-8                                            	 3051128	       381 ns/op
-BenchmarkCache_SetLargeValue-8                                             	 2995904	       382 ns/op
-BenchmarkCache_SetSmallValueWhenUsingMaxMemoryUsage-8                      	 2752288	       428 ns/op
-BenchmarkCache_SetMediumValueWhenUsingMaxMemoryUsage-8                     	 2744899	       436 ns/op
-BenchmarkCache_SetLargeValueWhenUsingMaxMemoryUsage-8                      	 2756816	       430 ns/op
-BenchmarkCache_SetSmallValueWithMaxSize10-8                                	 5308886	       226 ns/op
-BenchmarkCache_SetMediumValueWithMaxSize10-8                               	 5304098	       226 ns/op
-BenchmarkCache_SetLargeValueWithMaxSize10-8                                	 5277986	       227 ns/op
-BenchmarkCache_SetSmallValueWithMaxSize1000-8                              	 5130580	       236 ns/op
-BenchmarkCache_SetMediumValueWithMaxSize1000-8                             	 5102404	       237 ns/op
-BenchmarkCache_SetLargeValueWithMaxSize1000-8                              	 5084695	       237 ns/op
-BenchmarkCache_SetSmallValueWithMaxSize100000-8                            	 3858066	       315 ns/op
-BenchmarkCache_SetMediumValueWithMaxSize100000-8                           	 3909277	       315 ns/op
-BenchmarkCache_SetLargeValueWithMaxSize100000-8                            	 3870913	       315 ns/op
-BenchmarkCache_SetSmallValueWithMaxSize100000AndLRU-8                      	 3856012	       316 ns/op
-BenchmarkCache_SetMediumValueWithMaxSize100000AndLRU-8                     	 3809518	       316 ns/op
-BenchmarkCache_SetLargeValueWithMaxSize100000AndLRU-8                      	 3834754	       318 ns/op
-BenchmarkCache_GetAndSetConcurrently-8                                     	 1779258	       672 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndLRU-8                 	 2569590	       487 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndFIFO-8                	 2608369	       474 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndNoEvictionAndLRU-8    	 2185795	       582 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndNoEvictionAndFIFO-8   	 2238811	       568 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithFrequentEvictionsAndLRU-8          	 3726714	       320 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithFrequentEvictionsAndFIFO-8         	 3682808	       325 ns/op
-BenchmarkCache_GetConcurrentlyWithLRU-8                                    	 1536589	       739 ns/op
-BenchmarkCache_GetConcurrentlyWithFIFO-8                                   	 1558513	       737 ns/op
-BenchmarkCache_GetKeysThatDoNotExistConcurrently-8                         	10173138	       119 ns/op
+// Normal map
+BenchmarkMap_Get
+BenchmarkMap_Get-8                                                              46087372  26.7 ns/op
+BenchmarkMap_Set                                                                   
+BenchmarkMap_Set/small_value-8                                                   3841911   389 ns/op
+BenchmarkMap_Set/medium_value-8                                                  3887074   391 ns/op
+BenchmarkMap_Set/large_value-8                                                   3921956   393 ns/op
+// Gocache                                                                         
+BenchmarkCache_Get                                                                 
+BenchmarkCache_Get/FirstInFirstOut-8                                            27273036  46.4 ns/op
+BenchmarkCache_Get/LeastRecentlyUsed-8                                          26648248  46.3 ns/op
+BenchmarkCache_Set                                                              
+BenchmarkCache_Set/FirstInFirstOut_small_value-8                                 2919584   405 ns/op
+BenchmarkCache_Set/FirstInFirstOut_medium_value-8                                2990841   391 ns/op
+BenchmarkCache_Set/FirstInFirstOut_large_value-8                                 2970513   391 ns/op
+BenchmarkCache_Set/LeastRecentlyUsed_small_value-8                               2962939   402 ns/op
+BenchmarkCache_Set/LeastRecentlyUsed_medium_value-8                              2962963   390 ns/op
+BenchmarkCache_Set/LeastRecentlyUsed_large_value-8                               2962928   394 ns/op
+BenchmarkCache_SetUsingMaxMemoryUsage                                           
+BenchmarkCache_SetUsingMaxMemoryUsage/small_value-8                              2683356   447 ns/op
+BenchmarkCache_SetUsingMaxMemoryUsage/medium_value-8                             2637578   441 ns/op
+BenchmarkCache_SetUsingMaxMemoryUsage/large_value-8                              2672434   443 ns/op
+BenchmarkCache_SetWithMaxSize                                                   
+BenchmarkCache_SetWithMaxSize/100_small_value-8                                  4782966   252 ns/op
+BenchmarkCache_SetWithMaxSize/10000_small_value-8                                4067967   296 ns/op
+BenchmarkCache_SetWithMaxSize/100000_small_value-8                               3762055   328 ns/op
+BenchmarkCache_SetWithMaxSize/100_medium_value-8                                 4760479   252 ns/op
+BenchmarkCache_SetWithMaxSize/10000_medium_value-8                               4081050   295 ns/op
+BenchmarkCache_SetWithMaxSize/100000_medium_value-8                              3785050   330 ns/op
+BenchmarkCache_SetWithMaxSize/100_large_value-8                                  4732909   254 ns/op
+BenchmarkCache_SetWithMaxSize/10000_large_value-8                                4079533   297 ns/op
+BenchmarkCache_SetWithMaxSize/100000_large_value-8                               3712820   331 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU                                             
+BenchmarkCache_SetWithMaxSizeAndLRU/100_small_value-8                            4761732   254 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/10000_small_value-8                          4084474   296 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/100000_small_value-8                         3761402   329 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/100_medium_value-8                           4783075   254 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/10000_medium_value-8                         4103980   296 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/100000_medium_value-8                        3646023   331 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/100_large_value-8                            4779025   254 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/10000_large_value-8                          4096192   296 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/100000_large_value-8                         3726823   331 ns/op
+BenchmarkCache_GetSetMultipleConcurrent                                         
+BenchmarkCache_GetSetMultipleConcurrent-8                                         707142  1698 ns/op
+BenchmarkCache_GetSetConcurrentWithFrequentEviction
+BenchmarkCache_GetSetConcurrentWithFrequentEviction/FirstInFirstOut-8            3616256   334 ns/op
+BenchmarkCache_GetSetConcurrentWithFrequentEviction/LeastRecentlyUsed-8          3636367   331 ns/op
+BenchmarkCache_GetConcurrentWithLRU                                              
+BenchmarkCache_GetConcurrentWithLRU/FirstInFirstOut-8                            4405557   268 ns/op
+BenchmarkCache_GetConcurrentWithLRU/LeastRecentlyUsed-8                          4445475   269 ns/op
+BenchmarkCache_WithForceNilInterfaceOnNilPointer
+BenchmarkCache_WithForceNilInterfaceOnNilPointer/true_with_nil_struct_pointer-8  6184591   191 ns/op
+BenchmarkCache_WithForceNilInterfaceOnNilPointer/true-8                          6090482   191 ns/op
+BenchmarkCache_WithForceNilInterfaceOnNilPointer/false_with_nil_struct_pointer-8 6184629   187 ns/op
+BenchmarkCache_WithForceNilInterfaceOnNilPointer/false-8                         6281781   186 ns/op
+(Trimmed "BenchmarkCache_" for readability)
+WithForceNilInterfaceOnNilPointerWithConcurrency
+WithForceNilInterfaceOnNilPointerWithConcurrency/true_with_nil_struct_pointer-8  4379564   268 ns/op
+WithForceNilInterfaceOnNilPointerWithConcurrency/true-8                          4379558   265 ns/op
+WithForceNilInterfaceOnNilPointerWithConcurrency/false_with_nil_struct_pointer-8 4444456   261 ns/op
+WithForceNilInterfaceOnNilPointerWithConcurrency/false-8                         4493896   262 ns/op
 ```
 
 
 ## FAQ
 
 ### Why does the memory usage not go down?
+
+> **NOTE**: As of Go 1.16, this will no longer apply. See [golang/go#42330](https://github.com/golang/go/issues/42330)
+
 By default, Go uses `MADV_FREE` if the kernel supports it to release memory, which is significantly more efficient 
 than using `MADV_DONTNEED`. Unfortunately, this means that RSS doesn't go down unless the OS actually needs the 
 memory. 
@@ -422,4 +473,4 @@ You can reproduce this by following the steps below:
 **Substituting gocache for a normal map will yield the same result.**
 
 If the released memory still appearing as used is a problem for you, 
-you can set the environment variable `GODEBUG` to `madvdontneed=1`.
+you can set the environment variable `GODEBUG` to `madvdontneed=1`.

vendor/github.com/TwinProduction/gocache/entry.go

@@ -6,8 +6,12 @@ import (
 	"unsafe"
 )
 
+// Entry is a cache entry
 type Entry struct {
-	Key   string
+	// Key is the name of the cache entry
+	Key string
+
+	// Value is the value of the cache entry
 	Value interface{}
 
 	// RelevantTimestamp is the variable used to store either:
@@ -24,10 +28,12 @@ type Entry struct {
 	previous *Entry
 }
 
+// Accessed updates the Entry's RelevantTimestamp to now
 func (entry *Entry) Accessed() {
 	entry.RelevantTimestamp = time.Now()
 }
 
+// Expired returns whether the Entry has expired
 func (entry Entry) Expired() bool {
 	if entry.Expiration > 0 {
 		if time.Now().UnixNano() > entry.Expiration {
@@ -37,6 +43,7 @@ func (entry Entry) Expired() bool {
 	return false
 }
 
+// SizeInBytes returns the size of an entry in bytes, approximately.
 func (entry *Entry) SizeInBytes() int {
 	return toBytes(entry.Key) + toBytes(entry.Value) + 32
 }

vendor/github.com/TwinProduction/gocache/gocache.go

@@ -2,13 +2,16 @@ package gocache
 
 import (
 	"errors"
+	"reflect"
 	"sync"
 	"time"
 )
 
-const (
+var (
 	Debug = false
+)
 
+const (
 	// NoMaxSize means that the cache has no maximum number of entries in the cache
 	// Setting Cache.maxSize to this value also means there will be no eviction
 	NoMaxSize = 0
@@ -23,15 +26,14 @@ const (
 	NoExpiration = -1
 
 	Kilobyte = 1024
-	Megabyte = 1024 * 1024
-	Gigabyte = 1024 * 1024 * 1024
+	Megabyte = 1024 * Kilobyte
+	Gigabyte = 1024 * Megabyte
 )
 
 var (
-	ErrKeyDoesNotExist        = errors.New("key does not exist")
-	ErrKeyHasNoExpiration     = errors.New("key has no expiration")
-	ErrJanitorAlreadyRunning  = errors.New("janitor is already running")
-	ErrAutoSaveAlreadyRunning = errors.New("autosave is already running")
+	ErrKeyDoesNotExist       = errors.New("key does not exist")
+	ErrKeyHasNoExpiration    = errors.New("key has no expiration")
+	ErrJanitorAlreadyRunning = errors.New("janitor is already running")
 )
 
 // Cache is the core struct of gocache which contains the data as well as all relevant configuration fields
@@ -68,6 +70,15 @@ type Cache struct {
 
 	// memoryUsage is the approximate memory usage of the cache (dataset only) in bytes
 	memoryUsage int
+
+	// forceNilInterfaceOnNilPointer determines whether all Set-like functions should set a value as nil if the
+	// interface passed has a nil value but not a nil type.
+	//
+	// By default, interfaces are only nil when both their type and value is nil.
+	// This means that when you pass a pointer to a nil value, the type of the interface
+	// will still show as nil, which means that if you don't cast the interface after
+	// retrieving it, a nil check will return that the value is not false.
+	forceNilInterfaceOnNilPointer bool
 }
 
 // MaxSize returns the maximum amount of keys that can be present in the cache before
@@ -87,8 +98,16 @@ func (cache *Cache) EvictionPolicy() EvictionPolicy {
 }
 
 // Stats returns statistics from the cache
-func (cache *Cache) Stats() *Statistics {
-	return cache.stats
+func (cache *Cache) Stats() Statistics {
+	cache.mutex.RLock()
+	stats := Statistics{
+		EvictedKeys: cache.stats.EvictedKeys,
+		ExpiredKeys: cache.stats.ExpiredKeys,
+		Hits:        cache.stats.Hits,
+		Misses:      cache.stats.Misses,
+	}
+	cache.mutex.RUnlock()
+	return stats
 }
 
 // MemoryUsage returns the current memory usage of the cache's dataset in bytes
@@ -103,6 +122,9 @@ func (cache *Cache) WithMaxSize(maxSize int) *Cache {
 	if maxSize < 0 {
 		maxSize = NoMaxSize
 	}
+	if maxSize != NoMaxSize && cache.Count() == 0 {
+		cache.entries = make(map[string]*Entry, maxSize)
+	}
 	cache.maxSize = maxSize
 	return cache
 }
@@ -127,20 +149,62 @@ func (cache *Cache) WithEvictionPolicy(policy EvictionPolicy) *Cache {
 	return cache
 }
 
+// WithForceNilInterfaceOnNilPointer sets whether all Set-like functions should set a value as nil if the
+// interface passed has a nil value but not a nil type.
+//
+// In Go, an interface is only nil if both its type and value are nil, which means that a nil pointer
+// (e.g. (*Struct)(nil)) will retain its attribution to the type, and the unmodified value returned from
+// Cache.Get, for instance, would return false when compared with nil if this option is set to false.
+//
+// We can bypass this by detecting if the interface's value is nil and setting it to nil rather than
+// a nil pointer, which will make the value returned from Cache.Get return true when compared with nil.
+// This is exactly what passing true to WithForceNilInterfaceOnNilPointer does, and it's also the default behavior.
+//
+// Alternatively, you may pass false to WithForceNilInterfaceOnNilPointer, which will mean that you'll have
+// to cast the value returned from Cache.Get to its original type to check for whether the pointer returned
+// is nil or not.
+//
+// If set to true:
+//     cache := gocache.NewCache().WithForceNilInterfaceOnNilPointer(true)
+//     cache.Set("key", (*Struct)(nil))
+//     value, _ := cache.Get("key")
+//     // the following returns true, because the interface{} was forcefully set to nil
+//     if value == nil {}
+//     // the following will panic, because the value has been casted to its type (which is nil)
+//     if value.(*Struct) == nil {}
+//
+// If set to false:
+//     cache := gocache.NewCache().WithForceNilInterfaceOnNilPointer(false)
+//     cache.Set("key", (*Struct)(nil))
+//     value, _ := cache.Get("key")
+//     // the following returns false, because the interface{} returned has a non-nil type (*Struct)
+//     if value == nil {}
+//     // the following returns true, because the value has been casted to its type
+//     if value.(*Struct) == nil {}
+//
+// In other words, if set to true, you do not need to cast the value returned from the cache to
+// to check if the value is nil.
+//
+// Defaults to true
+func (cache *Cache) WithForceNilInterfaceOnNilPointer(forceNilInterfaceOnNilPointer bool) *Cache {
+	cache.forceNilInterfaceOnNilPointer = forceNilInterfaceOnNilPointer
+	return cache
+}
+
 // NewCache creates a new Cache
 //
 // Should be used in conjunction with Cache.WithMaxSize, Cache.WithMaxMemoryUsage and/or Cache.WithEvictionPolicy
-//
 //     gocache.NewCache().WithMaxSize(10000).WithEvictionPolicy(gocache.LeastRecentlyUsed)
 //
 func NewCache() *Cache {
 	return &Cache{
-		maxSize:        DefaultMaxSize,
-		evictionPolicy: FirstInFirstOut,
-		stats:          &Statistics{},
-		entries:        make(map[string]*Entry),
-		mutex:          sync.RWMutex{},
-		stopJanitor:    nil,
+		maxSize:                       DefaultMaxSize,
+		evictionPolicy:                FirstInFirstOut,
+		stats:                         &Statistics{},
+		entries:                       make(map[string]*Entry),
+		mutex:                         sync.RWMutex{},
+		stopJanitor:                   nil,
+		forceNilInterfaceOnNilPointer: true,
 	}
 }
 
@@ -150,13 +214,23 @@ func (cache *Cache) Set(key string, value interface{}) {
 }
 
 // SetWithTTL creates or updates a key with a given value and sets an expiration time (-1 is NoExpiration)
+//
+// The TTL provided must be greater than 0, or NoExpiration (-1). If a negative value that isn't -1 (NoExpiration) is
+// provided, the entry will not be created if the key doesn't exist
 func (cache *Cache) SetWithTTL(key string, value interface{}, ttl time.Duration) {
+	// An interface is only nil if both its value and its type are nil, however, passing a nil pointer as an interface{}
+	// means that the interface itself is not nil, because the interface value is nil but not the type.
+	if cache.forceNilInterfaceOnNilPointer {
+		if value != nil && (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
+			value = nil
+		}
+	}
 	cache.mutex.Lock()
 	entry, ok := cache.get(key)
 	if !ok {
-		// A negative TTL that isn't -1 (NoExpiration) is an entry that will expire instantly,
+		// A negative TTL that isn't -1 (NoExpiration) or 0 is an entry that will expire instantly,
 		// so might as well just not create it in the first place
-		if ttl != NoExpiration && ttl < 0 {
+		if ttl != NoExpiration && ttl < 1 {
 			cache.mutex.Unlock()
 			return
 		}
@@ -178,6 +252,13 @@ func (cache *Cache) SetWithTTL(key string, value interface{}, ttl time.Duration)
 			cache.memoryUsage += entry.SizeInBytes()
 		}
 	} else {
+		// A negative TTL that isn't -1 (NoExpiration) or 0 is an entry that will expire instantly,
+		// so might as well just delete it immediately instead of updating it
+		if ttl != NoExpiration && ttl < 1 {
+			cache.delete(key)
+			cache.mutex.Unlock()
+			return
+		}
 		if cache.maxMemoryUsage != NoMaxMemoryUsage {
 			// Substract the old entry from the cache's memoryUsage
 			cache.memoryUsage -= entry.SizeInBytes()
@@ -234,12 +315,13 @@ func (cache *Cache) Get(key string) (interface{}, bool) {
 		cache.stats.Misses++
 		return nil, false
 	}
-	cache.stats.Hits++
 	if entry.Expired() {
+		cache.stats.ExpiredKeys++
 		cache.delete(key)
 		cache.mutex.Unlock()
 		return nil, false
 	}
+	cache.stats.Hits++
 	if cache.evictionPolicy == LeastRecentlyUsed {
 		entry.Accessed()
 		if cache.head == entry {
@@ -253,12 +335,18 @@ func (cache *Cache) Get(key string) (interface{}, bool) {
 	return entry.Value, true
 }
 
-// GetAll retrieves multiple entries using the keys passed as parameter
-// All keys are returned in the map, regardless of whether they exist or not,
-// however, entries that do not exist in the cache will return nil, meaning that
-// there is no way of determining whether a key genuinely has the value nil, or
-// whether it doesn't exist in the cache using only this function
-func (cache *Cache) GetAll(keys []string) map[string]interface{} {
+// GetValue retrieves an entry using the key passed as parameter
+// Unlike Get, this function only returns the value
+func (cache *Cache) GetValue(key string) interface{} {
+	value, _ := cache.Get(key)
+	return value
+}
+
+// GetByKeys retrieves multiple entries using the keys passed as parameter
+// All keys are returned in the map, regardless of whether they exist or not, however, entries that do not exist in the
+// cache will return nil, meaning that there is no way of determining whether a key genuinely has the value nil, or
+// whether it doesn't exist in the cache using only this function.
+func (cache *Cache) GetByKeys(keys []string) map[string]interface{} {
 	entries := make(map[string]interface{})
 	for _, key := range keys {
 		entries[key], _ = cache.Get(key)
@@ -266,18 +354,51 @@ func (cache *Cache) GetAll(keys []string) map[string]interface{} {
 	return entries
 }
 
+// GetAll retrieves all cache entries
+//
+// If the eviction policy is LeastRecentlyUsed, note that unlike Get and GetByKeys, this does not update the last access
+// timestamp. The reason for this is that since all cache entries will be accessed, updating the last access timestamp
+// would provide very little benefit while harming the ability to accurately determine the next key that will be evicted
+//
+// You should probably avoid using this if you have a lot of entries.
+//
+// GetKeysByPattern is a good alternative if you want to retrieve entries that you do not have the key for, as it only
+// retrieves the keys and does not trigger active eviction and has a parameter for setting a limit to the number of keys
+// you wish to retrieve.
+func (cache *Cache) GetAll() map[string]interface{} {
+	entries := make(map[string]interface{})
+	cache.mutex.Lock()
+	for key, entry := range cache.entries {
+		if entry.Expired() {
+			cache.delete(key)
+			continue
+		}
+		entries[key] = entry.Value
+	}
+	cache.stats.Hits += uint64(len(entries))
+	cache.mutex.Unlock()
+	return entries
+}
+
 // GetKeysByPattern retrieves a slice of keys that match a given pattern
 // If the limit is set to 0, the entire cache will be searched for matching keys.
 // If the limit is above 0, the search will stop once the specified number of matching keys have been found.
 //
-// e.g. cache.GetKeysByPattern("*some*", 0) will return all keys containing "some" in them
-// e.g. cache.GetKeysByPattern("*some*", 5) will return 5 keys (or less) containing "some" in them
+// e.g.
+//     cache.GetKeysByPattern("*some*", 0) will return all keys containing "some" in them
+//     cache.GetKeysByPattern("*some*", 5) will return 5 keys (or less) containing "some" in them
 //
-// Note that GetKeysByPattern does not trigger evictions, nor does it count as accessing the entry.
+// Note that GetKeysByPattern does not trigger active evictions, nor does it count as accessing the entry, the latter
+// only applying if the cache uses the LeastRecentlyUsed eviction policy.
+// The reason for that behavior is that these two (active eviction and access) only applies when you access the value
+// of the cache entry, and this function only returns the keys.
 func (cache *Cache) GetKeysByPattern(pattern string, limit int) []string {
 	var matchingKeys []string
-	cache.mutex.RLock()
-	for key := range cache.entries {
+	cache.mutex.Lock()
+	for key, value := range cache.entries {
+		if value.Expired() {
+			continue
+		}
 		if MatchPattern(pattern, key) {
 			matchingKeys = append(matchingKeys, key)
 			if limit > 0 && len(matchingKeys) >= limit {
@@ -285,7 +406,7 @@ func (cache *Cache) GetKeysByPattern(pattern string, limit int) []string {
 			}
 		}
 	}
-	cache.mutex.RUnlock()
+	cache.mutex.Unlock()
 	return matchingKeys
 }
 

vendor/github.com/TwinProduction/gocache/janitor.go

@@ -2,7 +2,6 @@ package gocache
 
 import (
 	"log"
-	"runtime"
 	"time"
 )
 
@@ -24,9 +23,10 @@ const (
 )
 
 // StartJanitor starts the janitor on a different goroutine
-// The janitor's job is to delete expired keys in the background.
+// The janitor's job is to delete expired keys in the background, in other words, it takes care of passive eviction.
 // It can be stopped by calling Cache.StopJanitor.
-// If you do not start the janitor, expired keys will only be deleted when they are accessed through Get
+// If you do not start the janitor, expired keys will only be deleted when they are accessed through Get, GetByKeys, or
+// GetAll.
 func (cache *Cache) StartJanitor() error {
 	if cache.stopJanitor != nil {
 		return ErrJanitorAlreadyRunning
@@ -109,26 +109,32 @@ func (cache *Cache) StartJanitor() error {
 				}
 				cache.mutex.Unlock()
 			case <-cache.stopJanitor:
-				cache.stopJanitor = nil
+				cache.stopJanitor <- true
 				return
 			}
 		}
 	}()
-	if Debug {
-		go func() {
-			var m runtime.MemStats
-			for {
-				runtime.ReadMemStats(&m)
-				log.Printf("Alloc=%vMB; HeapReleased=%vMB; Sys=%vMB; HeapInUse=%vMB; HeapObjects=%v; HeapObjectsFreed=%v; GC=%v; cache.memoryUsage=%vMB; cacheSize=%d\n", m.Alloc/1024/1024, m.HeapReleased/1024/1024, m.Sys/1024/1024, m.HeapInuse/1024/1024, m.HeapObjects, m.Frees, m.NumGC, cache.memoryUsage/1024/1024, cache.Count())
-				time.Sleep(3 * time.Second)
-			}
-		}()
-	}
+	//if Debug {
+	//	go func() {
+	//		var m runtime.MemStats
+	//		for {
+	//			runtime.ReadMemStats(&m)
+	//			log.Printf("Alloc=%vMB; HeapReleased=%vMB; Sys=%vMB; HeapInUse=%vMB; HeapObjects=%v; HeapObjectsFreed=%v; GC=%v; cache.memoryUsage=%vMB; cacheSize=%d\n", m.Alloc/1024/1024, m.HeapReleased/1024/1024, m.Sys/1024/1024, m.HeapInuse/1024/1024, m.HeapObjects, m.Frees, m.NumGC, cache.memoryUsage/1024/1024, cache.Count())
+	//			time.Sleep(3 * time.Second)
+	//		}
+	//	}()
+	//}
 	return nil
 }
 
 // StopJanitor stops the janitor
 func (cache *Cache) StopJanitor() {
-	cache.stopJanitor <- true
-	time.Sleep(100 * time.Millisecond)
+	if cache.stopJanitor != nil {
+		// Tell the janitor to stop, and then wait for the janitor to reply on the same channel that it's stopping
+		// This may seem a bit odd, but this allows us to avoid a data race condition in which setting cache.stopJanitor
+		// to nil
+		cache.stopJanitor <- true
+		<-cache.stopJanitor
+		cache.stopJanitor = nil
+	}
 }

vendor/github.com/TwinProduction/gocache/persistence.go

@@ -3,11 +3,12 @@ package gocache
 import (
 	"bytes"
 	"encoding/gob"
-	"github.com/boltdb/bolt"
 	"log"
 	"os"
 	"sort"
 	"time"
+
+	"github.com/boltdb/bolt"
 )
 
 // SaveToFile stores the content of the cache to a file so that it can be read using

vendor/github.com/TwinProduction/gocache/policy.go

@@ -3,6 +3,30 @@ package gocache
 type EvictionPolicy string
 
 var (
+	// LeastRecentlyUsed is an eviction policy that causes the most recently accessed cache entry to be moved to the
+	// head of the cache. Effectively, this causes the cache entries that have not been accessed for some time to
+	// gradually move closer and closer to the tail, and since the tail is the entry that gets deleted when an eviction
+	// is required, it allows less used cache entries to be evicted while keeping recently accessed entries at or close
+	// to the head.
+	//
+	// For instance, creating a Cache with a Cache.MaxSize of 3 and creating the entries 1, 2 and 3 in that order would
+	// put 3 at the head and 1 at the tail:
+	//     3 (head) -> 2 -> 1 (tail)
+	// If the cache entry 1 was then accessed, 1 would become the head and 2 the tail:
+	//     1 (head) -> 3 -> 2 (tail)
+	// If a cache entry 4 was then created, because the Cache.MaxSize is 3, the tail (2) would then be evicted:
+	//     4 (head) -> 1 -> 3 (tail)
 	LeastRecentlyUsed EvictionPolicy = "LeastRecentlyUsed"
-	FirstInFirstOut   EvictionPolicy = "FirstInFirstOut"
+
+	// FirstInFirstOut is an eviction policy that causes cache entries to be evicted in the same order that they are
+	// created.
+	//
+	// For instance, creating a Cache with a Cache.MaxSize of 3 and creating the entries 1, 2 and 3 in that order would
+	// put 3 at the head and 1 at the tail:
+	//     3 (head) -> 2 -> 1 (tail)
+	// If the cache entry 1 was then accessed, unlike with LeastRecentlyUsed, nothing would change:
+	//     3 (head) -> 2 -> 1 (tail)
+	// If a cache entry 4 was then created, because the Cache.MaxSize is 3, the tail (1) would then be evicted:
+	//     4 (head) -> 3 -> 2 (tail)
+	FirstInFirstOut EvictionPolicy = "FirstInFirstOut"
 )

vendor/modules.txt

@@ -1,7 +1,7 @@
 # cloud.google.com/go v0.74.0
 ## explicit
 cloud.google.com/go/compute/metadata
-# github.com/TwinProduction/gocache v0.3.0
+# github.com/TwinProduction/gocache v1.2.0
 ## explicit
 github.com/TwinProduction/gocache
 # github.com/beorn7/perks v1.0.1

watchdog/alerting.go

@@ -26,30 +26,28 @@ func handleAlertsToTrigger(service *core.Service, result *core.Result, cfg *conf
 	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 {
+		if !alert.Enabled || alert.FailureThreshold > service.NumberOfFailuresInARow {
 			continue
 		}
 		if alert.Triggered {
 			if cfg.Debug {
-				log.Printf("[watchdog][handleAlertsToTrigger] Alert with description='%s' has already been TRIGGERED, skipping", alert.Description)
+				log.Printf("[watchdog][handleAlertsToTrigger] Alert for service=%s with description='%s' has already been TRIGGERED, skipping", service.Name, alert.Description)
 			}
 			continue
 		}
 		alertProvider := config.GetAlertingProviderByAlertType(cfg, alert.Type)
 		if alertProvider != nil && alertProvider.IsValid() {
-			log.Printf("[watchdog][handleAlertsToTrigger] Sending %s alert because alert with description='%s' has been TRIGGERED", alert.Type, alert.Description)
+			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)
 			// TODO: retry on error
 			var err error
 			// We need to extract the DedupKey from PagerDuty's response
 			if alert.Type == core.PagerDutyAlert {
 				var body []byte
-				body, err = customAlertProvider.Send(service.Name, alert.Description, false)
-				if err == nil {
+				if body, err = customAlertProvider.Send(service.Name, alert.Description, false); err == nil {
 					var response pagerDutyResponse
-					err = json.Unmarshal(body, &response)
-					if err != nil {
-						log.Printf("[watchdog][handleAlertsToTrigger] Ran into error unmarshaling pager duty response: %s", err.Error())
+					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
 					}
@@ -59,11 +57,10 @@ func handleAlertsToTrigger(service *core.Service, result *core.Result, cfg *conf
 				_, err = customAlertProvider.Send(service.Name, alert.Description, false)
 			}
 			if err != nil {
-				log.Printf("[watchdog][handleAlertsToTrigger] Ran into error sending an alert: %s", err.Error())
+				log.Printf("[watchdog][handleAlertsToTrigger] Failed to send an alert for service=%s: %s", service.Name, err.Error())
 			} else {
 				alert.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)
 		}
@@ -76,18 +73,20 @@ func handleAlertsToResolve(service *core.Service, result *core.Result, cfg *conf
 		if !alert.Enabled || !alert.Triggered || alert.SuccessThreshold > service.NumberOfSuccessesInARow {
 			continue
 		}
+		// Even if the alert provider returns an error, we still set the alert's Triggered variable to false.
+		// Further explanation can be found on Alert's Triggered field.
 		alert.Triggered = false
 		if !alert.SendOnResolved {
 			continue
 		}
 		alertProvider := config.GetAlertingProviderByAlertType(cfg, alert.Type)
 		if alertProvider != nil && alertProvider.IsValid() {
-			log.Printf("[watchdog][handleAlertsToResolve] Sending %s alert because alert with description='%s' has been RESOLVED", alert.Type, alert.Description)
+			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)
 			// TODO: retry on error
 			_, err := customAlertProvider.Send(service.Name, alert.Description, true)
 			if err != nil {
-				log.Printf("[watchdog][handleAlertsToResolve] Ran into error sending an alert: %s", err.Error())
+				log.Printf("[watchdog][handleAlertsToResolve] Failed to send an alert for service=%s: %s", service.Name, err.Error())
 			} else {
 				if alert.Type == core.PagerDutyAlert {
 					alert.ResolveKey = ""

watchdog/alerting_test.go

@@ -0,0 +1,332 @@
+package watchdog
+
+import (
+	"os"
+	"testing"
+
+	"github.com/TwinProduction/gatus/alerting"
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/alerting/provider/pagerduty"
+	"github.com/TwinProduction/gatus/config"
+	"github.com/TwinProduction/gatus/core"
+)
+
+func TestHandleAlerting(t *testing.T) {
+	_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
+	defer os.Clearenv()
+
+	cfg := &config.Config{
+		Debug: true,
+		Alerting: &alerting.Config{
+			Custom: &custom.AlertProvider{
+				URL:    "https://twinnation.org/health",
+				Method: "GET",
+			},
+		},
+	}
+	config.Set(cfg)
+	service := &core.Service{
+		URL: "http://example.com",
+		Alerts: []*core.Alert{
+			{
+				Type:             core.CustomAlert,
+				Enabled:          true,
+				FailureThreshold: 2,
+				SuccessThreshold: 3,
+				SendOnResolved:   true,
+				Triggered:        false,
+			},
+		},
+	}
+
+	verify(t, service, 0, 0, false, "The alert shouldn't start triggered")
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 1, 0, false, "The alert shouldn't have triggered")
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 2, 0, true, "The alert should've triggered")
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 3, 0, true, "The alert should still be triggered")
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 4, 0, true, "The alert should still be triggered")
+	HandleAlerting(service, &core.Result{Success: true})
+	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})
+	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})
+	verify(t, service, 0, 3, false, "The alert should've been resolved")
+	HandleAlerting(service, &core.Result{Success: true})
+	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)
+}
+
+func TestHandleAlertingWithBadAlertProvider(t *testing.T) {
+	_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
+	defer os.Clearenv()
+
+	cfg := &config.Config{
+		Alerting: &alerting.Config{},
+	}
+	config.Set(cfg)
+	service := &core.Service{
+		URL: "http://example.com",
+		Alerts: []*core.Alert{
+			{
+				Type:             core.CustomAlert,
+				Enabled:          true,
+				FailureThreshold: 1,
+				SuccessThreshold: 1,
+				SendOnResolved:   true,
+				Triggered:        false,
+			},
+		},
+	}
+
+	verify(t, service, 0, 0, false, "The alert shouldn't start triggered")
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 1, 0, false, "The alert shouldn't have triggered")
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 2, 0, false, "The alert shouldn't have triggered, because the provider wasn't configured properly")
+}
+
+func TestHandleAlertingWhenTriggeredAlertIsAlmostResolvedButServiceStartFailingAgain(t *testing.T) {
+	_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
+	defer os.Clearenv()
+
+	cfg := &config.Config{
+		Debug: true,
+		Alerting: &alerting.Config{
+			Custom: &custom.AlertProvider{
+				URL:    "https://twinnation.org/health",
+				Method: "GET",
+			},
+		},
+	}
+	config.Set(cfg)
+	service := &core.Service{
+		URL: "http://example.com",
+		Alerts: []*core.Alert{
+			{
+				Type:             core.CustomAlert,
+				Enabled:          true,
+				FailureThreshold: 2,
+				SuccessThreshold: 3,
+				SendOnResolved:   true,
+				Triggered:        true,
+			},
+		},
+		NumberOfFailuresInARow: 1,
+	}
+
+	// This test simulate an alert that was already triggered
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 2, 0, true, "The alert was already triggered at the beginning of this test")
+}
+
+func TestHandleAlertingWhenTriggeredAlertIsResolvedButSendOnResolvedIsFalse(t *testing.T) {
+	_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
+	defer os.Clearenv()
+
+	cfg := &config.Config{
+		Debug: true,
+		Alerting: &alerting.Config{
+			Custom: &custom.AlertProvider{
+				URL:    "https://twinnation.org/health",
+				Method: "GET",
+			},
+		},
+	}
+	config.Set(cfg)
+	service := &core.Service{
+		URL: "http://example.com",
+		Alerts: []*core.Alert{
+			{
+				Type:             core.CustomAlert,
+				Enabled:          true,
+				FailureThreshold: 1,
+				SuccessThreshold: 1,
+				SendOnResolved:   false,
+				Triggered:        true,
+			},
+		},
+		NumberOfFailuresInARow: 1,
+	}
+
+	HandleAlerting(service, &core.Result{Success: true})
+	verify(t, service, 0, 1, false, "The alert should've been resolved")
+}
+
+func TestHandleAlertingWhenTriggeredAlertIsResolvedPagerDuty(t *testing.T) {
+	_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
+	defer os.Clearenv()
+
+	cfg := &config.Config{
+		Debug: true,
+		Alerting: &alerting.Config{
+			PagerDuty: &pagerduty.AlertProvider{
+				IntegrationKey: "00000000000000000000000000000000",
+			},
+		},
+	}
+	config.Set(cfg)
+	service := &core.Service{
+		URL: "http://example.com",
+		Alerts: []*core.Alert{
+			{
+				Type:             core.PagerDutyAlert,
+				Enabled:          true,
+				FailureThreshold: 1,
+				SuccessThreshold: 1,
+				SendOnResolved:   true,
+				Triggered:        false,
+			},
+		},
+		NumberOfFailuresInARow: 0,
+	}
+
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 1, 0, true, "")
+
+	HandleAlerting(service, &core.Result{Success: true})
+	verify(t, service, 0, 1, false, "The alert should've been resolved")
+}
+
+func TestHandleAlertingWithProviderThatReturnsAnError(t *testing.T) {
+	_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
+	defer os.Clearenv()
+
+	cfg := &config.Config{
+		Debug: true,
+		Alerting: &alerting.Config{
+			Custom: &custom.AlertProvider{
+				URL:    "https://twinnation.org/health",
+				Method: "GET",
+			},
+		},
+	}
+	config.Set(cfg)
+	service := &core.Service{
+		URL: "http://example.com",
+		Alerts: []*core.Alert{
+			{
+				Type:             core.CustomAlert,
+				Enabled:          true,
+				FailureThreshold: 2,
+				SuccessThreshold: 2,
+				SendOnResolved:   true,
+				Triggered:        false,
+			},
+		},
+	}
+
+	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "true")
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 1, 0, false, "")
+	HandleAlerting(service, &core.Result{Success: false})
+	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})
+	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})
+	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})
+	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})
+	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})
+	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})
+	verify(t, service, 1, 0, false, "")
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 2, 0, true, "The alert should have triggered")
+	HandleAlerting(service, &core.Result{Success: true})
+	verify(t, service, 0, 1, true, "The alert should still be triggered")
+	HandleAlerting(service, &core.Result{Success: true})
+	verify(t, service, 0, 2, false, "The alert should have been resolved")
+}
+
+func TestHandleAlertingWithProviderThatOnlyReturnsErrorOnResolve(t *testing.T) {
+	_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
+	defer os.Clearenv()
+
+	cfg := &config.Config{
+		Debug: true,
+		Alerting: &alerting.Config{
+			Custom: &custom.AlertProvider{
+				URL:    "https://twinnation.org/health",
+				Method: "GET",
+			},
+		},
+	}
+	config.Set(cfg)
+	service := &core.Service{
+		URL: "http://example.com",
+		Alerts: []*core.Alert{
+			{
+				Type:             core.CustomAlert,
+				Enabled:          true,
+				FailureThreshold: 1,
+				SuccessThreshold: 1,
+				SendOnResolved:   true,
+				Triggered:        false,
+			},
+		},
+	}
+
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 1, 0, true, "")
+	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "true")
+	HandleAlerting(service, &core.Result{Success: true})
+	verify(t, service, 0, 1, false, "")
+	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "false")
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 1, 0, true, "")
+	_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "true")
+	HandleAlerting(service, &core.Result{Success: true})
+	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})
+	verify(t, service, 1, 0, true, "")
+	HandleAlerting(service, &core.Result{Success: false})
+	verify(t, service, 2, 0, true, "")
+	HandleAlerting(service, &core.Result{Success: true})
+	verify(t, service, 0, 1, false, "")
+	HandleAlerting(service, &core.Result{Success: true})
+	verify(t, service, 0, 2, false, "")
+}
+
+func verify(t *testing.T, service *core.Service, expectedNumberOfFailuresInARow, expectedNumberOfSuccessInARow int, expectedTriggered bool, expectedTriggeredReason string) {
+	if service.NumberOfFailuresInARow != expectedNumberOfFailuresInARow {
+		t.Fatalf("service.NumberOfFailuresInARow should've been %d, got %d", expectedNumberOfFailuresInARow, service.NumberOfFailuresInARow)
+	}
+	if service.NumberOfSuccessesInARow != expectedNumberOfSuccessInARow {
+		t.Fatalf("service.NumberOfSuccessesInARow should've been %d, got %d", expectedNumberOfSuccessInARow, service.NumberOfSuccessesInARow)
+	}
+	if service.Alerts[0].Triggered != expectedTriggered {
+		if len(expectedTriggeredReason) != 0 {
+			t.Fatal(expectedTriggeredReason)
+		} else {
+			if expectedTriggered {
+				t.Fatal("The alert should've been triggered")
+			} else {
+				t.Fatal("The alert shouldn't have been triggered")
+			}
+		}
+	}
+}

watchdog/watchdog.go

@@ -1,7 +1,6 @@
 package watchdog
 
 import (
-	"encoding/json"
 	"fmt"
 	"log"
 	"sync"
@@ -14,28 +13,30 @@ import (
 )
 
 var (
-	store = storage.NewInMemoryStore()
-
 	// 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
 )
 
-// GetServiceStatusesAsJSON returns a list of core.ServiceStatus for each services encoded using json.Marshal.
+// GetServiceStatusesAsJSON the JSON encoding of all core.ServiceStatus recorded
 func GetServiceStatusesAsJSON() ([]byte, error) {
-	serviceStatuses := store.GetAll()
-	return json.Marshal(serviceStatuses)
+	return storage.Get().GetAllAsJSON()
 }
 
-// GetUptimeByServiceGroupAndName returns the uptime of a service based on its group and name
-func GetUptimeByServiceGroupAndName(group, name string) *core.Uptime {
-	serviceStatus := store.GetServiceStatus(group, name)
+// GetUptimeByKey returns the uptime of a service based on the ServiceStatus key
+func GetUptimeByKey(key string) *core.Uptime {
+	serviceStatus := storage.Get().GetServiceStatusByKey(key)
 	if serviceStatus == nil {
 		return nil
 	}
 	return serviceStatus.Uptime
 }
 
+// GetServiceStatusByKey returns the uptime of a service based on its ServiceStatus key
+func GetServiceStatusByKey(key string) *core.ServiceStatus {
+	return storage.Get().GetServiceStatusByKey(key)
+}
+
 // Monitor loops over each services and starts a goroutine to monitor each services separately
 func Monitor(cfg *config.Config) {
 	for _, service := range cfg.Services {
@@ -85,5 +86,5 @@ func monitor(service *core.Service) {
 
 // UpdateServiceStatuses updates the slice of service statuses
 func UpdateServiceStatuses(service *core.Service, result *core.Result) {
-	store.Insert(service, result)
+	storage.Get().Insert(service, result)
 }

web/app/.gitignore

@@ -0,0 +1,23 @@
+.DS_Store
+node_modules
+/dist
+
+
+# local env files
+.env.local
+.env.*.local
+
+# Log files
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

web/app/README.md

@@ -0,0 +1,24 @@
+# app
+
+## Project setup
+```
+npm install
+```
+
+### Compiles and hot-reloads for development
+```
+npm run serve
+```
+
+### Compiles and minifies for production
+```
+npm run build
+```
+
+### Lints and fixes files
+```
+npm run lint
+```
+
+### Customize configuration
+See [Configuration Reference](https://cli.vuejs.org/config/).

web/app/babel.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  presets: [
+    '@vue/cli-plugin-babel/preset'
+  ]
+}

web/app/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "app",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "serve": "vue-cli-service serve --mode development",
+    "build": "vue-cli-service build --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"
+  },
+  "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",
+    "babel-eslint": "^10.1.0",
+    "eslint": "^6.7.2",
+    "eslint-plugin-vue": "^7.0.0-0"
+  },
+  "eslintConfig": {
+    "root": true,
+    "env": {
+      "node": true
+    },
+    "extends": [
+      "plugin:vue/vue3-essential",
+      "eslint:recommended"
+    ],
+    "parserOptions": {
+      "parser": "babel-eslint"
+    },
+    "rules": {}
+  },
+  "browserslist": [
+    "> 1%",
+    "last 2 versions",
+    "not dead"
+  ]
+}

web/app/postcss.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+	plugins: [
+		require('tailwindcss')
+	],
+};

web/app/public/index.html

@@ -0,0 +1,16 @@
+<!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.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>
+    <div id="app"></div>
+  </body>
+</html>

web/app/src/App.vue

@@ -0,0 +1,56 @@
+<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="mb-2">
+      <div class="flex flex-wrap">
+        <div class="w-3/4 text-left my-auto">
+          <div class="text-3xl xl:text-5xl lg:text-4xl font-light">Health Status</div>
+        </div>
+        <div class="w-1/4 flex justify-end">
+          <img src="./assets/logo.png" alt="Gatus" class="object-scale-down" style="max-width: 100px; min-width: 50px; min-height:50px;"/>
+        </div>
+      </div>
+    </div>
+    <router-view @showTooltip="showTooltip"/>
+  </div>
+  <Tooltip :result="tooltip.result" :event="tooltip.event"/>
+  <Social/>
+</template>
+
+
+<script>
+import Social from './components/Social.vue'
+import Tooltip from './components/Tooltip.vue';
+
+export default {
+  name: 'App',
+  components: {
+    Social,
+    Tooltip
+  },
+  methods: {
+    showTooltip(result, event) {
+      this.tooltip = {result: result, event: event};
+    }
+  },
+  data() {
+    return {
+      tooltip: {}
+    }
+  },
+}
+</script>
+
+
+<style>
+html {
+  height: 100%;
+}
+
+html, body {
+  background-color: #f7f9fb;
+}
+
+#global, #results {
+  max-width: 1200px;
+}
+</style>

web/app/src/components/Service.vue

@@ -0,0 +1,147 @@
+<template>
+  <div class='service px-3 py-3 border-l border-r border-t rounded-none hover:bg-gray-100' v-if="data && data.results && data.results.length">
+    <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">
+          {{ data.name }}
+        </router-link>
+        <span 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'>
+          {{ (minResponseTime === maxResponseTime ? minResponseTime : (minResponseTime + '-' + maxResponseTime)) }}ms
+        </span>
+      </div>
+    </div>
+    <div>
+      <div class='status-over-time flex flex-row'>
+        <slot v-for="filler in maximumNumberOfResults - data.results.length" :key="filler">
+          <span class="status rounded border border-dashed"> </span>
+        </slot>
+        <slot v-for="result in data.results" :key="result">
+          <span v-if="result.success" class="status rounded bg-success" @mouseenter="showTooltip(result, $event)" @mouseleave="showTooltip(null, $event)">&#10003;</span>
+          <span v-else class="status rounded bg-red-600" @mouseenter="showTooltip(result, $event)" @mouseleave="showTooltip(null, $event)">X</span>
+        </slot>
+      </div>
+    </div>
+    <div class='flex flex-wrap status-time-ago'>
+      <!-- Show "Last update at" instead? -->
+      <div class='w-1/2'>
+        {{ generatePrettyTimeAgo(data.results[0].timestamp) }}
+      </div>
+      <div class='w-1/2 text-right'>
+        {{ generatePrettyTimeAgo(data.results[data.results.length - 1].timestamp) }}
+      </div>
+    </div>
+  </div>
+</template>
+
+
+<script>
+import {helper} from "@/mixins/helper";
+
+export default {
+  name: 'Service',
+  props: {
+    maximumNumberOfResults: Number,
+    data: Object,
+  },
+  emits: ['showTooltip'],
+  mixins: [helper],
+  methods: {
+    updateMinAndMaxResponseTimes() {
+      let minResponseTime = null;
+      let maxResponseTime = null;
+      for (let i in this.data.results) {
+        const responseTime = parseInt(this.data.results[i].duration/1000000);
+        if (minResponseTime == null || minResponseTime > responseTime) {
+          minResponseTime = responseTime;
+        }
+        if (maxResponseTime == null || maxResponseTime < responseTime) {
+          maxResponseTime = responseTime;
+        }
+      }
+      if (this.minResponseTime !== minResponseTime) {
+        this.minResponseTime = minResponseTime;
+      }
+      if (this.maxResponseTime !== maxResponseTime) {
+        this.maxResponseTime = maxResponseTime;
+      }
+    },
+    generatePath() {
+      if (!this.data) {
+        return '/';
+      }
+      return `/services/${this.data.key}`;
+    },
+    showTooltip(result, event) {
+      this.$emit('showTooltip', result, event);
+    }
+  },
+  watch: {
+    data: function () {
+      this.updateMinAndMaxResponseTimes();
+    }
+  },
+  created() {
+    this.updateMinAndMaxResponseTimes()
+  },
+  data() {
+    return {
+      minResponseTime: 0,
+      maxResponseTime: 0
+    }
+  }
+}
+</script>
+
+
+<style>
+.service:first-child {
+  border-top-left-radius: 3px;
+  border-top-right-radius: 3px;
+}
+
+.service:last-child {
+  border-bottom-left-radius: 3px;
+  border-bottom-right-radius: 3px;
+  border-bottom-width: 3px;
+  border-color: #dee2e6;
+  border-style: solid;
+}
+
+.status {
+  cursor: pointer;
+  transition: all 500ms ease-in-out;
+  overflow-x: hidden;
+  color: white;
+  width: 5%;
+  font-size: 75%;
+  font-weight: 700;
+  text-align: center;
+}
+
+.status:hover {
+  opacity: 0.7;
+  transition: opacity 100ms ease-in-out;
+  color: black;
+}
+
+.status-over-time {
+  overflow: auto;
+}
+
+.status-over-time > span:not(:first-child) {
+  margin-left: 2px;
+}
+
+.status-time-ago {
+  color: #6a737d;
+  opacity: 0.5;
+  margin-top: 5px;
+}
+
+.status-min-max-ms {
+  overflow-x: hidden;
+}
+</style>

web/app/src/components/ServiceGroup.vue

@@ -0,0 +1,92 @@
+<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'>
+          <span v-if="healthy" class='text-green-600'>&#10003;</span>
+          <span v-else class='text-yellow-400'>~</span>
+          {{ name }}
+          <span class='float-right service-group-arrow'>
+            {{ collapsed ? '&#9660;' : '&#9650;' }}
+          </span>
+        </h5>
+      </div>
+    </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"/>
+      </slot>
+    </div>
+  </div>
+</template>
+
+
+<script>
+import Service from './Service.vue';
+
+export default {
+  name: 'ServiceGroup',
+  components: {
+    Service
+  },
+  props: {
+    name: String,
+    services: Array
+  },
+  emits: ['showTooltip'],
+  methods: {
+    healthCheck() {
+      if (this.services) {
+        for (let i in this.services) {
+          for (let j in this.services[i].results) {
+            if (!this.services[i].results[j].success) {
+              // Set the service group to unhealthy (only if it's currently healthy)
+              if (this.healthy) {
+                this.healthy = false;
+              }
+              return;
+            }
+          }
+        }
+      }
+      // Set the service group to healthy (only if it's currently unhealthy)
+      if (!this.healthy) {
+        this.healthy = true;
+      }
+    },
+    toggleGroup() {
+      this.collapsed = !this.collapsed;
+      sessionStorage.setItem(`service-group:${this.name}:collapsed`, this.collapsed);
+    },
+    showTooltip(result, event) {
+      this.$emit('showTooltip', result, event);
+    }
+  },
+  watch: {
+    services: function () {
+      this.healthCheck();
+    }
+  },
+  created() {
+    this.healthCheck();
+  },
+  data() {
+    return {
+      healthy: true,
+      collapsed: sessionStorage.getItem(`service-group:${this.name}:collapsed`) === "true"
+    }
+  }
+}
+</script>
+
+
+<style>
+.service-group {
+  cursor: pointer;
+  user-select: none;
+}
+
+.service-group h5:hover {
+  color: #1b1e21 !important;
+}
+</style>

web/app/src/components/Services.vue

@@ -0,0 +1,70 @@
+<template>
+  <div id="results">
+    <slot v-for="serviceGroup in serviceGroups" :key="serviceGroup">
+      <ServiceGroup :services="serviceGroup.services" :name="serviceGroup.name" @showTooltip="showTooltip"/>
+    </slot>
+  </div>
+</template>
+
+
+<script>
+import ServiceGroup from './ServiceGroup.vue';
+
+export default {
+  name: 'Services',
+  components: {
+    ServiceGroup
+  },
+  props: {
+    showStatusOnHover: Boolean,
+    serviceStatuses: Object
+  },
+  emits: ['showTooltip'],
+  methods: {
+    process() {
+      let outputByGroup = {};
+      for (let serviceStatusIndex in this.serviceStatuses) {
+        let serviceStatus = this.serviceStatuses[serviceStatusIndex];
+        // create an empty entry if this group is new
+        if (!outputByGroup[serviceStatus.group] || outputByGroup[serviceStatus.group].length === 0) {
+          outputByGroup[serviceStatus.group] = [];
+        }
+        outputByGroup[serviceStatus.group].push(serviceStatus);
+      }
+      let serviceGroups = [];
+      for (let name in outputByGroup) {
+        if (name !== 'undefined') {
+          serviceGroups.push({name: name, services: outputByGroup[name]})
+        }
+      }
+      // Add all services that don't have a group at the end
+      if (outputByGroup['undefined']) {
+        serviceGroups.push({name: 'undefined', services: outputByGroup['undefined']})
+      }
+      this.serviceGroups = serviceGroups;
+    },
+    showTooltip(result, event) {
+      this.$emit('showTooltip', result, event);
+    }
+  },
+  watch: {
+    serviceStatuses: function () {
+      this.process();
+    }
+  },
+  data() {
+    return {
+      userClickedStatus: false,
+      serviceGroups: []
+    }
+  }
+}
+</script>
+
+
+<style>
+.service-group-content > div:nth-child(1) {
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}
+</style>

web/app/src/components/Settings.vue

@@ -0,0 +1,70 @@
+<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>
+      <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>
+
+
+<script>
+export default {
+  name: 'Settings',
+  props: {},
+  methods: {
+    setRefreshInterval(seconds) {
+      let that = this;
+      this.refreshIntervalHandler = setInterval(function () {
+        that.refreshData();
+      }, seconds * 1000);
+    },
+    refreshData() {
+      this.$emit('refreshData');
+    },
+    handleChangeRefreshInterval() {
+      this.refreshData();
+      clearInterval(this.refreshIntervalHandler);
+      this.setRefreshInterval(this.$refs.refreshInterval.value);
+    }
+  },
+  created() {
+    this.setRefreshInterval(this.refreshInterval);
+  },
+  unmounted() {
+    clearInterval(this.refreshIntervalHandler);
+  },
+  data() {
+    return {
+      refreshInterval: 30,
+      refreshIntervalHandler: 0,
+    }
+  },
+}
+
+// props.refreshInterval = 30
+//$("#refresh-rate").val(30);
+</script>
+
+
+<style scoped>
+#settings {
+  position: fixed;
+  left: 5px;
+  bottom: 5px;
+  padding: 5px;
+}
+
+#settings select:focus {
+  box-shadow: none;
+}
+</style>

web/app/src/components/Social.vue

@@ -0,0 +1,34 @@
+<template>
+  <div id="social">
+    <a href="https://github.com/TwinProduction/gatus" target="_blank" title="Gatus on GitHub">
+      <img src="../assets/github.png" alt="GitHub" width="32" height="auto"/>
+    </a>
+  </div>
+</template>
+
+
+<script>
+export default {
+  name: 'Social'
+}
+</script>
+
+
+<style scoped>
+#social {
+  position: fixed;
+  right: 5px;
+  bottom: 5px;
+  padding: 5px;
+  margin: 0;
+  z-index: 100;
+}
+
+#social img {
+  opacity: 0.3;
+}
+
+#social img:hover {
+  opacity: 1;
+}
+</style>

web/app/src/components/Tooltip.vue

@@ -0,0 +1,135 @@
+<template>
+  <div id="tooltip" ref="tooltip" :class="hidden ? 'invisible' : ''" :style="'top:' + top + 'px; left:' + left + 'px'">
+    <slot v-if="result">
+      <div class="tooltip-title">Timestamp:</div>
+      <code id="tooltip-timestamp">{{ prettifyTimestamp(result.timestamp) }}</code>
+      <div class="tooltip-title">Response time:</div>
+      <code id="tooltip-response-time">{{ (result.duration / 1000000).toFixed(0) }}ms</code>
+      <div class="tooltip-title">Conditions:</div>
+      <code id="tooltip-conditions">
+        <slot v-for="conditionResult in result.conditionResults" :key="conditionResult">
+          {{ conditionResult.success ? "&#10003;" : "X" }} ~ {{ conditionResult.condition }}<br/>
+        </slot>
+      </code>
+      <div id="tooltip-errors-container" v-if="result.errors && result.errors.length">
+        <div class="tooltip-title">Errors:</div>
+        <code id="tooltip-errors">
+          <slot v-for="error in result.errors" :key="error">
+            - {{ error }}<br/>
+          </slot>
+        </code>
+      </div>
+    </slot>
+  </div>
+</template>
+
+
+<script>
+export default {
+  name: 'Services',
+  props: {
+    event: Event,
+    result: Object
+  },
+  methods: {
+    prettifyTimestamp(timestamp) {
+      let date = new Date(timestamp);
+      let YYYY = date.getFullYear();
+      let MM = ((date.getMonth() + 1) < 10 ? "0" : "") + "" + (date.getMonth() + 1);
+      let DD = ((date.getDate()) < 10 ? "0" : "") + "" + (date.getDate());
+      let hh = ((date.getHours()) < 10 ? "0" : "") + "" + (date.getHours());
+      let mm = ((date.getMinutes()) < 10 ? "0" : "") + "" + (date.getMinutes());
+      let ss = ((date.getSeconds()) < 10 ? "0" : "") + "" + (date.getSeconds());
+      return YYYY + "-" + MM + "-" + DD + " " + hh + ":" + mm + ":" + ss;
+    },
+    htmlEntities(s) {
+      return String(s)
+          .replace(/&/g, '&amp;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;')
+          .replace(/'/g, '&apos;');
+    },
+    reposition() {
+      if (this.event && this.event.type) {
+        if (this.event.type === 'mouseenter') {
+          let targetTopPosition = this.event.target.getBoundingClientRect().y + 30;
+          let targetLeftPosition = this.event.target.getBoundingClientRect().x;
+          let tooltipBoundingClientRect = this.$refs.tooltip.getBoundingClientRect();
+          if (targetLeftPosition + window.scrollX + tooltipBoundingClientRect.width + 50 > document.body.getBoundingClientRect().width) {
+            targetLeftPosition = this.event.target.getBoundingClientRect().x - tooltipBoundingClientRect.width + this.event.target.getBoundingClientRect().width;
+            if (targetLeftPosition < 0) {
+              targetLeftPosition += -targetLeftPosition;
+            }
+          }
+          if (targetTopPosition + window.scrollY + tooltipBoundingClientRect.height + 50 > document.body.getBoundingClientRect().height && targetTopPosition >= 0) {
+            targetTopPosition = this.event.target.getBoundingClientRect().y - (tooltipBoundingClientRect.height + 10);
+            if (targetTopPosition < 0) {
+              targetTopPosition = this.event.target.getBoundingClientRect().y + 30;
+            }
+          }
+          this.top = targetTopPosition;
+          this.left = targetLeftPosition;
+        } else if (this.event.type === 'mouseleave') {
+          this.hidden = true;
+        }
+      }
+    }
+  },
+  watch: {
+    event: function (value) {
+      if (value && value.type) {
+        if (value.type === 'mouseenter') {
+          this.hidden = false;
+        } else if (value.type === 'mouseleave') {
+          this.hidden = true;
+        }
+      }
+    }
+  },
+  updated() {
+    this.reposition();
+  },
+  created() {
+    this.reposition();
+  },
+  data() {
+    return {
+      hidden: true,
+      top: 0,
+      left: 0
+    }
+  }
+}
+</script>
+
+
+<style>
+#tooltip {
+  position: fixed;
+  background-color: white;
+  border: 1px solid lightgray;
+  border-radius: 4px;
+  padding: 6px;
+  font-size: 13px;
+}
+
+#tooltip code {
+  color: #212529;
+  line-height: 1;
+}
+
+#tooltip .tooltip-title {
+  font-weight: bold;
+  margin-bottom: 0;
+  display: block;
+}
+
+#tooltip .tooltip-title {
+  margin-top: 8px;
+}
+
+#tooltip > .tooltip-title:first-child {
+  margin-top: 0;
+}
+</style>

web/app/src/index.css

@@ -0,0 +1,11 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+.bg-success {
+    background-color: #28a745;
+}
+
+.text-monospace {
+    font-family: Consolas, monospace;
+}

web/app/src/main.js

@@ -0,0 +1,8 @@
+import { createApp } from 'vue'
+import App from './App.vue'
+import './index.css'
+import router from './router'
+
+export const SERVER_URL = process.env.NODE_ENV === 'production' ? '.' : 'http://localhost:8080'
+
+createApp(App).use(router).mount('#app')

web/app/src/mixins/helper.js

@@ -0,0 +1,16 @@
+export const helper = {
+	methods: {
+		generatePrettyTimeAgo(t) {
+			let differenceInMs = new Date().getTime() - new Date(t).getTime();
+			if (differenceInMs > 3600000) {
+				let hours = (differenceInMs / 3600000).toFixed(0);
+				return hours + " hour" + (hours !== "1" ? "s" : "") + " ago";
+			}
+			if (differenceInMs > 60000) {
+				let minutes = (differenceInMs / 60000).toFixed(0);
+				return minutes + " minute" + (minutes !== "1" ? "s" : "") + " ago";
+			}
+			return (differenceInMs / 1000).toFixed(0) + " seconds ago";
+		},
+	}
+}

web/app/src/router/index.js

@@ -0,0 +1,23 @@
+import {createRouter, createWebHistory} from 'vue-router'
+import Home from '@/views/Home'
+import Details from "@/views/Details";
+
+const routes = [
+	{
+		path: '/',
+		name: 'Home',
+		component: Home
+	},
+	{
+		path: '/services/:key',
+		name: 'Details',
+		component: Details,
+	},
+]
+
+const router = createRouter({
+	history: createWebHistory(process.env.BASE_URL),
+	routes
+})
+
+export default router

web/app/src/views/Details.vue

@@ -0,0 +1,165 @@
+<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">
+    &larr;
+  </router-link>
+  <div>
+    <slot v-if="serviceStatus">
+      <h1 class="text-xl xl:text-3xl text-monospace text-gray-400">RECENT CHECKS</h1>
+      <hr class="mb-4" />
+      <Service :data="serviceStatus" :maximumNumberOfResults="20" @showTooltip="showTooltip" />
+    </slot>
+    <div v-if="uptime" class="mt-12">
+      <h1 class="text-xl xl:text-3xl text-monospace 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">
+          {{ prettifyUptime(uptime['7d']) }}
+          <h2 class="text-sm text-gray-400">Last 7 days</h2>
+        </div>
+        <div class="flex-1">
+          {{ prettifyUptime(uptime['24h']) }}
+          <h2 class="text-sm text-gray-400">Last 24 hours</h2>
+        </div>
+        <div class="flex-1">
+          {{ prettifyUptime(uptime['1h']) }}
+          <h2 class="text-sm text-gray-400">Last hour</h2>
+        </div>
+      </div>
+      <hr class="mt-1"/>
+      <h3 class="text-xl text-monospace 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" />
+        </div>
+        <div class="flex-1">
+          <img :src="generateBadgeImageURL('24h')" alt="24h uptime badge" class="mx-auto" />
+        </div>
+        <div class="flex-1">
+          <img :src="generateBadgeImageURL('1h')" alt="1h uptime badge" class="mx-auto" />
+        </div>
+      </div>
+    </div>
+    <div>
+      <h1 class="text-xl xl:text-3xl text-monospace text-gray-400 mt-4">EVENTS</h1>
+      <hr class="mb-4" />
+      <div>
+        <slot v-for="event in events" :key="event">
+          <div class="p-3 my-4">
+            <h2 class="text-lg">
+              <img v-if="event.type === 'HEALTHY'" src="../assets/arrow-up-green.png" alt="Healthy" class="border border-green-600 rounded-full opacity-75 bg-green-100 mr-2 inline" width="26" />
+              <img v-else-if="event.type === 'UNHEALTHY'" src="../assets/arrow-down-red.png" alt="Unhealthy" class="border border-red-500 rounded-full opacity-75 bg-red-100 mr-2 inline" width="26" />
+              <img v-else-if="event.type === 'START'" src="../assets/arrow-right-black.png" alt="Start" class="border border-gray-500 rounded-full opacity-75 bg-gray-100 mr-2 inline" width="26" />
+              {{ event.fancyText }}
+            </h2>
+            <div class="flex mt-1 text-sm text-gray-400">
+              <div class="flex-1 text-left pl-10">
+                {{ new Date(event.timestamp).toISOString() }}
+              </div>
+              <div class="flex-1 text-right">
+                {{ event.fancyTimeAgo }}
+              </div>
+            </div>
+          </div>
+        </slot>
+      </div>
+    </div>
+  </div>
+  <Settings @refreshData="fetchData"/>
+</template>
+
+
+<script>
+import Settings from '@/components/Settings.vue'
+import Service from '@/components/Service.vue';
+import {SERVER_URL} from "@/main.js";
+import {helper} from "@/mixins/helper.js";
+
+export default {
+  name: 'Details',
+  components: {
+    Service,
+    Settings,
+  },
+  emits: ['showTooltip'],
+  mixins: [helper],
+  methods: {
+    fetchData() {
+      //console.log("[Details][fetchData] Fetching data");
+      fetch(`${this.serverUrl}/api/v1/statuses/${this.$route.params.key}`)
+          .then(response => response.json())
+          .then(data => {
+            if (JSON.stringify(this.serviceStatus) !== JSON.stringify(data)) {
+              this.serviceStatus = data.serviceStatus;
+              this.uptime = data.uptime;
+              let events = [];
+              for (let i = data.events.length-1; i >= 0; i--) {
+                let event = data.events[i];
+                if (i === data.events.length-1) {
+                  if (event.type === 'UNHEALTHY') {
+                    event.fancyText = 'Service is unhealthy';
+                  } else if (event.type === 'HEALTHY') {
+                    event.fancyText = 'Service is healthy';
+                  } else if (event.type === 'START') {
+                    event.fancyText = 'Monitoring started';
+                  }
+                } else {
+                  let nextEvent = data.events[i+1];
+                  if (event.type === 'HEALTHY') {
+                    event.fancyText = 'Service became healthy';
+                  } else if (event.type === 'UNHEALTHY') {
+                    if (nextEvent) {
+                      event.fancyText = 'Service was unhealthy for ' + this.prettifyTimeDifference(nextEvent.timestamp, event.timestamp);
+                    } else {
+                      event.fancyText = 'Service became unhealthy';
+                    }
+                  } else if (event.type === 'START') {
+                    event.fancyText = 'Monitoring started';
+                  }
+                }
+                event.fancyTimeAgo = this.generatePrettyTimeAgo(event.timestamp);
+                events.push(event);
+              }
+              this.events = events;
+            }
+          });
+    },
+    generateBadgeImageURL(duration) {
+      return `${this.serverUrl}/api/v1/badges/uptime/${duration}/${this.serviceStatus.key}`;
+    },
+    prettifyUptime(uptime) {
+      if (!uptime) {
+        return '0%';
+      }
+      return (uptime * 100).toFixed(2) + '%'
+    },
+    prettifyTimeDifference(start, end) {
+      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);
+    }
+  },
+  data() {
+    return {
+      serviceStatus: {},
+      events: [],
+      uptime: {"7d": 0, "24h": 0, "1h": 0},
+      // Since this page isn't at the root, we need to modify the server URL a bit
+      serverUrl: SERVER_URL === '.' ? '..' : SERVER_URL,
+    }
+  },
+  created() {
+    this.fetchData();
+  }
+}
+</script>
+
+<style scoped>
+.service {
+  border-radius: 3px;
+  border-bottom-width: 3px;
+  border-color: #dee2e6;
+  border-style: solid;
+}
+</style>

web/app/src/views/Home.vue

@@ -0,0 +1,42 @@
+<template>
+  <Services :serviceStatuses="serviceStatuses" :showStatusOnHover="true" @showTooltip="showTooltip"/>
+  <Settings @refreshData="fetchData"/>
+</template>
+
+<script>
+import Settings from '@/components/Settings.vue'
+import Services from '@/components/Services.vue';
+import {SERVER_URL} from "@/main.js";
+
+export default {
+  name: 'Home',
+  components: {
+    Services,
+    Settings,
+  },
+  emits: ['showTooltip'],
+  methods: {
+    fetchData() {
+      //console.log("[Home][fetchData] Fetching data");
+      fetch(`${SERVER_URL}/api/v1/statuses`)
+          .then(response => response.json())
+          .then(data => {
+            if (JSON.stringify(this.serviceStatuses) !== JSON.stringify(data)) {
+              this.serviceStatuses = data;
+            }
+          });
+    },
+    showTooltip(result, event) {
+      this.$emit('showTooltip', result, event);
+    }
+  },
+  data() {
+    return {
+      serviceStatuses: {}
+    }
+  },
+  created() {
+    this.fetchData();
+  }
+}
+</script>

web/app/tailwind.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+  purge: ['./index.html', './src/**/*.{vue,js,ts,jsx,tsx}'],
+  darkMode: false, // or 'media' or 'class'
+  theme: {
+    extend: {},
+  },
+  variants: {
+    extend: {},
+  },
+  plugins: [],
+}

web/app/vue.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+	filenameHashing: false,
+	productionSourceMap: false,
+	outputDir: '../static',
+	publicPath: '/'
+}

web/static/index.html

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