Minor visual improvement

- Omits verbose responses when using pattern match
- Change contains to match prefix and suffix, add 2nd test

.dockerignore

@@ -1,3 +1,6 @@
 example
+Dockerfile
 .github
 .idea
+.git
+web/app

.gitattributes

@@ -0,0 +1 @@
+* text=lf

.github/codecov.yml

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

.github/workflows/build.yml

@@ -14,14 +14,20 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
-      - name: Set up Go 1.14
-        uses: actions/setup-go@v1
+      - name: Set up Go
+        uses: actions/setup-go@v2
         with:
-          go-version: 1.14
-        id: go
+          go-version: 1.16
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v1
+        uses: actions/checkout@v2
       - name: Build binary to make sure it works
         run: go build -mod vendor
       - name: Test
-        run: go test -mod vendor -cover ./...
+        # 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:
+          file: ./coverage.txt

.github/workflows/publish.yml

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

.gitignore

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

Dockerfile

@@ -1,16 +1,20 @@
 # Build the go application into a binary
 FROM golang:alpine as builder
-WORKDIR /app
-ADD . ./
-RUN CGO_ENABLED=0 GOOS=linux go build -mod vendor -a -installsuffix cgo -o gatus .
 RUN apk --update add ca-certificates
+WORKDIR /app
+COPY . ./
+RUN CGO_ENABLED=0 GOOS=linux go build -mod vendor -a -installsuffix cgo -o gatus .
+
+# Run Tests inside docker image if you don't have a configured go environment
+#RUN apk update && apk add --virtual build-dependencies build-base gcc
+#RUN go test ./... -mod vendor
 
 # Run the binary on an empty container
 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}
-ENTRYPOINT ["/gatus"]
+ENTRYPOINT ["/gatus"]

LICENSE.md

@@ -1,201 +1,9 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+MIT License
 
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+Copyright (c) 2021 TwinProduction
 
-   1. Definitions.
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2020 TwinProduction
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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 ./alerting/... ./client/... ./config/... ./controller/... ./core/... ./jsonpath/... ./pattern/... ./security/... ./storage/... ./util/... ./watchdog/... -cover

alerting/config.go

@@ -0,0 +1,39 @@
+package alerting
+
+import (
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/alerting/provider/discord"
+	"github.com/TwinProduction/gatus/alerting/provider/mattermost"
+	"github.com/TwinProduction/gatus/alerting/provider/messagebird"
+	"github.com/TwinProduction/gatus/alerting/provider/pagerduty"
+	"github.com/TwinProduction/gatus/alerting/provider/slack"
+	"github.com/TwinProduction/gatus/alerting/provider/telegram"
+	"github.com/TwinProduction/gatus/alerting/provider/twilio"
+)
+
+// Config is the configuration for alerting providers
+type Config struct {
+	// Custom is the configuration for the custom alerting provider
+	Custom *custom.AlertProvider `yaml:"custom"`
+
+	// Discord is the configuration for the discord alerting provider
+	Discord *discord.AlertProvider `yaml:"discord"`
+
+	// Mattermost is the configuration for the mattermost alerting provider
+	Mattermost *mattermost.AlertProvider `yaml:"mattermost"`
+
+	// Messagebird is the configuration for the messagebird alerting provider
+	Messagebird *messagebird.AlertProvider `yaml:"messagebird"`
+
+	// PagerDuty is the configuration for the pagerduty alerting provider
+	PagerDuty *pagerduty.AlertProvider `yaml:"pagerduty"`
+
+	// Slack is the configuration for the slack alerting provider
+	Slack *slack.AlertProvider `yaml:"slack"`
+
+	// Telegram is the configuration for the telegram alerting provider
+	Telegram *telegram.AlertProvider `yaml:"telegram"`
+
+	// Twilio is the configuration for the twilio alerting provider
+	Twilio *twilio.AlertProvider `yaml:"twilio"`
+}

alerting/provider/custom/custom.go

@@ -0,0 +1,114 @@
+package custom
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/TwinProduction/gatus/client"
+	"github.com/TwinProduction/gatus/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using a custom HTTP request
+// Technically, all alert providers should be reachable using the custom alert provider
+type AlertProvider struct {
+	URL          string                       `yaml:"url"`
+	Method       string                       `yaml:"method,omitempty"`
+	Insecure     bool                         `yaml:"insecure,omitempty"`
+	Body         string                       `yaml:"body,omitempty"`
+	Headers      map[string]string            `yaml:"headers,omitempty"`
+	Placeholders map[string]map[string]string `yaml:"placeholders,omitempty"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.URL) > 0
+}
+
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *AlertProvider {
+	return provider
+}
+
+// GetAlertStatePlaceholderValue returns the Placeholder value for ALERT_TRIGGERED_OR_RESOLVED if configured
+func (provider *AlertProvider) GetAlertStatePlaceholderValue(resolved bool) string {
+	status := "TRIGGERED"
+	if resolved {
+		status = "RESOLVED"
+	}
+	if _, ok := provider.Placeholders["ALERT_TRIGGERED_OR_RESOLVED"]; ok {
+		if val, ok := provider.Placeholders["ALERT_TRIGGERED_OR_RESOLVED"][status]; ok {
+			return val
+		}
+	}
+	return status
+}
+
+func (provider *AlertProvider) buildHTTPRequest(serviceName, alertDescription string, resolved bool) *http.Request {
+	body := provider.Body
+	providerURL := provider.URL
+	method := provider.Method
+
+	if strings.Contains(body, "[ALERT_DESCRIPTION]") {
+		body = strings.ReplaceAll(body, "[ALERT_DESCRIPTION]", alertDescription)
+	}
+	if strings.Contains(body, "[SERVICE_NAME]") {
+		body = strings.ReplaceAll(body, "[SERVICE_NAME]", serviceName)
+	}
+	if strings.Contains(body, "[ALERT_TRIGGERED_OR_RESOLVED]") {
+		if resolved {
+			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(true))
+		} else {
+			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(false))
+		}
+	}
+	if strings.Contains(providerURL, "[ALERT_DESCRIPTION]") {
+		providerURL = strings.ReplaceAll(providerURL, "[ALERT_DESCRIPTION]", alertDescription)
+	}
+	if strings.Contains(providerURL, "[SERVICE_NAME]") {
+		providerURL = strings.ReplaceAll(providerURL, "[SERVICE_NAME]", serviceName)
+	}
+	if strings.Contains(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]") {
+		if resolved {
+			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(true))
+		} else {
+			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(false))
+		}
+	}
+	if len(method) == 0 {
+		method = http.MethodGet
+	}
+	bodyBuffer := bytes.NewBuffer([]byte(body))
+	request, _ := http.NewRequest(method, providerURL, bodyBuffer)
+	for k, v := range provider.Headers {
+		request.Header.Set(k, v)
+	}
+	return request
+}
+
+// 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 {
+		return nil, err
+	}
+	if response.StatusCode > 399 {
+		body, err := ioutil.ReadAll(response.Body)
+		if err != nil {
+			return nil, fmt.Errorf("call to provider alert returned status code %d", response.StatusCode)
+		}
+		return nil, fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return ioutil.ReadAll(response.Body)
+}

alerting/provider/custom/custom_test.go

@@ -0,0 +1,110 @@
+package custom
+
+import (
+	"io/ioutil"
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{URL: ""}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{URL: "http://example.com"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_buildHTTPRequestWhenResolved(t *testing.T) {
+	const (
+		ExpectedURL  = "http://example.com/service-name?event=RESOLVED&description=alert-description"
+		ExpectedBody = "service-name,alert-description,RESOLVED"
+	)
+	customAlertProvider := &AlertProvider{
+		URL:     "http://example.com/[SERVICE_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
+		Body:    "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
+		Headers: nil,
+	}
+	request := customAlertProvider.buildHTTPRequest("service-name", "alert-description", true)
+	if request.URL.String() != ExpectedURL {
+		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
+	}
+	body, _ := ioutil.ReadAll(request.Body)
+	if string(body) != ExpectedBody {
+		t.Error("expected body to be", ExpectedBody, "was", string(body))
+	}
+}
+
+func TestAlertProvider_buildHTTPRequestWhenTriggered(t *testing.T) {
+	const (
+		ExpectedURL  = "http://example.com/service-name?event=TRIGGERED&description=alert-description"
+		ExpectedBody = "service-name,alert-description,TRIGGERED"
+	)
+	customAlertProvider := &AlertProvider{
+		URL:     "http://example.com/[SERVICE_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
+		Body:    "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
+		Headers: map[string]string{"Authorization": "Basic hunter2"},
+	}
+	request := customAlertProvider.buildHTTPRequest("service-name", "alert-description", false)
+	if request.URL.String() != ExpectedURL {
+		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
+	}
+	body, _ := ioutil.ReadAll(request.Body)
+	if string(body) != ExpectedBody {
+		t.Error("expected body to be", ExpectedBody, "was", string(body))
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProvider(t *testing.T) {
+	provider := AlertProvider{URL: "http://example.com"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if customAlertProvider.URL != "http://example.com" {
+		t.Error("expected URL to be http://example.com, got", customAlertProvider.URL)
+	}
+}
+
+func TestAlertProvider_buildHTTPRequestWithCustomPlaceholder(t *testing.T) {
+	const (
+		ExpectedURL  = "http://example.com/service-name?event=test&description=alert-description"
+		ExpectedBody = "service-name,alert-description,test"
+	)
+	customAlertProvider := &AlertProvider{
+		URL:     "http://example.com/[SERVICE_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
+		Body:    "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
+		Headers: nil,
+		Placeholders: map[string]map[string]string{
+			"ALERT_TRIGGERED_OR_RESOLVED": {
+				"RESOLVED": "test",
+			},
+		},
+	}
+	request := customAlertProvider.buildHTTPRequest("service-name", "alert-description", true)
+	if request.URL.String() != ExpectedURL {
+		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
+	}
+	body, _ := ioutil.ReadAll(request.Body)
+	if string(body) != ExpectedBody {
+		t.Error("expected body to be", ExpectedBody, "was", string(body))
+	}
+}
+
+func TestAlertProvider_GetAlertStatePlaceholderValueDefaults(t *testing.T) {
+	customAlertProvider := &AlertProvider{
+		URL:          "http://example.com/[SERVICE_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
+		Body:         "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
+		Headers:      nil,
+		Placeholders: nil,
+	}
+	if customAlertProvider.GetAlertStatePlaceholderValue(true) != "RESOLVED" {
+		t.Error("expected RESOLVED, got", customAlertProvider.GetAlertStatePlaceholderValue(true))
+	}
+	if customAlertProvider.GetAlertStatePlaceholderValue(false) != "TRIGGERED" {
+		t.Error("expected TRIGGERED, got", customAlertProvider.GetAlertStatePlaceholderValue(false))
+	}
+}

alerting/provider/discord/discord.go

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

alerting/provider/discord/discord_test.go

@@ -0,0 +1,65 @@
+package discord
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{WebhookURL: ""}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{WebhookURL: "http://example.com"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.com"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "resolved") {
+		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	}
+	if customAlertProvider.URL != "http://example.com" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.com"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "triggered") {
+		t.Error("customAlertProvider.Body should've contained the substring triggered")
+	}
+	if customAlertProvider.URL != "http://example.com" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}

alerting/provider/mattermost/mattermost.go

@@ -0,0 +1,75 @@
+package mattermost
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Mattermost
+type AlertProvider struct {
+	WebhookURL string `yaml:"webhook-url"`
+	Insecure   bool   `yaml:"insecure,omitempty"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.WebhookURL) > 0
+}
+
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+	var message string
+	var color string
+	if resolved {
+		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", service.Name, alert.SuccessThreshold)
+		color = "#36A64F"
+	} else {
+		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", service.Name, alert.FailureThreshold)
+		color = "#DD0000"
+	}
+	var results string
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = ":white_check_mark:"
+		} else {
+			prefix = ":x:"
+		}
+		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
+	}
+	return &custom.AlertProvider{
+		URL:      provider.WebhookURL,
+		Method:   http.MethodPost,
+		Insecure: provider.Insecure,
+		Body: fmt.Sprintf(`{
+  "text": "",
+  "username": "gatus",
+  "icon_url": "https://raw.githubusercontent.com/TwinProduction/gatus/master/static/logo.png",
+  "attachments": [
+    {
+      "title": ":rescue_worker_helmet: Gatus",
+      "fallback": "Gatus - %s",
+      "text": "%s:\n> %s",
+      "short": false,
+      "color": "%s",
+      "fields": [
+        {
+          "title": "URL",
+          "value": "%s",
+          "short": false
+        },
+        {
+          "title": "Condition results",
+          "value": "%s",
+          "short": false
+        }
+      ]
+    }
+  ]
+}`, message, message, alert.Description, color, service.URL, results),
+		Headers: map[string]string{"Content-Type": "application/json"},
+	}
+}

alerting/provider/mattermost/mattermost_test.go

@@ -0,0 +1,65 @@
+package mattermost
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{WebhookURL: ""}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{WebhookURL: "http://example.com"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.org"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "resolved") {
+		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	}
+	if customAlertProvider.URL != "http://example.org" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.org"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "triggered") {
+		t.Error("customAlertProvider.Body should've contained the substring triggered")
+	}
+	if customAlertProvider.URL != "http://example.org" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}

alerting/provider/messagebird/messagebird.go

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

alerting/provider/messagebird/messagebird_test.go

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

alerting/provider/pagerduty/pagerduty.go

@@ -0,0 +1,52 @@
+package pagerduty
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using PagerDuty
+type AlertProvider struct {
+	IntegrationKey string `yaml:"integration-key"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.IntegrationKey) == 32
+}
+
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+//
+// relevant: https://developer.pagerduty.com/docs/events-api-v2/trigger-events/
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
+	var message, eventAction, resolveKey string
+	if resolved {
+		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.Description)
+		eventAction = "resolve"
+		resolveKey = alert.ResolveKey
+	} else {
+		message = fmt.Sprintf("TRIGGERED: %s - %s", service.Name, alert.Description)
+		eventAction = "trigger"
+		resolveKey = ""
+	}
+	return &custom.AlertProvider{
+		URL:    "https://events.pagerduty.com/v2/enqueue",
+		Method: http.MethodPost,
+		Body: fmt.Sprintf(`{
+  "routing_key": "%s",
+  "dedup_key": "%s",
+  "event_action": "%s",
+  "payload": {
+    "summary": "%s",
+    "source": "%s",
+    "severity": "critical"
+  }
+}`, provider.IntegrationKey, resolveKey, eventAction, message, service.Name),
+		Headers: map[string]string{
+			"Content-Type": "application/json",
+		},
+	}
+}

alerting/provider/pagerduty/pagerduty_test.go

@@ -0,0 +1,65 @@
+package pagerduty
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{IntegrationKey: ""}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{IntegrationKey: "00000000000000000000000000000000"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{IntegrationKey: "00000000000000000000000000000000"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
+		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
+	}
+	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
+		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{IntegrationKey: "00000000000000000000000000000000"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, false)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
+		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
+	}
+	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
+		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}

alerting/provider/provider.go

@@ -0,0 +1,34 @@
+package provider
+
+import (
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/alerting/provider/discord"
+	"github.com/TwinProduction/gatus/alerting/provider/mattermost"
+	"github.com/TwinProduction/gatus/alerting/provider/messagebird"
+	"github.com/TwinProduction/gatus/alerting/provider/pagerduty"
+	"github.com/TwinProduction/gatus/alerting/provider/slack"
+	"github.com/TwinProduction/gatus/alerting/provider/telegram"
+	"github.com/TwinProduction/gatus/alerting/provider/twilio"
+	"github.com/TwinProduction/gatus/core"
+)
+
+// AlertProvider is the interface that each providers should implement
+type AlertProvider interface {
+	// IsValid returns whether the provider's configuration is valid
+	IsValid() bool
+
+	// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+	ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *custom.AlertProvider
+}
+
+var (
+	// Validate interface implementation on compile
+	_ AlertProvider = (*custom.AlertProvider)(nil)
+	_ AlertProvider = (*discord.AlertProvider)(nil)
+	_ AlertProvider = (*mattermost.AlertProvider)(nil)
+	_ AlertProvider = (*messagebird.AlertProvider)(nil)
+	_ AlertProvider = (*pagerduty.AlertProvider)(nil)
+	_ AlertProvider = (*slack.AlertProvider)(nil)
+	_ AlertProvider = (*telegram.AlertProvider)(nil)
+	_ AlertProvider = (*twilio.AlertProvider)(nil)
+)

alerting/provider/slack/slack.go

@@ -0,0 +1,63 @@
+package slack
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Slack
+type AlertProvider struct {
+	WebhookURL string `yaml:"webhook-url"` // Slack webhook URL
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.WebhookURL) > 0
+}
+
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+	var message, color, results string
+	if resolved {
+		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", service.Name, alert.SuccessThreshold)
+		color = "#36A64F"
+	} else {
+		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", service.Name, alert.FailureThreshold)
+		color = "#DD0000"
+	}
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = ":white_check_mark:"
+		} else {
+			prefix = ":x:"
+		}
+		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
+	}
+	return &custom.AlertProvider{
+		URL:    provider.WebhookURL,
+		Method: http.MethodPost,
+		Body: fmt.Sprintf(`{
+  "text": "",
+  "attachments": [
+    {
+      "title": ":helmet_with_white_cross: Gatus",
+      "text": "%s:\n> %s",
+      "short": false,
+      "color": "%s",
+      "fields": [
+        {
+          "title": "Condition results",
+          "value": "%s",
+          "short": false
+        }
+      ]
+    }
+  ]
+}`, message, alert.Description, color, results),
+		Headers: map[string]string{"Content-Type": "application/json"},
+	}
+}

alerting/provider/slack/slack_test.go

@@ -0,0 +1,65 @@
+package slack
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{WebhookURL: ""}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{WebhookURL: "http://example.com"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.com"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "resolved") {
+		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	}
+	if customAlertProvider.URL != "http://example.com" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.com"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "triggered") {
+		t.Error("customAlertProvider.Body should've contained the substring triggered")
+	}
+	if customAlertProvider.URL != "http://example.com" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+}

alerting/provider/telegram/telegram.go

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

alerting/provider/telegram/telegram_test.go

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

alerting/provider/twilio/twilio.go

@@ -0,0 +1,47 @@
+package twilio
+
+import (
+	"encoding/base64"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Twilio
+type AlertProvider struct {
+	SID   string `yaml:"sid"`
+	Token string `yaml:"token"`
+	From  string `yaml:"from"`
+	To    string `yaml:"to"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	return len(provider.Token) > 0 && len(provider.SID) > 0 && len(provider.From) > 0 && len(provider.To) > 0
+}
+
+// ToCustomAlertProvider converts the provider into a custom.AlertProvider
+func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, alert *core.Alert, _ *core.Result, resolved bool) *custom.AlertProvider {
+	var message string
+	if resolved {
+		message = fmt.Sprintf("RESOLVED: %s - %s", service.Name, alert.Description)
+	} else {
+		message = fmt.Sprintf("TRIGGERED: %s - %s", service.Name, alert.Description)
+	}
+	return &custom.AlertProvider{
+		URL:    fmt.Sprintf("https://api.twilio.com/2010-04-01/Accounts/%s/Messages.json", provider.SID),
+		Method: http.MethodPost,
+		Body: url.Values{
+			"To":   {provider.To},
+			"From": {provider.From},
+			"Body": {message},
+		}.Encode(),
+		Headers: map[string]string{
+			"Content-Type":  "application/x-www-form-urlencoded",
+			"Authorization": fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", provider.SID, provider.Token)))),
+		},
+	}
+}

alerting/provider/twilio/twilio_test.go

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

client/client.go

@@ -1,19 +1,101 @@
 package client
 
 import (
+	"crypto/tls"
+	"net"
 	"net/http"
+	"os"
+	"strconv"
 	"time"
+
+	"github.com/go-ping/ping"
 )
 
 var (
-	client *http.Client
+	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
+
+	// httpTimeout is the timeout for secureHTTPClient and insecureHTTPClient
+	httpTimeout = 10 * time.Second
 )
 
-func GetHttpClient() *http.Client {
-	if client == nil {
-		client = &http.Client{
-			Timeout: time.Second * 10,
+func init() {
+	// XXX: This is an undocumented feature. See https://github.com/TwinProduction/gatus/issues/104.
+	httpTimeoutInSecondsFromEnvironmentVariable := os.Getenv("HTTP_CLIENT_TIMEOUT_IN_SECONDS")
+	if len(httpTimeoutInSecondsFromEnvironmentVariable) > 0 {
+		if httpTimeoutInSeconds, err := strconv.Atoi(httpTimeoutInSecondsFromEnvironmentVariable); err == nil {
+			httpTimeout = time.Duration(httpTimeoutInSeconds) * time.Second
 		}
 	}
-	return client
+}
+
+// GetHTTPClient returns the shared HTTP client
+func GetHTTPClient(insecure bool) *http.Client {
+	if insecure {
+		if insecureHTTPClient == nil {
+			insecureHTTPClient = &http.Client{
+				Timeout: httpTimeout,
+				Transport: &http.Transport{
+					MaxIdleConns:        100,
+					MaxIdleConnsPerHost: 20,
+					Proxy:               http.ProxyFromEnvironment,
+					TLSClientConfig: &tls.Config{
+						InsecureSkipVerify: true,
+					},
+				},
+			}
+		}
+		return insecureHTTPClient
+	}
+	if secureHTTPClient == nil {
+		secureHTTPClient = &http.Client{
+			Timeout: httpTimeout,
+			Transport: &http.Transport{
+				MaxIdleConns:        100,
+				MaxIdleConnsPerHost: 20,
+				Proxy:               http.ProxyFromEnvironment,
+			},
+		}
+	}
+	return secureHTTPClient
+}
+
+// CanCreateTCPConnection checks whether a connection can be established with a TCP service
+func CanCreateTCPConnection(address string) bool {
+	conn, err := net.DialTimeout("tcp", address, 5*time.Second)
+	if err != nil {
+		return false
+	}
+	_ = conn.Close()
+	return true
+}
+
+// Ping checks if an address can be pinged and returns the round-trip time if the address can be pinged
+//
+// Note that this function takes at least 100ms, even if the address is 127.0.0.1
+func Ping(address string) (bool, time.Duration) {
+	pinger, err := ping.NewPinger(address)
+	if err != nil {
+		return false, 0
+	}
+	pinger.Count = 1
+	pinger.Timeout = pingTimeout
+	pinger.SetNetwork("ip4")
+	pinger.SetPrivileged(true)
+	err = pinger.Run()
+	if err != nil {
+		return false, 0
+	}
+	if pinger.Statistics() != nil {
+		// If the packet loss is 100, it means that the packet didn't reach the host
+		if pinger.Statistics().PacketLoss == 100 {
+			return false, pinger.Timeout
+		}
+		return true, pinger.Statistics().MaxRtt
+	}
+	return true, 0
 }

client/client_test.go

@@ -0,0 +1,51 @@
+package client
+
+import (
+	"testing"
+	"time"
+)
+
+func TestGetHTTPClient(t *testing.T) {
+	if secureHTTPClient != nil {
+		t.Error("secureHTTPClient should've been nil since it hasn't been called a single time yet")
+	}
+	if insecureHTTPClient != nil {
+		t.Error("insecureHTTPClient should've been nil since it hasn't been called a single time yet")
+	}
+	_ = GetHTTPClient(false)
+	if secureHTTPClient == nil {
+		t.Error("secureHTTPClient shouldn't have been nil, since it has been called once")
+	}
+	if insecureHTTPClient != nil {
+		t.Error("insecureHTTPClient should've been nil since it hasn't been called a single time yet")
+	}
+	_ = GetHTTPClient(true)
+	if secureHTTPClient == nil {
+		t.Error("secureHTTPClient shouldn't have been nil, since it has been called once")
+	}
+	if insecureHTTPClient == nil {
+		t.Error("insecureHTTPClient shouldn't have been nil, since it has been called once")
+	}
+}
+
+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 {
+			t.Error("Round-trip time returned on success should've higher than 0")
+		}
+	}
+	if success, rtt := Ping("256.256.256.256"); success {
+		t.Error("expected false, because the IP is invalid")
+		if rtt != 0 {
+			t.Error("Round-trip time returned on failure should've been 0")
+		}
+	}
+	if success, rtt := Ping("192.168.152.153"); 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,17 +1,48 @@
-metrics: true
 services:
-  - name: twinnation
-    interval: 30s
-    url: https://twinnation.org/health
+  - name: front-end
+    group: core
+    url: "https://twinnation.org/health"
+    interval: 1m
     conditions:
       - "[STATUS] == 200"
       - "[BODY].status == UP"
-      - "[RESPONSE_TIME] < 1000"
-  - name: twinnation-articles-api
-    interval: 30s
-    url: "https://twinnation.org/api/v1/articles/24"
+      - "[RESPONSE_TIME] < 150"
+
+  - name: back-end
+    group: core
+    url: "http://example.org/"
+    interval: 5m
     conditions:
       - "[STATUS] == 200"
-      - "[BODY].id == 24"
-      - "[BODY].tags[0] == spring"
-      - "len([BODY].tags) > 0"
+
+  - name: monitoring
+    group: internal
+    url: "http://example.com/"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+
+  - name: nas
+    group: internal
+    url: "https://example.org/"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+
+  - name: cat-fact
+    url: "https://cat-fact.herokuapp.com/facts/random"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].deleted == false"
+      - "len([BODY].text) > 0"
+
+  - name: example-dns-query
+    url: "8.8.8.8" # Address of the DNS server to use
+    interval: 5m
+    dns:
+      query-name: "example.com"
+      query-type: "A"
+    conditions:
+      - "[BODY] == 93.184.216.34"
+      - "[DNS_RCODE] == NOERROR"

config/config.go

@@ -2,31 +2,85 @@ package config
 
 import (
 	"errors"
-	"github.com/TwinProduction/gatus/core"
-	"gopkg.in/yaml.v2"
 	"io/ioutil"
 	"log"
 	"os"
+
+	"github.com/TwinProduction/gatus/alerting"
+	"github.com/TwinProduction/gatus/alerting/provider"
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/k8s"
+	"github.com/TwinProduction/gatus/security"
+	"github.com/TwinProduction/gatus/storage"
+	"github.com/TwinProduction/gatus/util"
+	"gopkg.in/yaml.v2"
 )
 
 const (
+	// DefaultConfigurationFilePath is the default path that will be used to search for the configuration file
+	// if a custom path isn't configured through the GATUS_CONFIG_FILE environment variable
 	DefaultConfigurationFilePath = "config/config.yaml"
+
+	// DefaultFallbackConfigurationFilePath is the default fallback path that will be used to search for the
+	// configuration file if DefaultConfigurationFilePath didn't work
+	DefaultFallbackConfigurationFilePath = "config/config.yml"
+
+	// DefaultAddress is the default address the service will bind to
+	DefaultAddress = "0.0.0.0"
+
+	// DefaultPort is the default port the service will listen on
+	DefaultPort = 8080
 )
 
 var (
-	ErrNoServiceInConfig  = errors.New("configuration file should contain at least 1 service")
+	// ErrNoServiceInConfig is an error returned when a configuration file has no services configured
+	ErrNoServiceInConfig = errors.New("configuration file should contain at least 1 service")
+
+	// ErrConfigFileNotFound is an error returned when the configuration file could not be found
 	ErrConfigFileNotFound = errors.New("configuration file not found")
-	ErrConfigNotLoaded    = errors.New("configuration is nil")
-	config                *Config
+
+	// ErrConfigNotLoaded is an error returned when an attempt to Get() the configuration before loading it is made
+	ErrConfigNotLoaded = errors.New("configuration is nil")
+
+	// ErrInvalidSecurityConfig is an error returned when the security configuration is invalid
+	ErrInvalidSecurityConfig = errors.New("invalid security configuration")
+
+	config *Config
 )
 
+// Config is the main configuration structure
 type Config struct {
-	Metrics  bool                 `yaml:"metrics"`
-	Debug    bool                 `yaml:"debug"`
-	Alerting *core.AlertingConfig `yaml:"alerting"`
-	Services []*core.Service      `yaml:"services"`
+	// Debug Whether to enable debug logs
+	Debug bool `yaml:"debug"`
+
+	// Metrics Whether to expose metrics at /metrics
+	Metrics bool `yaml:"metrics"`
+
+	// DisableMonitoringLock Whether to disable the monitoring lock
+	// The monitoring lock is what prevents multiple services from being processed at the same time.
+	// Disabling this may lead to inaccurate response times
+	DisableMonitoringLock bool `yaml:"disable-monitoring-lock"`
+
+	// Security Configuration for securing access to Gatus
+	Security *security.Config `yaml:"security"`
+
+	// Alerting Configuration for alerting
+	Alerting *alerting.Config `yaml:"alerting"`
+
+	// Services List of services to monitor
+	Services []*core.Service `yaml:"services"`
+
+	// Kubernetes is the Kubernetes configuration
+	Kubernetes *k8s.Config `yaml:"kubernetes"`
+
+	// Storage is the configuration for how the data is stored
+	Storage *storage.Config `yaml:"storage"`
+
+	// Web is the configuration for the web listener
+	Web *WebConfig `yaml:"web"`
 }
 
+// Get returns the configuration, or panics if the configuration hasn't loaded yet
 func Get() *Config {
 	if config == nil {
 		panic(ErrConfigNotLoaded)
@@ -34,25 +88,33 @@ 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 {
-	log.Printf("[config][Load] Attempting to load config from configFile=%s", configFile)
+	log.Printf("[config][Load] Reading configuration from configFile=%s", configFile)
 	cfg, err := readConfigurationFile(configFile)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return ErrConfigFileNotFound
-		} else {
-			return err
 		}
+		return err
 	}
 	config = cfg
 	return nil
 }
 
+// LoadDefaultConfiguration loads the default configuration file
 func LoadDefaultConfiguration() error {
 	err := Load(DefaultConfigurationFilePath)
 	if err != nil {
 		if err == ErrConfigFileNotFound {
-			return Load("config/config.yml")
+			return Load(DefaultFallbackConfigurationFilePath)
 		}
 		return err
 	}
@@ -73,14 +135,176 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 	yamlBytes = []byte(os.ExpandEnv(string(yamlBytes)))
 	// Parse configuration file
 	err = yaml.Unmarshal(yamlBytes, &config)
-	// Check if the configuration file at least has services.
-	if config == nil || len(config.Services) == 0 {
+	if err != nil {
+		return
+	}
+	// Check if the configuration file at least has services configured or Kubernetes auto discovery enabled
+	if config == nil || ((config.Services == nil || len(config.Services) == 0) && (config.Kubernetes == nil || !config.Kubernetes.AutoDiscover)) {
 		err = ErrNoServiceInConfig
 	} else {
-		// Set the default values if they aren't set
-		for _, service := range config.Services {
-			service.Validate()
-		}
+		// Note that the functions below may panic, and this is on purpose to prevent Gatus from starting with
+		// invalid configurations
+		validateAlertingConfig(config)
+		validateSecurityConfig(config)
+		validateServicesConfig(config)
+		validateKubernetesConfig(config)
+		validateWebConfig(config)
+		validateStorageConfig(config)
 	}
 	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}
+	} else {
+		config.Web.validateAndSetDefaults()
+	}
+}
+
+func validateKubernetesConfig(config *Config) {
+	if config.Kubernetes != nil && config.Kubernetes.AutoDiscover {
+		if config.Kubernetes.ServiceTemplate == nil {
+			panic("kubernetes.service-template cannot be nil")
+		}
+		if config.Debug {
+			log.Println("[config][validateKubernetesConfig] Automatically discovering Kubernetes services...")
+		}
+		discoveredServices, err := k8s.DiscoverServices(config.Kubernetes)
+		if err != nil {
+			panic(err)
+		}
+		config.Services = append(config.Services, discoveredServices...)
+		log.Printf("[config][validateKubernetesConfig] Discovered %d Kubernetes services", len(discoveredServices))
+	}
+}
+
+func validateServicesConfig(config *Config) {
+	for _, service := range config.Services {
+		if config.Debug {
+			log.Printf("[config][validateServicesConfig] Validating service '%s'", service.Name)
+		}
+		service.ValidateAndSetDefaults()
+	}
+	log.Printf("[config][validateServicesConfig] Validated %d services", len(config.Services))
+}
+
+func validateSecurityConfig(config *Config) {
+	if config.Security != nil {
+		if config.Security.IsValid() {
+			if config.Debug {
+				log.Printf("[config][validateSecurityConfig] Basic security configuration has been validated")
+			}
+		} else {
+			// If there was an attempt to configure security, then it must mean that some confidential or private
+			// data are exposed. As a result, we'll force a panic because it's better to be safe than sorry.
+			panic(ErrInvalidSecurityConfig)
+		}
+	}
+}
+
+func validateAlertingConfig(config *Config) {
+	if config.Alerting == nil {
+		log.Printf("[config][validateAlertingConfig] Alerting is not configured")
+		return
+	}
+	alertTypes := []core.AlertType{
+		core.CustomAlert,
+		core.DiscordAlert,
+		core.MattermostAlert,
+		core.MessagebirdAlert,
+		core.PagerDutyAlert,
+		core.SlackAlert,
+		core.TelegramAlert,
+		core.TwilioAlert,
+	}
+	var validProviders, invalidProviders []core.AlertType
+	for _, alertType := range alertTypes {
+		alertProvider := GetAlertingProviderByAlertType(config, alertType)
+		if alertProvider != nil {
+			if alertProvider.IsValid() {
+				validProviders = append(validProviders, alertType)
+			} else {
+				log.Printf("[config][validateAlertingConfig] Ignoring provider=%s because configuration is invalid", alertType)
+				invalidProviders = append(invalidProviders, alertType)
+			}
+		} else {
+			invalidProviders = append(invalidProviders, alertType)
+		}
+	}
+	log.Printf("[config][validateAlertingConfig] configuredProviders=%s; ignoredProviders=%s", validProviders, invalidProviders)
+}
+
+// GetAlertingProviderByAlertType returns an provider.AlertProvider by its corresponding core.AlertType
+func GetAlertingProviderByAlertType(config *Config, alertType core.AlertType) provider.AlertProvider {
+	switch alertType {
+	case core.CustomAlert:
+		if config.Alerting.Custom == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Alerting.Custom
+	case core.DiscordAlert:
+		if config.Alerting.Discord == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Alerting.Discord
+	case core.MattermostAlert:
+		if config.Alerting.Mattermost == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Alerting.Mattermost
+	case core.MessagebirdAlert:
+		if config.Alerting.Messagebird == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Alerting.Messagebird
+	case core.PagerDutyAlert:
+		if config.Alerting.PagerDuty == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Alerting.PagerDuty
+	case core.SlackAlert:
+		if config.Alerting.Slack == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Alerting.Slack
+	case core.TelegramAlert:
+		if config.Alerting.Telegram == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Alerting.Telegram
+	case core.TwilioAlert:
+		if config.Alerting.Twilio == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Alerting.Twilio
+	}
+	return nil
+}

config/config_test.go

@@ -2,16 +2,62 @@ package config
 
 import (
 	"fmt"
-	"github.com/TwinProduction/gatus/core"
+	"strings"
 	"testing"
 	"time"
+
+	"github.com/TwinProduction/gatus/alerting"
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/alerting/provider/discord"
+	"github.com/TwinProduction/gatus/alerting/provider/mattermost"
+	"github.com/TwinProduction/gatus/alerting/provider/messagebird"
+	"github.com/TwinProduction/gatus/alerting/provider/pagerduty"
+	"github.com/TwinProduction/gatus/alerting/provider/slack"
+	"github.com/TwinProduction/gatus/alerting/provider/telegram"
+	"github.com/TwinProduction/gatus/alerting/provider/twilio"
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/k8stest"
+	v1 "k8s.io/api/core/v1"
 )
 
+func TestGetBeforeConfigIsLoaded(t *testing.T) {
+	defer func() { recover() }()
+	Get()
+	t.Fatal("Should've panicked because the configuration hasn't been loaded yet")
+}
+
+func TestSet(t *testing.T) {
+	if config != nil {
+		t.Fatal("config should've been nil")
+	}
+	Set(&Config{})
+	if config == nil {
+		t.Fatal("config shouldn't have been nil")
+	}
+}
+
+func TestLoadFileThatDoesNotExist(t *testing.T) {
+	err := Load("file-that-does-not-exist.yaml")
+	if err == nil {
+		t.Error("Should've returned an error, because the file specified doesn't exist")
+	}
+}
+
+func TestLoadDefaultConfigurationFile(t *testing.T) {
+	err := LoadDefaultConfiguration()
+	if err == nil {
+		t.Error("Should've returned an error, because there's no configuration files at the default path nor the default fallback path")
+	}
+}
+
 func 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/actuator/health
+    url: https://twinnation.org/health
     interval: 15s
     conditions:
       - "[STATUS] == 200"
@@ -20,9 +66,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")
@@ -30,13 +76,18 @@ services:
 	if len(config.Services) != 2 {
 		t.Error("Should have returned two services")
 	}
-	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[1].Url != "https://api.github.com/healthz" {
+	if config.Services[1].URL != "https://api.github.com/healthz" {
 		t.Errorf("URL should have been %s", "https://api.github.com/healthz")
 	}
-	fmt.Println(config.Services[0].Interval)
+	if config.Services[0].Method != "GET" {
+		t.Errorf("Method should have been %s (default)", "GET")
+	}
+	if config.Services[1].Method != "GET" {
+		t.Errorf("Method should have been %s (default)", "GET")
+	}
 	if config.Services[0].Interval != 15*time.Second {
 		t.Errorf("Interval should have been %s", 15*time.Second)
 	}
@@ -55,12 +106,12 @@ func TestParseAndValidateConfigBytesDefault(t *testing.T) {
 	config, err := parseAndValidateConfigBytes([]byte(`
 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")
@@ -68,17 +119,24 @@ 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 != DefaultPort {
+		t.Errorf("Port should have been %d, because it is the default value", DefaultPort)
+	}
 }
 
-func TestParseAndValidateConfigBytesWithMetrics(t *testing.T) {
+func TestParseAndValidateConfigBytesWithAddress(t *testing.T) {
 	config, err := parseAndValidateConfigBytes([]byte(`
-metrics: true
+web:
+  address: 127.0.0.1
 services:
   - name: twinnation
     url: https://twinnation.org/actuator/health
@@ -86,7 +144,125 @@ 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")
+	}
+	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].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 != DefaultPort {
+		t.Errorf("Port should have been %d, because it is the default value", DefaultPort)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithPort(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+web:
+  port: 12345
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.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 != 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)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithPortAndHost(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+web:
+  port: 12345
+  address: 127.0.0.1
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.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)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithInvalidPort(t *testing.T) {
+	defer func() { recover() }()
+	_, _ = parseAndValidateConfigBytes([]byte(`
+web:
+  port: 65536
+  address: 127.0.0.1
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	t.Fatal("Should've panicked because the configuration specifies an invalid port value")
+}
+
+func TestParseAndValidateConfigBytesWithMetricsAndCustomUserAgentHeader(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+metrics: true
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    headers:
+      User-Agent: Test/2.0
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -94,12 +270,59 @@ services:
 	if !config.Metrics {
 		t.Error("Metrics should have been true")
 	}
-	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 != DefaultPort {
+		t.Errorf("Port should have been %d, because it is the default value", DefaultPort)
+	}
+	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)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithMetricsAndHostAndPort(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+metrics: true
+web:
+  address: 192.168.0.1
+  port: 9090
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if !config.Metrics {
+		t.Error("Metrics should have been true")
+	}
+	if config.Web.Address != "192.168.0.1" {
+		t.Errorf("Bind address should have been %s, because it is the default value", "192.168.0.1")
+	}
+	if config.Web.Port != 9090 {
+		t.Errorf("Port should have been %d, because it is specified in config", 9090)
+	}
+	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 userAgent := config.Services[0].Headers["User-Agent"]; userAgent != core.GatusUserAgent {
+		t.Errorf("User-Agent should've been %s because it's the default value, got %s", core.GatusUserAgent, userAgent)
+	}
 }
 
 func TestParseAndValidateBadConfigBytes(t *testing.T) {
@@ -120,21 +343,43 @@ badconfig:
 
 func TestParseAndValidateConfigBytesWithAlerting(t *testing.T) {
 	config, err := parseAndValidateConfigBytes([]byte(`
+debug: true
 alerting:
-  slack: "http://example.com"
+  slack:
+    webhook-url: "http://example.com"
+  discord:
+    webhook-url: "http://example.org"
+  pagerduty:
+    integration-key: "00000000000000000000000000000000"
+  messagebird:
+    access-key: "1"
+    originator: "31619191918"
+    recipients: "31619191919"
+  telegram:
+    token: 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11
+    id: 0123456789
 services:
   - name: twinnation
-    url: https://twinnation.org/actuator/health
+    url: https://twinnation.org/health
     alerts:
       - type: slack
         enabled: true
-        threshold: 7
+      - type: pagerduty
+        enabled: true
+        failure-threshold: 7
+        success-threshold: 5
         description: "Healthcheck failed 7 times in a row"
+      - type: messagebird
+      - type: discord
+        enabled: true
+        failure-threshold: 10
+      - type: telegram
+        enabled: true
     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")
@@ -142,37 +387,512 @@ services:
 	if config.Metrics {
 		t.Error("Metrics should've been false by default")
 	}
+	// Alerting providers
 	if config.Alerting == nil {
-		t.Fatal("config.AlertingConfig shouldn't have been nil")
+		t.Fatal("config.Alerting shouldn't have been nil")
 	}
-	if config.Alerting.Slack != "http://example.com" {
-		t.Errorf("Slack webhook should've been %s, but was %s", "http://example.com", config.Alerting.Slack)
+	if config.Alerting.Slack == nil || !config.Alerting.Slack.IsValid() {
+		t.Fatal("Slack alerting config should've been valid")
 	}
+	if config.Alerting.Slack.WebhookURL != "http://example.com" {
+		t.Errorf("Slack webhook should've been %s, but was %s", "http://example.com", config.Alerting.Slack.WebhookURL)
+	}
+	if config.Alerting.PagerDuty == nil || !config.Alerting.PagerDuty.IsValid() {
+		t.Fatal("PagerDuty alerting config should've been valid")
+	}
+	if config.Alerting.PagerDuty.IntegrationKey != "00000000000000000000000000000000" {
+		t.Errorf("PagerDuty integration key should've been %s, but was %s", "00000000000000000000000000000000", config.Alerting.PagerDuty.IntegrationKey)
+	}
+
+	if config.Alerting.Messagebird == nil || !config.Alerting.Messagebird.IsValid() {
+		t.Fatal("Messagebird alerting config should've been valid")
+	}
+	if config.Alerting.Messagebird.AccessKey != "1" {
+		t.Errorf("Messagebird access key should've been %s, but was %s", "1", config.Alerting.Messagebird.AccessKey)
+	}
+	if config.Alerting.Messagebird.Originator != "31619191918" {
+		t.Errorf("Messagebird originator field should've been %s, but was %s", "31619191918", config.Alerting.Messagebird.Originator)
+	}
+	if config.Alerting.Messagebird.Recipients != "31619191919" {
+		t.Errorf("Messagebird to recipients should've been %s, but was %s", "31619191919", config.Alerting.Messagebird.Recipients)
+	}
+
+	if config.Alerting.Discord == nil || !config.Alerting.Discord.IsValid() {
+		t.Fatal("Discord alerting config should've been valid")
+	}
+	if config.Alerting.Discord.WebhookURL != "http://example.org" {
+		t.Errorf("Discord webhook should've been %s, but was %s", "http://example.org", config.Alerting.Discord.WebhookURL)
+	}
+
+	if config.Alerting.Telegram.Token != "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11" {
+		t.Errorf("Telegram token should've been %s, but was %s", "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", config.Alerting.Telegram.Token)
+	}
+	if config.Alerting.Telegram.ID != "0123456789" {
+		t.Errorf("Telegram ID should've been %s, but was %s", "012345689", config.Alerting.Telegram.ID)
+	}
+	if GetAlertingProviderByAlertType(config, core.DiscordAlert) != config.Alerting.Discord {
+		t.Error("expected discord configuration")
+	}
+	// Services
 	if len(config.Services) != 1 {
 		t.Error("There should've been 1 service")
 	}
-	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.Services[0].Alerts == nil {
-		t.Fatal("The service alerts shouldn't have been nil")
+	if len(config.Services[0].Alerts) != 5 {
+		t.Fatal("There should've been 5 alerts configured")
 	}
-	if len(config.Services[0].Alerts) != 1 {
-		t.Fatal("There should've been 1 alert configured")
+
+	if config.Services[0].Alerts[0].Type != core.SlackAlert {
+		t.Errorf("The type of the alert should've been %s, but it was %s", core.SlackAlert, config.Services[0].Alerts[0].Type)
 	}
 	if !config.Services[0].Alerts[0].Enabled {
 		t.Error("The alert should've been enabled")
 	}
-	if config.Services[0].Alerts[0].Threshold != 7 {
-		t.Errorf("The threshold of the alert should've been %d, but it was %d", 7, config.Services[0].Alerts[0].Threshold)
+	if config.Services[0].Alerts[0].FailureThreshold != 3 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 3, config.Services[0].Alerts[0].FailureThreshold)
 	}
-	if config.Services[0].Alerts[0].Type != core.SlackAlert {
-		t.Errorf("The type of the alert should've been %s, but it was %s", core.SlackAlert, config.Services[0].Alerts[0].Type)
+	if config.Services[0].Alerts[0].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[0].SuccessThreshold)
 	}
-	if config.Services[0].Alerts[0].Description != "Healthcheck failed 7 times in a row" {
-		t.Errorf("The type of the alert should've been %s, but it was %s", "Healthcheck failed 7 times in a row", config.Services[0].Alerts[0].Description)
+
+	if config.Services[0].Alerts[1].Type != core.PagerDutyAlert {
+		t.Errorf("The type of the alert should've been %s, but it was %s", core.PagerDutyAlert, config.Services[0].Alerts[1].Type)
+	}
+	if config.Services[0].Alerts[1].Description != "Healthcheck failed 7 times in a row" {
+		t.Errorf("The description of the alert should've been %s, but it was %s", "Healthcheck failed 7 times in a row", config.Services[0].Alerts[1].Description)
+	}
+	if config.Services[0].Alerts[1].SuccessThreshold != 5 {
+		t.Errorf("The success threshold of the alert should've been %d, but it was %d", 5, config.Services[0].Alerts[1].SuccessThreshold)
+	}
+
+	if config.Services[0].Alerts[2].Type != core.MessagebirdAlert {
+		t.Errorf("The type of the alert should've been %s, but it was %s", core.MessagebirdAlert, config.Services[0].Alerts[2].Type)
+	}
+	if config.Services[0].Alerts[2].Enabled {
+		t.Error("The alert should've been disabled")
+	}
+
+	if config.Services[0].Alerts[3].Type != core.DiscordAlert {
+		t.Errorf("The type of the alert should've been %s, but it was %s", core.DiscordAlert, config.Services[0].Alerts[3].Type)
+	}
+	if config.Services[0].Alerts[3].FailureThreshold != 10 {
+		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 10, config.Services[0].Alerts[3].FailureThreshold)
+	}
+	if config.Services[0].Alerts[3].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[3].SuccessThreshold)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithInvalidPagerDutyAlertingConfig(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+alerting:
+  pagerduty:
+    integration-key: "INVALID_KEY"
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    alerts:
+      - type: pagerduty
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Alerting == nil {
+		t.Fatal("config.Alerting shouldn't have been nil")
+	}
+	if config.Alerting.PagerDuty == nil {
+		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+	}
+	if config.Alerting.PagerDuty.IsValid() {
+		t.Fatal("PagerDuty alerting config should've been invalid")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithCustomAlertingConfig(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+alerting:
+  custom:
+    url: "https://example.com"
+    body: |
+      {
+        "text": "[ALERT_TRIGGERED_OR_RESOLVED]: [SERVICE_NAME] - [ALERT_DESCRIPTION]"
+      }
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    alerts:
+      - type: custom
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Alerting == nil {
+		t.Fatal("config.Alerting shouldn't have been nil")
+	}
+	if config.Alerting.Custom == nil {
+		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+	}
+	if !config.Alerting.Custom.IsValid() {
+		t.Fatal("Custom alerting config should've been valid")
+	}
+	if config.Alerting.Custom.GetAlertStatePlaceholderValue(true) != "RESOLVED" {
+		t.Fatal("ALERT_TRIGGERED_OR_RESOLVED placeholder value for RESOLVED should've been 'RESOLVED', got", config.Alerting.Custom.GetAlertStatePlaceholderValue(true))
+	}
+	if config.Alerting.Custom.GetAlertStatePlaceholderValue(false) != "TRIGGERED" {
+		t.Fatal("ALERT_TRIGGERED_OR_RESOLVED placeholder value for TRIGGERED should've been 'TRIGGERED', got", config.Alerting.Custom.GetAlertStatePlaceholderValue(false))
+	}
+	if config.Alerting.Custom.Insecure {
+		t.Fatal("config.Alerting.Custom.Insecure shouldn't have been true")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithCustomAlertingConfigAndCustomPlaceholderValues(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+alerting:
+  custom:
+    placeholders:
+      ALERT_TRIGGERED_OR_RESOLVED:
+        TRIGGERED: "partial_outage"
+        RESOLVED: "operational"
+    url: "https://example.com"
+    insecure: true
+    body: "[ALERT_TRIGGERED_OR_RESOLVED]: [SERVICE_NAME] - [ALERT_DESCRIPTION]"
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    alerts:
+      - type: custom
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Alerting == nil {
+		t.Fatal("config.Alerting shouldn't have been nil")
+	}
+	if config.Alerting.Custom == nil {
+		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+	}
+	if !config.Alerting.Custom.IsValid() {
+		t.Fatal("Custom alerting config should've been valid")
+	}
+	if config.Alerting.Custom.GetAlertStatePlaceholderValue(true) != "operational" {
+		t.Fatal("ALERT_TRIGGERED_OR_RESOLVED placeholder value for RESOLVED should've been 'operational'")
+	}
+	if config.Alerting.Custom.GetAlertStatePlaceholderValue(false) != "partial_outage" {
+		t.Fatal("ALERT_TRIGGERED_OR_RESOLVED placeholder value for TRIGGERED should've been 'partial_outage'")
+	}
+	if !config.Alerting.Custom.Insecure {
+		t.Fatal("config.Alerting.Custom.Insecure shouldn't have been true")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithCustomAlertingConfigAndOneCustomPlaceholderValue(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+alerting:
+  custom:
+    placeholders:
+      ALERT_TRIGGERED_OR_RESOLVED:
+        TRIGGERED: "partial_outage"
+    url: "https://example.com"
+    insecure: true
+    body: "[ALERT_TRIGGERED_OR_RESOLVED]: [SERVICE_NAME] - [ALERT_DESCRIPTION]"
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    alerts:
+      - type: custom
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Alerting == nil {
+		t.Fatal("config.Alerting shouldn't have been nil")
+	}
+	if config.Alerting.Custom == nil {
+		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+	}
+	if !config.Alerting.Custom.IsValid() {
+		t.Fatal("Custom alerting config should've been valid")
+	}
+	if config.Alerting.Custom.GetAlertStatePlaceholderValue(true) != "RESOLVED" {
+		t.Fatal("ALERT_TRIGGERED_OR_RESOLVED placeholder value for RESOLVED should've been 'RESOLVED'")
+	}
+	if config.Alerting.Custom.GetAlertStatePlaceholderValue(false) != "partial_outage" {
+		t.Fatal("ALERT_TRIGGERED_OR_RESOLVED placeholder value for TRIGGERED should've been 'partial_outage'")
+	}
+	if !config.Alerting.Custom.Insecure {
+		t.Fatal("config.Alerting.Custom.Insecure shouldn't have been true")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithCustomAlertingConfigThatHasInsecureSetToTrue(t *testing.T) {
+	config, err := parseAndValidateConfigBytes([]byte(`
+alerting:
+  custom:
+    url: "https://example.com"
+    method: "POST"
+    insecure: true
+    body: |
+      {
+        "text": "[ALERT_TRIGGERED_OR_RESOLVED]: [SERVICE_NAME] - [ALERT_DESCRIPTION]"
+      }
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    alerts:
+      - type: custom
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Alerting == nil {
+		t.Fatal("config.Alerting shouldn't have been nil")
+	}
+	if config.Alerting.Custom == nil {
+		t.Fatal("PagerDuty alerting config shouldn't have been nil")
+	}
+	if !config.Alerting.Custom.IsValid() {
+		t.Error("Custom alerting config should've been valid")
+	}
+	if config.Alerting.Custom.Method != "POST" {
+		t.Error("config.Alerting.Custom.Method should've been POST")
+	}
+	if !config.Alerting.Custom.Insecure {
+		t.Error("config.Alerting.Custom.Insecure shouldn't have been true")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithInvalidSecurityConfig(t *testing.T) {
+	defer func() { recover() }()
+	_, _ = parseAndValidateConfigBytes([]byte(`
+security:
+  basic:
+    username: "admin"
+    password-sha512: "invalid-sha512-hash"
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	t.Error("Function should've panicked")
+}
+
+func TestParseAndValidateConfigBytesWithValidSecurityConfig(t *testing.T) {
+	const expectedUsername = "admin"
+	const expectedPasswordHash = "6b97ed68d14eb3f1aa959ce5d49c7dc612e1eb1dafd73b1e705847483fd6a6c809f2ceb4e8df6ff9984c6298ff0285cace6614bf8daa9f0070101b6c89899e22"
+	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
+security:
+  basic:
+    username: "%s"
+    password-sha512: "%s"
+services:
+  - name: twinnation
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`, expectedUsername, expectedPasswordHash)))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Security == nil {
+		t.Fatal("config.Security shouldn't have been nil")
+	}
+	if !config.Security.IsValid() {
+		t.Error("Security config should've been valid")
+	}
+	if config.Security.Basic == nil {
+		t.Fatal("config.Security.Basic shouldn't have been nil")
+	}
+	if config.Security.Basic.Username != expectedUsername {
+		t.Errorf("config.Security.Basic.Username should've been %s, but was %s", expectedUsername, config.Security.Basic.Username)
+	}
+	if config.Security.Basic.PasswordSha512Hash != expectedPasswordHash {
+		t.Errorf("config.Security.Basic.PasswordSha512Hash should've been %s, but was %s", expectedPasswordHash, config.Security.Basic.PasswordSha512Hash)
+	}
+}
+
+func TestParseAndValidateConfigBytesWithNoServicesOrAutoDiscovery(t *testing.T) {
+	_, err := parseAndValidateConfigBytes([]byte(``))
+	if err != ErrNoServiceInConfig {
+		t.Error("The error returned should have been of type ErrNoServiceInConfig")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithKubernetesAutoDiscovery(t *testing.T) {
+	var kubernetesServices []v1.Service
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-1", "default", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-2", "default", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-2-canary", "default", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-3", "kube-system", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-4", "tools", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-5", "tools", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-6", "tools", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-7", "metrics", 8080))
+	kubernetesServices = append(kubernetesServices, k8stest.CreateTestServices("service-7-canary", "metrics", 8080))
+	k8stest.InitializeMockedKubernetesClient(kubernetesServices)
+	config, err := parseAndValidateConfigBytes([]byte(`
+debug: true
+
+kubernetes:
+  cluster-mode: "mock"
+  auto-discover: true
+  excluded-service-suffixes:
+    - canary
+  service-template:
+    interval: 29s
+    conditions:
+      - "[STATUS] == 200"
+  namespaces:
+    - name: default
+      hostname-suffix: ".default.svc.cluster.local"
+      target-path: "/health"
+    - name: tools
+      hostname-suffix: ".tools.svc.cluster.local"
+      target-path: "/health"
+      excluded-services:
+        - service-6
+    - name: metrics
+      hostname-suffix: ".metrics.svc.cluster.local"
+      target-path: "/health"
+`))
+	if err != nil {
+		t.Error("expected no error, got", err.Error())
+	}
+	if config == nil {
+		t.Fatal("Config shouldn't have been nil")
+	}
+	if config.Kubernetes == nil {
+		t.Fatal("Kuberbetes config shouldn't have been nil")
+	}
+	if len(config.Services) != 5 {
+		t.Error("Expected 5 services to have been added through k8s auto discovery, got", len(config.Services))
+	}
+	for _, service := range config.Services {
+		if service.Name == "service-2-canary" || service.Name == "service-7-canary" {
+			t.Errorf("service '%s' should've been excluded because excluded-service-suffixes has 'canary'", service.Name)
+		} else if service.Name == "service-6" {
+			t.Errorf("service '%s' should've been excluded because excluded-services has 'service-6'", service.Name)
+		} else if service.Name == "service-3" {
+			t.Errorf("service '%s' should've been excluded because the namespace 'kube-system' is not configured for auto discovery", service.Name)
+		} else {
+			if service.Interval != 29*time.Second {
+				t.Errorf("service '%s' should've had an interval of 29s, because the template is configured for it", service.Name)
+			}
+			if len(service.Conditions) != 1 {
+				t.Errorf("service '%s' should've had 1 condition", service.Name)
+			}
+			if len(service.Conditions) == 1 && *service.Conditions[0] != "[STATUS] == 200" {
+				t.Errorf("service '%s' should've had the condition '[STATUS] == 200', because the template is configured for it", service.Name)
+			}
+			if !strings.HasSuffix(service.URL, ".svc.cluster.local:8080/health") {
+				t.Errorf("service '%s' should've had an URL with the suffix '.svc.cluster.local:8080/health'", service.Name)
+			}
+		}
+	}
+}
+
+func TestParseAndValidateConfigBytesWithKubernetesAutoDiscoveryButNoServiceTemplate(t *testing.T) {
+	defer func() { recover() }()
+	_, _ = parseAndValidateConfigBytes([]byte(`
+kubernetes:
+  cluster-mode: "mock"
+  auto-discover: true
+  namespaces:
+    - name: default
+      hostname-suffix: ".default.svc.cluster.local"
+      target-path: "/health"
+`))
+	t.Error("Function should've panicked because providing a service-template is mandatory")
+}
+
+func TestParseAndValidateConfigBytesWithKubernetesAutoDiscoveryUsingClusterModeIn(t *testing.T) {
+	defer func() { recover() }()
+	_, _ = parseAndValidateConfigBytes([]byte(`
+kubernetes:
+  cluster-mode: "in"
+  auto-discover: true
+  service-template:
+    interval: 30s
+    conditions:
+      - "[STATUS] == 200"
+  namespaces:
+    - name: default
+      hostname-suffix: ".default.svc.cluster.local"
+      target-path: "/health"
+`))
+	// TODO: find a way to test this?
+	t.Error("Function should've panicked because testing with ClusterModeIn isn't supported")
+}
+
+func TestGetAlertingProviderByAlertType(t *testing.T) {
+	cfg := &Config{
+		Alerting: &alerting.Config{
+			Custom:      &custom.AlertProvider{},
+			Discord:     &discord.AlertProvider{},
+			Mattermost:  &mattermost.AlertProvider{},
+			Messagebird: &messagebird.AlertProvider{},
+			PagerDuty:   &pagerduty.AlertProvider{},
+			Slack:       &slack.AlertProvider{},
+			Telegram:    &telegram.AlertProvider{},
+			Twilio:      &twilio.AlertProvider{},
+		},
+	}
+	if GetAlertingProviderByAlertType(cfg, core.CustomAlert) != cfg.Alerting.Custom {
+		t.Error("expected Custom configuration")
+	}
+	if GetAlertingProviderByAlertType(cfg, core.DiscordAlert) != cfg.Alerting.Discord {
+		t.Error("expected Discord configuration")
+	}
+	if GetAlertingProviderByAlertType(cfg, core.MattermostAlert) != cfg.Alerting.Mattermost {
+		t.Error("expected Mattermost configuration")
+	}
+	if GetAlertingProviderByAlertType(cfg, core.MessagebirdAlert) != cfg.Alerting.Messagebird {
+		t.Error("expected Messagebird configuration")
+	}
+	if GetAlertingProviderByAlertType(cfg, core.PagerDutyAlert) != cfg.Alerting.PagerDuty {
+		t.Error("expected PagerDuty configuration")
+	}
+	if GetAlertingProviderByAlertType(cfg, core.SlackAlert) != cfg.Alerting.Slack {
+		t.Error("expected Slack configuration")
+	}
+	if GetAlertingProviderByAlertType(cfg, core.TelegramAlert) != cfg.Alerting.Telegram {
+		t.Error("expected Telegram configuration")
+	}
+	if GetAlertingProviderByAlertType(cfg, core.TwilioAlert) != cfg.Alerting.Twilio {
+		t.Error("expected Twilio configuration")
 	}
 }

config/web.go

@@ -0,0 +1,35 @@
+package config
+
+import (
+	"fmt"
+	"math"
+)
+
+// WebConfig is the structure which supports the configuration of the endpoint
+// which provides access to the web frontend
+type WebConfig struct {
+	// Address to listen on (defaults to 0.0.0.0 specified by DefaultAddress)
+	Address string `yaml:"address"`
+
+	// Port to listen on (default to 8080 specified by DefaultPort)
+	Port int `yaml:"port"`
+}
+
+// validateAndSetDefaults checks and sets the default values for fields that are not set
+func (web *WebConfig) validateAndSetDefaults() {
+	// Validate the Address
+	if len(web.Address) == 0 {
+		web.Address = DefaultAddress
+	}
+	// Validate the Port
+	if web.Port == 0 {
+		web.Port = DefaultPort
+	} else if web.Port < 0 || web.Port > math.MaxUint16 {
+		panic(fmt.Sprintf("invalid port: value should be between %d and %d", 0, math.MaxUint16))
+	}
+}
+
+// SocketAddress returns the combination of the Address and the Port
+func (web *WebConfig) SocketAddress() string {
+	return fmt.Sprintf("%s:%d", web.Address, web.Port)
+}

config/web_test.go

@@ -0,0 +1,15 @@
+package config
+
+import (
+	"testing"
+)
+
+func TestWebConfig_SocketAddress(t *testing.T) {
+	web := &WebConfig{
+		Address: "0.0.0.0",
+		Port:    8081,
+	}
+	if web.SocketAddress() != "0.0.0.0:8081" {
+		t.Errorf("expected %s, got %s", "0.0.0.0:8081", web.SocketAddress())
+	}
+}

controller/badge.go

@@ -0,0 +1,105 @@
+package controller
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage"
+	"github.com/gorilla/mux"
+)
+
+// 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}: <KEY>.svg
+func badgeHandler(writer http.ResponseWriter, request *http.Request) {
+	variables := mux.Vars(request)
+	duration := variables["duration"]
+	if duration != "7d" && duration != "24h" && duration != "1h" {
+		writer.WriteHeader(http.StatusBadRequest)
+		_, _ = writer.Write([]byte("Durations supported: 7d, 24h, 1h"))
+		return
+	}
+	identifier := variables["identifier"]
+	key := strings.TrimSuffix(identifier, ".svg")
+	serviceStatus := storage.Get().GetServiceStatusByKey(key)
+	if serviceStatus == nil {
+		writer.WriteHeader(http.StatusNotFound)
+		_, _ = writer.Write([]byte("Requested service not found"))
+		return
+	}
+	if serviceStatus.Uptime == nil {
+		writer.WriteHeader(http.StatusInternalServerError)
+		_, _ = writer.Write([]byte("Failed to compute uptime"))
+		return
+	}
+	formattedDate := time.Now().Format(http.TimeFormat)
+	writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	writer.Header().Set("Date", formattedDate)
+	writer.Header().Set("Expires", formattedDate)
+	writer.Header().Set("Content-Type", "image/svg+xml")
+	_, _ = writer.Write(generateSVG(duration, serviceStatus.Uptime))
+}
+
+func generateSVG(duration string, uptime *core.Uptime) []byte {
+	var labelWidth, valueWidth, valueWidthAdjustment int
+	var color string
+	var value float64
+	switch duration {
+	case "7d":
+		labelWidth = 65
+		value = uptime.LastSevenDays
+	case "24h":
+		labelWidth = 70
+		value = uptime.LastTwentyFourHours
+	case "1h":
+		labelWidth = 65
+		value = uptime.LastHour
+	default:
+	}
+	if value >= 0.8 {
+		color = "#40cc11"
+	} else {
+		color = "#c7130a"
+	}
+	sanitizedValue := strings.TrimRight(strings.TrimRight(fmt.Sprintf("%.2f", value*100), "0"), ".") + "%"
+	if strings.Contains(sanitizedValue, ".") {
+		valueWidthAdjustment = -10
+	}
+	valueWidth = (len(sanitizedValue) * 11) + valueWidthAdjustment
+	width := labelWidth + valueWidth
+	labelX := labelWidth / 2
+	valueX := labelWidth + (valueWidth / 2)
+	svg := []byte(fmt.Sprintf(`<svg xmlns="http://www.w3.org/2000/svg" width="%d" height="20">
+  <linearGradient id="b" x2="0" y2="100%%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <mask id="a">
+    <rect width="%d" height="20" rx="3" fill="#fff"/>
+  </mask>
+  <g mask="url(#a)">
+    <path fill="#555" d="M0 0h%dv20H0z"/>
+    <path fill="%s" d="M%d 0h%dv20H%dz"/>
+    <path fill="url(#b)" d="M0 0h%dv20H0z"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
+    <text x="%d" y="15" fill="#010101" fill-opacity=".3">
+      uptime %s
+    </text>
+    <text x="%d" y="14">
+      uptime %s
+    </text>
+    <text x="%d" y="15" fill="#010101" fill-opacity=".3">
+      %s
+    </text>
+    <text x="%d" y="14">
+      %s
+    </text>
+  </g>
+</svg>`, width, width, labelWidth, color, labelWidth, valueWidth, labelWidth, width, labelX, duration, labelX, duration, valueX, sanitizedValue, valueX, sanitizedValue))
+	return svg
+}

controller/controller.go

@@ -0,0 +1,171 @@
+package controller
+
+import (
+	"bytes"
+	"compress/gzip"
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/TwinProduction/gatus/config"
+	"github.com/TwinProduction/gatus/security"
+	"github.com/TwinProduction/gatus/storage"
+	"github.com/TwinProduction/gocache"
+	"github.com/TwinProduction/health"
+	"github.com/gorilla/mux"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+const (
+	cacheTTL = 10 * time.Second
+)
+
+var (
+	cache = gocache.NewCache().WithMaxSize(100).WithEvictionPolicy(gocache.FirstInFirstOut)
+
+	// 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() {
+	if err := cache.StartJanitor(); err != nil {
+		log.Fatal("[controller][init] Failed to start cache janitor:", err.Error())
+	}
+}
+
+// Handle creates the router and starts the server
+func Handle() {
+	cfg := config.Get()
+	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.Println("[controller][Handle] Listening on " + cfg.Web.SocketAddress())
+	if os.Getenv("ROUTER_TEST") == "true" {
+		return
+	}
+	log.Println("[controller][Handle]", server.ListenAndServe())
+}
+
+// Shutdown stops the server
+func Shutdown() {
+	if server != nil {
+		_ = server.Shutdown(context.TODO())
+		server = nil
+	}
+}
+
+// CreateRouter creates the router for the http server
+func CreateRouter(cfg *config.Config) *mux.Router {
+	router := mux.NewRouter()
+	if cfg.Metrics {
+		router.Handle("/metrics", promhttp.Handler()).Methods("GET")
+	}
+	router.Handle("/health", health.Handler().WithJSON(true)).Methods("GET")
+	router.HandleFunc("/favicon.ico", favIconHandler).Methods("GET")
+	router.HandleFunc("/api/v1/statuses", secureIfNecessary(cfg, serviceStatusesHandler)).Methods("GET") // No GzipHandler for this one, because we cache the content
+	router.HandleFunc("/api/v1/statuses/{key}", secureIfNecessary(cfg, GzipHandlerFunc(serviceStatusHandler))).Methods("GET")
+	router.HandleFunc("/api/v1/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) {
+	page, pageSize := extractPageAndPageSizeFromRequest(r)
+	gzipped := strings.Contains(r.Header.Get("Accept-Encoding"), "gzip")
+	var exists bool
+	var value interface{}
+	if gzipped {
+		writer.Header().Set("Content-Encoding", "gzip")
+		value, exists = cache.Get(fmt.Sprintf("service-status-%d-%d-gzipped", page, pageSize))
+	} else {
+		value, exists = cache.Get(fmt.Sprintf("service-status-%d-%d", page, pageSize))
+	}
+	var data []byte
+	if !exists {
+		var err error
+		buffer := &bytes.Buffer{}
+		gzipWriter := gzip.NewWriter(buffer)
+		data, err = json.Marshal(storage.Get().GetAllServiceStatusesWithResultPagination(page, pageSize))
+		if err != nil {
+			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
+		}
+		_, _ = gzipWriter.Write(data)
+		_ = gzipWriter.Close()
+		gzippedData := buffer.Bytes()
+		cache.SetWithTTL(fmt.Sprintf("service-status-%d-%d", page, pageSize), data, cacheTTL)
+		cache.SetWithTTL(fmt.Sprintf("service-status-%d-%d-gzipped", page, pageSize), gzippedData, cacheTTL)
+		if gzipped {
+			data = gzippedData
+		}
+	} else {
+		data = value.([]byte)
+	}
+	writer.Header().Add("Content-Type", "application/json")
+	writer.WriteHeader(http.StatusOK)
+	_, _ = writer.Write(data)
+}
+
+// serviceStatusHandler retrieves a single ServiceStatus by group name and service name
+func serviceStatusHandler(writer http.ResponseWriter, r *http.Request) {
+	page, pageSize := extractPageAndPageSizeFromRequest(r)
+	vars := mux.Vars(r)
+	serviceStatus := storage.Get().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.WithResultPagination(page, pageSize),
+		// 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)
+}

controller/controller_test.go

@@ -0,0 +1,331 @@
+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/storage"
+	"github.com/TwinProduction/gatus/watchdog"
+)
+
+var (
+	firstCondition  = core.Condition("[STATUS] == 200")
+	secondCondition = core.Condition("[RESPONSE_TIME] < 500")
+	thirdCondition  = core.Condition("[CERTIFICATE_EXPIRATION] < 72h")
+
+	timestamp = time.Now()
+
+	testService = core.Service{
+		Name:                    "name",
+		Group:                   "group",
+		URL:                     "https://example.org/what/ever",
+		Method:                  "GET",
+		Body:                    "body",
+		Interval:                30 * time.Second,
+		Conditions:              []*core.Condition{&firstCondition, &secondCondition, &thirdCondition},
+		Alerts:                  nil,
+		Insecure:                false,
+		NumberOfFailuresInARow:  0,
+		NumberOfSuccessesInARow: 0,
+	}
+	testSuccessfulResult = core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Errors:                nil,
+		Connected:             true,
+		Success:               true,
+		Timestamp:             timestamp,
+		Duration:              150 * time.Millisecond,
+		CertificateExpiration: 10 * time.Hour,
+		ConditionResults: []*core.ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   true,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   true,
+			},
+		},
+	}
+	testUnsuccessfulResult = core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Errors:                []string{"error-1", "error-2"},
+		Connected:             true,
+		Success:               false,
+		Timestamp:             timestamp,
+		Duration:              750 * time.Millisecond,
+		CertificateExpiration: 10 * time.Hour,
+		ConditionResults: []*core.ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   false,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   false,
+			},
+		},
+	}
+)
+
+func TestCreateRouter(t *testing.T) {
+	defer storage.Get().Clear()
+	defer cache.Clear()
+	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-statuses-pagination",
+			Path:         "/api/v1/statuses?page=1&pageSize=20",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			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) {
+	defer storage.Get().Clear()
+	defer cache.Clear()
+	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)
+	defer config.Set(nil)
+	_ = os.Setenv("ROUTER_TEST", "true")
+	_ = os.Setenv("ENVIRONMENT", "dev")
+	defer os.Clearenv()
+	Handle()
+	defer Shutdown()
+	request, _ := http.NewRequest("GET", "/health", nil)
+	responseRecorder := httptest.NewRecorder()
+	server.Handler.ServeHTTP(responseRecorder, request)
+	if responseRecorder.Code != http.StatusOK {
+		t.Error("expected GET /health to return status code 200")
+	}
+	if server == nil {
+		t.Fatal("server should've been set (but because we set ROUTER_TEST, it shouldn't have been started)")
+	}
+}
+
+func TestShutdown(t *testing.T) {
+	// Pretend that we called controller.Handle(), which initializes the server variable
+	server = &http.Server{}
+	Shutdown()
+	if server != nil {
+		t.Error("server should've been shut down")
+	}
+}
+
+func TestServiceStatusesHandler(t *testing.T) {
+	defer storage.Get().Clear()
+	defer cache.Clear()
+	staticFolder = "../web/static"
+	firstResult := &testSuccessfulResult
+	secondResult := &testUnsuccessfulResult
+	storage.Get().Insert(&testService, firstResult)
+	storage.Get().Insert(&testService, secondResult)
+	// Can't be bothered dealing with timezone issues on the worker that runs the automated tests
+	firstResult.Timestamp = time.Time{}
+	secondResult.Timestamp = time.Time{}
+	router := CreateRouter(&config.Config{})
+
+	type Scenario struct {
+		Name         string
+		Path         string
+		ExpectedCode int
+		ExpectedBody string
+	}
+	scenarios := []Scenario{
+		{
+			Name:         "no-pagination",
+			Path:         "/api/v1/statuses",
+			ExpectedCode: http.StatusOK,
+			ExpectedBody: `{"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"}]}}`,
+		},
+		{
+			Name:         "pagination-first-result",
+			Path:         "/api/v1/statuses?page=1&pageSize=1",
+			ExpectedCode: http.StatusOK,
+			ExpectedBody: `{"group_name":{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}]}}`,
+		},
+		{
+			Name:         "pagination-second-result",
+			Path:         "/api/v1/statuses?page=2&pageSize=1",
+			ExpectedCode: http.StatusOK,
+			ExpectedBody: `{"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"}]}}`,
+		},
+		{
+			Name:         "pagination-no-results",
+			Path:         "/api/v1/statuses?page=5&pageSize=20",
+			ExpectedCode: http.StatusOK,
+			ExpectedBody: `{"group_name":{"name":"name","group":"group","key":"group_name","results":[]}}`,
+		},
+		{
+			Name:         "invalid-pagination-should-fall-back-to-default",
+			Path:         "/api/v1/statuses?page=INVALID&pageSize=INVALID",
+			ExpectedCode: http.StatusOK,
+			ExpectedBody: `{"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"}]}}`,
+		},
+	}
+
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			request, _ := http.NewRequest("GET", scenario.Path, nil)
+			responseRecorder := httptest.NewRecorder()
+			router.ServeHTTP(responseRecorder, request)
+			if responseRecorder.Code != scenario.ExpectedCode {
+				t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, responseRecorder.Code)
+			}
+			output := responseRecorder.Body.String()
+			if output != scenario.ExpectedBody {
+				t.Errorf("expected:\n %s\n\ngot:\n %s", scenario.ExpectedBody, output)
+			}
+		})
+	}
+}

controller/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/favicon.go

@@ -0,0 +1,8 @@
+package controller
+
+import "net/http"
+
+// favIconHandler handles requests for /favicon.ico
+func favIconHandler(writer http.ResponseWriter, request *http.Request) {
+	http.ServeFile(writer, request, staticFolder+"/favicon.ico")
+}

controller/gzip.go

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

controller/spa.go

@@ -0,0 +1,8 @@
+package controller
+
+import "net/http"
+
+// spaHandler handles requests for /
+func spaHandler(writer http.ResponseWriter, request *http.Request) {
+	http.ServeFile(writer, request, staticFolder+"/index.html")
+}

controller/util.go

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

controller/util_test.go

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

core/alert.go

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

core/alerting.go

@@ -1,149 +0,0 @@
-package core
-
-import (
-	"bytes"
-	"encoding/base64"
-	"fmt"
-	"github.com/TwinProduction/gatus/client"
-	"net/http"
-	"net/url"
-	"strings"
-)
-
-type AlertingConfig struct {
-	Slack  string               `yaml:"slack"`
-	Twilio *TwilioAlertProvider `yaml:"twilio"`
-	Custom *CustomAlertProvider `yaml:"custom"`
-}
-
-type TwilioAlertProvider struct {
-	SID   string `yaml:"sid"`
-	Token string `yaml:"token"`
-	From  string `yaml:"from"`
-	To    string `yaml:"to"`
-}
-
-func (provider *TwilioAlertProvider) IsValid() bool {
-	return len(provider.Token) > 0 && len(provider.SID) > 0 && len(provider.From) > 0 && len(provider.To) > 0
-}
-
-type CustomAlertProvider struct {
-	Url     string            `yaml:"url"`
-	Method  string            `yaml:"method,omitempty"`
-	Body    string            `yaml:"body,omitempty"`
-	Headers map[string]string `yaml:"headers,omitempty"`
-}
-
-func (provider *CustomAlertProvider) IsValid() bool {
-	return len(provider.Url) > 0
-}
-
-func (provider *CustomAlertProvider) buildRequest(serviceName, alertDescription string, resolved bool) *http.Request {
-	body := provider.Body
-	providerUrl := provider.Url
-	if strings.Contains(body, "[ALERT_DESCRIPTION]") {
-		body = strings.ReplaceAll(body, "[ALERT_DESCRIPTION]", alertDescription)
-	}
-	if strings.Contains(body, "[SERVICE_NAME]") {
-		body = strings.ReplaceAll(body, "[SERVICE_NAME]", serviceName)
-	}
-	if strings.Contains(body, "[ALERT_TRIGGERED_OR_RESOLVED]") {
-		if resolved {
-			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", "RESOLVED")
-		} else {
-			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", "TRIGGERED")
-		}
-	}
-	if strings.Contains(providerUrl, "[ALERT_DESCRIPTION]") {
-		providerUrl = strings.ReplaceAll(providerUrl, "[ALERT_DESCRIPTION]", alertDescription)
-	}
-	if strings.Contains(providerUrl, "[SERVICE_NAME]") {
-		providerUrl = strings.ReplaceAll(providerUrl, "[SERVICE_NAME]", serviceName)
-	}
-	if strings.Contains(providerUrl, "[ALERT_TRIGGERED_OR_RESOLVED]") {
-		if resolved {
-			providerUrl = strings.ReplaceAll(providerUrl, "[ALERT_TRIGGERED_OR_RESOLVED]", "RESOLVED")
-		} else {
-			providerUrl = strings.ReplaceAll(providerUrl, "[ALERT_TRIGGERED_OR_RESOLVED]", "TRIGGERED")
-		}
-	}
-	bodyBuffer := bytes.NewBuffer([]byte(body))
-	request, _ := http.NewRequest(provider.Method, providerUrl, bodyBuffer)
-	for k, v := range provider.Headers {
-		request.Header.Set(k, v)
-	}
-	return request
-}
-
-func (provider *CustomAlertProvider) Send(serviceName, alertDescription string, resolved bool) error {
-	request := provider.buildRequest(serviceName, alertDescription, resolved)
-	response, err := client.GetHttpClient().Do(request)
-	if err != nil {
-		return err
-	}
-	if response.StatusCode > 399 {
-		return fmt.Errorf("call to provider alert returned status code %d", response.StatusCode)
-	}
-	return nil
-}
-
-func CreateSlackCustomAlertProvider(slackWebHookUrl string, service *Service, alert *Alert, result *Result, resolved bool) *CustomAlertProvider {
-	var message string
-	var color string
-	if resolved {
-		message = fmt.Sprintf("An alert for *%s* has been resolved after %d failures in a row", service.Name, service.NumberOfFailuresInARow)
-		color = "#36A64F"
-	} else {
-		message = fmt.Sprintf("An alert for *%s* has been triggered", service.Name)
-		color = "#DD0000"
-	}
-	var results string
-	for _, conditionResult := range result.ConditionResults {
-		var prefix string
-		if conditionResult.Success {
-			prefix = ":heavy_check_mark:"
-		} else {
-			prefix = ":x:"
-		}
-		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
-	}
-	return &CustomAlertProvider{
-		Url:    slackWebHookUrl,
-		Method: "POST",
-		Body: fmt.Sprintf(`{
-  "text": "",
-  "attachments": [
-    {
-      "title": ":helmet_with_white_cross: Gatus",
-      "text": "%s:\n> %s",
-      "short": false,
-      "color": "%s",
-      "fields": [
-        {
-          "title": "Condition results",
-          "value": "%s",
-          "short": false
-        }
-      ]
-    },
-  ]
-}`, message, alert.Description, color, results),
-		Headers: map[string]string{"Content-Type": "application/json"},
-	}
-}
-
-func CreateTwilioCustomAlertProvider(provider *TwilioAlertProvider, message string) *CustomAlertProvider {
-	return &CustomAlertProvider{
-		Url:    fmt.Sprintf("https://api.twilio.com/2010-04-01/Accounts/%s/Messages.json", provider.SID),
-		Method: "POST",
-		Body: url.Values{
-			"To":   {provider.To},
-			"From": {provider.From},
-			"Body": {message},
-		}.Encode(),
-		Headers: map[string]string{
-			"Content-Type":  "application/x-www-form-urlencoded",
-			"Authorization": fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", provider.SID, provider.Token)))),
-		},
-	}
-}

core/condition-result.go

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

core/condition.go

@@ -2,50 +2,313 @@ package core
 
 import (
 	"fmt"
-	"log"
+	"strconv"
 	"strings"
+	"time"
+
+	"github.com/TwinProduction/gatus/jsonpath"
+	"github.com/TwinProduction/gatus/pattern"
 )
 
+const (
+	// StatusPlaceholder is a placeholder for a HTTP status.
+	//
+	// Values that could replace the placeholder: 200, 404, 500, ...
+	StatusPlaceholder = "[STATUS]"
+
+	// IPPlaceholder is a placeholder for an IP.
+	//
+	// Values that could replace the placeholder: 127.0.0.1, 10.0.0.1, ...
+	IPPlaceholder = "[IP]"
+
+	// DNSRCodePlaceholder is a place holder for DNS_RCODE
+	//
+	// Values that could replace the placeholder: NOERROR, FORMERR, SERVFAIL, NXDOMAIN, NOTIMP, REFUSED
+	DNSRCodePlaceholder = "[DNS_RCODE]"
+
+	// ResponseTimePlaceholder is a placeholder for the request response time, in milliseconds.
+	//
+	// Values that could replace the placeholder: 1, 500, 1000, ...
+	ResponseTimePlaceholder = "[RESPONSE_TIME]"
+
+	// BodyPlaceholder is a placeholder for the body of the response
+	//
+	// Values that could replace the placeholder: {}, {"data":{"name":"john"}}, ...
+	BodyPlaceholder = "[BODY]"
+
+	// ConnectedPlaceholder is a placeholder for whether a connection was successfully established.
+	//
+	// Values that could replace the placeholder: true, false
+	ConnectedPlaceholder = "[CONNECTED]"
+
+	// CertificateExpirationPlaceholder is a placeholder for the duration before certificate expiration, in milliseconds.
+	//
+	// Values that could replace the placeholder: 4461677039 (~52 days)
+	CertificateExpirationPlaceholder = "[CERTIFICATE_EXPIRATION]"
+
+	// LengthFunctionPrefix is the prefix for the length function
+	//
+	// Usage: len([BODY].articles) == 10, len([BODY].name) > 5
+	LengthFunctionPrefix = "len("
+
+	// HasFunctionPrefix is the prefix for the has function
+	//
+	// Usage: has([BODY].errors) == true
+	HasFunctionPrefix = "has("
+
+	// PatternFunctionPrefix is the prefix for the pattern function
+	//
+	// Usage: [IP] == pat(192.168.*.*)
+	PatternFunctionPrefix = "pat("
+
+	// AnyFunctionPrefix is the prefix for the any function
+	//
+	// Usage: [IP] == any(1.1.1.1, 1.0.0.1)
+	AnyFunctionPrefix = "any("
+
+	// FunctionSuffix is the suffix for all functions
+	FunctionSuffix = ")"
+
+	// InvalidConditionElementSuffix is the suffix that will be appended to an invalid condition
+	InvalidConditionElementSuffix = "(INVALID)"
+
+	// maximumLengthBeforeTruncatingWhenComparedWithPattern is the maximum length an element being compared to a
+	// pattern can have.
+	//
+	// This is only used for aesthetic purposes; it does not influence whether the condition evaluation results in a
+	// success or a failure
+	maximumLengthBeforeTruncatingWhenComparedWithPattern = 25
+)
+
+// Condition is a condition that needs to be met in order for a Service to be considered healthy.
 type Condition string
 
-func (c *Condition) evaluate(result *Result) bool {
-	condition := string(*c)
+// evaluate the Condition with the Result of the health check
+// TODO: Add a mandatory space between each operators (e.g. " == " instead of "==") (BREAKING CHANGE)
+func (c Condition) evaluate(result *Result) bool {
+	condition := string(c)
 	success := false
-	var resolvedCondition string
+	conditionToDisplay := condition
 	if strings.Contains(condition, "==") {
-		parts := sanitizeAndResolve(strings.Split(condition, "=="), result)
-		success = 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 = 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)
-		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
 }
+
+// hasBodyPlaceholder checks whether the condition has a BodyPlaceholder
+// Used for determining whether the response body should be read or not
+func (c Condition) hasBodyPlaceholder() bool {
+	return strings.Contains(string(c), BodyPlaceholder)
+}
+
+// isEqual compares two strings.
+//
+// Supports the pattern and the any functions.
+// i.e. if one of the parameters starts with PatternFunctionPrefix and ends with FunctionSuffix, it will be treated like
+// a pattern.
+func isEqual(first, second string) bool {
+	firstHasFunctionSuffix := strings.HasSuffix(first, FunctionSuffix)
+	secondHasFunctionSuffix := strings.HasSuffix(second, FunctionSuffix)
+	if firstHasFunctionSuffix || secondHasFunctionSuffix {
+		var isFirstPattern, isSecondPattern bool
+		if strings.HasPrefix(first, PatternFunctionPrefix) && firstHasFunctionSuffix {
+			isFirstPattern = true
+			first = strings.TrimSuffix(strings.TrimPrefix(first, PatternFunctionPrefix), FunctionSuffix)
+		}
+		if strings.HasPrefix(second, PatternFunctionPrefix) && secondHasFunctionSuffix {
+			isSecondPattern = true
+			second = strings.TrimSuffix(strings.TrimPrefix(second, PatternFunctionPrefix), FunctionSuffix)
+		}
+		if isFirstPattern && !isSecondPattern {
+			return pattern.Match(first, second)
+		} else if !isFirstPattern && isSecondPattern {
+			return pattern.Match(second, first)
+		}
+		var isFirstAny, isSecondAny bool
+		if strings.HasPrefix(first, AnyFunctionPrefix) && firstHasFunctionSuffix {
+			isFirstAny = true
+			first = strings.TrimSuffix(strings.TrimPrefix(first, AnyFunctionPrefix), FunctionSuffix)
+		}
+		if strings.HasPrefix(second, AnyFunctionPrefix) && secondHasFunctionSuffix {
+			isSecondAny = true
+			second = strings.TrimSuffix(strings.TrimPrefix(second, AnyFunctionPrefix), FunctionSuffix)
+		}
+		if isFirstAny && !isSecondAny {
+			options := strings.Split(first, ",")
+			for _, option := range options {
+				if strings.TrimSpace(option) == second {
+					return true
+				}
+			}
+			return false
+		} else if !isFirstAny && isSecondAny {
+			options := strings.Split(second, ",")
+			for _, option := range options {
+				if strings.TrimSpace(option) == first {
+					return true
+				}
+			}
+			return false
+		}
+	}
+	return first == second
+}
+
+// sanitizeAndResolve sanitizes and resolves a list of elements and returns the list of parameters as well as a list
+// of resolved parameters
+func sanitizeAndResolve(elements []string, result *Result) ([]string, []string) {
+	parameters := make([]string, len(elements))
+	resolvedParameters := make([]string, len(elements))
+	body := strings.TrimSpace(string(result.body))
+	for i, element := range elements {
+		element = strings.TrimSpace(element)
+		parameters[i] = element
+		switch strings.ToUpper(element) {
+		case StatusPlaceholder:
+			element = strconv.Itoa(result.HTTPStatus)
+		case IPPlaceholder:
+			element = result.IP
+		case ResponseTimePlaceholder:
+			element = strconv.Itoa(int(result.Duration.Milliseconds()))
+		case BodyPlaceholder:
+			element = body
+		case DNSRCodePlaceholder:
+			element = result.DNSRCode
+		case ConnectedPlaceholder:
+			element = strconv.FormatBool(result.Connected)
+		case CertificateExpirationPlaceholder:
+			element = strconv.FormatInt(result.CertificateExpiration.Milliseconds(), 10)
+		default:
+			// if contains the BodyPlaceholder, then evaluate json path
+			if strings.Contains(element, BodyPlaceholder) {
+				checkingForLength := false
+				checkingForExistence := false
+				if strings.HasPrefix(element, LengthFunctionPrefix) && strings.HasSuffix(element, FunctionSuffix) {
+					checkingForLength = true
+					element = strings.TrimSuffix(strings.TrimPrefix(element, LengthFunctionPrefix), FunctionSuffix)
+				}
+				if strings.HasPrefix(element, HasFunctionPrefix) && strings.HasSuffix(element, FunctionSuffix) {
+					checkingForExistence = true
+					element = strings.TrimSuffix(strings.TrimPrefix(element, HasFunctionPrefix), FunctionSuffix)
+				}
+				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.TrimPrefix(strings.TrimPrefix(element, BodyPlaceholder), "."), result.body)
+				if checkingForExistence {
+					if err != nil {
+						element = "false"
+					} else {
+						element = "true"
+					}
+				} else {
+					if err != nil {
+						if err.Error() != "unexpected end of JSON input" {
+							result.Errors = append(result.Errors, err.Error())
+						}
+						if checkingForLength {
+							element = LengthFunctionPrefix + element + FunctionSuffix + " " + InvalidConditionElementSuffix
+						} else {
+							element = element + " " + InvalidConditionElementSuffix
+						}
+					} else {
+						if checkingForLength {
+							element = strconv.Itoa(resolvedElementLength)
+						} else {
+							element = resolvedElement
+						}
+					}
+				}
+			}
+		}
+		resolvedParameters[i] = element
+	}
+	return parameters, resolvedParameters
+}
+
+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 {
+			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
+			resolvedNumericalParameters = append(resolvedNumericalParameters, 0)
+		} else {
+			resolvedNumericalParameters = append(resolvedNumericalParameters, number)
+		}
+	}
+	return parameters, resolvedNumericalParameters
+}
+
+func prettifyNumericalParameters(parameters []string, resolvedParameters []int64, operator string) string {
+	return prettify(parameters, []string{strconv.Itoa(int(resolvedParameters[0])), strconv.Itoa(int(resolvedParameters[1]))}, operator)
+}
+
+// XXX: make this configurable? i.e. show-resolved-conditions-on-failure
+func prettify(parameters []string, resolvedParameters []string, operator string) string {
+	// Since, in the event of an invalid path, the resolvedParameters also contain the condition itself,
+	// we'll return the resolvedParameters as-is.
+	if strings.HasSuffix(resolvedParameters[0], InvalidConditionElementSuffix) || strings.HasSuffix(resolvedParameters[1], InvalidConditionElementSuffix) {
+		return resolvedParameters[0] + " " + operator + " " + resolvedParameters[1]
+	}
+	// If using the pattern function, truncate the parameter it's being compared to if said parameter is long enough
+	if strings.HasPrefix(parameters[0], PatternFunctionPrefix) && strings.HasSuffix(parameters[0], FunctionSuffix) && len(resolvedParameters[1]) > maximumLengthBeforeTruncatingWhenComparedWithPattern {
+		resolvedParameters[1] = fmt.Sprintf("%.25s...(truncated)", resolvedParameters[1])
+	}
+	if strings.HasPrefix(parameters[1], PatternFunctionPrefix) && strings.HasSuffix(parameters[1], FunctionSuffix) && len(resolvedParameters[0]) > maximumLengthBeforeTruncatingWhenComparedWithPattern {
+		resolvedParameters[0] = fmt.Sprintf("%.25s...(truncated)", resolvedParameters[0])
+	}
+	// First element is a placeholder
+	if parameters[0] != resolvedParameters[0] && parameters[1] == resolvedParameters[1] {
+		return parameters[0] + " (" + resolvedParameters[0] + ") " + operator + " " + parameters[1]
+	}
+	// Second element is a placeholder
+	if parameters[0] == resolvedParameters[0] && parameters[1] != resolvedParameters[1] {
+		return parameters[0] + " " + operator + " " + parameters[1] + " (" + resolvedParameters[1] + ")"
+	}
+	// Both elements are placeholders...?
+	if parameters[0] != resolvedParameters[0] && parameters[1] != resolvedParameters[1] {
+		return parameters[0] + " (" + resolvedParameters[0] + ") " + operator + " " + parameters[1] + " (" + resolvedParameters[1] + ")"
+	}
+	// Neither elements are placeholders
+	return parameters[0] + " " + operator + " " + parameters[1]
+}

core/condition_bench_test.go

@@ -0,0 +1,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,186 +1,469 @@
 package core
 
 import (
+	"strconv"
 	"testing"
 	"time"
 )
 
-func TestCondition_evaluateWithIp(t *testing.T) {
-	condition := Condition("[IP] == 127.0.0.1")
-	result := &Result{Ip: "127.0.0.1"}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
+func TestCondition_evaluate(t *testing.T) {
+	type scenario struct {
+		Name            string
+		Condition       Condition
+		Result          *Result
+		ExpectedSuccess bool
+		ExpectedOutput  string
+	}
+	scenarios := []scenario{
+		{
+			Name:            "ip",
+			Condition:       Condition("[IP] == 127.0.0.1"),
+			Result:          &Result{IP: "127.0.0.1"},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[IP] == 127.0.0.1",
+		},
+		{
+			Name:            "status",
+			Condition:       Condition("[STATUS] == 200"),
+			Result:          &Result{HTTPStatus: 200},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[STATUS] == 200",
+		},
+		{
+			Name:            "status-failure",
+			Condition:       Condition("[STATUS] == 200"),
+			Result:          &Result{HTTPStatus: 500},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[STATUS] (500) == 200",
+		},
+		{
+			Name:            "status-using-less-than",
+			Condition:       Condition("[STATUS] < 300"),
+			Result:          &Result{HTTPStatus: 201},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[STATUS] < 300",
+		},
+		{
+			Name:            "status-using-less-than-failure",
+			Condition:       Condition("[STATUS] < 300"),
+			Result:          &Result{HTTPStatus: 404},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[STATUS] (404) < 300",
+		},
+		{
+			Name:            "response-time-using-less-than",
+			Condition:       Condition("[RESPONSE_TIME] < 500"),
+			Result:          &Result{Duration: 50 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] < 500",
+		},
+		{
+			Name:            "response-time-using-less-than-with-duration",
+			Condition:       Condition("[RESPONSE_TIME] < 1s"),
+			Result:          &Result{Duration: 50 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] < 1s",
+		},
+		{
+			Name:            "response-time-using-less-than-invalid",
+			Condition:       Condition("[RESPONSE_TIME] < potato"),
+			Result:          &Result{Duration: 50 * time.Millisecond},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[RESPONSE_TIME] (50) < potato (0)", // Non-numerical values automatically resolve to 0
+		},
+		{
+			Name:            "response-time-using-greater-than",
+			Condition:       Condition("[RESPONSE_TIME] > 500"),
+			Result:          &Result{Duration: 750 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] > 500",
+		},
+		{
+			Name:            "response-time-using-greater-than-with-duration",
+			Condition:       Condition("[RESPONSE_TIME] > 1s"),
+			Result:          &Result{Duration: 2 * time.Second},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] > 1s",
+		},
+		{
+			Name:            "response-time-using-greater-than-or-equal-to-equal",
+			Condition:       Condition("[RESPONSE_TIME] >= 500"),
+			Result:          &Result{Duration: 500 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] >= 500",
+		},
+		{
+			Name:            "response-time-using-greater-than-or-equal-to-greater",
+			Condition:       Condition("[RESPONSE_TIME] >= 500"),
+			Result:          &Result{Duration: 499 * time.Millisecond},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[RESPONSE_TIME] (499) >= 500",
+		},
+		{
+			Name:            "response-time-using-greater-than-or-equal-to-failure",
+			Condition:       Condition("[RESPONSE_TIME] >= 500"),
+			Result:          &Result{Duration: 499 * time.Millisecond},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[RESPONSE_TIME] (499) >= 500",
+		},
+		{
+			Name:            "response-time-using-less-than-or-equal-to-equal",
+			Condition:       Condition("[RESPONSE_TIME] <= 500"),
+			Result:          &Result{Duration: 500 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] <= 500",
+		},
+		{
+			Name:            "response-time-using-less-than-or-equal-to-less",
+			Condition:       Condition("[RESPONSE_TIME] <= 500"),
+			Result:          &Result{Duration: 25 * time.Millisecond},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[RESPONSE_TIME] <= 500",
+		},
+		{
+			Name:            "response-time-using-less-than-or-equal-to-failure",
+			Condition:       Condition("[RESPONSE_TIME] <= 500"),
+			Result:          &Result{Duration: 750 * time.Millisecond},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[RESPONSE_TIME] (750) <= 500",
+		},
+		{
+			Name:            "body",
+			Condition:       Condition("[BODY] == test"),
+			Result:          &Result{body: []byte("test")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY] == test",
+		},
+		{
+			Name:            "body-jsonpath",
+			Condition:       Condition("[BODY].status == UP"),
+			Result:          &Result{body: []byte("{\"status\":\"UP\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].status == UP",
+		},
+		{
+			Name:            "body-jsonpath-complex",
+			Condition:       Condition("[BODY].data.name == john"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1, \"name\": \"john\"}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].data.name == john",
+		},
+		{
+			Name:            "body-jsonpath-complex-invalid",
+			Condition:       Condition("[BODY].data.name == john"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].data.name (INVALID) == john",
+		},
+		{
+			Name:            "body-jsonpath-complex-len",
+			Condition:       Condition("len([BODY].data.name) == 4"),
+			Result:          &Result{body: []byte("{\"data\": {\"name\": \"john\"}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "len([BODY].data.name) == 4",
+		},
+		{
+			Name:            "body-jsonpath-complex-len-invalid",
+			Condition:       Condition("len([BODY].data.name) == john"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "len([BODY].data.name) (INVALID) == john",
+		},
+		{
+			Name:            "body-jsonpath-double-placeholder",
+			Condition:       Condition("[BODY].user.firstName != [BODY].user.lastName"),
+			Result:          &Result{body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].user.firstName != [BODY].user.lastName",
+		},
+		{
+			Name:            "body-jsonpath-double-placeholder-failure",
+			Condition:       Condition("[BODY].user.firstName == [BODY].user.lastName"),
+			Result:          &Result{body: []byte("{\"user\": {\"firstName\": \"john\", \"lastName\": \"doe\"}}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].user.firstName (john) == [BODY].user.lastName (doe)",
+		},
+		{
+			Name:            "body-jsonpath-when-body-is-array",
+			Condition:       Condition("[BODY][0].id == 1"),
+			Result:          &Result{body: []byte("[{\"id\": 1}, {\"id\": 2}]")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY][0].id == 1",
+		},
+		{
+			Name:            "body-jsonpath-complex-int",
+			Condition:       Condition("[BODY].data.id == 1"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].data.id == 1",
+		},
+		{
+			Name:            "body-jsonpath-complex-array-int",
+			Condition:       Condition("[BODY].data[1].id == 2"),
+			Result:          &Result{body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].data[1].id == 2",
+		},
+		{
+			Name:            "body-jsonpath-complex-int-using-greater-than",
+			Condition:       Condition("[BODY].data.id > 0"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].data.id > 0",
+		},
+		{
+			Name:            "body-jsonpath-complex-int-using-greater-than-failure",
+			Condition:       Condition("[BODY].data.id > 5"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 1}}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].data.id (1) > 5",
+		},
+		{
+			Name:            "body-jsonpath-complex-int-using-less-than",
+			Condition:       Condition("[BODY].data.id < 5"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 2}}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].data.id < 5",
+		},
+		{
+			Name:            "body-jsonpath-complex-int-using-less-than-failure",
+			Condition:       Condition("[BODY].data.id < 5"),
+			Result:          &Result{body: []byte("{\"data\": {\"id\": 10}}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].data.id (10) < 5",
+		},
+		{
+			Name:            "body-len-array",
+			Condition:       Condition("len([BODY].data) == 3"),
+			Result:          &Result{body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "len([BODY].data) == 3",
+		},
+		{
+			Name:            "body-len-array-invalid",
+			Condition:       Condition("len([BODY].data) == 8"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "len([BODY].data) (INVALID) == 8",
+		},
+		{
+			Name:            "body-len-string",
+			Condition:       Condition("len([BODY].name) == 8"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "len([BODY].name) == 8",
+		},
+		{
+			Name:            "body-pattern",
+			Condition:       Condition("[BODY] == pat(*john*)"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY] == pat(*john*)",
+		},
+		{
+			Name:            "body-pattern-2",
+			Condition:       Condition("[BODY].name == pat(john*)"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].name == pat(john*)",
+		},
+		{
+			Name:            "body-pattern-failure",
+			Condition:       Condition("[BODY].name == pat(bob*)"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].name (john.doe) == pat(bob*)",
+		},
+		{
+			Name:            "body-pattern-html",
+			Condition:       Condition("[BODY] == pat(*<div id=\"user\">john.doe</div>*)"),
+			Result:          &Result{body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">john.doe</div></body></html>`)},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY] == pat(*<div id=\"user\">john.doe</div>*)",
+		},
+		{
+			Name:            "body-pattern-html-failure",
+			Condition:       Condition("[BODY] == pat(*<div id=\"user\">john.doe</div>*)"),
+			Result:          &Result{body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">jane.doe</div></body></html>`)},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY] (<!DOCTYPE html><html lang...(truncated)) == pat(*<div id=\"user\">john.doe</div>*)",
+		},
+		{
+			Name:            "body-pattern-html-failure-alt",
+			Condition:       Condition("pat(*<div id=\"user\">john.doe</div>*) == [BODY]"),
+			Result:          &Result{body: []byte(`<!DOCTYPE html><html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body><div id="user">jane.doe</div></body></html>`)},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "pat(*<div id=\"user\">john.doe</div>*) == [BODY] (<!DOCTYPE html><html lang...(truncated))",
+		},
+		{
+			Name:            "ip-pattern",
+			Condition:       Condition("[IP] == pat(10.*)"),
+			Result:          &Result{IP: "10.0.0.0"},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[IP] == pat(10.*)",
+		},
+		{
+			Name:            "ip-pattern-failure",
+			Condition:       Condition("[IP] == pat(10.*)"),
+			Result:          &Result{IP: "255.255.255.255"},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[IP] (255.255.255.255) == pat(10.*)",
+		},
+		{
+			Name:            "status-pattern",
+			Condition:       Condition("[STATUS] == pat(4*)"),
+			Result:          &Result{HTTPStatus: 404},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[STATUS] == pat(4*)",
+		},
+		{
+			Name:            "status-pattern-failure",
+			Condition:       Condition("[STATUS] == pat(4*)"),
+			Result:          &Result{HTTPStatus: 200},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[STATUS] (200) == pat(4*)",
+		},
+		{
+			Name:            "body-any",
+			Condition:       Condition("[BODY].name == any(john.doe, jane.doe)"),
+			Result:          &Result{body: []byte("{\"name\": \"john.doe\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].name == any(john.doe, jane.doe)",
+		},
+		{
+			Name:            "body-any-2",
+			Condition:       Condition("[BODY].name == any(john.doe, jane.doe)"),
+			Result:          &Result{body: []byte("{\"name\": \"jane.doe\"}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[BODY].name == any(john.doe, jane.doe)",
+		},
+		{
+			Name:            "body-any-failure",
+			Condition:       Condition("[BODY].name == any(john.doe, jane.doe)"),
+			Result:          &Result{body: []byte("{\"name\": \"bob\"}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[BODY].name (bob) == any(john.doe, jane.doe)",
+		},
+		{
+			Name:            "status-any",
+			Condition:       Condition("[STATUS] == any(200, 429)"),
+			Result:          &Result{HTTPStatus: 200},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[STATUS] == any(200, 429)",
+		},
+		{
+			Name:            "status-any-2",
+			Condition:       Condition("[STATUS] == any(200, 429)"),
+			Result:          &Result{HTTPStatus: 429},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[STATUS] == any(200, 429)",
+		},
+		{
+			Name:            "status-any-reverse",
+			Condition:       Condition("any(200, 429) == [STATUS]"),
+			Result:          &Result{HTTPStatus: 429},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "any(200, 429) == [STATUS]",
+		},
+		{
+			Name:            "status-any-failure",
+			Condition:       Condition("[STATUS] == any(200, 429)"),
+			Result:          &Result{HTTPStatus: 404},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[STATUS] (404) == any(200, 429)",
+		},
+		{
+			Name:            "connected",
+			Condition:       Condition("[CONNECTED] == true"),
+			Result:          &Result{Connected: true},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[CONNECTED] == true",
+		},
+		{
+			Name:            "connected-failure",
+			Condition:       Condition("[CONNECTED] == true"),
+			Result:          &Result{Connected: false},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[CONNECTED] (false) == true",
+		},
+		{
+			Name:            "certificate-expiration-not-set",
+			Condition:       Condition("[CERTIFICATE_EXPIRATION] == 0"),
+			Result:          &Result{},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[CERTIFICATE_EXPIRATION] == 0",
+		},
+		{
+			Name:            "certificate-expiration-greater-than-numerical",
+			Condition:       Condition("[CERTIFICATE_EXPIRATION] > " + strconv.FormatInt((time.Hour*24*28).Milliseconds(), 10)),
+			Result:          &Result{CertificateExpiration: time.Hour * 24 * 60},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[CERTIFICATE_EXPIRATION] > 2419200000",
+		},
+		{
+			Name:            "certificate-expiration-greater-than-numerical-failure",
+			Condition:       Condition("[CERTIFICATE_EXPIRATION] > " + strconv.FormatInt((time.Hour*24*28).Milliseconds(), 10)),
+			Result:          &Result{CertificateExpiration: time.Hour * 24 * 14},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[CERTIFICATE_EXPIRATION] (1209600000) > 2419200000",
+		},
+		{
+			Name:            "certificate-expiration-greater-than-duration",
+			Condition:       Condition("[CERTIFICATE_EXPIRATION] > 12h"),
+			Result:          &Result{CertificateExpiration: 24 * time.Hour},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "[CERTIFICATE_EXPIRATION] > 12h",
+		},
+		{
+			Name:            "certificate-expiration-greater-than-duration",
+			Condition:       Condition("[CERTIFICATE_EXPIRATION] > 48h"),
+			Result:          &Result{CertificateExpiration: 24 * time.Hour},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "[CERTIFICATE_EXPIRATION] (86400000) > 48h (172800000)",
+		},
+		{
+			Name:            "has",
+			Condition:       Condition("has([BODY].errors) == false"),
+			Result:          &Result{body: []byte("{}")},
+			ExpectedSuccess: true,
+			ExpectedOutput:  "has([BODY].errors) == false",
+		},
+		{
+			Name:            "has-failure",
+			Condition:       Condition("has([BODY].errors) == false"),
+			Result:          &Result{body: []byte("{\"errors\": [\"1\"]}")},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "has([BODY].errors) (true) == false",
+		},
+		{
+			Name:            "no-placeholders",
+			Condition:       Condition("1 == 2"),
+			Result:          &Result{},
+			ExpectedSuccess: false,
+			ExpectedOutput:  "1 == 2",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			scenario.Condition.evaluate(scenario.Result)
+			if scenario.Result.ConditionResults[0].Success != scenario.ExpectedSuccess {
+				t.Errorf("Condition '%s' should have been success=%v", scenario.Condition, scenario.ExpectedSuccess)
+			}
+			if scenario.Result.ConditionResults[0].Condition != scenario.ExpectedOutput {
+				t.Errorf("Condition '%s' should have resolved to '%s', got '%s'", scenario.Condition, scenario.ExpectedOutput, scenario.Result.ConditionResults[0].Condition)
+			}
+		})
 	}
 }
 
-func TestCondition_evaluateWithStatus(t *testing.T) {
-	condition := Condition("[STATUS] == 201")
-	result := &Result{HttpStatus: 201}
+func TestCondition_evaluateWithInvalidOperator(t *testing.T) {
+	condition := Condition("[STATUS] ? 201")
+	result := &Result{HTTPStatus: 201}
 	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithStatusFailure(t *testing.T) {
-	condition := Condition("[STATUS] == 200")
-	result := &Result{HttpStatus: 500}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithStatusUsingLessThan(t *testing.T) {
-	condition := Condition("[STATUS] < 300")
-	result := &Result{HttpStatus: 201}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithStatusFailureUsingLessThan(t *testing.T) {
-	condition := Condition("[STATUS] < 300")
-	result := &Result{HttpStatus: 404}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithResponseTimeUsingLessThan(t *testing.T) {
-	condition := Condition("[RESPONSE_TIME] < 500")
-	result := &Result{Duration: time.Millisecond * 50}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithResponseTimeUsingGreaterThan(t *testing.T) {
-	condition := Condition("[RESPONSE_TIME] > 500")
-	result := &Result{Duration: time.Millisecond * 750}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithResponseTimeUsingGreaterThanOrEqualTo(t *testing.T) {
-	condition := Condition("[RESPONSE_TIME] >= 500")
-	result := &Result{Duration: time.Millisecond * 500}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithResponseTimeUsingLessThanOrEqualTo(t *testing.T) {
-	condition := Condition("[RESPONSE_TIME] <= 500")
-	result := &Result{Duration: time.Millisecond * 500}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBody(t *testing.T) {
-	condition := Condition("[BODY] == test")
-	result := &Result{Body: []byte("test")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJsonPath(t *testing.T) {
-	condition := Condition("[BODY].status == UP")
-	result := &Result{Body: []byte("{\"status\":\"UP\"}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJsonPathComplex(t *testing.T) {
-	condition := Condition("[BODY].data.name == john")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 1, \"name\": \"john\"}}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJsonPathLongInt(t *testing.T) {
-	condition := Condition("[BODY].data.id == 1")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJsonPathComplexInt(t *testing.T) {
-	condition := Condition("[BODY].data[1].id == 2")
-	result := &Result{Body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJsonPathComplexIntUsingGreaterThan(t *testing.T) {
-	condition := Condition("[BODY].data.id > 0")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJsonPathComplexIntFailureUsingGreaterThan(t *testing.T) {
-	condition := Condition("[BODY].data.id > 5")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 1}}")}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJsonPathComplexIntUsingLessThan(t *testing.T) {
-	condition := Condition("[BODY].data.id < 5")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 2}}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyJsonPathComplexIntFailureUsingLessThan(t *testing.T) {
-	condition := Condition("[BODY].data.id < 5")
-	result := &Result{Body: []byte("{\"data\": {\"id\": 10}}")}
-	condition.evaluate(result)
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodySliceLength(t *testing.T) {
-	condition := Condition("len([BODY].data) == 3")
-	result := &Result{Body: []byte("{\"data\": [{\"id\": 1}, {\"id\": 2}, {\"id\": 3}]}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
-	}
-}
-
-func TestCondition_evaluateWithBodyStringLength(t *testing.T) {
-	condition := Condition("len([BODY].name) == 8")
-	result := &Result{Body: []byte("{\"name\": \"john.doe\"}")}
-	condition.evaluate(result)
-	if !result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a success", condition)
+	if result.Success {
+		t.Error("condition was invalid, result should've been a failure")
+	}
+	if len(result.Errors) != 1 {
+		t.Error("condition was invalid, result should've had an error")
 	}
 }

core/dns.go

@@ -0,0 +1,85 @@
+package core
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/miekg/dns"
+)
+
+var (
+	// ErrDNSWithNoQueryName is the error with which gatus will panic if a dns is configured without query name
+	ErrDNSWithNoQueryName = errors.New("you must specify a query name for DNS")
+
+	// ErrDNSWithInvalidQueryType is the error with which gatus will panic if a dns is configured with invalid query type
+	ErrDNSWithInvalidQueryType = errors.New("invalid query type")
+)
+
+const (
+	dnsPort = 53
+)
+
+// DNS is the configuration for a Service of type DNS
+type DNS struct {
+	// QueryType is the type for the DNS records like A, AAAA, CNAME...
+	QueryType string `yaml:"query-type"`
+
+	// QueryName is the query for DNS
+	QueryName string `yaml:"query-name"`
+}
+
+func (d *DNS) validateAndSetDefault() {
+	if len(d.QueryName) == 0 {
+		panic(ErrDNSWithNoQueryName)
+	}
+	if !strings.HasSuffix(d.QueryName, ".") {
+		d.QueryName += "."
+	}
+	if _, ok := dns.StringToType[d.QueryType]; !ok {
+		panic(ErrDNSWithInvalidQueryType)
+	}
+}
+
+func (d *DNS) query(url string, result *Result) {
+	if !strings.Contains(url, ":") {
+		url = fmt.Sprintf("%s:%d", url, dnsPort)
+	}
+	queryType := dns.StringToType[d.QueryType]
+	c := new(dns.Client)
+	m := new(dns.Msg)
+	m.SetQuestion(d.QueryName, queryType)
+	r, _, err := c.Exchange(m, url)
+	if err != nil {
+		result.Errors = append(result.Errors, err.Error())
+		return
+	}
+	result.Connected = true
+	result.DNSRCode = dns.RcodeToString[r.Rcode]
+	for _, rr := range r.Answer {
+		switch rr.Header().Rrtype {
+		case dns.TypeA:
+			if a, ok := rr.(*dns.A); ok {
+				result.body = []byte(a.A.String())
+			}
+		case dns.TypeAAAA:
+			if aaaa, ok := rr.(*dns.AAAA); ok {
+				result.body = []byte(aaaa.AAAA.String())
+			}
+		case dns.TypeCNAME:
+			if cname, ok := rr.(*dns.CNAME); ok {
+				result.body = []byte(cname.Target)
+			}
+		case dns.TypeMX:
+			if mx, ok := rr.(*dns.MX); ok {
+				result.body = []byte(mx.Mx)
+			}
+		case dns.TypeNS:
+			if ns, ok := rr.(*dns.NS); ok {
+				result.body = []byte(ns.Ns)
+			}
+		default:
+			result.body = []byte("query type is not supported yet")
+		}
+	}
+}

core/dns_test.go

@@ -0,0 +1,124 @@
+package core
+
+import (
+	"testing"
+
+	"github.com/TwinProduction/gatus/pattern"
+)
+
+func TestIntegrationQuery(t *testing.T) {
+	tests := []struct {
+		name            string
+		inputDNS        DNS
+		inputURL        string
+		expectedDNSCode string
+		expectedBody    string
+		isErrExpected   bool
+	}{
+		{
+			name: "test DNS with type A",
+			inputDNS: DNS{
+				QueryType: "A",
+				QueryName: "example.com.",
+			},
+			inputURL:        "8.8.8.8",
+			expectedDNSCode: "NOERROR",
+			expectedBody:    "93.184.216.34",
+		},
+		{
+			name: "test DNS with type AAAA",
+			inputDNS: DNS{
+				QueryType: "AAAA",
+				QueryName: "example.com.",
+			},
+			inputURL:        "8.8.8.8",
+			expectedDNSCode: "NOERROR",
+			expectedBody:    "2606:2800:220:1:248:1893:25c8:1946",
+		},
+		{
+			name: "test DNS with type CNAME",
+			inputDNS: DNS{
+				QueryType: "CNAME",
+				QueryName: "doc.google.com.",
+			},
+			inputURL:        "8.8.8.8",
+			expectedDNSCode: "NOERROR",
+			expectedBody:    "writely.l.google.com.",
+		},
+		{
+			name: "test DNS with type MX",
+			inputDNS: DNS{
+				QueryType: "MX",
+				QueryName: "example.com.",
+			},
+			inputURL:        "8.8.8.8",
+			expectedDNSCode: "NOERROR",
+			expectedBody:    ".",
+		},
+		{
+			name: "test DNS with type NS",
+			inputDNS: DNS{
+				QueryType: "NS",
+				QueryName: "example.com.",
+			},
+			inputURL:        "8.8.8.8",
+			expectedDNSCode: "NOERROR",
+			expectedBody:    "*.iana-servers.net.",
+		},
+		{
+			name: "test DNS with fake type and retrieve error",
+			inputDNS: DNS{
+				QueryType: "B",
+				QueryName: "google",
+			},
+			inputURL:      "8.8.8.8",
+			isErrExpected: true,
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			dns := test.inputDNS
+			result := &Result{}
+			dns.query(test.inputURL, result)
+			if test.isErrExpected && len(result.Errors) == 0 {
+				t.Errorf("there should be errors")
+			}
+			if result.DNSRCode != test.expectedDNSCode {
+				t.Errorf("DNSRCodePlaceholder '%s' should have been %s", result.DNSRCode, test.expectedDNSCode)
+			}
+
+			if test.inputDNS.QueryType == "NS" {
+				// Because there are often multiple nameservers backing a single domain, we'll only look at the suffix
+				if !pattern.Match(test.expectedBody, string(result.body)) {
+					t.Errorf("got %s, expected result %s,", string(result.body), test.expectedBody)
+				}
+			} else {
+				if string(result.body) != test.expectedBody {
+					t.Errorf("got %s, expected result %s,", string(result.body), test.expectedBody)
+				}
+			}
+		})
+	}
+}
+
+func TestService_ValidateAndSetDefaultsWithNoDNSQueryName(t *testing.T) {
+	defer func() { recover() }()
+	dns := &DNS{
+		QueryType: "A",
+		QueryName: "",
+	}
+	dns.validateAndSetDefault()
+	t.Fatal("Should've panicked because service`s dns didn't have a query name, which is a mandatory field for dns")
+}
+
+func TestService_ValidateAndSetDefaultsWithInvalidDNSQueryType(t *testing.T) {
+	defer func() { recover() }()
+	dns := &DNS{
+		QueryType: "B",
+		QueryName: "example.com",
+	}
+	dns.validateAndSetDefault()
+	t.Fatal("Should've panicked because service`s dns query type is invalid, it needs to be a valid query name like A, AAAA, CNAME...")
+}

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/health-status.go

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

core/result.go

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

core/service-status.go

@@ -0,0 +1,114 @@
+package core
+
+import (
+	"time"
+
+	"github.com/TwinProduction/gatus/util"
+)
+
+const (
+	// MaximumNumberOfResults is the maximum number of results that ServiceStatus.Results can have
+	MaximumNumberOfResults = 100
+
+	// MaximumNumberOfEvents is the maximum number of events that ServiceStatus.Events can have
+	MaximumNumberOfEvents = 50
+)
+
+// ServiceStatus contains the evaluation Results of a Service
+type ServiceStatus struct {
+	// Name of the service
+	Name string `json:"name,omitempty"`
+
+	// Group the service is a part of. Used for grouping multiple services together on the front end.
+	Group string `json:"group,omitempty"`
+
+	// Key is the key representing the ServiceStatus
+	Key string `json:"key"`
+
+	// Results is the list of service evaluation results
+	Results []*Result `json:"results"`
+
+	// Events is a list of events
+	//
+	// 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
+	//
+	// 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
+func NewServiceStatus(service *Service) *ServiceStatus {
+	return &ServiceStatus{
+		Name:    service.Name,
+		Group:   service.Group,
+		Key:     util.ConvertGroupAndServiceToKey(service.Group, service.Name),
+		Results: make([]*Result, 0),
+		Events: []*Event{{
+			Type:      EventStart,
+			Timestamp: time.Now(),
+		}},
+		Uptime: NewUptime(),
+	}
+}
+
+// WithResultPagination returns a shallow copy of the ServiceStatus with only the results
+// within the range defined by the page and pageSize parameters
+func (ss ServiceStatus) WithResultPagination(page, pageSize int) *ServiceStatus {
+	shallowCopy := ss
+	numberOfResults := len(shallowCopy.Results)
+	start := numberOfResults - (page * pageSize)
+	end := numberOfResults - ((page - 1) * pageSize)
+	if start > numberOfResults {
+		start = -1
+	} else if start < 0 {
+		start = 0
+	}
+	if end > numberOfResults {
+		end = numberOfResults
+	}
+	if start < 0 || end < 0 {
+		shallowCopy.Results = []*Result{}
+	} else {
+		shallowCopy.Results = shallowCopy.Results[start:end]
+	}
+	return &shallowCopy
+}
+
+// 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) > MaximumNumberOfEvents {
+				// Doing ss.Events[1:] would usually be sufficient, but in the case where for some reason, the slice has
+				// more than one extra element, we can get rid of all of them at once and thus returning the slice to a
+				// length of MaximumNumberOfEvents by using ss.Events[len(ss.Events)-MaximumNumberOfEvents:] instead
+				ss.Events = ss.Events[len(ss.Events)-MaximumNumberOfEvents:]
+			}
+		}
+	}
+	ss.Results = append(ss.Results, result)
+	if len(ss.Results) > MaximumNumberOfResults {
+		// Doing ss.Results[1:] would usually be sufficient, but in the case where for some reason, the slice has more
+		// than one extra element, we can get rid of all of them at once and thus returning the slice to a length of
+		// MaximumNumberOfResults by using ss.Results[len(ss.Results)-MaximumNumberOfResults:] instead
+		ss.Results = ss.Results[len(ss.Results)-MaximumNumberOfResults:]
+	}
+	ss.Uptime.ProcessResult(result)
+}

core/service-status_bench_test.go

@@ -0,0 +1,92 @@
+package core
+
+import (
+	"testing"
+	"time"
+)
+
+var (
+	firstCondition  = Condition("[STATUS] == 200")
+	secondCondition = Condition("[RESPONSE_TIME] < 500")
+	thirdCondition  = Condition("[CERTIFICATE_EXPIRATION] < 72h")
+
+	timestamp = time.Now()
+
+	testService = Service{
+		Name:                    "name",
+		Group:                   "group",
+		URL:                     "https://example.org/what/ever",
+		Method:                  "GET",
+		Body:                    "body",
+		Interval:                30 * time.Second,
+		Conditions:              []*Condition{&firstCondition, &secondCondition, &thirdCondition},
+		Alerts:                  nil,
+		Insecure:                false,
+		NumberOfFailuresInARow:  0,
+		NumberOfSuccessesInARow: 0,
+	}
+	testSuccessfulResult = 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: []*ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   true,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   true,
+			},
+		},
+	}
+	testUnsuccessfulResult = 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: []*ConditionResult{
+			{
+				Condition: "[STATUS] == 200",
+				Success:   true,
+			},
+			{
+				Condition: "[RESPONSE_TIME] < 500",
+				Success:   false,
+			},
+			{
+				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
+				Success:   false,
+			},
+		},
+	}
+)
+
+func BenchmarkServiceStatus_WithResultPagination(b *testing.B) {
+	service := &testService
+	serviceStatus := NewServiceStatus(service)
+	for i := 0; i < MaximumNumberOfResults; i++ {
+		serviceStatus.AddResult(&testSuccessfulResult)
+	}
+	for n := 0; n < b.N; n++ {
+		serviceStatus.WithResultPagination(1, 20)
+	}
+	b.ReportAllocs()
+}

core/service-status_test.go

@@ -0,0 +1,66 @@
+package core
+
+import (
+	"testing"
+	"time"
+)
+
+func TestNewServiceStatus(t *testing.T) {
+	service := &Service{Name: "name", Group: "group"}
+	serviceStatus := NewServiceStatus(service)
+	if serviceStatus.Name != service.Name {
+		t.Errorf("expected %s, got %s", service.Name, serviceStatus.Name)
+	}
+	if serviceStatus.Group != service.Group {
+		t.Errorf("expected %s, got %s", service.Group, serviceStatus.Group)
+	}
+	if serviceStatus.Key != "group_name" {
+		t.Errorf("expected %s, got %s", "group_name", serviceStatus.Key)
+	}
+}
+
+func TestServiceStatus_AddResult(t *testing.T) {
+	service := &Service{Name: "name", Group: "group"}
+	serviceStatus := NewServiceStatus(service)
+	for i := 0; i < MaximumNumberOfResults+10; i++ {
+		serviceStatus.AddResult(&Result{Timestamp: time.Now()})
+	}
+	if len(serviceStatus.Results) != MaximumNumberOfResults {
+		t.Errorf("expected serviceStatus.Results to not exceed a length of %d", MaximumNumberOfResults)
+	}
+}
+
+func TestServiceStatus_WithResultPagination(t *testing.T) {
+	service := &Service{Name: "name", Group: "group"}
+	serviceStatus := NewServiceStatus(service)
+	for i := 0; i < 25; i++ {
+		serviceStatus.AddResult(&Result{Timestamp: time.Now()})
+	}
+	if len(serviceStatus.WithResultPagination(1, 1).Results) != 1 {
+		t.Errorf("expected to have 1 result")
+	}
+	if len(serviceStatus.WithResultPagination(5, 0).Results) != 0 {
+		t.Errorf("expected to have 0 results")
+	}
+	if len(serviceStatus.WithResultPagination(-1, 20).Results) != 0 {
+		t.Errorf("expected to have 0 result, because the page was invalid")
+	}
+	if len(serviceStatus.WithResultPagination(1, -1).Results) != 0 {
+		t.Errorf("expected to have 0 result, because the page size was invalid")
+	}
+	if len(serviceStatus.WithResultPagination(1, 10).Results) != 10 {
+		t.Errorf("expected to have 10 results, because given a page size of 10, page 1 should have 10 elements")
+	}
+	if len(serviceStatus.WithResultPagination(2, 10).Results) != 10 {
+		t.Errorf("expected to have 10 results, because given a page size of 10, page 2 should have 10 elements")
+	}
+	if len(serviceStatus.WithResultPagination(3, 10).Results) != 5 {
+		t.Errorf("expected to have 5 results, because given a page size of 10, page 3 should have 5 elements")
+	}
+	if len(serviceStatus.WithResultPagination(4, 10).Results) != 0 {
+		t.Errorf("expected to have 0 results, because given a page size of 10, page 4 should have 0 elements")
+	}
+	if len(serviceStatus.WithResultPagination(1, 50).Results) != 25 {
+		t.Errorf("expected to have 25 results, because there's only 25 results")
+	}
+}

core/service.go

@@ -4,17 +4,39 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
-	"github.com/TwinProduction/gatus/client"
 	"io/ioutil"
 	"net"
 	"net/http"
 	"net/url"
+	"strings"
 	"time"
+
+	"github.com/TwinProduction/gatus/client"
+)
+
+const (
+	// HostHeader is the name of the header used to specify the host
+	HostHeader = "Host"
+
+	// ContentTypeHeader is the name of the header used to specify the content type
+	ContentTypeHeader = "Content-Type"
+
+	// UserAgentHeader is the name of the header used to specify the request's user agent
+	UserAgentHeader = "User-Agent"
+
+	// GatusUserAgent is the default user agent that Gatus uses to send requests.
+	GatusUserAgent = "Gatus/1.0"
 )
 
 var (
-	ErrNoCondition = errors.New("you must specify at least one condition per service")
-	ErrNoUrl       = errors.New("you must specify an url for each service")
+	// ErrServiceWithNoCondition is the error with which Gatus will panic if a service is configured with no conditions
+	ErrServiceWithNoCondition = errors.New("you must specify at least one condition per service")
+
+	// ErrServiceWithNoURL is the error with which Gatus will panic if a service is configured with no url
+	ErrServiceWithNoURL = errors.New("you must specify an url for each service")
+
+	// ErrServiceWithNoName is the error with which Gatus will panic if a service is configured with no name
+	ErrServiceWithNoName = errors.New("you must specify a name for each service")
 )
 
 // Service is the configuration of a monitored endpoint
@@ -22,8 +44,14 @@ type Service struct {
 	// Name of the service. Can be anything.
 	Name string `yaml:"name"`
 
+	// Group the service is a part of. Used for grouping multiple services together on the front end.
+	Group string `yaml:"group,omitempty"`
+
 	// URL to send the request to
-	Url string `yaml:"url"`
+	URL string `yaml:"url"`
+
+	// DNS is the configuration of DNS monitoring
+	DNS *DNS `yaml:"dns,omitempty"`
 
 	// Method of the request made to the url of the service
 	Method string `yaml:"method,omitempty"`
@@ -46,10 +74,18 @@ type Service struct {
 	// Alerts is the alerting configuration for the service in case of failure
 	Alerts []*Alert `yaml:"alerts"`
 
+	// Insecure is whether to skip verifying the server's certificate chain and host name
+	Insecure bool `yaml:"insecure,omitempty"`
+
+	// NumberOfFailuresInARow is the number of unsuccessful evaluations in a row
 	NumberOfFailuresInARow int
+
+	// NumberOfSuccessesInARow is the number of successful evaluations in a row
+	NumberOfSuccessesInARow int
 }
 
-func (service *Service) Validate() {
+// ValidateAndSetDefaults validates the service's configuration and sets the default value of fields that have one
+func (service *Service) ValidateAndSetDefaults() {
 	// Set default values
 	if service.Interval == 0 {
 		service.Interval = 1 * time.Minute
@@ -60,28 +96,47 @@ func (service *Service) Validate() {
 	if len(service.Headers) == 0 {
 		service.Headers = make(map[string]string)
 	}
+	// Automatically add user agent header if there isn't one specified in the service configuration
+	if _, userAgentHeaderExists := service.Headers[UserAgentHeader]; !userAgentHeaderExists {
+		service.Headers[UserAgentHeader] = GatusUserAgent
+	}
+	// Automatically add "Content-Type: application/json" header if there's no Content-Type set
+	// and service.GraphQL is set to true
+	if _, contentTypeHeaderExists := service.Headers[ContentTypeHeader]; !contentTypeHeaderExists && service.GraphQL {
+		service.Headers[ContentTypeHeader] = "application/json"
+	}
 	for _, alert := range service.Alerts {
-		if alert.Threshold <= 0 {
-			alert.Threshold = 3
+		if alert.FailureThreshold <= 0 {
+			alert.FailureThreshold = 3
+		}
+		if alert.SuccessThreshold <= 0 {
+			alert.SuccessThreshold = 2
 		}
 	}
-	if len(service.Url) == 0 {
-		panic(ErrNoUrl)
+	if len(service.Name) == 0 {
+		panic(ErrServiceWithNoName)
+	}
+	if len(service.URL) == 0 {
+		panic(ErrServiceWithNoURL)
 	}
 	if len(service.Conditions) == 0 {
-		panic(ErrNoCondition)
+		panic(ErrServiceWithNoCondition)
+	}
+	if service.DNS != nil {
+		service.DNS.validateAndSetDefault()
+		return
 	}
-
 	// Make sure that the request can be created
-	_, err := http.NewRequest(service.Method, service.Url, bytes.NewBuffer([]byte(service.Body)))
+	_, err := http.NewRequest(service.Method, service.URL, bytes.NewBuffer([]byte(service.Body)))
 	if err != nil {
 		panic(err)
 	}
 }
 
-func (service *Service) EvaluateConditions() *Result {
+// EvaluateHealth sends a request to the service's URL and evaluates the conditions of the service.
+func (service *Service) EvaluateHealth() *Result {
 	result := &Result{Success: true, Errors: []string{}}
-	service.getIp(result)
+	service.getIP(result)
 	if len(result.Errors) == 0 {
 		service.call(result)
 	} else {
@@ -94,16 +149,19 @@ func (service *Service) EvaluateConditions() *Result {
 		}
 	}
 	result.Timestamp = time.Now()
+	// No need to keep the body after the service has been evaluated
+	result.body = nil
 	return result
 }
 
+// GetAlertsTriggered returns a slice of alerts that have been triggered
 func (service *Service) GetAlertsTriggered() []Alert {
 	var alerts []Alert
 	if service.NumberOfFailuresInARow == 0 {
 		return alerts
 	}
 	for _, alert := range service.Alerts {
-		if alert.Enabled && alert.Threshold == service.NumberOfFailuresInARow {
+		if alert.Enabled && alert.FailureThreshold == service.NumberOfFailuresInARow {
 			alerts = append(alerts, *alert)
 			continue
 		}
@@ -111,39 +169,70 @@ func (service *Service) GetAlertsTriggered() []Alert {
 	return alerts
 }
 
-func (service *Service) getIp(result *Result) {
-	urlObject, err := url.Parse(service.Url)
+func (service *Service) getIP(result *Result) {
+	if service.DNS != nil {
+		result.Hostname = strings.TrimSuffix(service.URL, ":53")
+	} else {
+		urlObject, err := url.Parse(service.URL)
+		if err != nil {
+			result.Errors = append(result.Errors, err.Error())
+			return
+		}
+		result.Hostname = urlObject.Hostname()
+	}
+	ips, err := net.LookupIP(result.Hostname)
 	if err != nil {
 		result.Errors = append(result.Errors, err.Error())
 		return
 	}
-	result.Hostname = urlObject.Hostname()
-	ips, err := net.LookupIP(urlObject.Hostname())
-	if err != nil {
-		result.Errors = append(result.Errors, err.Error())
-		return
-	}
-	result.Ip = ips[0].String()
+	result.IP = ips[0].String()
 }
 
 func (service *Service) call(result *Result) {
-	request := service.buildRequest()
-	startTime := time.Now()
-	response, err := client.GetHttpClient().Do(request)
-	if err != nil {
-		result.Duration = time.Since(startTime)
-		result.Errors = append(result.Errors, err.Error())
-		return
+	var request *http.Request
+	var response *http.Response
+	var err error
+	isServiceDNS := service.DNS != nil
+	isServiceTCP := strings.HasPrefix(service.URL, "tcp://")
+	isServiceICMP := strings.HasPrefix(service.URL, "icmp://")
+	isServiceHTTP := !isServiceDNS && !isServiceTCP && !isServiceICMP
+	if isServiceHTTP {
+		request = service.buildHTTPRequest()
 	}
-	result.Duration = time.Since(startTime)
-	result.HttpStatus = response.StatusCode
-	result.Body, err = ioutil.ReadAll(response.Body)
-	if err != nil {
-		result.Errors = append(result.Errors, err.Error())
+	startTime := time.Now()
+	if isServiceDNS {
+		service.DNS.query(service.URL, result)
+		result.Duration = time.Since(startTime)
+	} else if isServiceTCP {
+		result.Connected = client.CanCreateTCPConnection(strings.TrimPrefix(service.URL, "tcp://"))
+		result.Duration = time.Since(startTime)
+	} else if isServiceICMP {
+		result.Connected, result.Duration = client.Ping(strings.TrimPrefix(service.URL, "icmp://"))
+	} else {
+		response, err = client.GetHTTPClient(service.Insecure).Do(request)
+		result.Duration = time.Since(startTime)
+		if err != nil {
+			result.Errors = append(result.Errors, err.Error())
+			return
+		}
+		defer response.Body.Close()
+		if response.TLS != nil && len(response.TLS.PeerCertificates) > 0 {
+			certificate := response.TLS.PeerCertificates[0]
+			result.CertificateExpiration = time.Until(certificate.NotAfter)
+		}
+		result.HTTPStatus = response.StatusCode
+		result.Connected = response.StatusCode > 0
+		// Only read the body if there's a condition that uses the BodyPlaceholder
+		if service.needsToReadBody() {
+			result.body, err = ioutil.ReadAll(response.Body)
+			if err != nil {
+				result.Errors = append(result.Errors, err.Error())
+			}
+		}
 	}
 }
 
-func (service *Service) buildRequest() *http.Request {
+func (service *Service) buildHTTPRequest() *http.Request {
 	var bodyBuffer *bytes.Buffer
 	if service.GraphQL {
 		graphQlBody := map[string]string{
@@ -154,9 +243,22 @@ func (service *Service) buildRequest() *http.Request {
 	} else {
 		bodyBuffer = bytes.NewBuffer([]byte(service.Body))
 	}
-	request, _ := http.NewRequest(service.Method, service.Url, bodyBuffer)
+	request, _ := http.NewRequest(service.Method, service.URL, bodyBuffer)
 	for k, v := range service.Headers {
 		request.Header.Set(k, v)
+		if k == HostHeader {
+			request.Host = v
+		}
 	}
 	return request
 }
+
+// needsToReadBody checks if there's any conditions that requires the response body to be read
+func (service *Service) needsToReadBody() bool {
+	for _, condition := range service.Conditions {
+		if condition.hasBodyPlaceholder() {
+			return true
+		}
+	}
+	return false
+}

core/service_test.go

@@ -1,37 +1,331 @@
 package core
 
 import (
+	"io/ioutil"
+	"strings"
 	"testing"
+	"time"
 )
 
-func TestIntegrationEvaluateConditions(t *testing.T) {
+func TestService_ValidateAndSetDefaults(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	service := Service{
-		Name:       "TwiNNatioN",
-		Url:        "https://twinnation.org/health",
+		Name:       "twinnation-health",
+		URL:        "https://twinnation.org/health",
+		Conditions: []*Condition{&condition},
+		Alerts:     []*Alert{{Type: PagerDutyAlert}},
+	}
+	service.ValidateAndSetDefaults()
+	if service.Method != "GET" {
+		t.Error("Service method should've defaulted to GET")
+	}
+	if service.Interval != time.Minute {
+		t.Error("Service interval should've defaulted to 1 minute")
+	}
+	if service.Headers == nil {
+		t.Error("Service headers should've defaulted to an empty map")
+	}
+	if len(service.Alerts) != 1 {
+		t.Error("Service should've had 1 alert")
+	}
+	if service.Alerts[0].Enabled {
+		t.Error("Service alert should've defaulted to disabled")
+	}
+	if service.Alerts[0].SuccessThreshold != 2 {
+		t.Error("Service alert should've defaulted to a success threshold of 2")
+	}
+	if service.Alerts[0].FailureThreshold != 3 {
+		t.Error("Service alert should've defaulted to a failure threshold of 3")
+	}
+}
+
+func TestService_ValidateAndSetDefaultsWithNoName(t *testing.T) {
+	defer func() { recover() }()
+	condition := Condition("[STATUS] == 200")
+	service := &Service{
+		Name:       "",
+		URL:        "http://example.com",
 		Conditions: []*Condition{&condition},
 	}
-	result := service.EvaluateConditions()
+	service.ValidateAndSetDefaults()
+	t.Fatal("Should've panicked because service didn't have a name, which is a mandatory field")
+}
+
+func TestService_ValidateAndSetDefaultsWithNoUrl(t *testing.T) {
+	defer func() { recover() }()
+	condition := Condition("[STATUS] == 200")
+	service := &Service{
+		Name:       "example",
+		URL:        "",
+		Conditions: []*Condition{&condition},
+	}
+	service.ValidateAndSetDefaults()
+	t.Fatal("Should've panicked because service didn't have an url, which is a mandatory field")
+}
+
+func TestService_ValidateAndSetDefaultsWithNoConditions(t *testing.T) {
+	defer func() { recover() }()
+	service := &Service{
+		Name:       "example",
+		URL:        "http://example.com",
+		Conditions: nil,
+	}
+	service.ValidateAndSetDefaults()
+	t.Fatal("Should've panicked because service didn't have at least 1 condition")
+}
+
+func TestService_ValidateAndSetDefaultsWithDNS(t *testing.T) {
+	conditionSuccess := Condition("[DNS_RCODE] == NOERROR")
+	service := &Service{
+		Name: "dns-test",
+		URL:  "http://example.com",
+		DNS: &DNS{
+			QueryType: "A",
+			QueryName: "example.com",
+		},
+		Conditions: []*Condition{&conditionSuccess},
+	}
+	service.ValidateAndSetDefaults()
+	if service.DNS.QueryName != "example.com." {
+		t.Error("Service.dns.query-name should be formatted with . suffix")
+	}
+}
+
+func TestService_GetAlertsTriggered(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "twinnation-health",
+		URL:        "https://twinnation.org/health",
+		Conditions: []*Condition{&condition},
+		Alerts:     []*Alert{{Type: PagerDutyAlert, Enabled: true}},
+	}
+	service.ValidateAndSetDefaults()
+	if service.NumberOfFailuresInARow != 0 {
+		t.Error("Service.NumberOfFailuresInARow should start with 0")
+	}
+	if service.NumberOfSuccessesInARow != 0 {
+		t.Error("Service.NumberOfSuccessesInARow should start with 0")
+	}
+	if len(service.GetAlertsTriggered()) > 0 {
+		t.Error("No alerts should've been triggered, because service.NumberOfFailuresInARow is 0, which is below the failure threshold")
+	}
+	service.NumberOfFailuresInARow = service.Alerts[0].FailureThreshold
+	if len(service.GetAlertsTriggered()) != 1 {
+		t.Error("Alert should've been triggered")
+	}
+}
+
+func TestService_buildHTTPRequest(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "twinnation-health",
+		URL:        "https://twinnation.org/health",
+		Conditions: []*Condition{&condition},
+	}
+	service.ValidateAndSetDefaults()
+	request := service.buildHTTPRequest()
+	if request.Method != "GET" {
+		t.Error("request.Method should've been GET, but was", request.Method)
+	}
+	if request.Host != "twinnation.org" {
+		t.Error("request.Host should've been twinnation.org, but was", request.Host)
+	}
+	if userAgent := request.Header.Get("User-Agent"); userAgent != GatusUserAgent {
+		t.Errorf("request.Header.Get(User-Agent) should've been %s, but was %s", GatusUserAgent, userAgent)
+	}
+}
+
+func TestService_buildHTTPRequestWithCustomUserAgent(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "twinnation-health",
+		URL:        "https://twinnation.org/health",
+		Conditions: []*Condition{&condition},
+		Headers: map[string]string{
+			"User-Agent": "Test/2.0",
+		},
+	}
+	service.ValidateAndSetDefaults()
+	request := service.buildHTTPRequest()
+	if request.Method != "GET" {
+		t.Error("request.Method should've been GET, but was", request.Method)
+	}
+	if request.Host != "twinnation.org" {
+		t.Error("request.Host should've been twinnation.org, but was", request.Host)
+	}
+	if userAgent := request.Header.Get("User-Agent"); userAgent != "Test/2.0" {
+		t.Errorf("request.Header.Get(User-Agent) should've been %s, but was %s", "Test/2.0", userAgent)
+	}
+}
+
+func TestService_buildHTTPRequestWithHostHeader(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "twinnation-health",
+		URL:        "https://twinnation.org/health",
+		Method:     "POST",
+		Conditions: []*Condition{&condition},
+		Headers: map[string]string{
+			"Host": "example.com",
+		},
+	}
+	service.ValidateAndSetDefaults()
+	request := service.buildHTTPRequest()
+	if request.Method != "POST" {
+		t.Error("request.Method should've been POST, but was", request.Method)
+	}
+	if request.Host != "example.com" {
+		t.Error("request.Host should've been example.com, but was", request.Host)
+	}
+}
+
+func TestService_buildHTTPRequestWithGraphQLEnabled(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "twinnation-graphql",
+		URL:        "https://twinnation.org/graphql",
+		Method:     "POST",
+		Conditions: []*Condition{&condition},
+		GraphQL:    true,
+		Body: `{
+  users(gender: "female") {
+    id
+    name
+    gender
+    avatar
+  }
+}`,
+	}
+	service.ValidateAndSetDefaults()
+	request := service.buildHTTPRequest()
+	if request.Method != "POST" {
+		t.Error("request.Method should've been POST, but was", request.Method)
+	}
+	if contentType := request.Header.Get(ContentTypeHeader); contentType != "application/json" {
+		t.Error("request.Header.Content-Type should've been application/json, but was", contentType)
+	}
+	body, _ := ioutil.ReadAll(request.Body)
+	if !strings.HasPrefix(string(body), "{\"query\":") {
+		t.Error("request.body should've started with '{\"query\":', but it didn't:", string(body))
+	}
+}
+
+func TestIntegrationEvaluateHealth(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	bodyCondition := Condition("[BODY].status == UP")
+	service := Service{
+		Name:       "twinnation-health",
+		URL:        "https://twinnation.org/health",
+		Conditions: []*Condition{&condition, &bodyCondition},
+	}
+	result := service.EvaluateHealth()
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
 	}
+	if !result.Connected {
+		t.Error("Because the connection has been established, result.Connected should've been true")
+	}
 	if !result.Success {
 		t.Error("Because all conditions passed, this should have been a success")
 	}
 }
 
-func TestIntegrationEvaluateConditionsWithFailure(t *testing.T) {
+func TestIntegrationEvaluateHealthWithFailure(t *testing.T) {
 	condition := Condition("[STATUS] == 500")
 	service := Service{
-		Name:       "TwiNNatioN",
-		Url:        "https://twinnation.org/health",
+		Name:       "twinnation-health",
+		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition},
 	}
-	result := service.EvaluateConditions()
+	result := service.EvaluateHealth()
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
 	}
+	if !result.Connected {
+		t.Error("Because the connection has been established, result.Connected should've been true")
+	}
 	if result.Success {
 		t.Error("Because one of the conditions failed, success should have been false")
 	}
 }
+
+func TestIntegrationEvaluateHealthForDNS(t *testing.T) {
+	conditionSuccess := Condition("[DNS_RCODE] == NOERROR")
+	conditionBody := Condition("[BODY] == 93.184.216.34")
+	service := Service{
+		Name: "example",
+		URL:  "8.8.8.8",
+		DNS: &DNS{
+			QueryType: "A",
+			QueryName: "example.com.",
+		},
+		Conditions: []*Condition{&conditionSuccess, &conditionBody},
+	}
+	result := service.EvaluateHealth()
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Conditions '%s' and %s should have been a success", conditionSuccess, conditionBody)
+	}
+	if !result.Connected {
+		t.Error("Because the connection has been established, result.Connected should've been true")
+	}
+	if !result.Success {
+		t.Error("Because all conditions passed, this should have been a success")
+	}
+}
+
+func TestIntegrationEvaluateHealthForICMP(t *testing.T) {
+	conditionSuccess := Condition("[CONNECTED] == true")
+	service := Service{
+		Name:       "icmp-test",
+		URL:        "icmp://127.0.0.1",
+		Conditions: []*Condition{&conditionSuccess},
+	}
+	result := service.EvaluateHealth()
+	if !result.ConditionResults[0].Success {
+		t.Errorf("Conditions '%s' should have been a success", conditionSuccess)
+	}
+	if !result.Connected {
+		t.Error("Because the connection has been established, result.Connected should've been true")
+	}
+	if !result.Success {
+		t.Error("Because all conditions passed, this should have been a success")
+	}
+}
+
+func TestService_getIP(t *testing.T) {
+	conditionSuccess := Condition("[CONNECTED] == true")
+	service := Service{
+		Name:       "invalid-url-test",
+		URL:        "",
+		Conditions: []*Condition{&conditionSuccess},
+	}
+	result := &Result{}
+	service.getIP(result)
+	if len(result.Errors) == 0 {
+		t.Error("service.getIP(result) should've thrown an error because the URL is invalid, thus cannot be parsed")
+	}
+}
+
+func TestService_NeedsToReadBody(t *testing.T) {
+	statusCondition := Condition("[STATUS] == 200")
+	bodyCondition := Condition("[BODY].status == UP")
+	bodyConditionWithLength := Condition("len([BODY].tags) > 0")
+	if (&Service{Conditions: []*Condition{&statusCondition}}).needsToReadBody() {
+		t.Error("expected false, got true")
+	}
+	if !(&Service{Conditions: []*Condition{&bodyCondition}}).needsToReadBody() {
+		t.Error("expected true, got false")
+	}
+	if !(&Service{Conditions: []*Condition{&bodyConditionWithLength}}).needsToReadBody() {
+		t.Error("expected true, got false")
+	}
+	if !(&Service{Conditions: []*Condition{&statusCondition, &bodyCondition}}).needsToReadBody() {
+		t.Error("expected true, got false")
+	}
+	if !(&Service{Conditions: []*Condition{&bodyCondition, &statusCondition}}).needsToReadBody() {
+		t.Error("expected true, got false")
+	}
+	if !(&Service{Conditions: []*Condition{&bodyConditionWithLength, &statusCondition}}).needsToReadBody() {
+		t.Error("expected true, got false")
+	}
+}

core/types.go

@@ -1,27 +0,0 @@
-package core
-
-import (
-	"time"
-)
-
-type HealthStatus struct {
-	Status  string `json:"status"`
-	Message string `json:"message,omitempty"`
-}
-
-type Result struct {
-	HttpStatus       int                `json:"status"`
-	Body             []byte             `json:"-"`
-	Hostname         string             `json:"hostname"`
-	Ip               string             `json:"-"`
-	Duration         time.Duration      `json:"duration"`
-	Errors           []string           `json:"errors"`
-	ConditionResults []*ConditionResult `json:"condition-results"`
-	Success          bool               `json:"success"`
-	Timestamp        time.Time          `json:"timestamp"`
-}
-
-type ConditionResult struct {
-	Condition string `json:"condition"`
-	Success   bool   `json:"success"`
-}

core/uptime.go

@@ -0,0 +1,152 @@
+package core
+
+import (
+	"log"
+	"time"
+)
+
+const (
+	numberOfHoursInTenDays = 10 * 24
+	sevenDays              = 7 * 24 * time.Hour
+)
+
+// Uptime is the struct that contains the relevant data for calculating the uptime as well as the uptime itself
+// and some other statistics
+type Uptime struct {
+	LastSevenDays       float64 `json:"7d"`  // Uptime percentage over the past 7 days
+	LastTwentyFourHours float64 `json:"24h"` // Uptime percentage over the past 24 hours
+	LastHour            float64 `json:"1h"`  // Uptime percentage over the past hour
+
+	// SuccessfulExecutionsPerHour is a map containing the number of successes (value)
+	// for every hourly unix timestamps (key)
+	// Deprecated
+	SuccessfulExecutionsPerHour map[int64]uint64 `json:"-"`
+
+	// TotalExecutionsPerHour is a map containing the total number of checks (value)
+	// for every hourly unix timestamps (key)
+	// Deprecated
+	TotalExecutionsPerHour map[int64]uint64 `json:"-"`
+
+	// HourlyStatistics is a map containing metrics collected (value) for every hourly unix timestamps (key)
+	HourlyStatistics map[int64]*HourlyUptimeStatistics `json:"-"`
+}
+
+// HourlyUptimeStatistics is a struct containing all metrics collected over the course of an hour
+type HourlyUptimeStatistics struct {
+	TotalExecutions             uint64 // Total number of checks
+	SuccessfulExecutions        uint64 // Number of successful executions
+	TotalExecutionsResponseTime uint64 // Total response time for all executions
+}
+
+// NewUptime creates a new Uptime
+func NewUptime() *Uptime {
+	return &Uptime{
+		HourlyStatistics: make(map[int64]*HourlyUptimeStatistics),
+	}
+}
+
+// ProcessResult processes the result by extracting the relevant from the result and recalculating the uptime
+// if necessary
+func (uptime *Uptime) ProcessResult(result *Result) {
+	// XXX: Remove this on v3.0.0
+	if len(uptime.SuccessfulExecutionsPerHour) != 0 || len(uptime.TotalExecutionsPerHour) != 0 {
+		uptime.migrateToHourlyStatistics()
+	}
+	if uptime.HourlyStatistics == nil {
+		uptime.HourlyStatistics = make(map[int64]*HourlyUptimeStatistics)
+	}
+	unixTimestampFlooredAtHour := result.Timestamp.Unix() - (result.Timestamp.Unix() % 3600)
+	hourlyStats, _ := uptime.HourlyStatistics[unixTimestampFlooredAtHour]
+	if hourlyStats == nil {
+		hourlyStats = &HourlyUptimeStatistics{}
+		uptime.HourlyStatistics[unixTimestampFlooredAtHour] = hourlyStats
+	}
+	if result.Success {
+		hourlyStats.SuccessfulExecutions++
+	}
+	hourlyStats.TotalExecutions++
+	hourlyStats.TotalExecutionsResponseTime += uint64(result.Duration.Milliseconds())
+	// Clean up only when we're starting to have too many useless keys
+	// Note that this is only triggered when there are more entries than there should be after
+	// 10 days, despite the fact that we are deleting everything that's older than 7 days.
+	// This is to prevent re-iterating on every `ProcessResult` as soon as the uptime has been logged for 7 days.
+	if len(uptime.HourlyStatistics) > numberOfHoursInTenDays {
+		sevenDaysAgo := time.Now().Add(-(sevenDays + time.Hour)).Unix()
+		for hourlyUnixTimestamp := range uptime.HourlyStatistics {
+			if sevenDaysAgo > hourlyUnixTimestamp {
+				delete(uptime.HourlyStatistics, hourlyUnixTimestamp)
+			}
+		}
+	}
+	if result.Success {
+		// Recalculate uptime if at least one of the 1h, 24h or 7d uptime are not 100%
+		// If they're all 100%, then recalculating the uptime would be useless unless
+		// the result added was a failure (!result.Success)
+		if uptime.LastSevenDays != 1 || uptime.LastTwentyFourHours != 1 || uptime.LastHour != 1 {
+			uptime.recalculate()
+		}
+	} else {
+		// Recalculate uptime if at least one of the 1h, 24h or 7d uptime are not 0%
+		// If they're all 0%, then recalculating the uptime would be useless unless
+		// the result added was a success (result.Success)
+		if uptime.LastSevenDays != 0 || uptime.LastTwentyFourHours != 0 || uptime.LastHour != 0 {
+			uptime.recalculate()
+		}
+	}
+}
+
+func (uptime *Uptime) recalculate() {
+	uptimeBrackets := make(map[string]uint64)
+	now := time.Now()
+	// The oldest uptime bracket starts 7 days ago, so we'll start from there
+	timestamp := now.Add(-sevenDays)
+	for now.Sub(timestamp) >= 0 {
+		hourlyUnixTimestamp := timestamp.Unix() - (timestamp.Unix() % 3600)
+		hourlyStats := uptime.HourlyStatistics[hourlyUnixTimestamp]
+		if hourlyStats == nil || hourlyStats.TotalExecutions == 0 {
+			timestamp = timestamp.Add(time.Hour)
+			continue
+		}
+		uptimeBrackets["7d_success"] += hourlyStats.SuccessfulExecutions
+		uptimeBrackets["7d_total"] += hourlyStats.TotalExecutions
+		if now.Sub(timestamp) <= 24*time.Hour {
+			uptimeBrackets["24h_success"] += hourlyStats.SuccessfulExecutions
+			uptimeBrackets["24h_total"] += hourlyStats.TotalExecutions
+		}
+		if now.Sub(timestamp) <= time.Hour {
+			uptimeBrackets["1h_success"] += hourlyStats.SuccessfulExecutions
+			uptimeBrackets["1h_total"] += hourlyStats.TotalExecutions
+		}
+		timestamp = timestamp.Add(time.Hour)
+	}
+	if uptimeBrackets["7d_total"] > 0 {
+		uptime.LastSevenDays = float64(uptimeBrackets["7d_success"]) / float64(uptimeBrackets["7d_total"])
+	}
+	if uptimeBrackets["24h_total"] > 0 {
+		uptime.LastTwentyFourHours = float64(uptimeBrackets["24h_success"]) / float64(uptimeBrackets["24h_total"])
+	}
+	if uptimeBrackets["1h_total"] > 0 {
+		uptime.LastHour = float64(uptimeBrackets["1h_success"]) / float64(uptimeBrackets["1h_total"])
+	}
+}
+
+// XXX: Remove this on v3.0.0
+// Deprecated
+func (uptime *Uptime) migrateToHourlyStatistics() {
+	log.Println("[migrateToHourlyStatistics] Got", len(uptime.SuccessfulExecutionsPerHour), "entries for successful executions and", len(uptime.TotalExecutionsPerHour), "entries for total executions")
+	uptime.HourlyStatistics = make(map[int64]*HourlyUptimeStatistics)
+	for hourlyUnixTimestamp, totalExecutions := range uptime.TotalExecutionsPerHour {
+		if totalExecutions == 0 {
+			log.Println("[migrateToHourlyStatistics] Skipping entry at", hourlyUnixTimestamp, "because total number of executions is 0")
+			continue
+		}
+		uptime.HourlyStatistics[hourlyUnixTimestamp] = &HourlyUptimeStatistics{
+			TotalExecutions:             totalExecutions,
+			SuccessfulExecutions:        uptime.SuccessfulExecutionsPerHour[hourlyUnixTimestamp],
+			TotalExecutionsResponseTime: 0,
+		}
+	}
+	log.Println("[migrateToHourlyStatistics] Migrated", len(uptime.HourlyStatistics), "entries")
+	uptime.SuccessfulExecutionsPerHour = nil
+	uptime.TotalExecutionsPerHour = nil
+}

core/uptime_bench_test.go

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

core/uptime_test.go

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

core/util.go

@@ -1,74 +0,0 @@
-package core
-
-import (
-	"fmt"
-	"github.com/TwinProduction/gatus/jsonpath"
-	"strconv"
-	"strings"
-)
-
-const (
-	StatusPlaceholder       = "[STATUS]"
-	IPPlaceHolder           = "[IP]"
-	ResponseTimePlaceHolder = "[RESPONSE_TIME]"
-	BodyPlaceHolder         = "[BODY]"
-
-	LengthFunctionPrefix = "len("
-	FunctionSuffix       = ")"
-
-	InvalidConditionElementSuffix = "(INVALID)"
-)
-
-func sanitizeAndResolve(list []string, result *Result) []string {
-	var sanitizedList []string
-	body := strings.TrimSpace(string(result.Body))
-	for _, element := range list {
-		element = strings.TrimSpace(element)
-		switch strings.ToUpper(element) {
-		case StatusPlaceholder:
-			element = strconv.Itoa(result.HttpStatus)
-		case IPPlaceHolder:
-			element = result.Ip
-		case ResponseTimePlaceHolder:
-			element = strconv.Itoa(int(result.Duration.Milliseconds()))
-		case BodyPlaceHolder:
-			element = body
-		default:
-			// if starts with BodyPlaceHolder, then evaluate json path
-			if strings.Contains(element, BodyPlaceHolder) {
-				wantLength := false
-				if strings.HasPrefix(element, LengthFunctionPrefix) && strings.HasSuffix(element, FunctionSuffix) {
-					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)
-				if err != nil {
-					result.Errors = append(result.Errors, err.Error())
-					element = fmt.Sprintf("%s %s", element, InvalidConditionElementSuffix)
-				} else {
-					if wantLength {
-						element = fmt.Sprintf("%d", resolvedElementLength)
-					} else {
-						element = resolvedElement
-					}
-				}
-			}
-		}
-		sanitizedList = append(sanitizedList, element)
-	}
-	return sanitizedList
-}
-
-func sanitizeAndResolveNumerical(list []string, result *Result) []int {
-	var sanitizedNumbers []int
-	sanitizedList := sanitizeAndResolve(list, result)
-	for _, element := range sanitizedList {
-		if number, err := strconv.Atoi(element); err != nil {
-			// Default to 0 if the string couldn't be converted to an integer
-			sanitizedNumbers = append(sanitizedNumbers, 0)
-		} else {
-			sanitizedNumbers = append(sanitizedNumbers, number)
-		}
-	}
-	return sanitizedNumbers
-}

docs/pagerduty-integration-guide.md

@@ -0,0 +1,74 @@
+# PagerDuty + Gatus Integration Benefits
+- Notify on-call responders based on alerts sent from Gatus.
+- Incidents will automatically resolve in PagerDuty when the service that caused the incident in Gatus returns to a healthy state.
+
+
+# How it Works
+- Services that do not meet the user-specified conditions and that are configured with alerts of type `pagerduty` will trigger a new incident on the corresponding PagerDuty service when the alert's defined `failure-threshold` has been reached.
+- Once the unhealthy services have returned to a healthy state for the number of executions defined in `success-threshold`, the previously triggered incident will be automatically resolved.
+
+
+# Requirements
+- PagerDuty integrations require an Admin base role for account authorization. If you do not have this role, please reach out to an Admin or Account Owner within your organization to configure the integration.
+
+
+# Support
+If you need help with this integration, please create an issue at https://github.com/TwinProduction/gatus/issues
+
+
+# Integration Walkthrough
+## In PagerDuty
+### Integrating With a PagerDuty Service
+1. From the **Configuration** menu, select **Services**.
+2. There are two ways to add an integration to a service:
+   * **If you are adding your integration to an existing service**: Click the **name** of the service you want to add the integration to. Then, select the **Integrations** tab and click the **New Integration** button.
+   * **If you are creating a new service for your integration**: Please read our documentation in section [Configuring Services and Integrations](https://support.pagerduty.com/docs/services-and-integrations#section-configuring-services-and-integrations) and follow the steps outlined in the [Create a New Service](https://support.pagerduty.com/docs/services-and-integrations#section-create-a-new-service) section, selecting **Gatus** as the **Integration Type** in step 4. Continue with the In Gatus section (below) once you have finished these steps.
+3. Enter an **Integration Name** in the format `gatus-service-name` (e.g. `Gatus-Shopping-Cart`) and select **Gatus** from the Integration Type menu.
+4. Click the **Add Integration** button to save your new integration. You will be redirected to the Integrations tab for your service.
+5. An **Integration Key** will be generated on this screen. Keep this key saved in a safe place, as it will be used when you configure the integration with **Gatus** in the next section.
+![PagerDuty Integration Key](https://raw.githubusercontent.com/TwinProduction/gatus/master/.github/assets/pagerduty-integration-key.png)
+
+
+## In Gatus
+In your configuration file, you must first specify the integration key at `alerting.pagerduty.integration-key`, like so:
+```yaml
+alerting:
+  pagerduty: 
+    integration-key: "********************************"
+```
+You can now add alerts of type `pagerduty` in the services you've defined, like so:
+```yaml
+services:
+  - name: twinnation
+    interval: 30s
+    url: "https://twinnation.org/health"
+    alerts:
+      - type: pagerduty
+        enabled: true
+        failure-threshold: 3
+        success-threshold: 5
+        description: "healthcheck failed 3 times in a row"
+        send-on-resolved: true
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 300"
+```
+
+The sample above will do the following:
+- Send a request to the `https://twinnation.org/health` (`services[].url`) specified every **30s** (`services[].interval`)
+- Evaluate the conditions to determine whether the service is "healthy" or not
+- **If all conditions are not met 3 (`services[].alerts[].failure-threshold`) times in a row**: Gatus will create a new incident
+- **If, after an incident has been triggered, all conditions are met 5 (`services[].alerts[].success-threshold`) times in a row _AND_ `services[].alerts[].send-on-resolved` is set to `true`**: Gatus will resolve the triggered incident
+
+It is highly recommended to set `services[].alerts[].send-on-resolved` to true for alerts of type `pagerduty`.
+
+
+# How to Uninstall
+1. Navigate to the PagerDuty service you'd like to uninstall the Gatus integration from
+2. Click on the **Integration** tab
+3. Click on the **Gatus** integration
+4. Click on **Delete Integration**
+
+While the above will prevent incidents from being created, you are also highly encouraged to disable the alerts
+in your Gatus configuration files or simply remove the integration key from the configuration file.

example/docker-compose-mattermost/config.yaml

@@ -0,0 +1,16 @@
+alerting:
+  mattermost:
+    webhook-url: "http://mattermost:8065/hooks/tokengoeshere"
+    insecure: true
+
+services:
+  - name: example
+    url: http://example.org
+    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

@@ -0,0 +1,24 @@
+version: "3.8"
+
+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

example/docker-compose/config.yaml

@@ -0,0 +1,6 @@
+services:
+  - name: example
+    url: http://example.org
+    interval: 30s
+    conditions:
+      - "[STATUS] == 200"

example/docker-compose/docker-compose.yml

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

example/kubernetes-with-auto-discovery/gatus.yaml

@@ -0,0 +1,109 @@
+apiVersion: v1
+data:
+  config.yaml: |
+    kubernetes:
+      cluster-mode: "in"
+      auto-discover: true
+      excluded-service-suffixes:
+        - canary
+      service-template:
+        interval: 30s
+        conditions:
+          - "[STATUS] == 200"
+      namespaces:
+        - name: default
+          hostname-suffix: ".default.svc.cluster.local"
+          target-path: "/health"
+          excluded-services:
+            - gatus
+kind: ConfigMap
+metadata:
+  name: gatus
+  namespace: kube-system
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: gatus
+rules:
+  - apiGroups:
+      - ""
+    resources:
+      - services
+    verbs:
+      - list
+      - get
+---
+apiVersion: v1
+automountServiceAccountToken: true
+kind: ServiceAccount
+metadata:
+  name: gatus
+  namespace: kube-system
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: gatus
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: gatus
+subjects:
+  - kind: ServiceAccount
+    name: gatus
+    namespace: kube-system
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: gatus
+  namespace: kube-system
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      k8s-app: gatus
+  template:
+    metadata:
+      labels:
+        k8s-app: gatus
+      name: gatus
+      namespace: kube-system
+    spec:
+      containers:
+        - image: twinproduction/gatus
+          imagePullPolicy: IfNotPresent
+          name: gatus
+          ports:
+            - containerPort: 8080
+              name: http
+              protocol: TCP
+          resources:
+            limits:
+              cpu: 250m
+              memory: 100M
+            requests:
+              cpu: 50m
+              memory: 30M
+          volumeMounts:
+            - mountPath: /config
+              name: gatus-config
+      volumes:
+        - configMap:
+            name: gatus
+          name: gatus-config
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: gatus
+  namespace: kube-system
+spec:
+  ports:
+    - name: http
+      port: 8080
+      protocol: TCP
+      targetPort: 8080
+  selector:
+    k8s-app: gatus

example/kubernetes/gatus.yaml

@@ -13,6 +13,16 @@ data:
         interval: 5m
         conditions:
           - "[STATUS] == 200"
+      - name: cat-fact
+        url: "https://cat-fact.herokuapp.com/facts/random"
+        interval: 5m
+        conditions:
+          - "[STATUS] == 200"
+          - "[BODY].deleted == false"
+          - "len([BODY].text) > 0"
+          - "[BODY].text == pat(*cat*)"
+          - "[STATUS] == pat(2*)"
+          - "[CONNECTED] == true"
       - name: Example
         url: https://example.com/
         conditions:
@@ -49,11 +59,11 @@ spec:
               protocol: TCP
           resources:
             limits:
-              cpu: 50m
-              memory: 50M
+              cpu: 250m
+              memory: 100M
             requests:
-              cpu: 20m
-              memory: 20M
+              cpu: 50m
+              memory: 30M
           volumeMounts:
             - mountPath: /config
               name: gatus-config

go.mod

@@ -1,8 +1,26 @@
 module github.com/TwinProduction/gatus
 
-go 1.15
+go 1.16
 
 require (
-	github.com/prometheus/client_golang v1.2.1
-	gopkg.in/yaml.v2 v2.2.2
+	cloud.google.com/go v0.74.0 // indirect
+	github.com/TwinProduction/gocache v1.2.1
+	github.com/TwinProduction/health v1.0.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
+	github.com/imdario/mergo v0.3.11 // indirect
+	github.com/miekg/dns v1.1.35
+	github.com/prometheus/client_golang v1.9.0
+	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad // indirect
+	golang.org/x/net v0.0.0-20201224014010-6772e930b67b // indirect
+	golang.org/x/sys v0.0.0-20201223074533-0d417f636930 // indirect
+	golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf // indirect
+	golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 // indirect
+	gopkg.in/yaml.v2 v2.4.0
+	k8s.io/api v0.18.14
+	k8s.io/apimachinery v0.18.14
+	k8s.io/client-go v0.18.14
 )
+
+replace k8s.io/client-go => k8s.io/client-go v0.18.14

go.sum

@@ -1,79 +1,824 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
+cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
+cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
+cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
+cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
+cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
+cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
+cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI=
+cloud.google.com/go v0.74.0 h1:kpgPA77kSSbjSs+fWHkPTxQ6J5Z2Qkruo5jfXEkHxNQ=
+cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
+cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
+cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
+cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
+cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
+cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
+cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+github.com/Azure/go-autorest/autorest v0.9.0/go.mod h1:xyHB1BMZT0cuDHU7I0+g046+BFDTQ8rEZB0s4Yfa6bI=
+github.com/Azure/go-autorest/autorest/adal v0.5.0/go.mod h1:8Z9fGy2MpX0PvDjB1pEgQTmVqjGhiHBW7RJJEciWzS0=
+github.com/Azure/go-autorest/autorest/date v0.1.0/go.mod h1:plvfp3oPSKwf2DNjlBjWF/7vwR+cUD/ELuzDCXwHUVA=
+github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
+github.com/Azure/go-autorest/autorest/mocks v0.2.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
+github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc=
+github.com/Azure/go-autorest/tracing v0.5.0/go.mod h1:r/s2XiOKccPW3HrqB+W0TQzfbtp2fGCgRFtBroKn4Dk=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
+github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ=
+github.com/PuerkitoBio/purell v1.0.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
+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 v1.2.1 h1:NAdMwO9SQEZFmX69YWx6fzhwb6fHakkLri0451c+V1w=
+github.com/TwinProduction/gocache v1.2.1/go.mod h1:6zkBoLjrFLkIISwkZTgLy67qliCGSon1xpORM4Ri5HM=
+github.com/TwinProduction/health v1.0.0 h1:TVyYTAORQQZ8LaptX8jCHZRCGCAO6e+oJx19BUIzQYY=
+github.com/TwinProduction/health v1.0.0/go.mod h1:ys4mYKUeEfYrWmkm60xLtPjTuLIEDQNBZaTZvenLG1c=
+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=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
+github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
+github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
+github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
+github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
+github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
+github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A=
+github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU=
+github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
+github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/cespare/xxhash/v2 v2.1.0 h1:yTUvW7Vhb89inJ+8irsUqiWjh8iT6sQPZiQzI6ReGkA=
-github.com/cespare/xxhash/v2 v2.1.0/go.mod h1:dgIUBU3pDso/gPgZ1osOZ0iQf77oPR28Tjxl5dIMyVM=
+github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ=
+github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
+github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
+github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
+github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZgvJUkLughtfhJv5dyTYa91l1fOUCrgjqmcifM=
+github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
+github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
+github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
+github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
+github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
+github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
+github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4safvEdbitLhGGK48rN6g=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
+github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4=
+github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
+github.com/go-openapi/jsonpointer v0.0.0-20160704185906-46af16f9f7b1/go.mod h1:+35s3my2LFTysnkMfxsJBAMHj/DoqoB9knIWoYG/Vk0=
+github.com/go-openapi/jsonreference v0.0.0-20160704190145-13c6e3589ad9/go.mod h1:W3Z9FmVs9qj+KR4zFKmDPGiLdk1D9Rlm7cyMvf57TTg=
+github.com/go-openapi/spec v0.0.0-20160808142527-6aced65f8501/go.mod h1:J8+jY1nAiCcj+friV/PDoE1/3eeccG9LYBs0tYvLOWc=
+github.com/go-openapi/swag v0.0.0-20160704191624-1d0bd113de87/go.mod h1:DXUve3Dpr1UfpPtxFw+EFuQ41HhCWZfha5jSVRG7C7I=
+github.com/go-ping/ping v0.0.0-20201115131931-3300c582a663 h1:jI2GiiRh+pPbey52EVmbU6kuLiXqwy4CXZ4gwUBj8Y0=
+github.com/go-ping/ping v0.0.0-20201115131931-3300c582a663/go.mod h1:35JbSyV/BYqHwwRA6Zr1uVDm1637YlNOU61wI797NPI=
+github.com/go-redis/redis v6.15.9+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=
+github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
+github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls=
+github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
+github.com/golang/protobuf v0.0.0-20161109072736-4bd1920723d7/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.4 h1:L8R9j+yAqZuZjsqh/z+F1NCffTKKLShY6zXTItVIZ8M=
+github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
+github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
+github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY=
+github.com/googleapis/gnostic v0.1.0 h1:rVsPeBmXbYv4If/cumu1AzZPwV58q433hvONV1UEZoI=
+github.com/googleapis/gnostic v0.1.0/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY=
+github.com/gophercloud/gophercloud v0.1.0/go.mod h1:vxM41WHh5uqHVBMZHzuwNOHh8XEoIEcSTewFxm1c5g8=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
+github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
+github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
+github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
+github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
+github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE=
+github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
+github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
+github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU=
+github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
+github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
+github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
+github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
+github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
+github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg=
+github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
+github.com/imdario/mergo v0.3.11 h1:3tnifQM4i+fbajXKBHXWEH+KvNHqojZ778UH75j3bGA=
+github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo=
+github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.10 h1:Kz6Cvnvv2wGdaG/V8yMvfkmNiXq9Ya2KUv4rouJJr68=
+github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
+github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
+github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM=
+github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4=
+github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ=
+github.com/mailru/easyjson v0.0.0-20160728113105-d5b7844b561a/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/miekg/dns v1.1.35 h1:oTfOaDH+mZkdcgdIjH6yBajRGtIwcwcaR+rt23ZSrJs=
+github.com/miekg/dns v1.1.35/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
+github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
+github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
+github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg=
+github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
+github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw=
+github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg=
+github.com/nats-io/jwt v0.3.2/go.mod h1:/euKqTS1ZD+zzjYrY7pseZrTtWQSjujC7xjPc8wL6eU=
+github.com/nats-io/nats-server/v2 v2.1.2/go.mod h1:Afk+wRZqkMQs/p45uXdrVLuab3gwv3Z8C4HTBu8GD/k=
+github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w=
+github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
+github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
+github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs=
+github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
+github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
+github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.14.1/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
+github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/onsi/gomega v1.10.2/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=
+github.com/opentracing-contrib/go-observer v0.0.0-20170622124052-a52f23424492/go.mod h1:Ngi6UdF0k5OKD5t5wlmGhe/EDKPoUM3BXZSSfIuJbis=
+github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74=
+github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/openzipkin-contrib/zipkin-go-opentracing v0.4.5/go.mod h1:/wsWhb9smxSfWAKL3wpBW7V8scJMt8N8gnaMCS9E/cA=
+github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw=
+github.com/openzipkin/zipkin-go v0.2.1/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4=
+github.com/openzipkin/zipkin-go v0.2.2/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4=
+github.com/pact-foundation/pact-go v1.0.4/go.mod h1:uExwJY4kCzNPcHRj+hCR/HBbOOIwwtUjcrb0b5/5kLM=
+github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
+github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
+github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac=
+github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
+github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc=
+github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
-github.com/prometheus/client_golang v1.2.1 h1:JnMpQc6ppsNgw9QPAGF6Dod479itz7lvlsMzzNayLOI=
-github.com/prometheus/client_golang v1.2.1/go.mod h1:XMU6Z2MjaRKVu/dC1qupJI9SiNkDYzz3xecMgSW/F+U=
+github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og=
+github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
+github.com/prometheus/client_golang v1.9.0 h1:Rrch9mh17XcxvEu9D9DEpb4isxjGBtcevQjKvxPRQIU=
+github.com/prometheus/client_golang v1.9.0/go.mod h1:FqZLKOZnGdFAhOK4nqGHa7D66IdsO+O441Eve7ptJDU=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4 h1:gQz4mCbXsO+nc9n1hCxHcGA3Zx3Eo+UHZoInFGUIXNM=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
+github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/common v0.7.0 h1:L+1lyG48J1zAQXA3RBX/nG/B3gjlHq0zTt2tlbJLyCY=
 github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA=
+github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
+github.com/prometheus/common v0.15.0 h1:4fgOnadei3EZvgRwxJ7RMpG1k1pOZth5Pc13tyspaKM=
+github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
-github.com/prometheus/procfs v0.0.5 h1:3+auTFlqw+ZaQYJARz6ArODtkaIwtvBTx3N2NehQlL8=
-github.com/prometheus/procfs v0.0.5/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=
+github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
+github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.2.0 h1:wH4vA7pcjKuZzjF7lM8awk4fnuJO6idemZXoKnULUx4=
+github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E=
+github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
+github.com/sony/gobreaker v0.4.1/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY=
+github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
+github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
+github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
+github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/tidwall/redcon v1.3.2/go.mod h1:bdYBm4rlcWpst2XMwKVzWDF9CoUxEbUmM7CQrKeOZas=
+github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
+github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
+github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
+go.etcd.io/bbolt v1.3.5 h1:XAzx9gjCb0Rxj7EoqcClPD1d5ZBxZJk0jbuoPHenBt0=
+go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=
+go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg=
+go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
+go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
+go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
+go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
+go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad h1:DN0cp81fZ3njFcrLCytUHRSUkqBjfTo4Tx9RJTWs0EY=
+golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
+golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20170114055629-f2499483f923/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191004110552-13f9640d40b9/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200904194848-62affa334b73/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20201224014010-6772e930b67b h1:iFwSg7t5GZmB/Q5TjiEAsdoLDrdJRC1RiF2WhuV29Qw=
+golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5 h1:Lm4OryKCca1vehdsWogr9N4t7NfZxLbJoc/H0w4K4S4=
+golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9 h1:SQFwaSi55rU7vdNs9Yr0Z324VNlrF+0wMqRXT4St8ck=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20170830134202-bb24a47a89ea/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190209173611-3b5209105503/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191010194322-b09406accb47 h1:/XfQ9z7ib8eEJX2hdgFTZJ/ntt0swNk5oYBziWeTCvY=
-golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191022100944-742c48ecaeb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201214210602-f9fddec55a1e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201223074533-0d417f636930 h1:vRgIt+nup/B/BwIS0g2oC0haq0iqbV3ZA+u6+0TlNCo=
+golang.org/x/sys v0.0.0-20201223074533-0d417f636930/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf h1:MZ2shdL+ZM/XzY3ZGOnh4Nlpnxz5GSOhOmtHo3iPU6M=
+golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.0.0-20160726164857-2910a502d2bf/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.4 h1:0YWbFKbhXG/wIiuHDSKpS0Iy7FSA+u45VtBMfQcFTTc=
+golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 h1:Hir2P/De0WpUhtrKGGjvSb2YxUgyZ7EFOSLIcSSpiwE=
+golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181011042414-1f849cf54d09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
+golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
+google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
+google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg=
+google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
+google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190530194941-fb225487d101/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
+google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.22.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
+google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
+google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/cheggaaa/pb.v1 v1.0.25/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o=
+gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=
+gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
+gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
+gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+k8s.io/api v0.18.14 h1:tKRYsRhfL7Hfs60rFm8sNdhWydDuk7vnBqnt8uy+i/Q=
+k8s.io/api v0.18.14/go.mod h1:rMEP0KbqUY9Bm/nbQBXtUizL9r7XvD7IV1XhnGSHsy4=
+k8s.io/apimachinery v0.18.14 h1:wH0doJJajeG0qIuQD1/yo5JrBDAsZ3olqlNXZBiauVw=
+k8s.io/apimachinery v0.18.14/go.mod h1:PF5taHbXgTEJLU+xMypMmYTXTWPJ5LaW8bfsisxnEXk=
+k8s.io/client-go v0.18.14 h1:9dWb5D0dBsuc2umLPuWVE07rPDmBNsggW3vvctDyJII=
+k8s.io/client-go v0.18.14/go.mod h1:fpZHBter1MB6bs+GISolsmIRsGlBEJyd0mllE0H9f2Y=
+k8s.io/gengo v0.0.0-20190128074634-0689ccc1d7d6/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
+k8s.io/klog v0.0.0-20181102134211-b9b56d5dfc92/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
+k8s.io/klog v0.3.0/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
+k8s.io/klog v1.0.0 h1:Pt+yjF5aB1xDSVbau4VsWe+dQNzA0qv1LlXdC2dF6Q8=
+k8s.io/klog v1.0.0/go.mod h1:4Bi6QPql/J/LkTDqv7R/cd3hPo4k2DG6Ptcz060Ez5I=
+k8s.io/kube-openapi v0.0.0-20200410145947-61e04a5be9a6/go.mod h1:GRQhZsXIAJ1xR0C9bd8UpWHZ5plfAS9fzPjJuQ6JL3E=
+k8s.io/utils v0.0.0-20200324210504-a9aa75ae1b89 h1:d4vVOjXm687F1iLSP2q3lyPPuyvTUt3aVoBpi2DqRsU=
+k8s.io/utils v0.0.0-20200324210504-a9aa75ae1b89/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.0-20200116222232-67a7b8c61874/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.0 h1:dOmIZBMfhcHS09XZkMyUgkq5trg3/jRyJYFZUiaOp8E=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.0/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw=
+sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
+sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q=
+sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=
+sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU=

jsonpath/jsonpath_test.go

@@ -20,6 +20,15 @@ func TestEval(t *testing.T) {
 	}
 }
 
+func TestEvalWithInvalidPath(t *testing.T) {
+	path := "errors"
+	data := `{}`
+	_, _, err := Eval(path, []byte(data))
+	if err == nil {
+		t.Error("Expected error, but got", err)
+	}
+}
+
 func TestEvalWithLongSimpleWalk(t *testing.T) {
 	path := "long.simple.walk"
 	data := `{"long": {"simple": {"walk": "value"}}}`

k8s/client.go

@@ -0,0 +1,86 @@
+package k8s
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/TwinProduction/gatus/k8stest"
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+)
+
+// KubernetesClientAPI is a minimal interface for interacting with Kubernetes
+// Created mostly to make mocking the Kubernetes client easier
+type KubernetesClientAPI interface {
+	GetServices(namespace string) ([]v1.Service, error)
+}
+
+// KubernetesClient is a working implementation of KubernetesClientAPI
+type KubernetesClient struct {
+	client *kubernetes.Clientset
+}
+
+// GetServices returns a list of services for a given namespace
+func (k *KubernetesClient) GetServices(namespace string) ([]v1.Service, error) {
+	services, err := k.client.CoreV1().Services(namespace).List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		return nil, err
+	}
+	return services.Items, nil
+}
+
+// NewKubernetesClient creates a KubernetesClient
+func NewKubernetesClient(client *kubernetes.Clientset) *KubernetesClient {
+	return &KubernetesClient{
+		client: client,
+	}
+}
+
+// NewClient creates a Kubernetes client for the given ClusterMode
+func NewClient(clusterMode ClusterMode) (KubernetesClientAPI, error) {
+	var kubeConfig *rest.Config
+	var err error
+	switch clusterMode {
+	case ClusterModeIn:
+		kubeConfig, err = rest.InClusterConfig()
+	case ClusterModeOut:
+		kubeConfig, err = getOutClusterConfig()
+	case ClusterModeMock:
+		return k8stest.GetMockedKubernetesClient(), nil
+	default:
+		return nil, fmt.Errorf("invalid cluster mode, try '%s' or '%s'", ClusterModeIn, ClusterModeOut)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("unable to get cluster config for mode '%s': %s", clusterMode, err.Error())
+	}
+	client, err := kubernetes.NewForConfig(kubeConfig)
+	if err != nil {
+		return nil, err
+	}
+	return NewKubernetesClient(client), nil
+}
+
+func homeDir() string {
+	if h := os.Getenv("HOME"); h != "" {
+		return h
+	}
+	return os.Getenv("USERPROFILE") // windows
+}
+
+func getOutClusterConfig() (*rest.Config, error) {
+	var kubeConfig *string
+	if home := homeDir(); home != "" {
+		kubeConfig = flag.String("kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
+	} else {
+		kubeConfig = flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
+	}
+	flag.Parse()
+	return clientcmd.BuildConfigFromFlags("", *kubeConfig)
+}

k8s/config.go

@@ -0,0 +1,45 @@
+package k8s
+
+import "github.com/TwinProduction/gatus/core"
+
+// Config for Kubernetes auto-discovery
+type Config struct {
+	// AutoDiscover to discover services to monitor
+	AutoDiscover bool `yaml:"auto-discover"`
+
+	// ClusterMode is the mode to use to authenticate with Kubernetes
+	ClusterMode ClusterMode `yaml:"cluster-mode"`
+
+	// ServiceTemplate is the template for auto discovered services
+	ServiceTemplate *core.Service `yaml:"service-template"`
+
+	// ExcludedServiceSuffixes is a list of service suffixes that should be ignored
+	ExcludedServiceSuffixes []string `yaml:"excluded-service-suffixes"`
+
+	// Namespaces is a list of configurations for the namespaces from which services will be discovered
+	Namespaces []*NamespaceConfig `yaml:"namespaces"`
+}
+
+// NamespaceConfig level config
+type NamespaceConfig struct {
+	// Name of the namespace
+	Name string `yaml:"name"`
+
+	// ExcludedServices is a list of services to exclude from the auto discovery
+	ExcludedServices []string `yaml:"excluded-services"`
+
+	// HostnameSuffix is a suffix to append to each service name before calling TargetPath
+	HostnameSuffix string `yaml:"hostname-suffix"`
+
+	// TargetPath Path to append after the HostnameSuffix
+	TargetPath string `yaml:"target-path"`
+}
+
+// ClusterMode is the mode to use to authenticate to Kubernetes
+type ClusterMode string
+
+const (
+	ClusterModeIn   ClusterMode = "in"
+	ClusterModeOut  ClusterMode = "out"
+	ClusterModeMock ClusterMode = "mock"
+)

k8s/discovery.go

@@ -0,0 +1,54 @@
+package k8s
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/TwinProduction/gatus/core"
+)
+
+// DiscoverServices return discovered services
+func DiscoverServices(kubernetesConfig *Config) ([]*core.Service, error) {
+	client, err := NewClient(kubernetesConfig.ClusterMode)
+	if err != nil {
+		return nil, err
+	}
+	services := make([]*core.Service, 0)
+	for _, ns := range kubernetesConfig.Namespaces {
+		kubernetesServices, err := GetKubernetesServices(client, ns.Name)
+		if err != nil {
+			return nil, err
+		}
+	skipExcluded:
+		for _, service := range kubernetesServices {
+			for _, excludedServiceSuffix := range kubernetesConfig.ExcludedServiceSuffixes {
+				if strings.HasSuffix(service.Name, excludedServiceSuffix) {
+					continue skipExcluded
+				}
+			}
+			for _, excludedService := range ns.ExcludedServices {
+				if service.Name == excludedService {
+					continue skipExcluded
+				}
+			}
+			// XXX: try to extract health from liveness probe endpoint?
+			var url, port string
+			if len(service.Spec.Ports) > 0 && !strings.Contains(ns.HostnameSuffix, ":") && strings.HasSuffix(ns.HostnameSuffix, ".svc.cluster.local") {
+				port = fmt.Sprintf(":%d", service.Spec.Ports[0].Port)
+			}
+			// If the path starts with a / or starts with a port
+			if strings.HasPrefix(ns.TargetPath, "/") {
+				url = fmt.Sprintf("http://%s%s%s%s", service.Name, ns.HostnameSuffix, port, ns.TargetPath)
+			} else {
+				url = fmt.Sprintf("http://%s%s%s/%s", service.Name, ns.HostnameSuffix, port, ns.TargetPath)
+			}
+			services = append(services, &core.Service{
+				Name:       service.Name,
+				URL:        url,
+				Interval:   kubernetesConfig.ServiceTemplate.Interval,
+				Conditions: kubernetesConfig.ServiceTemplate.Conditions,
+			})
+		}
+	}
+	return services, nil
+}

k8s/k8s.go

@@ -0,0 +1,10 @@
+package k8s
+
+import (
+	"k8s.io/api/core/v1"
+)
+
+// GetKubernetesServices return a list of Services from the given namespace
+func GetKubernetesServices(client KubernetesClientAPI, namespace string) ([]v1.Service, error) {
+	return client.GetServices(namespace)
+}

k8stest/k8stest.go

@@ -0,0 +1,55 @@
+package k8stest
+
+import (
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var (
+	mockedKubernetesClient *MockKubernetesClient
+)
+
+// MockKubernetesClient is a mocked implementation of k8s.KubernetesClientApi
+type MockKubernetesClient struct {
+	Services []v1.Service
+}
+
+// GetServices returns a list of services in a given namespace
+func (mock *MockKubernetesClient) GetServices(namespace string) ([]v1.Service, error) {
+	var services []v1.Service
+	for _, service := range mock.Services {
+		if service.Namespace == namespace {
+			services = append(services, service)
+		}
+	}
+	return services, nil
+}
+
+// GetMockedKubernetesClient returns a mocked implementation of k8s.KubernetesClientApi
+func GetMockedKubernetesClient() *MockKubernetesClient {
+	if mockedKubernetesClient != nil {
+		return mockedKubernetesClient
+	}
+	InitializeMockedKubernetesClient(nil)
+	return mockedKubernetesClient
+}
+
+// InitializeMockedKubernetesClient initializes a MockKubernetesClient with a given list of services
+func InitializeMockedKubernetesClient(services []v1.Service) {
+	mockedKubernetesClient = &MockKubernetesClient{
+		Services: services,
+	}
+}
+
+// CreateTestServices creates a mocked service for testing purposes
+func CreateTestServices(name, namespace string, port int32) v1.Service {
+	return v1.Service{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+		Spec: v1.ServiceSpec{
+			Ports: []v1.ServicePort{{Name: "http", Protocol: v1.ProtocolTCP, Port: port}},
+		},
+	}
+}

main.go

@@ -1,37 +1,37 @@
 package main
 
 import (
-	"bytes"
-	"compress/gzip"
-	"github.com/TwinProduction/gatus/config"
-	"github.com/TwinProduction/gatus/watchdog"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"log"
-	"net/http"
 	"os"
-	"strings"
-	"time"
-)
+	"os/signal"
+	"syscall"
 
-const CacheTTL = 10 * time.Second
-
-var (
-	cachedServiceResults          []byte
-	cachedServiceResultsGzipped   []byte
-	cachedServiceResultsTimestamp time.Time
+	"github.com/TwinProduction/gatus/config"
+	"github.com/TwinProduction/gatus/controller"
+	"github.com/TwinProduction/gatus/storage"
+	"github.com/TwinProduction/gatus/watchdog"
 )
 
 func main() {
 	cfg := loadConfiguration()
-	http.HandleFunc("/api/v1/results", serviceResultsHandler)
-	http.HandleFunc("/health", healthHandler)
-	http.Handle("/", http.FileServer(http.Dir("./static")))
-	if cfg.Metrics {
-		http.Handle("/metrics", promhttp.Handler())
-	}
-	log.Println("[main][main] Listening on port 8080")
 	go watchdog.Monitor(cfg)
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	go controller.Handle()
+	// Wait for termination signal
+	sig := make(chan os.Signal, 1)
+	done := make(chan bool, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-sig
+		log.Println("Received termination signal, attempting to gracefully shut down")
+		controller.Shutdown()
+		err := storage.Get().Save()
+		if err != nil {
+			log.Println("Failed to save storage provider:", err.Error())
+		}
+		done <- true
+	}()
+	<-done
+	log.Println("Shutting down")
 }
 
 func loadConfiguration() *config.Config {
@@ -47,38 +47,3 @@ func loadConfiguration() *config.Config {
 	}
 	return config.Get()
 }
-
-func serviceResultsHandler(writer http.ResponseWriter, r *http.Request) {
-	if isExpired := cachedServiceResultsTimestamp.IsZero() || time.Now().Sub(cachedServiceResultsTimestamp) > CacheTTL; isExpired {
-		buffer := &bytes.Buffer{}
-		gzipWriter := gzip.NewWriter(buffer)
-		data, err := watchdog.GetJsonEncodedServiceResults()
-		if err != nil {
-			log.Printf("[main][serviceResultsHandler] Unable to marshal object to JSON: %s", err.Error())
-			writer.WriteHeader(http.StatusInternalServerError)
-			_, _ = writer.Write([]byte("Unable to marshal object to JSON"))
-			return
-		}
-		gzipWriter.Write(data)
-		gzipWriter.Close()
-		cachedServiceResults = data
-		cachedServiceResultsGzipped = buffer.Bytes()
-		cachedServiceResultsTimestamp = time.Now()
-	}
-	var data []byte
-	if strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
-		writer.Header().Set("Content-Encoding", "gzip")
-		data = cachedServiceResultsGzipped
-	} else {
-		data = cachedServiceResults
-	}
-	writer.Header().Add("Content-type", "application/json")
-	writer.WriteHeader(http.StatusOK)
-	_, _ = writer.Write(data)
-}
-
-func healthHandler(writer http.ResponseWriter, _ *http.Request) {
-	writer.Header().Add("Content-type", "application/json")
-	writer.WriteHeader(http.StatusOK)
-	_, _ = writer.Write([]byte("{\"status\":\"UP\"}"))
-}

metric/metric.go

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

pattern/pattern.go

@@ -0,0 +1,20 @@
+package pattern
+
+import (
+	"path/filepath"
+	"strings"
+)
+
+// Match checks whether a string matches a pattern
+func Match(pattern, s string) bool {
+	if pattern == "*" {
+		return true
+	}
+	// 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
+}

pattern/pattern_bench_test.go

@@ -0,0 +1,21 @@
+package pattern
+
+import "testing"
+
+func BenchmarkMatch(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		if !Match("*ing*", "livingroom") {
+			b.Error("should've matched")
+		}
+	}
+	b.ReportAllocs()
+}
+
+func BenchmarkMatchWithBackslash(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		if !Match("*ing*", "living\\room") {
+			b.Error("should've matched")
+		}
+	}
+	b.ReportAllocs()
+}

pattern/pattern_test.go

@@ -0,0 +1,43 @@
+package pattern
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestMatch(t *testing.T) {
+	testMatch(t, "*", "livingroom_123", true)
+	testMatch(t, "**", "livingroom_123", true)
+	testMatch(t, "living*", "livingroom_123", true)
+	testMatch(t, "*living*", "livingroom_123", true)
+	testMatch(t, "*123", "livingroom_123", true)
+	testMatch(t, "*_*", "livingroom_123", true)
+	testMatch(t, "living*_*3", "livingroom_123", true)
+	testMatch(t, "living*room_*3", "livingroom_123", true)
+	testMatch(t, "living*room_*3", "livingroom_123", true)
+	testMatch(t, "*vin*om*2*", "livingroom_123", true)
+	testMatch(t, "livingroom_123", "livingroom_123", true)
+	testMatch(t, "*livingroom_123*", "livingroom_123", true)
+	testMatch(t, "*test*", "\\test", true)
+	testMatch(t, "livingroom", "livingroom_123", false)
+	testMatch(t, "livingroom123", "livingroom_123", false)
+	testMatch(t, "what", "livingroom_123", false)
+	testMatch(t, "*what*", "livingroom_123", false)
+	testMatch(t, "*.*", "livingroom_123", false)
+	testMatch(t, "room*123", "livingroom_123", false)
+}
+
+func testMatch(t *testing.T, pattern, key string, expectedToMatch bool) {
+	t.Run(fmt.Sprintf("pattern '%s' from '%s'", pattern, key), func(t *testing.T) {
+		matched := Match(pattern, key)
+		if expectedToMatch {
+			if !matched {
+				t.Errorf("%s should've matched pattern '%s'", key, pattern)
+			}
+		} else {
+			if matched {
+				t.Errorf("%s shouldn't have matched pattern '%s'", key, pattern)
+			}
+		}
+	})
+}

security/handler.go

@@ -0,0 +1,20 @@
+package security
+
+import (
+	"net/http"
+	"strings"
+)
+
+// Handler takes care of security for a given handler with the given security configuratioon
+func Handler(handler http.HandlerFunc, security *Config) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		usernameEntered, passwordEntered, ok := r.BasicAuth()
+		if !ok || usernameEntered != security.Basic.Username || Sha512(passwordEntered) != strings.ToLower(security.Basic.PasswordSha512Hash) {
+			w.Header().Set("WWW-Authenticate", "Basic")
+			w.WriteHeader(http.StatusUnauthorized)
+			_, _ = w.Write([]byte("Unauthorized"))
+			return
+		}
+		handler(w, r)
+	}
+}

security/handler_test.go

@@ -0,0 +1,58 @@
+package security
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func mockHandler(writer http.ResponseWriter, _ *http.Request) {
+	writer.WriteHeader(200)
+}
+
+func TestHandlerWhenNotAuthenticated(t *testing.T) {
+	handler := Handler(mockHandler, &Config{&BasicConfig{
+		Username:           "john.doe",
+		PasswordSha512Hash: "6b97ed68d14eb3f1aa959ce5d49c7dc612e1eb1dafd73b1e705847483fd6a6c809f2ceb4e8df6ff9984c6298ff0285cace6614bf8daa9f0070101b6c89899e22",
+	}})
+	request, _ := http.NewRequest("GET", "/api/v1/results", nil)
+	responseRecorder := httptest.NewRecorder()
+
+	handler.ServeHTTP(responseRecorder, request)
+
+	if responseRecorder.Code != http.StatusUnauthorized {
+		t.Error("Expected code to be 401, but was", responseRecorder.Code)
+	}
+}
+
+func TestHandlerWhenAuthenticated(t *testing.T) {
+	handler := Handler(mockHandler, &Config{&BasicConfig{
+		Username:           "john.doe",
+		PasswordSha512Hash: "6b97ed68d14eb3f1aa959ce5d49c7dc612e1eb1dafd73b1e705847483fd6a6c809f2ceb4e8df6ff9984c6298ff0285cace6614bf8daa9f0070101b6c89899e22",
+	}})
+	request, _ := http.NewRequest("GET", "/api/v1/results", nil)
+	request.SetBasicAuth("john.doe", "hunter2")
+	responseRecorder := httptest.NewRecorder()
+
+	handler.ServeHTTP(responseRecorder, request)
+
+	if responseRecorder.Code != http.StatusOK {
+		t.Error("Expected code to be 200, but was", responseRecorder.Code)
+	}
+}
+
+func TestHandlerWhenAuthenticatedWithBadCredentials(t *testing.T) {
+	handler := Handler(mockHandler, &Config{&BasicConfig{
+		Username:           "john.doe",
+		PasswordSha512Hash: "6b97ed68d14eb3f1aa959ce5d49c7dc612e1eb1dafd73b1e705847483fd6a6c809f2ceb4e8df6ff9984c6298ff0285cace6614bf8daa9f0070101b6c89899e22",
+	}})
+	request, _ := http.NewRequest("GET", "/api/v1/results", nil)
+	request.SetBasicAuth("john.doe", "bad-password")
+	responseRecorder := httptest.NewRecorder()
+
+	handler.ServeHTTP(responseRecorder, request)
+
+	if responseRecorder.Code != http.StatusUnauthorized {
+		t.Error("Expected code to be 401, but was", responseRecorder.Code)
+	}
+}

security/security.go

@@ -0,0 +1,25 @@
+package security
+
+// Config is the security configuration for Gatus
+type Config struct {
+	Basic *BasicConfig `yaml:"basic"`
+}
+
+// IsValid returns whether the security configuration is valid or not
+func (c *Config) IsValid() bool {
+	return c.Basic != nil && c.Basic.IsValid()
+}
+
+// BasicConfig is the configuration for Basic authentication
+type BasicConfig struct {
+	// Username is the name which will need to be used for a successful authentication
+	Username string `yaml:"username"`
+
+	// PasswordSha512Hash is the SHA512 hash of the password which will need to be used for a successful authentication
+	PasswordSha512Hash string `yaml:"password-sha512"`
+}
+
+// IsValid returns whether the basic security configuration is valid or not
+func (c *BasicConfig) IsValid() bool {
+	return len(c.Username) > 0 && len(c.PasswordSha512Hash) == 128
+}

security/security_test.go

@@ -0,0 +1,23 @@
+package security
+
+import "testing"
+
+func TestBasicConfig_IsValid(t *testing.T) {
+	basicConfig := &BasicConfig{
+		Username:           "admin",
+		PasswordSha512Hash: Sha512("test"),
+	}
+	if !basicConfig.IsValid() {
+		t.Error("basicConfig should've been valid")
+	}
+}
+
+func TestBasicConfig_IsValidWhenPasswordIsInvalid(t *testing.T) {
+	basicConfig := &BasicConfig{
+		Username:           "admin",
+		PasswordSha512Hash: "",
+	}
+	if basicConfig.IsValid() {
+		t.Error("basicConfig shouldn't have been valid")
+	}
+}

security/sha512.go

@@ -0,0 +1,13 @@
+package security
+
+import (
+	"crypto/sha512"
+	"fmt"
+)
+
+// Sha512 hashes a provided string using SHA512 and returns the resulting hash as a string
+func Sha512(s string) string {
+	hash := sha512.New()
+	hash.Write([]byte(s))
+	return fmt.Sprintf("%x", hash.Sum(nil))
+}

security/sha512_test.go

@@ -0,0 +1,12 @@
+package security
+
+import "testing"
+
+func TestSha512(t *testing.T) {
+	input := "password"
+	expectedHash := "b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86"
+	hash := Sha512(input)
+	if hash != expectedHash {
+		t.Errorf("Expected hash to be '%s', but was '%s'", expectedHash, hash)
+	}
+}

static/index.html

@@ -1,288 +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="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
-	<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-ok {
-			display: inline-block;
-			width: 1%;
-			height: 20px;
-			margin-right: 4px;
-			background-color: #28a745;
-		}
-		.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;
-		}
-	</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="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
-	<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"></script>
-
-	<script>
-		let serviceStatuses = {};
-		let timerHandler = 0;
-		let userClickedStatus = false;
-
-		function showTooltip(serviceName, index, element) {
-			userClickedStatus = false;
-			clearTimeout(timerHandler);
-			let serviceResult = serviceStatuses[serviceName][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 createStatusBadge(serviceName, index, success) {
-			if (success) {
-				return "<span class='status badge badge-success' style='width: 5%' onmouseenter='showTooltip(\""+serviceName+"\", "+index+", this)' onmouseleave='fadeTooltip()' onclick='userClickedStatus = !userClickedStatus;'>&#10003;</span>";
-			}
-			return "<span class='status badge badge-danger' style='width: 5%' onmouseenter='showTooltip(\""+serviceName+"\", "+index+", this)' onmouseleave='fadeTooltip()' onclick='userClickedStatus = !userClickedStatus;'>X</span>";
-		}
-
-		function refreshResults() {
-			$.getJSON("/api/v1/results", function (data) {
-				// Update the table only if there's a change
-				if (JSON.stringify(serviceStatuses) !== JSON.stringify(data)) {
-					serviceStatuses = data;
-					buildTable();
-				}
-			});
-		}
-
-		function buildTable() {
-			let output = "";
-			for (let serviceName in serviceStatuses) {
-				let serviceStatusOverTime = "";
-				let hostname = serviceStatuses[serviceName][serviceStatuses[serviceName].length-1].hostname
-				let minResponseTime = null;
-				let maxResponseTime = null;
-				let newestTimestamp = null;
-				let oldestTimestamp = null;
-				for (let key in serviceStatuses[serviceName]) {
-					let serviceResult = serviceStatuses[serviceName][key];
-					serviceStatusOverTime = createStatusBadge(serviceName, key, 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;
-					}
-				}
-				output += ""
-					+ "<div class='container py-3 border-left border-right border-top border-black'>"
-					+ "  <div class='row mb-2'>"
-					+ "    <div class='col-md-10'>"
-					+ "      <span class='font-weight-bold'>" + serviceName + "</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>";
-			}
-			$("#results").html(output);
-		}
-
-		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;');
-		}
-
-		refreshResults();
-		setInterval(function() {
-			refreshResults();
-		}, 30000);
-	</script>
-</body>
-</html>