Add missing newline

Add Telegram Alerting (#102 )
Add comment for future breaking change
2021-03-30 20:01:22 -04:00 · 2021-03-30 19:38:34 -04:00 · 2021-03-27 21:22:34 -04:00 · 2021-03-26 18:28:41 -04:00 · 2021-03-25 21:01:03 -04:00 · 2021-03-23 19:53:49 -04:00
132 changed files with 8653 additions and 4849 deletions
--- a/.github/assets/telegram-alerts.png
+++ b/.github/assets/telegram-alerts.png
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -24,9 +24,9 @@ jobs:
        run: go build -mod vendor
      - name: Test
        # We're using "sudo" because one of the tests leverages ping, which requires super-user privileges.
-        # As for the "PATH=$PATH", we need it to use the same "go" executable that was configured by the "Set
-        # up Go" step (otherwise, it'd use sudo's "go" executable)
-        run: sudo "PATH=$PATH" go test -mod vendor ./... -race -coverprofile=coverage.txt -covermode=atomic
+        # 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:
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 .idea
 .vscode
-gatus
+gatus
+db.db
+config/config.yml
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2020 TwinProduction
+Copyright (c) 2021 TwinProduction

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

--- a/5
+++ b/5
@@ -8,4 +8,7 @@ build-frontend:
 	npm --prefix web/app run build

 run-frontend:
-	npm --prefix web/app run serve
+	npm --prefix web/app run serve
+
+test:
+	go test ./alerting/... ./client/... ./config/... ./controller/... ./core/... ./jsonpath/... ./pattern/... ./security/... ./storage/... ./util/... ./watchdog/... -cover
--- a/README.md
+++ b/README.md
@@ -7,8 +7,10 @@
 [![Docker pulls](https://img.shields.io/docker/pulls/twinproduction/gatus.svg)](https://cloud.docker.com/repository/docker/twinproduction/gatus)
 [![Follow TwinProduction](https://img.shields.io/github/followers/TwinProduction?label=Follow&style=social)](https://github.com/TwinProduction)

-A service health dashboard in Go that is meant to be used as a docker 
-image with a custom configuration file.
+Gatus is a health dashboard that gives you the ability to monitor your services using HTTP, ICMP, TCP, and even DNS
+queries as well as evaluate the result of said queries by using a list of conditions on values like the status code,
+the response time, the certificate expiration, the body and many others. The icing on top is that each of these health
+checks can be paired with alerting via Slack, PagerDuty and even Twilio.

 I personally deploy it in my Kubernetes cluster and let it monitor the status of my
 core applications: https://status.twinnation.org/
@@ -18,16 +20,18 @@ core applications: https://status.twinnation.org/

 - [Features](#features)
 - [Usage](#usage)
-  - [Configuration](#configuration)
+- [Configuration](#configuration)
  - [Conditions](#conditions)
    - [Placeholders](#placeholders)
    - [Functions](#functions)
  - [Alerting](#alerting)
    - [Configuring Slack alerts](#configuring-slack-alerts)
+    - [Configuring Discord alerts](#configuring-discord-alerts)
    - [Configuring PagerDuty alerts](#configuring-pagerduty-alerts)
    - [Configuring Twilio alerts](#configuring-twilio-alerts)
    - [Configuring Mattermost alerts](#configuring-mattermost-alerts)
    - [Configuring Messagebird alerts](#configuring-messagebird-alerts)    
+    - [Configuring Telegram alerts](#configuring-telegram-alerts)
    - [Configuring custom alerts](#configuring-custom-alerts)
  - [Kubernetes (ALPHA)](#kubernetes-alpha)
    - [Auto Discovery](#auto-discovery)
@@ -47,6 +51,7 @@ core applications: https://status.twinnation.org/
  - [Service groups](#service-groups)
  - [Exposing Gatus on a custom port](#exposing-gatus-on-a-custom-port)
  - [Uptime Badges (ALPHA)](#uptime-badges)
+  - [API](#API)


 ## Features
@@ -82,7 +87,7 @@ services:
      - "[RESPONSE_TIME] < 300"   # Response time must be under 300ms
  - name: example
    url: "https://example.org/"
-    interval: 30s
+    interval: 5m
    conditions:
      - "[STATUS] == 200"
 ```
@@ -91,58 +96,38 @@ This example would look like this:

 ![Simple example](.github/assets/example.png)

-Note that you can also add environment variables in the configuration file (i.e. `$DOMAIN`, `${DOMAIN}`)
+Note that you can also add environment variables in the configuration file (e.g. `$DOMAIN`, `${DOMAIN}`)


-### Configuration
+## Configuration

 | Parameter                                | Description                                                                   | Default        |
 |:---------------------------------------- |:----------------------------------------------------------------------------- |:-------------- |
 | `debug`                                  | Whether to enable debug logs                                                  | `false`        |
 | `metrics`                                | Whether to expose metrics at /metrics                                         | `false`        |
+| `storage`                                | Storage configuration                                                         | `{}`           |
+| `storage.file`                           | File to persist the data in. If not set, storage is in-memory only.           | `""`           |
 | `services`                               | List of services to monitor                                                   | Required `[]`  |
 | `services[].name`                        | Name of the service. Can be anything.                                         | Required `""`  |
 | `services[].group`                       | Group name. Used to group multiple services together on the dashboard. See [Service groups](#service-groups). | `""`           |
 | `services[].url`                         | URL to send the request to                                                    | Required `""`  |
 | `services[].method`                      | Request method                                                                | `GET`          |
 | `services[].insecure`                    | Whether to skip verifying the server's certificate chain and host name        | `false`        |
-| `services[].conditions`                  | Conditions used to determine the health of the service                        | `[]`           |
+| `services[].conditions`                  | Conditions used to determine the health of the service. See [Conditions](#conditions) | `[]`           |
 | `services[].interval`                    | Duration to wait between every status check                                   | `60s`          |
 | `services[].graphql`                     | Whether to wrap the body in a query param (`{"query":"$body"}`)               | `false`        |
 | `services[].body`                        | Request body                                                                  | `""`           |
 | `services[].headers`                     | Request headers                                                               | `{}`           |
-| `services[].dns`                         | Configuration for a service of type DNS. See [Monitoring using DNS queries](#monitoring-using-dns-queries)  | `""`           |
+| `services[].dns`                         | Configuration for a service of type DNS. See [Monitoring a service using DNS queries](#monitoring-a-service-using-dns-queries). | `""`           |
 | `services[].dns.query-type`              | Query type for DNS service                                                    | `""`           |
 | `services[].dns.query-name`              | Query name for DNS service                                                    | `""`           |
-| `services[].alerts[].type`               | Type of alert. Valid types: `slack`, `pagerduty`, `twilio`, `mattermost`, `messagebird`, `custom` | Required `""`  |
+| `services[].alerts[].type`               | Type of alert. Valid types: `slack`, `discord`m `pagerduty`, `twilio`, `mattermost`, `messagebird`, `custom` | Required `""`  |
 | `services[].alerts[].enabled`            | Whether to enable the alert                                                   | `false`        |
 | `services[].alerts[].failure-threshold`  | Number of failures in a row needed before triggering the alert                | `3`            |
 | `services[].alerts[].success-threshold`  | Number of successes in a row before an ongoing incident is marked as resolved | `2`            |
 | `services[].alerts[].send-on-resolved`   | Whether to send a notification once a triggered alert is marked as resolved   | `false`        |
 | `services[].alerts[].description`        | Description of the alert. Will be included in the alert sent                  | `""`           |
-| `alerting`                               | Configuration for alerting                                                    | `{}`           |
-| `alerting.slack`                         | Configuration for alerts of type `slack`                                      | `{}`           |
-| `alerting.slack.webhook-url`             | Slack Webhook URL                                                             | Required `""`  |
-| `alerting.pagerduty`                     | Configuration for alerts of type `pagerduty`                                  | `{}`           |
-| `alerting.pagerduty.integration-key`     | PagerDuty Events API v2 integration key.                                      | Required `""`  |
-| `alerting.twilio`                        | Settings for alerts of type `twilio`                                          | `{}`           |
-| `alerting.twilio.sid`                    | Twilio account SID                                                            | Required `""`  |
-| `alerting.twilio.token`                  | Twilio auth token                                                             | Required `""`  |
-| `alerting.twilio.from`                   | Number to send Twilio alerts from                                             | Required `""`  |
-| `alerting.twilio.to`                     | Number to send twilio alerts to                                               | Required `""`  |
-| `alerting.mattermost`                    | Configuration for alerts of type `mattermost`                                 | `{}`           |
-| `alerting.mattermost.webhook-url`        | Mattermost Webhook URL                                                        | Required `""`  |
-| `alerting.mattermost.insecure`           | Whether to skip verifying the server's certificate chain and host name        | `false`        |
-| `alerting.messagebird`                   | Settings for alerts of type `messagebird`                                     | `{}`           |
-| `alerting.messagebird.access-key`        | Messagebird access key                                                        | Required `""`  |
-| `alerting.messagebird.originator`        | The sender of the message                                                     | Required `""`  |
-| `alerting.messagebird.recipients`        | The recipients of the message                                                 | Required `""`  |
-| `alerting.custom`                        | Configuration for custom actions on failure or alerts                         | `{}`           |
-| `alerting.custom.url`                    | Custom alerting request url                                                   | Required `""`  |
-| `alerting.custom.method`                 | Request method                                                                | `GET`          |
-| `alerting.custom.insecure`               | Whether to skip verifying the server's certificate chain and host name        | `false`        |
-| `alerting.custom.body`                   | Custom alerting request body.                                                 | `""`           |
-| `alerting.custom.headers`                | Custom alerting request headers                                               | `{}`           |
+| `alerting`                               | Configuration for alerting. See [Alerting](#alerting)                         | `{}`           |
 | `security`                               | Security configuration                                                        | `{}`           |
 | `security.basic`                         | Basic authentication security configuration                                   | `{}`           |
 | `security.basic.username`                | Username for Basic authentication                                             | Required `""`  |
@@ -152,7 +137,8 @@ Note that you can also add environment variables in the configuration file (i.e.
 | `web.address`                            | Address to listen on                                                          | `0.0.0.0`      |
 | `web.port`                               | Port to listen on                                                             | `8080`         |

-For Kubernetes configuration, see [Kubernetes](#kubernetes-alpha)
+- For Kubernetes configuration, see [Kubernetes](#kubernetes-alpha).
+- For alerting configuration, see [Alerting](#alerting).


 ### Conditions
@@ -165,7 +151,7 @@ Here are some examples of conditions you can use:
 | `[STATUS] < 300`             | Status must lower than 300                              | 200, 201, 299              | 301, 302, ...  |
 | `[STATUS] <= 299`            | Status must be less than or equal to 299                | 200, 201, 299              | 301, 302, ...  |
 | `[STATUS] > 400`             | Status must be greater than 400                         | 401, 402, 403, 404         | 400, 200, ...  |
-| `[STATUS] == any(200, 429)`  | Status must be either 200 or 420                        | 200, 429                   | 201, 400, ...  |
+| `[STATUS] == any(200, 429)`  | Status must be either 200 or 429                        | 200, 429                   | 201, 400, ...  |
 | `[CONNECTED] == true`        | Connection to host must've been successful              | true, false                |  |
 | `[RESPONSE_TIME] < 500`      | Response time must be below 500ms                       | 100ms, 200ms, 300ms        | 500ms, 501ms   |
 | `[IP] == 127.0.0.1`          | Target IP must be 127.0.0.1                             | 127.0.0.1                  | 0.0.0.0        |
@@ -175,6 +161,8 @@ Here are some examples of conditions you can use:
 | `[BODY].age == [BODY].id`    | JSONPath value of `$.age` is equal JSONPath `$.id`      | `{"age":1,"id":1}`         |  |
 | `len([BODY].data) < 5`       | Array at JSONPath `$.data` has less than 5 elements     | `{"data":[{"id":1}]}`      |  |
 | `len([BODY].name) == 8`      | String at JSONPath `$.name` has a length of 8           | `{"name":"john.doe"}`      | `{"name":"bob"}` |
+| `has([BODY].errors) == false` | JSONPath `$.errors` does not exist                     | `{"name":"john.doe"}`      | `{"errors":[]}` |
+| `has([BODY].users) == true`  | JSONPath `$.users` exists                               | `{"users":[]}`             | `{}` |
 | `[BODY].name == pat(john*)`  | String at JSONPath `$.name` matches pattern `john*`     | `{"name":"john.doe"}`      | `{"name":"bob"}` |
 | `[BODY].id == any(1, 2)`     | Value at JSONPath `$.id` is equal to `1` or `2`         | 1, 2                       | 3, 4, 5 |
 | `[CERTIFICATE_EXPIRATION] > 48h` | Certificate expiration is more than 48h away        | 49h, 50h, 123h             | 1h, 24h, ... |
@@ -198,6 +186,7 @@ Here are some examples of conditions you can use:
 | Function   | Description                                                                                                      | Example                    |
 |:-----------|:---------------------------------------------------------------------------------------------------------------- |:-------------------------- |
 | `len`      | Returns the length of the object/slice. Works only with the `[BODY]` placeholder.                                | `len([BODY].username) > 8`
+| `has`      | Returns `true` or `false` based on whether a given path is valid. Works only with the `[BODY]` placeholder.      | `has([BODY].errors) == false`
 | `pat`      | Specifies that the string passed as parameter should be evaluated as a pattern. Works only with `==` and `!=`.   | `[IP] == pat(192.168.*)`
 | `any`      | Specifies that any one of the values passed as parameters is a valid value. Works only with `==` and `!=`.       | `[BODY].ip == any(127.0.0.1, ::1)`

@@ -206,6 +195,42 @@ Here are some examples of conditions you can use:

 ### Alerting

+Gatus supports multiple alerting providers, such as Slack and PagerDuty, and supports different alerts for each
+individual services with configurable descriptions and thresholds.
+
+Note that if an alerting provider is not configured properly, all alerts configured with the provider's type will be
+ignored.
+
+| Parameter                                | Description                                                                   | Default        |
+|:---------------------------------------- |:----------------------------------------------------------------------------- |:-------------- |
+| `alerting.slack`                         | Configuration for alerts of type `slack`                                      | `{}`           |
+| `alerting.slack.webhook-url`             | Slack Webhook URL                                                             | Required `""`  |
+| `alerting.discord`                       | Configuration for alerts of type `discord`                                    | `{}`           |
+| `alerting.discord.webhook-url`           | Discord Webhook URL                                                           | Required `""`  |
+| `alerting.pagerduty`                     | Configuration for alerts of type `pagerduty`                                  | `{}`           |
+| `alerting.pagerduty.integration-key`     | PagerDuty Events API v2 integration key.                                      | Required `""`  |
+| `alerting.twilio`                        | Settings for alerts of type `twilio`                                          | `{}`           |
+| `alerting.twilio.sid`                    | Twilio account SID                                                            | Required `""`  |
+| `alerting.twilio.token`                  | Twilio auth token                                                             | Required `""`  |
+| `alerting.twilio.from`                   | Number to send Twilio alerts from                                             | Required `""`  |
+| `alerting.twilio.to`                     | Number to send twilio alerts to                                               | Required `""`  |
+| `alerting.mattermost`                    | Configuration for alerts of type `mattermost`                                 | `{}`           |
+| `alerting.mattermost.webhook-url`        | Mattermost Webhook URL                                                        | Required `""`  |
+| `alerting.mattermost.insecure`           | Whether to skip verifying the server's certificate chain and host name        | `false`        |
+| `alerting.messagebird`                   | Settings for alerts of type `messagebird`                                     | `{}`           |
+| `alerting.messagebird.access-key`        | Messagebird access key                                                        | Required `""`  |
+| `alerting.messagebird.originator`        | The sender of the message                                                     | Required `""`  |
+| `alerting.messagebird.recipients`        | The recipients of the message                                                 | Required `""`  |
+| `alerting.telegram`                      | Configuration for alerts of type `telegram`                                   | `{}`           |
+| `alerting.telegram.token`                | Telegram Bot Token                                                            | Required `""`  |
+| `alerting.telegram.id`                   | Telegram User ID                                                              | Required `""`  |
+| `alerting.custom`                        | Configuration for custom actions on failure or alerts                         | `{}`           |
+| `alerting.custom.url`                    | Custom alerting request url                                                   | Required `""`  |
+| `alerting.custom.method`                 | Request method                                                                | `GET`          |
+| `alerting.custom.insecure`               | Whether to skip verifying the server's certificate chain and host name        | `false`        |
+| `alerting.custom.body`                   | Custom alerting request body.                                                 | `""`           |
+| `alerting.custom.headers`                | Custom alerting request headers                                               | `{}`           |
+

 #### Configuring Slack alerts

@@ -213,6 +238,7 @@ Here are some examples of conditions you can use:
 alerting:
  slack: 
    webhook-url: "https://hooks.slack.com/services/**********/**********/**********"
+
 services:
  - name: twinnation
    url: "https://twinnation.org/health"
@@ -238,6 +264,29 @@ Here's an example of what the notifications look like:
 ![Slack notifications](.github/assets/slack-alerts.png)


+#### Configuring Discord alerts
+
+```yaml
+alerting:
+  discord: 
+    webhook-url: "https://discord.com/api/webhooks/**********/**********"
+
+services:
+  - name: twinnation
+    url: "https://twinnation.org/health"
+    interval: 30s
+    alerts:
+      - type: discord
+        enabled: true
+        description: "healthcheck failed"
+        send-on-resolved: true
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 300"
+```
+
+
 #### Configuring PagerDuty alerts

 It is highly recommended to set `services[].alerts[].send-on-resolved` to `true` for alerts 
@@ -249,6 +298,7 @@ PagerDuty instead.
 alerting:
  pagerduty: 
    integration-key: "********************************"
+
 services:
  - name: twinnation
    url: "https://twinnation.org/health"
@@ -259,7 +309,7 @@ services:
        failure-threshold: 3
        success-threshold: 5
        send-on-resolved: true
-        description: "healthcheck failed 3 times in a row"
+        description: "healthcheck failed"
    conditions:
      - "[STATUS] == 200"
      - "[BODY].status == UP"
@@ -276,6 +326,7 @@ alerting:
    token: "..."
    from: "+1-234-567-8901"
    to: "+1-234-567-8901"
+
 services:
  - name: twinnation
    interval: 30s
@@ -285,7 +336,7 @@ services:
        enabled: true
        failure-threshold: 5
        send-on-resolved: true
-        description: "healthcheck failed 5 times in a row"
+        description: "healthcheck failed"
    conditions:
      - "[STATUS] == 200"
      - "[BODY].status == UP"
@@ -300,6 +351,7 @@ alerting:
  mattermost: 
    webhook-url: "http://**********/hooks/**********"
    insecure: true
+
 services:
  - name: twinnation
    url: "https://twinnation.org/health"
@@ -307,7 +359,7 @@ services:
    alerts:
      - type: mattermost
        enabled: true
-        description: "healthcheck failed 3 times in a row"
+        description: "healthcheck failed"
        send-on-resolved: true
    conditions:
      - "[STATUS] == 200"
@@ -339,7 +391,7 @@ services:
        enabled: true
        failure-threshold: 3
        send-on-resolved: true
-        description: "healthcheck failed 3 times in a row"
+        description: "healthcheck failed"
    conditions:
      - "[STATUS] == 200"
      - "[BODY].status == UP"
@@ -347,6 +399,32 @@ services:
 ```


+#### Configuring Telegram alerts
+
+```yaml
+alerting:
+  telegram: 
+    token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"
+    id: "0123456789"
+
+services:
+  - name: twinnation
+    url: "https://twinnation.org/health"
+    interval: 30s
+    alerts:
+      - type: telegram
+        enabled: true
+        send-on-resolved: true
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+```
+
+Here's an example of what the notifications look like:
+
+![Telegram notifications](.github/assets/telegram-alerts.png)
+
+
 #### Configuring custom alerts

 While they're called alerts, you can use this feature to call anything. 
@@ -356,14 +434,15 @@ leveraging Gatus, you could have Gatus call that application endpoint when a ser
 would then check if the service that started failing was recently deployed, and if it was, then automatically 
 roll it back.

-The values `[ALERT_DESCRIPTION]` and `[SERVICE_NAME]` are automatically substituted for the alert description and the 
-service name respectively in the body (`alerting.custom.body`) as well as the url (`alerting.custom.url`).
+The placeholders `[ALERT_DESCRIPTION]` and `[SERVICE_NAME]` are automatically substituted for the alert description and
+the service name. These placeholders can be used in the body (`alerting.custom.body`) and in the url (`alerting.custom.url`).

-If you have `send-on-resolved` set to `true`, you may want to use `[ALERT_TRIGGERED_OR_RESOLVED]` to differentiate
-the notifications. It will be replaced for either `TRIGGERED` or `RESOLVED`, based on the situation.
+If you have an alert using the `custom` provider with `send-on-resolved` set to `true`, you can use the
+`[ALERT_TRIGGERED_OR_RESOLVED]` placeholder to differentiate the notifications. 
+The aforementioned placeholder will be replaced by `TRIGGERED` or `RESOLVED` accordingly, though it can be modified
+(details at the end of this section).

 For all intents and purpose, we'll configure the custom alert with a Slack webhook, but you can call anything you want.
-
 ```yaml
 alerting:
  custom:
@@ -384,13 +463,26 @@ services:
        failure-threshold: 10
        success-threshold: 3
        send-on-resolved: true
-        description: "healthcheck failed 10 times in a row"
+        description: "healthcheck failed"
    conditions:
      - "[STATUS] == 200"
      - "[BODY].status == UP"
      - "[RESPONSE_TIME] < 300"
 ```

+Note that you can customize the resolved values for the `[ALERT_TRIGGERED_OR_RESOLVED]` placeholder like so:
+```yaml
+alerting:
+  custom:
+    placeholders:
+      ALERT_TRIGGERED_OR_RESOLVED:
+        TRIGGERED: "partial_outage"
+        RESOLVED: "operational"
+```
+As a result, the `[ALERT_TRIGGERED_OR_RESOLVED]` in the body of first example of this section would be replaced by 
+`partial_outage` when an alert is triggered and `operational` when an alert is resolved.
+
+
 ### Kubernetes (ALPHA)

 > **WARNING**: This feature is in ALPHA. This means that it is very likely to change in the near future, which means that
@@ -491,29 +583,27 @@ By setting `services[].graphql` to true, the body will automatically be wrapped
 For instance, the following configuration:
 ```yaml
 services:
-  - name: filter users by gender
+  - name: filter-users-by-gender
    url: http://localhost:8080/playground
    method: POST
    graphql: true
    body: |
      {
-        user(gender: "female") {
+        users(gender: "female") {
          id
          name
          gender
          avatar
        }
      }
-    headers:
-      Content-Type: application/json # XXX: as of v1.9.2, this header is automatically added when graphql is set to true
    conditions:
      - "[STATUS] == 200"
-      - "[BODY].data.user[0].gender == female"
+      - "[BODY].data.users[0].gender == female"
 ```

 will send a `POST` request to `http://localhost:8080/playground` with the following body:
 ```json
-{"query":"      {\n        user(gender: \"female\") {\n          id\n          name\n          gender\n          avatar\n        }\n      }"}
+{"query":"      {\n        users(gender: \"female\") {\n          id\n          name\n          gender\n          avatar\n        }\n      }"}
 ```


@@ -585,7 +675,7 @@ commonly known as "ping" or "echo":

 ```yaml
 services:
-  - name: ICMP
+  - name: ping-example
    url: "icmp://example.com"
    conditions:
      - "[CONNECTED] == true"
@@ -600,7 +690,7 @@ You can specify a domain prefixed by `icmp://`, or an IP address prefixed by `ic
 Defining a `dns` configuration in a service will automatically mark that service as a service of type DNS:
 ```yaml
 services:
-  - name: example dns query
+  - name: example-dns-query
    url: "8.8.8.8" # Address of the DNS server to use
    interval: 30s
    dns:
@@ -740,3 +830,25 @@ Example: ![Uptime 24h](https://status.twinnation.org/api/v1/badges/uptime/24h/co
 ```

 If you'd like to see a visual example of each badges available, you can simply navigate to the service's detail page.
+
+### API
+Gatus provides a simple read-only API which can be queried in order to programmatically determine service status and history.
+
+All services are available via a GET request to the following endpoint:
+```
+/api/v1/statuses
+````
+
+Example: https://status.twinnation.org/api/v1/statuses
+
+Specific services can also be queried by using the following pattern:
+```
+/api/v1/statuses/{group}_{service}
+```
+
+Example: https://status.twinnation.org/api/v1/statuses/core_twinnation-home
+
+Gzip compression will be used if the `Accept-Encoding` HTTP header contains `gzip`.
+
+The API will return a JSON payload with the `Content-Type` response header set to `application/json`. 
+No such header is required to query the API.
--- a/alerting/config.go
+++ b/alerting/config.go
@@ -2,17 +2,22 @@ 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 {
-	// Slack is the configuration for the slack alerting provider
-	Slack *slack.AlertProvider `yaml:"slack"`
+	// Custom is the configuration for the custom alerting provider
+	Custom *custom.AlertProvider `yaml:"custom"`
+
+	// Discord is the configuration for the discord alerting provider
+	Discord *discord.AlertProvider `yaml:"discord"`

 	// Mattermost is the configuration for the mattermost alerting provider
 	Mattermost *mattermost.AlertProvider `yaml:"mattermost"`
@@ -20,12 +25,15 @@ type Config struct {
 	// Messagebird is the configuration for the messagebird alerting provider
 	Messagebird *messagebird.AlertProvider `yaml:"messagebird"`

-	// Pagerduty is the configuration for the pagerduty alerting provider
+	// PagerDuty is the configuration for the pagerduty alerting provider
 	PagerDuty *pagerduty.AlertProvider `yaml:"pagerduty"`

+	// Slack is the configuration for the slack alerting provider
+	Slack *slack.AlertProvider `yaml:"slack"`
+
+	// Telegram is the configuration for the telegram alerting provider
+	Telegram *telegram.AlertProvider `yaml:"telegram"`
+
 	// Twilio is the configuration for the twilio alerting provider
 	Twilio *twilio.AlertProvider `yaml:"twilio"`
-
-	// Custom is the configuration for the custom alerting provider
-	Custom *custom.AlertProvider `yaml:"custom"`
 }
--- a/alerting/provider/custom/custom.go
+++ b/alerting/provider/custom/custom.go
@@ -16,11 +16,12 @@ import (
 // AlertProvider is the configuration necessary for sending an alert using a custom HTTP request
 // Technically, all alert providers should be reachable using the custom alert provider
 type AlertProvider struct {
-	URL      string            `yaml:"url"`
-	Method   string            `yaml:"method,omitempty"`
-	Insecure bool              `yaml:"insecure,omitempty"`
-	Body     string            `yaml:"body,omitempty"`
-	Headers  map[string]string `yaml:"headers,omitempty"`
+	URL          string                       `yaml:"url"`
+	Method       string                       `yaml:"method,omitempty"`
+	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
@@ -33,10 +34,25 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 	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)
 	}
@@ -45,9 +61,9 @@ func (provider *AlertProvider) buildHTTPRequest(serviceName, alertDescription st
 	}
 	if strings.Contains(body, "[ALERT_TRIGGERED_OR_RESOLVED]") {
 		if resolved {
-			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", "RESOLVED")
+			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(true))
 		} else {
-			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", "TRIGGERED")
+			body = strings.ReplaceAll(body, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(false))
 		}
 	}
 	if strings.Contains(providerURL, "[ALERT_DESCRIPTION]") {
@@ -58,9 +74,9 @@ func (provider *AlertProvider) buildHTTPRequest(serviceName, alertDescription st
 	}
 	if strings.Contains(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]") {
 		if resolved {
-			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", "RESOLVED")
+			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(true))
 		} else {
-			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", "TRIGGERED")
+			providerURL = strings.ReplaceAll(providerURL, "[ALERT_TRIGGERED_OR_RESOLVED]", provider.GetAlertStatePlaceholderValue(false))
 		}
 	}
 	if len(method) == 0 {
--- a/alerting/provider/custom/custom_test.go
+++ b/alerting/provider/custom/custom_test.go
@@ -62,9 +62,49 @@ 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.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
-	if customAlertProvider != customAlertProvider {
-		t.Error("customAlertProvider should've been equal to customAlertProvider")
+	if customAlertProvider.URL != "http://example.com" {
+		t.Error("expected URL to be http://example.com, got", customAlertProvider.URL)
+	}
+}
+
+func TestAlertProvider_buildHTTPRequestWithCustomPlaceholder(t *testing.T) {
+	const (
+		ExpectedURL  = "http://example.com/service-name?event=test&description=alert-description"
+		ExpectedBody = "service-name,alert-description,test"
+	)
+	customAlertProvider := &AlertProvider{
+		URL:     "http://example.com/[SERVICE_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
+		Body:    "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
+		Headers: nil,
+		Placeholders: map[string]map[string]string{
+			"ALERT_TRIGGERED_OR_RESOLVED": {
+				"RESOLVED": "test",
+			},
+		},
+	}
+	request := customAlertProvider.buildHTTPRequest("service-name", "alert-description", true)
+	if request.URL.String() != ExpectedURL {
+		t.Error("expected URL to be", ExpectedURL, "was", request.URL.String())
+	}
+	body, _ := ioutil.ReadAll(request.Body)
+	if string(body) != ExpectedBody {
+		t.Error("expected body to be", ExpectedBody, "was", string(body))
+	}
+}
+
+func TestAlertProvider_GetAlertStatePlaceholderValueDefaults(t *testing.T) {
+	customAlertProvider := &AlertProvider{
+		URL:          "http://example.com/[SERVICE_NAME]?event=[ALERT_TRIGGERED_OR_RESOLVED]&description=[ALERT_DESCRIPTION]",
+		Body:         "[SERVICE_NAME],[ALERT_DESCRIPTION],[ALERT_TRIGGERED_OR_RESOLVED]",
+		Headers:      nil,
+		Placeholders: nil,
+	}
+	if customAlertProvider.GetAlertStatePlaceholderValue(true) != "RESOLVED" {
+		t.Error("expected RESOLVED, got", customAlertProvider.GetAlertStatePlaceholderValue(true))
+	}
+	if customAlertProvider.GetAlertStatePlaceholderValue(false) != "TRIGGERED" {
+		t.Error("expected TRIGGERED, got", customAlertProvider.GetAlertStatePlaceholderValue(false))
 	}
 }
--- a/alerting/provider/discord/discord.go
+++ b/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"},
+	}
+}
--- a/alerting/provider/discord/discord_test.go
+++ b/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())
+	}
+}
--- a/alerting/provider/mattermost/mattermost.go
+++ b/alerting/provider/mattermost/mattermost.go
@@ -38,7 +38,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		} else {
 			prefix = ":x:"
 		}
-		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
+		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
 	}
 	return &custom.AlertProvider{
 		URL:      provider.WebhookURL,
--- a/alerting/provider/mattermost/mattermost_test.go
+++ b/alerting/provider/mattermost/mattermost_test.go
@@ -1,6 +1,8 @@
 package mattermost

 import (
+	"encoding/json"
+	"net/http"
 	"strings"
 	"testing"

@@ -19,23 +21,45 @@ func TestAlertProvider_IsValid(t *testing.T) {
 }

 func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.com"}
+	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.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "resolved") {
 		t.Error("customAlertProvider.Body should've contained the substring resolved")
 	}
+	if customAlertProvider.URL != "http://example.org" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }

 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
-	provider := AlertProvider{WebhookURL: "http://example.com"}
+	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.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "triggered") {
 		t.Error("customAlertProvider.Body should've contained the substring triggered")
 	}
+	if customAlertProvider.URL != "http://example.org" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }
--- a/alerting/provider/messagebird/messagebird_test.go
+++ b/alerting/provider/messagebird/messagebird_test.go
@@ -1,6 +1,8 @@
 package messagebird

 import (
+	"encoding/json"
+	"net/http"
 	"strings"
 	"testing"

@@ -30,11 +32,22 @@ func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	}
 	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
 		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
 	}
+	if customAlertProvider.URL != "https://rest.messagebird.com/messages" {
+		t.Errorf("expected URL to be %s, got %s", "https://rest.messagebird.com/messages", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }

 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
@@ -45,9 +58,20 @@ func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
 	}
 	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, false)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
 		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
 	}
+	if customAlertProvider.URL != "https://rest.messagebird.com/messages" {
+		t.Errorf("expected URL to be %s, got %s", "https://rest.messagebird.com/messages", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }
--- a/alerting/provider/pagerduty/pagerduty_test.go
+++ b/alerting/provider/pagerduty/pagerduty_test.go
@@ -1,6 +1,8 @@
 package pagerduty

 import (
+	"encoding/json"
+	"net/http"
 	"strings"
 	"testing"

@@ -22,20 +24,42 @@ func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	provider := AlertProvider{IntegrationKey: "00000000000000000000000000000000"}
 	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, true)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "RESOLVED") {
 		t.Error("customAlertProvider.Body should've contained the substring RESOLVED")
 	}
+	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
+		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }

 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
 	provider := AlertProvider{IntegrationKey: "00000000000000000000000000000000"}
 	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, false)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
 		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
 	}
+	if customAlertProvider.URL != "https://events.pagerduty.com/v2/enqueue" {
+		t.Errorf("expected URL to be %s, got %s", "https://events.pagerduty.com/v2/enqueue", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }
--- a/alerting/provider/provider.go
+++ b/alerting/provider/provider.go
@@ -2,10 +2,12 @@ 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"
 )
@@ -22,9 +24,11 @@ type AlertProvider interface {
 var (
 	// Validate interface implementation on compile
 	_ AlertProvider = (*custom.AlertProvider)(nil)
-	_ AlertProvider = (*twilio.AlertProvider)(nil)
-	_ AlertProvider = (*slack.AlertProvider)(nil)
+	_ AlertProvider = (*discord.AlertProvider)(nil)
 	_ AlertProvider = (*mattermost.AlertProvider)(nil)
 	_ AlertProvider = (*messagebird.AlertProvider)(nil)
 	_ AlertProvider = (*pagerduty.AlertProvider)(nil)
+	_ AlertProvider = (*slack.AlertProvider)(nil)
+	_ AlertProvider = (*telegram.AlertProvider)(nil)
+	_ AlertProvider = (*twilio.AlertProvider)(nil)
 )
--- a/alerting/provider/slack/slack.go
+++ b/alerting/provider/slack/slack.go
@@ -35,7 +35,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		} else {
 			prefix = ":x:"
 		}
-		results += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition)
+		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
 	}
 	return &custom.AlertProvider{
 		URL:    provider.WebhookURL,
--- a/alerting/provider/slack/slack_test.go
+++ b/alerting/provider/slack/slack_test.go
@@ -1,6 +1,8 @@
 package slack

 import (
+	"encoding/json"
+	"net/http"
 	"strings"
 	"testing"

@@ -22,20 +24,42 @@ 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.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "resolved") {
 		t.Error("customAlertProvider.Body should've contained the substring resolved")
 	}
+	if customAlertProvider.URL != "http://example.com" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }

 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.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "triggered") {
 		t.Error("customAlertProvider.Body should've contained the substring triggered")
 	}
+	if customAlertProvider.URL != "http://example.com" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.com", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
 }
--- a/alerting/provider/telegram/telegram.go
+++ b/alerting/provider/telegram/telegram.go
@@ -0,0 +1,52 @@
+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"},
+	}
+}
--- a/alerting/provider/telegram/telegram_test.go
+++ b/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())
+	}
+}
--- a/alerting/provider/twilio/twilio_test.go
+++ b/alerting/provider/twilio/twilio_test.go
@@ -1,6 +1,7 @@
 package twilio

 import (
+	"net/http"
 	"strings"
 	"testing"

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

 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
 	provider := AlertProvider{
-		SID:   "1",
-		Token: "1",
-		From:  "1",
+		SID:   "4",
+		Token: "3",
+		From:  "2",
 		To:    "1",
 	}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &core.Alert{}, &core.Result{}, false)
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "service-name"}, &core.Alert{Description: "alert-description"}, &core.Result{}, false)
 	if customAlertProvider == nil {
-		t.Error("customAlertProvider shouldn't have been nil")
+		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
 	if !strings.Contains(customAlertProvider.Body, "TRIGGERED") {
 		t.Error("customAlertProvider.Body should've contained the substring TRIGGERED")
 	}
+	if customAlertProvider.URL != "https://api.twilio.com/2010-04-01/Accounts/4/Messages.json" {
+		t.Errorf("expected URL to be %s, got %s", "https://api.twilio.com/2010-04-01/Accounts/4/Messages.json", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	if customAlertProvider.Body != "Body=TRIGGERED%3A+service-name+-+alert-description&From=2&To=1" {
+		t.Errorf("expected body to be %s, got %s", "Body=TRIGGERED%3A+service-name+-+alert-description&From=2&To=1", customAlertProvider.Body)
+	}
 }
--- a/client/client.go
+++ b/client/client.go
@@ -27,6 +27,7 @@ func GetHTTPClient(insecure bool) *http.Client {
 				Transport: &http.Transport{
 					MaxIdleConns:        100,
 					MaxIdleConnsPerHost: 20,
+					Proxy:               http.ProxyFromEnvironment,
 					TLSClientConfig: &tls.Config{
 						InsecureSkipVerify: true,
 					},
@@ -41,6 +42,7 @@ func GetHTTPClient(insecure bool) *http.Client {
 			Transport: &http.Transport{
 				MaxIdleConns:        100,
 				MaxIdleConnsPerHost: 20,
+				Proxy:               http.ProxyFromEnvironment,
 			},
 		}
 	}
--- a/config/config.go
+++ b/config/config.go
@@ -11,6 +11,8 @@ import (
 	"github.com/TwinProduction/gatus/core"
 	"github.com/TwinProduction/gatus/k8s"
 	"github.com/TwinProduction/gatus/security"
+	"github.com/TwinProduction/gatus/storage"
+	"github.com/TwinProduction/gatus/util"
 	"gopkg.in/yaml.v2"
 )

@@ -71,8 +73,11 @@ type Config struct {
 	// Kubernetes is the Kubernetes configuration
 	Kubernetes *k8s.Config `yaml:"kubernetes"`

+	// Storage is the configuration for how the data is stored
+	Storage *storage.Config `yaml:"storage"`
+
 	// Web is the configuration for the web listener
-	Web *webConfig `yaml:"web"`
+	Web *WebConfig `yaml:"web"`
 }

 // Get returns the configuration, or panics if the configuration hasn't loaded yet
@@ -144,13 +149,33 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 		validateServicesConfig(config)
 		validateKubernetesConfig(config)
 		validateWebConfig(config)
+		validateStorageConfig(config)
 	}
 	return
 }

+func validateStorageConfig(config *Config) {
+	if config.Storage == nil {
+		config.Storage = &storage.Config{}
+	}
+	err := storage.Initialize(config.Storage)
+	if err != nil {
+		panic(err)
+	}
+	// Remove all ServiceStatus that represent services which no longer exist in the configuration
+	var keys []string
+	for _, service := range config.Services {
+		keys = append(keys, util.ConvertGroupAndServiceToKey(service.Group, service.Name))
+	}
+	numberOfServiceStatusesDeleted := storage.Get().DeleteAllServiceStatusesNotInKeys(keys)
+	if numberOfServiceStatusesDeleted > 0 {
+		log.Printf("[config][validateStorageConfig] Deleted %d service statuses because their matching services no longer existed", numberOfServiceStatusesDeleted)
+	}
+}
+
 func validateWebConfig(config *Config) {
 	if config.Web == nil {
-		config.Web = &webConfig{Address: DefaultAddress, Port: DefaultPort}
+		config.Web = &WebConfig{Address: DefaultAddress, Port: DefaultPort}
 	} else {
 		config.Web.validateAndSetDefaults()
 	}
@@ -203,12 +228,14 @@ func validateAlertingConfig(config *Config) {
 		return
 	}
 	alertTypes := []core.AlertType{
-		core.SlackAlert,
+		core.CustomAlert,
+		core.DiscordAlert,
 		core.MattermostAlert,
 		core.MessagebirdAlert,
-		core.TwilioAlert,
 		core.PagerDutyAlert,
-		core.CustomAlert,
+		core.SlackAlert,
+		core.TelegramAlert,
+		core.TwilioAlert,
 	}
 	var validProviders, invalidProviders []core.AlertType
 	for _, alertType := range alertTypes {
@@ -230,12 +257,18 @@ func validateAlertingConfig(config *Config) {
 // GetAlertingProviderByAlertType returns an provider.AlertProvider by its corresponding core.AlertType
 func GetAlertingProviderByAlertType(config *Config, alertType core.AlertType) provider.AlertProvider {
 	switch alertType {
-	case core.SlackAlert:
-		if config.Alerting.Slack == nil {
+	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.Slack
+		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
@@ -248,24 +281,30 @@ func GetAlertingProviderByAlertType(config *Config, alertType core.AlertType) pr
 			return nil
 		}
 		return config.Alerting.Messagebird
-	case core.TwilioAlert:
-		if config.Alerting.Twilio == nil {
-			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
-			return nil
-		}
-		return config.Alerting.Twilio
 	case core.PagerDutyAlert:
 		if config.Alerting.PagerDuty == nil {
 			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
 			return nil
 		}
 		return config.Alerting.PagerDuty
-	case core.CustomAlert:
-		if config.Alerting.Custom == nil {
+	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.Custom
+		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
 }
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -6,6 +6,15 @@ import (
 	"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"
@@ -42,7 +51,10 @@ func TestLoadDefaultConfigurationFile(t *testing.T) {
 }

 func TestParseAndValidateConfigBytes(t *testing.T) {
-	config, err := parseAndValidateConfigBytes([]byte(`
+	file := t.TempDir() + "/test.db"
+	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
+storage:
+  file: %s
 services:
  - name: twinnation
    url: https://twinnation.org/health
@@ -54,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")
@@ -99,7 +111,7 @@ services:
      - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -132,7 +144,7 @@ services:
      - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -167,7 +179,7 @@ services:
      - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -201,7 +213,7 @@ services:
      - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -250,7 +262,7 @@ services:
      - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -288,7 +300,7 @@ services:
      - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -332,16 +344,20 @@ badconfig:
 func TestParseAndValidateConfigBytesWithAlerting(t *testing.T) {
 	config, err := parseAndValidateConfigBytes([]byte(`
 debug: true
-
 alerting:
  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/health
@@ -354,12 +370,16 @@ services:
        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")
@@ -367,6 +387,7 @@ services:
 	if config.Metrics {
 		t.Error("Metrics should've been false by default")
 	}
+	// Alerting providers
 	if config.Alerting == nil {
 		t.Fatal("config.Alerting shouldn't have been nil")
 	}
@@ -379,12 +400,13 @@ services:
 	if config.Alerting.PagerDuty == nil || !config.Alerting.PagerDuty.IsValid() {
 		t.Fatal("PagerDuty alerting config should've been valid")
 	}
-	if config.Alerting.Messagebird == nil || !config.Alerting.Messagebird.IsValid() {
-		t.Fatal("Messagebird alerting config should've been valid")
-	}
 	if config.Alerting.PagerDuty.IntegrationKey != "00000000000000000000000000000000" {
 		t.Errorf("PagerDuty integration key should've been %s, but was %s", "00000000000000000000000000000000", config.Alerting.PagerDuty.IntegrationKey)
 	}
+
+	if config.Alerting.Messagebird == 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)
 	}
@@ -394,6 +416,24 @@ services:
 	if config.Alerting.Messagebird.Recipients != "31619191919" {
 		t.Errorf("Messagebird to recipients should've been %s, but was %s", "31619191919", config.Alerting.Messagebird.Recipients)
 	}
+
+	if config.Alerting.Discord == nil || !config.Alerting.Discord.IsValid() {
+		t.Fatal("Discord alerting config should've been valid")
+	}
+	if config.Alerting.Discord.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")
 	}
@@ -403,11 +443,12 @@ services:
 	if config.Services[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
 	}
-	if 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) != 3 {
-		t.Fatal("There should've been 3 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")
@@ -418,23 +459,32 @@ services:
 	if config.Services[0].Alerts[0].SuccessThreshold != 2 {
 		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[0].SuccessThreshold)
 	}
-	if config.Services[0].Alerts[1].FailureThreshold != 7 {
-		t.Errorf("The failure threshold of the alert should've been %d, but it was %d", 7, config.Services[0].Alerts[1].FailureThreshold)
-	}
-	if config.Services[0].Alerts[1].SuccessThreshold != 5 {
-		t.Errorf("The success threshold of the alert should've been %d, but it was %d", 5, config.Services[0].Alerts[1].SuccessThreshold)
-	}
-	if config.Services[0].Alerts[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[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[0].Description)
+		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[1].Type)
+		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)
 	}
 }

@@ -452,7 +502,7 @@ services:
      - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -486,7 +536,7 @@ services:
      - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -500,11 +550,106 @@ services:
 	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:
@@ -525,7 +670,7 @@ services:
      - "[STATUS] == 200"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -578,7 +723,7 @@ services:
      - "[STATUS] == 200"
 `, expectedUsername, expectedPasswordHash)))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -645,7 +790,7 @@ kubernetes:
      target-path: "/health"
 `))
 	if err != nil {
-		t.Error("No error should've been returned")
+		t.Error("expected no error, got", err.Error())
 	}
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
@@ -712,3 +857,42 @@ kubernetes:
 	// 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")
+	}
+}
--- a/config/web.go
+++ b/config/web.go
@@ -5,9 +5,9 @@ import (
 	"math"
 )

-// webConfig is the structure which supports the configuration of the endpoint
+// WebConfig is the structure which supports the configuration of the endpoint
 // which provides access to the web frontend
-type webConfig struct {
+type WebConfig struct {
 	// Address to listen on (defaults to 0.0.0.0 specified by DefaultAddress)
 	Address string `yaml:"address"`

@@ -16,7 +16,7 @@ type webConfig struct {
 }

 // validateAndSetDefaults checks and sets the default values for fields that are not set
-func (web *webConfig) validateAndSetDefaults() {
+func (web *WebConfig) validateAndSetDefaults() {
 	// Validate the Address
 	if len(web.Address) == 0 {
 		web.Address = DefaultAddress
@@ -30,6 +30,6 @@ func (web *webConfig) validateAndSetDefaults() {
 }

 // SocketAddress returns the combination of the Address and the Port
-func (web *webConfig) SocketAddress() string {
+func (web *WebConfig) SocketAddress() string {
 	return fmt.Sprintf("%s:%d", web.Address, web.Port)
 }
--- a/config/web_test.go
+++ b/config/web_test.go
@@ -5,7 +5,7 @@ import (
 )

 func TestWebConfig_SocketAddress(t *testing.T) {
-	web := &webConfig{
+	web := &WebConfig{
 		Address: "0.0.0.0",
 		Port:    8081,
 	}
--- a/controller/badge.go
+++ b/controller/badge.go
@@ -7,7 +7,7 @@ import (
 	"time"

 	"github.com/TwinProduction/gatus/core"
-	"github.com/TwinProduction/gatus/watchdog"
+	"github.com/TwinProduction/gatus/storage"
 	"github.com/gorilla/mux"
 )

@@ -25,18 +25,23 @@ func badgeHandler(writer http.ResponseWriter, request *http.Request) {
 	}
 	identifier := variables["identifier"]
 	key := strings.TrimSuffix(identifier, ".svg")
-	uptime := watchdog.GetUptimeByKey(key)
-	if uptime == nil {
+	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, uptime))
+	_, _ = writer.Write(generateSVG(duration, serviceStatus.Uptime))
 }

 func generateSVG(duration string, uptime *core.Uptime) []byte {
--- a/controller/controller.go
+++ b/controller/controller.go
@@ -3,6 +3,7 @@ package controller
 import (
 	"bytes"
 	"compress/gzip"
+	"context"
 	"encoding/json"
 	"fmt"
 	"log"
@@ -13,8 +14,9 @@ import (

 	"github.com/TwinProduction/gatus/config"
 	"github.com/TwinProduction/gatus/security"
-	"github.com/TwinProduction/gatus/watchdog"
+	"github.com/TwinProduction/gatus/storage"
 	"github.com/TwinProduction/gocache"
+	"github.com/TwinProduction/health"
 	"github.com/gorilla/mux"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
@@ -24,7 +26,15 @@ const (
 )

 var (
-	cache = gocache.NewCache().WithMaxSize(100).WithEvictionPolicy(gocache.LeastRecentlyUsed)
+	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() {
@@ -40,36 +50,49 @@ func Handle() {
 	if os.Getenv("ENVIRONMENT") == "dev" {
 		router = developmentCorsHandler(router)
 	}
-	server := &http.Server{
+	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())
-	log.Fatal(server.ListenAndServe())
+	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()
-	router.HandleFunc("/favicon.ico", favIconHandler).Methods("GET") // favicon needs to be always served from the root
-	router.HandleFunc("/services/{service}", spaHandler).Methods("GET")
-	router.HandleFunc("/api/v1/statuses", secureIfNecessary(cfg, serviceStatusesHandler)).Methods("GET")
-	router.HandleFunc("/api/v1/statuses/{key}", secureIfNecessary(cfg, GzipHandlerFunc(serviceStatusHandler))).Methods("GET")
-	router.HandleFunc("/api/v1/badges/uptime/{duration}/{identifier}", badgeHandler).Methods("GET")
-	router.HandleFunc("/health", healthHandler).Methods("GET")
-	router.PathPrefix("/").Handler(GzipHandler(http.FileServer(http.Dir("./web/static"))))
 	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(serviceStatusesHandler, cfg.Security)
+		return security.Handler(handler, cfg.Security)
 	}
 	return handler
 }
@@ -78,21 +101,22 @@ func secureIfNecessary(cfg *config.Config, handler http.HandlerFunc) http.Handle
 // 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("service-status-gzipped")
+		value, exists = cache.Get(fmt.Sprintf("service-status-%d-%d-gzipped", page, pageSize))
 	} else {
-		value, exists = cache.Get("service-status")
+		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 = watchdog.GetServiceStatusesAsJSON()
+		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)
@@ -102,8 +126,8 @@ func serviceStatusesHandler(writer http.ResponseWriter, r *http.Request) {
 		_, _ = gzipWriter.Write(data)
 		_ = gzipWriter.Close()
 		gzippedData := buffer.Bytes()
-		cache.SetWithTTL("service-status", data, cacheTTL)
-		cache.SetWithTTL("service-status-gzipped", gzippedData, cacheTTL)
+		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
 		}
@@ -117,8 +141,9 @@ func serviceStatusesHandler(writer http.ResponseWriter, r *http.Request) {

 // 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 := watchdog.GetServiceStatusByKey(vars["key"])
+	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)
@@ -126,36 +151,21 @@ func serviceStatusHandler(writer http.ResponseWriter, r *http.Request) {
 		return
 	}
 	data := map[string]interface{}{
-		"serviceStatus": serviceStatus,
-		// This is my lazy way of exposing events even though they're not visible from the json annotation
-		// present in ServiceStatus. We do this because creating a separate object for each endpoints
-		// would be wasteful (one with and one without Events)
+		"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"))
+		_, _ = writer.Write([]byte("unable to marshal object to JSON"))
 		return
 	}
 	writer.Header().Add("Content-Type", "application/json")
 	writer.WriteHeader(http.StatusOK)
 	_, _ = writer.Write(output)
 }
-
-func healthHandler(writer http.ResponseWriter, _ *http.Request) {
-	writer.Header().Add("Content-Type", "application/json")
-	writer.WriteHeader(http.StatusOK)
-	_, _ = writer.Write([]byte("{\"status\":\"UP\"}"))
-}
-
-// favIconHandler handles requests for /favicon.ico
-func favIconHandler(writer http.ResponseWriter, request *http.Request) {
-	http.ServeFile(writer, request, "./web/static/favicon.ico")
-}
-
-// spaHandler handles requests for /favicon.ico
-func spaHandler(writer http.ResponseWriter, request *http.Request) {
-	http.ServeFile(writer, request, "./web/static/index.html")
-}
--- a/controller/controller_test.go
+++ b/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)
+			}
+		})
+	}
+}
--- a/controller/favicon.go
+++ b/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")
+}
--- a/controller/spa.go
+++ b/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")
+}
--- a/controller/util.go
+++ b/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
+}
--- a/controller/util_test.go
+++ b/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)
+			}
+		})
+	}
+}
--- a/core/alert.go
+++ b/core/alert.go
@@ -40,8 +40,11 @@ type Alert struct {
 type AlertType string

 const (
-	// SlackAlert is the AlertType for the slack alerting provider
-	SlackAlert AlertType = "slack"
+	// 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"
@@ -52,9 +55,12 @@ const (
 	// 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"
-
-	// CustomAlert is the AlertType for the custom alerting provider
-	CustomAlert AlertType = "custom"
 )
--- a/core/condition.go
+++ b/core/condition.go
@@ -23,7 +23,7 @@ const (

 	// DNSRCodePlaceholder is a place holder for DNS_RCODE
 	//
-	// Values that could be NOERROR, FORMERR, SERVFAIL, NXDOMAIN, NOTIMP and REFUSED
+	// Values that could replace the placeholder: NOERROR, FORMERR, SERVFAIL, NXDOMAIN, NOTIMP, REFUSED
 	DNSRCodePlaceholder = "[DNS_RCODE]"

 	// ResponseTimePlaceholder is a placeholder for the request response time, in milliseconds.
@@ -51,14 +51,19 @@ const (
 	// 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: pat(192.168.*.*)
+	// Usage: [IP] == pat(192.168.*.*)
 	PatternFunctionPrefix = "pat("

 	// AnyFunctionPrefix is the prefix for the any function
 	//
-	// Usage: any(1.1.1.1, 1.0.0.1)
+	// Usage: [IP] == any(1.1.1.1, 1.0.0.1)
 	AnyFunctionPrefix = "any("

 	// FunctionSuffix is the suffix for all functions
@@ -66,12 +71,20 @@ const (

 	// InvalidConditionElementSuffix is the suffix that will be appended to an invalid condition
 	InvalidConditionElementSuffix = "(INVALID)"
+
+	// maximumLengthBeforeTruncatingWhenComparedWithPattern is the maximum length an element being compared to a
+	// pattern can have.
+	//
+	// This is only used for aesthetic purposes; it does not influence whether the condition evaluation results in a
+	// success or a failure
+	maximumLengthBeforeTruncatingWhenComparedWithPattern = 25
 )

 // Condition is a condition that needs to be met in order for a Service to be considered healthy.
 type Condition string

 // evaluate the Condition with the Result of the health check
+// TODO: Add a mandatory space between each operators (e.g. " == " instead of "==") (BREAKING CHANGE)
 func (c Condition) evaluate(result *Result) bool {
 	condition := string(c)
 	success := false
@@ -123,6 +136,12 @@ func (c Condition) evaluate(result *Result) bool {
 	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.
@@ -181,7 +200,7 @@ func isEqual(first, second string) bool {
 func sanitizeAndResolve(elements []string, result *Result) ([]string, []string) {
 	parameters := make([]string, len(elements))
 	resolvedParameters := make([]string, len(elements))
-	body := strings.TrimSpace(string(result.Body))
+	body := strings.TrimSpace(string(result.body))
 	for i, element := range elements {
 		element = strings.TrimSpace(element)
 		parameters[i] = element
@@ -203,26 +222,39 @@ func sanitizeAndResolve(elements []string, result *Result) ([]string, []string)
 		default:
 			// if contains the BodyPlaceholder, then evaluate json path
 			if strings.Contains(element, BodyPlaceholder) {
-				wantLength := false
+				checkingForLength := false
+				checkingForExistence := false
 				if strings.HasPrefix(element, LengthFunctionPrefix) && strings.HasSuffix(element, FunctionSuffix) {
-					wantLength = true
+					checkingForLength = true
 					element = strings.TrimSuffix(strings.TrimPrefix(element, LengthFunctionPrefix), FunctionSuffix)
 				}
-				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.TrimPrefix(element, BodyPlaceholder+"."), result.Body)
-				if err != nil {
-					if err.Error() != "unexpected end of JSON input" {
-						result.Errors = append(result.Errors, err.Error())
-					}
-					if wantLength {
-						element = LengthFunctionPrefix + element + FunctionSuffix + " " + InvalidConditionElementSuffix
+				if strings.HasPrefix(element, HasFunctionPrefix) && strings.HasSuffix(element, FunctionSuffix) {
+					checkingForExistence = true
+					element = strings.TrimSuffix(strings.TrimPrefix(element, HasFunctionPrefix), FunctionSuffix)
+				}
+				resolvedElement, resolvedElementLength, err := jsonpath.Eval(strings.TrimPrefix(element, BodyPlaceholder+"."), result.body)
+				if checkingForExistence {
+					if err != nil {
+						element = "false"
 					} else {
-						element = element + " " + InvalidConditionElementSuffix
+						element = "true"
 					}
 				} else {
-					if wantLength {
-						element = strconv.Itoa(resolvedElementLength)
+					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 {
-						element = resolvedElement
+						if checkingForLength {
+							element = strconv.Itoa(resolvedElementLength)
+						} else {
+							element = resolvedElement
+						}
 					}
 				}
 			}
@@ -258,6 +290,13 @@ func prettify(parameters []string, resolvedParameters []string, operator string)
 	if strings.HasSuffix(resolvedParameters[0], InvalidConditionElementSuffix) || strings.HasSuffix(resolvedParameters[1], InvalidConditionElementSuffix) {
 		return resolvedParameters[0] + " " + operator + " " + resolvedParameters[1]
 	}
+	// If using the pattern function, truncate the parameter it's being compared to if said parameter is long enough
+	if strings.HasPrefix(parameters[0], PatternFunctionPrefix) && strings.HasSuffix(parameters[0], FunctionSuffix) && len(resolvedParameters[1]) > maximumLengthBeforeTruncatingWhenComparedWithPattern {
+		resolvedParameters[1] = fmt.Sprintf("%.25s...(truncated)", resolvedParameters[1])
+	}
+	if strings.HasPrefix(parameters[1], PatternFunctionPrefix) && strings.HasSuffix(parameters[1], FunctionSuffix) && len(resolvedParameters[0]) > maximumLengthBeforeTruncatingWhenComparedWithPattern {
+		resolvedParameters[0] = fmt.Sprintf("%.25s...(truncated)", resolvedParameters[0])
+	}
 	// First element is a placeholder
 	if parameters[0] != resolvedParameters[0] && parameters[1] == resolvedParameters[1] {
 		return parameters[0] + " (" + resolvedParameters[0] + ") " + operator + " " + parameters[1]
--- a/core/condition_bench_test.go
+++ b/core/condition_bench_test.go
@@ -5,7 +5,7 @@ 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\"}")}
+		result := &Result{body: []byte("{\"name\": \"john.doe\"}")}
 		condition.evaluate(result)
 	}
 	b.ReportAllocs()
@@ -14,7 +14,7 @@ func BenchmarkCondition_evaluateWithBodyStringAny(b *testing.B) {
 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\"}")}
+		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
 		condition.evaluate(result)
 	}
 	b.ReportAllocs()
@@ -23,7 +23,7 @@ func BenchmarkCondition_evaluateWithBodyStringAnyFailure(b *testing.B) {
 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\"}")}
+		result := &Result{body: []byte("{\"name\": \"john.doe\"}")}
 		condition.evaluate(result)
 	}
 	b.ReportAllocs()
@@ -32,7 +32,7 @@ func BenchmarkCondition_evaluateWithBodyString(b *testing.B) {
 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\"}")}
+		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
 		condition.evaluate(result)
 	}
 	b.ReportAllocs()
@@ -41,7 +41,7 @@ func BenchmarkCondition_evaluateWithBodyStringFailure(b *testing.B) {
 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\"}")}
+		result := &Result{body: []byte("{\"name\": \"john.doe\"}")}
 		condition.evaluate(result)
 	}
 	b.ReportAllocs()
@@ -50,7 +50,7 @@ func BenchmarkCondition_evaluateWithBodyStringLen(b *testing.B) {
 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\"}")}
+		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
 		condition.evaluate(result)
 	}
 	b.ReportAllocs()
--- a/core/condition_test.go
+++ b/core/condition_test.go
--- a/core/dns.go
+++ b/core/dns.go
@@ -60,26 +60,26 @@ func (d *DNS) query(url string, result *Result) {
 		switch rr.Header().Rrtype {
 		case dns.TypeA:
 			if a, ok := rr.(*dns.A); ok {
-				result.Body = []byte(a.A.String())
+				result.body = []byte(a.A.String())
 			}
 		case dns.TypeAAAA:
 			if aaaa, ok := rr.(*dns.AAAA); ok {
-				result.Body = []byte(aaaa.AAAA.String())
+				result.body = []byte(aaaa.AAAA.String())
 			}
 		case dns.TypeCNAME:
 			if cname, ok := rr.(*dns.CNAME); ok {
-				result.Body = []byte(cname.Target)
+				result.body = []byte(cname.Target)
 			}
 		case dns.TypeMX:
 			if mx, ok := rr.(*dns.MX); ok {
-				result.Body = []byte(mx.Mx)
+				result.body = []byte(mx.Mx)
 			}
 		case dns.TypeNS:
 			if ns, ok := rr.(*dns.NS); ok {
-				result.Body = []byte(ns.Ns)
+				result.body = []byte(ns.Ns)
 			}
 		default:
-			result.Body = []byte("query type is not supported yet")
+			result.body = []byte("query type is not supported yet")
 		}
 	}
 }
--- a/core/dns_test.go
+++ b/core/dns_test.go
@@ -91,12 +91,12 @@ func TestIntegrationQuery(t *testing.T) {

 			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)
+				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)
+				if string(result.body) != test.expectedBody {
+					t.Errorf("got %s, expected result %s,", string(result.body), test.expectedBody)
 				}
 			}
 		})
--- a/core/result.go
+++ b/core/result.go
@@ -12,10 +12,7 @@ type Result struct {
 	// DNSRCode is the response code of a DNS query in a human readable format
 	DNSRCode string `json:"-"`

-	// Body is the response body
-	Body []byte `json:"-"`
-
-	// Hostname extracted from the Service URL
+	// Hostname extracted from Service.URL
 	Hostname string `json:"hostname"`

 	// IP resolved from the Service URL
@@ -41,4 +38,11 @@ type Result struct {

 	// 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
 }
--- a/core/service-status.go
+++ b/core/service-status.go
@@ -6,6 +6,14 @@ import (
 	"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
@@ -22,13 +30,17 @@ type ServiceStatus struct {

 	// Events is a list of events
 	//
-	// We don't expose this through JSON, because the main dashboard doesn't need to have these events.
+	// We don't expose this through JSON, because the main dashboard doesn't need to have this data.
 	// However, the detailed service page does leverage this by including it to a map that will be
 	// marshalled alongside the ServiceStatus.
 	Events []*Event `json:"-"`

 	// Uptime information on the service's uptime
-	Uptime *Uptime `json:"uptime"`
+	//
+	// We don't expose this through JSON, because the main dashboard doesn't need to have this data.
+	// However, the detailed service page does leverage this by including it to a map that will be
+	// marshalled alongside the ServiceStatus.
+	Uptime *Uptime `json:"-"`
 }

 // NewServiceStatus creates a new ServiceStatus
@@ -46,6 +58,29 @@ func NewServiceStatus(service *Service) *ServiceStatus {
 	}
 }

+// 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) {
@@ -60,14 +95,20 @@ func (ss *ServiceStatus) AddResult(result *Result) {
 				event.Type = EventUnhealthy
 			}
 			ss.Events = append(ss.Events, event)
-			if len(ss.Events) > 20 {
-				ss.Events = ss.Events[1:]
+			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) > 20 {
-		ss.Results = ss.Results[1:]
+	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)
 }
--- a/core/service-status_bench_test.go
+++ b/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()
+}
--- a/core/service-status_test.go
+++ b/core/service-status_test.go
@@ -22,10 +22,45 @@ func TestNewServiceStatus(t *testing.T) {
 func TestServiceStatus_AddResult(t *testing.T) {
 	service := &Service{Name: "name", Group: "group"}
 	serviceStatus := NewServiceStatus(service)
-	for i := 0; i < 50; i++ {
+	for i := 0; i < MaximumNumberOfResults+10; i++ {
 		serviceStatus.AddResult(&Result{Timestamp: time.Now()})
 	}
-	if len(serviceStatus.Results) != 20 {
-		t.Errorf("expected serviceStatus.Results to not exceed a length of 20")
+	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")
 	}
 }
--- a/core/service.go
+++ b/core/service.go
@@ -80,7 +80,7 @@ type Service struct {
 	// NumberOfFailuresInARow is the number of unsuccessful evaluations in a row
 	NumberOfFailuresInARow int

-	// NumberOfFailuresInARow is the number of successful evaluations in a row
+	// NumberOfSuccessesInARow is the number of successful evaluations in a row
 	NumberOfSuccessesInARow int
 }

@@ -149,6 +149,8 @@ func (service *Service) EvaluateHealth() *Result {
 		}
 	}
 	result.Timestamp = time.Now()
+	// No need to keep the body after the service has been evaluated
+	result.body = nil
 	return result
 }

@@ -213,15 +215,19 @@ func (service *Service) call(result *Result) {
 			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 = certificate.NotAfter.Sub(time.Now())
+			result.CertificateExpiration = time.Until(certificate.NotAfter)
 		}
 		result.HTTPStatus = response.StatusCode
 		result.Connected = response.StatusCode > 0
-		result.Body, err = ioutil.ReadAll(response.Body)
-		if err != nil {
-			result.Errors = append(result.Errors, err.Error())
+		// Only read the body if there's a condition that uses the BodyPlaceholder
+		if service.needsToReadBody() {
+			result.body, err = ioutil.ReadAll(response.Body)
+			if err != nil {
+				result.Errors = append(result.Errors, err.Error())
+			}
 		}
 	}
 }
@@ -246,3 +252,13 @@ func (service *Service) buildHTTPRequest() *http.Request {
 	}
 	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
+}
--- a/core/service_test.go
+++ b/core/service_test.go
@@ -10,7 +10,7 @@ import (
 func TestService_ValidateAndSetDefaults(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	service := Service{
-		Name:       "TwiNNatioN",
+		Name:       "twinnation-health",
 		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition},
 		Alerts:     []*Alert{{Type: PagerDutyAlert}},
@@ -94,7 +94,7 @@ func TestService_ValidateAndSetDefaultsWithDNS(t *testing.T) {
 func TestService_GetAlertsTriggered(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	service := Service{
-		Name:       "TwiNNatioN",
+		Name:       "twinnation-health",
 		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition},
 		Alerts:     []*Alert{{Type: PagerDutyAlert, Enabled: true}},
@@ -118,7 +118,7 @@ func TestService_GetAlertsTriggered(t *testing.T) {
 func TestService_buildHTTPRequest(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	service := Service{
-		Name:       "TwiNNatioN",
+		Name:       "twinnation-health",
 		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition},
 	}
@@ -138,7 +138,7 @@ func TestService_buildHTTPRequest(t *testing.T) {
 func TestService_buildHTTPRequestWithCustomUserAgent(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	service := Service{
-		Name:       "TwiNNatioN",
+		Name:       "twinnation-health",
 		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition},
 		Headers: map[string]string{
@@ -161,7 +161,7 @@ func TestService_buildHTTPRequestWithCustomUserAgent(t *testing.T) {
 func TestService_buildHTTPRequestWithHostHeader(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	service := Service{
-		Name:       "TwiNNatioN",
+		Name:       "twinnation-health",
 		URL:        "https://twinnation.org/health",
 		Method:     "POST",
 		Conditions: []*Condition{&condition},
@@ -182,13 +182,13 @@ func TestService_buildHTTPRequestWithHostHeader(t *testing.T) {
 func TestService_buildHTTPRequestWithGraphQLEnabled(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	service := Service{
-		Name:       "TwiNNatioN",
+		Name:       "twinnation-graphql",
 		URL:        "https://twinnation.org/graphql",
 		Method:     "POST",
 		Conditions: []*Condition{&condition},
 		GraphQL:    true,
 		Body: `{
-  user(gender: "female") {
+  users(gender: "female") {
    id
    name
    gender
@@ -206,16 +206,17 @@ func TestService_buildHTTPRequestWithGraphQLEnabled(t *testing.T) {
 	}
 	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))
+		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",
+		Name:       "twinnation-health",
 		URL:        "https://twinnation.org/health",
-		Conditions: []*Condition{&condition},
+		Conditions: []*Condition{&condition, &bodyCondition},
 	}
 	result := service.EvaluateHealth()
 	if !result.ConditionResults[0].Success {
@@ -232,7 +233,7 @@ func TestIntegrationEvaluateHealth(t *testing.T) {
 func TestIntegrationEvaluateHealthWithFailure(t *testing.T) {
 	condition := Condition("[STATUS] == 500")
 	service := Service{
-		Name:       "TwiNNatioN",
+		Name:       "twinnation-health",
 		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition},
 	}
@@ -252,7 +253,7 @@ func TestIntegrationEvaluateHealthForDNS(t *testing.T) {
 	conditionSuccess := Condition("[DNS_RCODE] == NOERROR")
 	conditionBody := Condition("[BODY] == 93.184.216.34")
 	service := Service{
-		Name: "TwiNNatioN",
+		Name: "example",
 		URL:  "8.8.8.8",
 		DNS: &DNS{
 			QueryType: "A",
@@ -275,7 +276,7 @@ func TestIntegrationEvaluateHealthForDNS(t *testing.T) {
 func TestIntegrationEvaluateHealthForICMP(t *testing.T) {
 	conditionSuccess := Condition("[CONNECTED] == true")
 	service := Service{
-		Name:       "ICMP test",
+		Name:       "icmp-test",
 		URL:        "icmp://127.0.0.1",
 		Conditions: []*Condition{&conditionSuccess},
 	}
@@ -294,7 +295,7 @@ func TestIntegrationEvaluateHealthForICMP(t *testing.T) {
 func TestService_getIP(t *testing.T) {
 	conditionSuccess := Condition("[CONNECTED] == true")
 	service := Service{
-		Name:       "Invalid URL test",
+		Name:       "invalid-url-test",
 		URL:        "",
 		Conditions: []*Condition{&conditionSuccess},
 	}
@@ -304,3 +305,27 @@ func TestService_getIP(t *testing.T) {
 		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")
+	}
+}
--- a/core/uptime.go
+++ b/core/uptime.go
@@ -1,15 +1,10 @@
 package core

 import (
-	"log"
 	"time"
 )

 const (
-	// RFC3339WithoutMinutesAndSeconds is the format defined by RFC3339 (see time.RFC3339) but with the minutes
-	// and seconds hardcoded to 0.
-	RFC3339WithoutMinutesAndSeconds = "2006-01-02T15:00:00Z07:00"
-
 	numberOfHoursInTenDays = 10 * 24
 	sevenDays              = 7 * 24 * time.Hour
 )
@@ -25,42 +20,45 @@ type Uptime struct {
 	// LastHour is the uptime percentage over the past hour
 	LastHour float64 `json:"1h"`

-	successCountPerHour map[string]uint64
-	totalCountPerHour   map[string]uint64
+	// SuccessfulExecutionsPerHour is a map containing the number of successes (value)
+	// for every hourly unix timestamps (key)
+	SuccessfulExecutionsPerHour map[int64]uint64 `json:"-"`
+
+	// TotalExecutionsPerHour is a map containing the total number of checks (value)
+	// for every hourly unix timestamps (key)
+	TotalExecutionsPerHour map[int64]uint64 `json:"-"`
 }

 // NewUptime creates a new Uptime
 func NewUptime() *Uptime {
 	return &Uptime{
-		successCountPerHour: make(map[string]uint64),
-		totalCountPerHour:   make(map[string]uint64),
+		SuccessfulExecutionsPerHour: make(map[int64]uint64),
+		TotalExecutionsPerHour:      make(map[int64]uint64),
 	}
 }

 // ProcessResult processes the result by extracting the relevant from the result and recalculating the uptime
 // if necessary
 func (uptime *Uptime) ProcessResult(result *Result) {
-	timestampDateWithHour := result.Timestamp.Format(RFC3339WithoutMinutesAndSeconds)
-	if result.Success {
-		uptime.successCountPerHour[timestampDateWithHour]++
+	if uptime.SuccessfulExecutionsPerHour == nil || uptime.TotalExecutionsPerHour == nil {
+		uptime.SuccessfulExecutionsPerHour = make(map[int64]uint64)
+		uptime.TotalExecutionsPerHour = make(map[int64]uint64)
 	}
-	uptime.totalCountPerHour[timestampDateWithHour]++
+	unixTimestampFlooredAtHour := result.Timestamp.Unix() - (result.Timestamp.Unix() % 3600)
+	if result.Success {
+		uptime.SuccessfulExecutionsPerHour[unixTimestampFlooredAtHour]++
+	}
+	uptime.TotalExecutionsPerHour[unixTimestampFlooredAtHour]++
 	// Clean up only when we're starting to have too many useless keys
 	// Note that this is only triggered when there are more entries than there should be after
 	// 10 days, despite the fact that we are deleting everything that's older than 7 days.
 	// This is to prevent re-iterating on every `ProcessResult` as soon as the uptime has been logged for 7 days.
-	if len(uptime.totalCountPerHour) > numberOfHoursInTenDays {
-		sevenDaysAgo := time.Now().Add(-(sevenDays + time.Hour))
-		for k := range uptime.totalCountPerHour {
-			dateWithHour, err := time.Parse(time.RFC3339, k)
-			if err != nil {
-				// This shouldn't happen, but we'll log it in case it does happen
-				log.Println("[uptime][ProcessResult] Failed to parse programmatically generated timestamp:", err.Error())
-				continue
-			}
-			if sevenDaysAgo.Unix() > dateWithHour.Unix() {
-				delete(uptime.totalCountPerHour, k)
-				delete(uptime.successCountPerHour, k)
+	if len(uptime.TotalExecutionsPerHour) > numberOfHoursInTenDays {
+		sevenDaysAgo := time.Now().Add(-(sevenDays + time.Hour)).Unix()
+		for hourlyUnixTimestamp := range uptime.TotalExecutionsPerHour {
+			if sevenDaysAgo > hourlyUnixTimestamp {
+				delete(uptime.TotalExecutionsPerHour, hourlyUnixTimestamp)
+				delete(uptime.SuccessfulExecutionsPerHour, hourlyUnixTimestamp)
 			}
 		}
 	}
@@ -87,9 +85,9 @@ func (uptime *Uptime) recalculate() {
 	// The oldest uptime bracket starts 7 days ago, so we'll start from there
 	timestamp := now.Add(-sevenDays)
 	for now.Sub(timestamp) >= 0 {
-		timestampDateWithHour := timestamp.Format(RFC3339WithoutMinutesAndSeconds)
-		successCountForTimestamp := uptime.successCountPerHour[timestampDateWithHour]
-		totalCountForTimestamp := uptime.totalCountPerHour[timestampDateWithHour]
+		hourlyUnixTimestamp := timestamp.Unix() - (timestamp.Unix() % 3600)
+		successCountForTimestamp := uptime.SuccessfulExecutionsPerHour[hourlyUnixTimestamp]
+		totalCountForTimestamp := uptime.TotalExecutionsPerHour[hourlyUnixTimestamp]
 		uptimeBrackets["7d_success"] += successCountForTimestamp
 		uptimeBrackets["7d_total"] += totalCountForTimestamp
 		if now.Sub(timestamp) <= 24*time.Hour {
--- a/core/uptime_test.go
+++ b/core/uptime_test.go
@@ -51,10 +51,9 @@ func TestServiceStatus_AddResultUptimeIsCleaningUpAfterItself(t *testing.T) {
 	timestamp := now.Add(-12 * 24 * time.Hour)
 	for timestamp.Unix() <= now.Unix() {
 		serviceStatus.AddResult(&Result{Timestamp: timestamp, Success: true})
-		if len(serviceStatus.Uptime.successCountPerHour) > numberOfHoursInTenDays {
-			t.Errorf("At no point in time should there be more than %d entries in serviceStatus.successCountPerHour", numberOfHoursInTenDays)
+		if len(serviceStatus.Uptime.SuccessfulExecutionsPerHour) > numberOfHoursInTenDays {
+			t.Errorf("At no point in time should there be more than %d entries in serviceStatus.SuccessfulExecutionsPerHour, but there are %d", numberOfHoursInTenDays, len(serviceStatus.Uptime.SuccessfulExecutionsPerHour))
 		}
-		//fmt.Printf("timestamp=%s; uptimeDuringLastHour=%f; timeAgo=%s\n", timestamp.Format(time.RFC3339), serviceStatus.UptimeDuringLastHour, time.Since(timestamp))
 		if now.Sub(timestamp) > time.Hour && serviceStatus.Uptime.LastHour != 0 {
 			t.Error("most recent timestamp > 1h ago, expected serviceStatus.Uptime.LastHour to be 0, got", serviceStatus.Uptime.LastHour)
 		}
--- a/example/kubernetes-with-auto-discovery/gatus.yaml
+++ b/example/kubernetes-with-auto-discovery/gatus.yaml
@@ -81,11 +81,11 @@ spec:
              protocol: TCP
          resources:
            limits:
-              cpu: 200m
-              memory: 50M
+              cpu: 250m
+              memory: 100M
            requests:
              cpu: 50m
-              memory: 20M
+              memory: 30M
          volumeMounts:
            - mountPath: /config
              name: gatus-config
--- a/example/kubernetes/gatus.yaml
+++ b/example/kubernetes/gatus.yaml
@@ -59,11 +59,11 @@ spec:
              protocol: TCP
          resources:
            limits:
-              cpu: 200m
-              memory: 50M
+              cpu: 250m
+              memory: 100M
            requests:
              cpu: 50m
-              memory: 20M
+              memory: 30M
          volumeMounts:
            - mountPath: /config
              name: gatus-config
--- a/go.mod
+++ b/go.mod
@@ -1,10 +1,11 @@
 module github.com/TwinProduction/gatus

-go 1.15
+go 1.16

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

-// KubernetesClientApi is a minimal interface for interacting with Kubernetes
+// KubernetesClientAPI is a minimal interface for interacting with Kubernetes
 // Created mostly to make mocking the Kubernetes client easier
-type KubernetesClientApi interface {
+type KubernetesClientAPI interface {
 	GetServices(namespace string) ([]v1.Service, error)
 }

-// KubernetesClient is a working implementation of KubernetesClientApi
+// KubernetesClient is a working implementation of KubernetesClientAPI
 type KubernetesClient struct {
 	client *kubernetes.Clientset
 }
@@ -44,7 +44,7 @@ func NewKubernetesClient(client *kubernetes.Clientset) *KubernetesClient {
 }

 // NewClient creates a Kubernetes client for the given ClusterMode
-func NewClient(clusterMode ClusterMode) (KubernetesClientApi, error) {
+func NewClient(clusterMode ClusterMode) (KubernetesClientAPI, error) {
 	var kubeConfig *rest.Config
 	var err error
 	switch clusterMode {
--- a/k8s/k8s.go
+++ b/k8s/k8s.go
@@ -5,6 +5,6 @@ import (
 )

 // GetKubernetesServices return a list of Services from the given namespace
-func GetKubernetesServices(client KubernetesClientApi, namespace string) ([]v1.Service, error) {
+func GetKubernetesServices(client KubernetesClientAPI, namespace string) ([]v1.Service, error) {
 	return client.GetServices(namespace)
 }
--- a/main.go
+++ b/main.go
@@ -1,17 +1,37 @@
 package main

 import (
+	"log"
 	"os"
+	"os/signal"
+	"syscall"

 	"github.com/TwinProduction/gatus/config"
 	"github.com/TwinProduction/gatus/controller"
+	"github.com/TwinProduction/gatus/storage"
 	"github.com/TwinProduction/gatus/watchdog"
 )

 func main() {
 	cfg := loadConfiguration()
 	go watchdog.Monitor(cfg)
-	controller.Handle()
+	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 {
--- a/storage/config.go
+++ b/storage/config.go
@@ -0,0 +1,8 @@
+package storage
+
+// Config is the configuration for alerting providers
+type Config struct {
+	// File is the path of the file to use for persistence
+	// If blank, persistence is disabled.
+	File string `yaml:"file"`
+}
--- a/storage/memory.go
+++ b/storage/memory.go
@@ -1,69 +0,0 @@
-package storage
-
-import (
-	"encoding/json"
-	"sync"
-
-	"github.com/TwinProduction/gatus/core"
-	"github.com/TwinProduction/gatus/util"
-)
-
-// InMemoryStore implements an in-memory store
-type InMemoryStore struct {
-	serviceStatuses     map[string]*core.ServiceStatus
-	serviceResultsMutex sync.RWMutex
-}
-
-// NewInMemoryStore returns an in-memory store. Note that the store acts as a singleton, so although new-ing
-// up in-memory stores will give you a unique reference to a struct each time, all structs returned
-// by this function will act on the same in-memory store.
-func NewInMemoryStore() *InMemoryStore {
-	return &InMemoryStore{
-		serviceStatuses: make(map[string]*core.ServiceStatus),
-	}
-}
-
-// GetAllAsJSON returns the JSON encoding of all monitored core.ServiceStatus
-func (ims *InMemoryStore) GetAllAsJSON() ([]byte, error) {
-	ims.serviceResultsMutex.RLock()
-	serviceStatuses, err := json.Marshal(ims.serviceStatuses)
-	ims.serviceResultsMutex.RUnlock()
-	return serviceStatuses, err
-}
-
-// GetServiceStatus returns the service status for a given service name in the given group
-func (ims *InMemoryStore) GetServiceStatus(groupName, serviceName string) *core.ServiceStatus {
-	key := util.ConvertGroupAndServiceToKey(groupName, serviceName)
-	ims.serviceResultsMutex.RLock()
-	serviceStatus := ims.serviceStatuses[key]
-	ims.serviceResultsMutex.RUnlock()
-	return serviceStatus
-}
-
-// GetServiceStatusByKey returns the service status for a given key
-func (ims *InMemoryStore) GetServiceStatusByKey(key string) *core.ServiceStatus {
-	ims.serviceResultsMutex.RLock()
-	serviceStatus := ims.serviceStatuses[key]
-	ims.serviceResultsMutex.RUnlock()
-	return serviceStatus
-}
-
-// Insert inserts the observed result for the specified service into the in memory store
-func (ims *InMemoryStore) Insert(service *core.Service, result *core.Result) {
-	key := util.ConvertGroupAndServiceToKey(service.Group, service.Name)
-	ims.serviceResultsMutex.Lock()
-	serviceStatus, exists := ims.serviceStatuses[key]
-	if !exists {
-		serviceStatus = core.NewServiceStatus(service)
-		ims.serviceStatuses[key] = serviceStatus
-	}
-	serviceStatus.AddResult(result)
-	ims.serviceResultsMutex.Unlock()
-}
-
-// Clear will empty all the results from the in memory store
-func (ims *InMemoryStore) Clear() {
-	ims.serviceResultsMutex.Lock()
-	ims.serviceStatuses = make(map[string]*core.ServiceStatus)
-	ims.serviceResultsMutex.Unlock()
-}
--- a/storage/storage.go
+++ b/storage/storage.go
@@ -0,0 +1,63 @@
+package storage
+
+import (
+	"log"
+	"time"
+
+	"github.com/TwinProduction/gatus/storage/store"
+	"github.com/TwinProduction/gatus/storage/store/memory"
+)
+
+var (
+	provider store.Store
+
+	// initialized keeps track of whether the storage provider was initialized
+	// Because store.Store is an interface, a nil check wouldn't be sufficient, so instead of doing reflection
+	// every single time Get is called, we'll just lazily keep track of its existence through this variable
+	initialized bool
+)
+
+// Get retrieves the storage provider
+func Get() store.Store {
+	if !initialized {
+		log.Println("[storage][Get] Provider requested before it was initialized, automatically initializing")
+		err := Initialize(nil)
+		if err != nil {
+			panic("failed to automatically initialize store: " + err.Error())
+		}
+	}
+	return provider
+}
+
+// Initialize instantiates the storage provider based on the Config provider
+func Initialize(cfg *Config) error {
+	initialized = true
+	var err error
+	if cfg == nil || len(cfg.File) == 0 {
+		log.Println("[storage][Initialize] Creating storage provider")
+		provider, err = memory.NewStore("")
+		if err != nil {
+			return err
+		}
+	} else {
+		log.Printf("[storage][Initialize] Creating storage provider with file=%s", cfg.File)
+		provider, err = memory.NewStore(cfg.File)
+		if err != nil {
+			return err
+		}
+		go autoSave(7 * time.Minute)
+	}
+	return nil
+}
+
+// autoSave automatically calls the Save function of the provider at every interval
+func autoSave(interval time.Duration) {
+	for {
+		time.Sleep(interval)
+		log.Printf("[storage][autoSave] Saving")
+		err := provider.Save()
+		if err != nil {
+			log.Println("[storage][autoSave] Save failed:", err.Error())
+		}
+	}
+}
--- a/storage/store/memory/memory.go
+++ b/storage/store/memory/memory.go
@@ -0,0 +1,104 @@
+package memory
+
+import (
+	"encoding/gob"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/util"
+	"github.com/TwinProduction/gocache"
+)
+
+func init() {
+	gob.Register(&core.ServiceStatus{})
+	gob.Register(&core.Uptime{})
+	gob.Register(&core.Result{})
+	gob.Register(&core.Event{})
+}
+
+// Store that leverages gocache
+type Store struct {
+	file  string
+	cache *gocache.Cache
+}
+
+// NewStore creates a new store
+func NewStore(file string) (*Store, error) {
+	store := &Store{
+		file:  file,
+		cache: gocache.NewCache().WithMaxSize(gocache.NoMaxSize),
+	}
+	if len(file) > 0 {
+		_, err := store.cache.ReadFromFile(file)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return store, nil
+}
+
+// GetAllServiceStatusesWithResultPagination returns all monitored core.ServiceStatus
+// with a subset of core.Result defined by the page and pageSize parameters
+func (s *Store) GetAllServiceStatusesWithResultPagination(page, pageSize int) map[string]*core.ServiceStatus {
+	serviceStatuses := s.cache.GetAll()
+	pagedServiceStatuses := make(map[string]*core.ServiceStatus, len(serviceStatuses))
+	for k, v := range serviceStatuses {
+		pagedServiceStatuses[k] = v.(*core.ServiceStatus).WithResultPagination(page, pageSize)
+	}
+	return pagedServiceStatuses
+}
+
+// GetServiceStatus returns the service status for a given service name in the given group
+func (s *Store) GetServiceStatus(groupName, serviceName string) *core.ServiceStatus {
+	return s.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(groupName, serviceName))
+}
+
+// GetServiceStatusByKey returns the service status for a given key
+func (s *Store) GetServiceStatusByKey(key string) *core.ServiceStatus {
+	serviceStatus := s.cache.GetValue(key)
+	if serviceStatus == nil {
+		return nil
+	}
+	return serviceStatus.(*core.ServiceStatus)
+}
+
+// Insert adds the observed result for the specified service into the store
+func (s *Store) Insert(service *core.Service, result *core.Result) {
+	key := util.ConvertGroupAndServiceToKey(service.Group, service.Name)
+	serviceStatus, exists := s.cache.Get(key)
+	if !exists {
+		serviceStatus = core.NewServiceStatus(service)
+	}
+	serviceStatus.(*core.ServiceStatus).AddResult(result)
+	s.cache.Set(key, serviceStatus)
+}
+
+// DeleteAllServiceStatusesNotInKeys removes all ServiceStatus that are not within the keys provided
+func (s *Store) DeleteAllServiceStatusesNotInKeys(keys []string) int {
+	var keysToDelete []string
+	for _, existingKey := range s.cache.GetKeysByPattern("*", 0) {
+		shouldDelete := true
+		for _, key := range keys {
+			if existingKey == key {
+				shouldDelete = false
+				break
+			}
+		}
+		if shouldDelete {
+			keysToDelete = append(keysToDelete, existingKey)
+		}
+	}
+	return s.cache.DeleteAll(keysToDelete)
+}
+
+// Clear deletes everything from the store
+func (s *Store) Clear() {
+	s.cache.Clear()
+}
+
+// Save persists the cache to the store file
+func (s *Store) Save() error {
+	if len(s.file) > 0 {
+		return s.cache.SaveToFile(s.file)
+	}
+	return nil
+}
--- a/storage/store/memory/memory_test.go
+++ b/storage/store/memory/memory_test.go
@@ -1,4 +1,4 @@
-package storage
+package memory

 import (
 	"fmt"
@@ -33,7 +33,6 @@ var (
 		Hostname:              "example.org",
 		IP:                    "127.0.0.1",
 		HTTPStatus:            200,
-		Body:                  []byte("body"),
 		Errors:                nil,
 		Connected:             true,
 		Success:               true,
@@ -59,7 +58,6 @@ var (
 		Hostname:              "example.org",
 		IP:                    "127.0.0.1",
 		HTTPStatus:            200,
-		Body:                  []byte("body"),
 		Errors:                []string{"error-1", "error-2"},
 		Connected:             true,
 		Success:               false,
@@ -83,17 +81,17 @@ var (
 	}
 )

-func TestInMemoryStore_Insert(t *testing.T) {
-	store := NewInMemoryStore()
+func TestStore_Insert(t *testing.T) {
+	store, _ := NewStore("")
 	store.Insert(&testService, &testSuccessfulResult)
 	store.Insert(&testService, &testUnsuccessfulResult)

-	if len(store.serviceStatuses) != 1 {
-		t.Fatalf("expected 1 ServiceStatus, got %d", len(store.serviceStatuses))
+	if store.cache.Count() != 1 {
+		t.Fatalf("expected 1 ServiceStatus, got %d", store.cache.Count())
 	}
 	key := fmt.Sprintf("%s_%s", testService.Group, testService.Name)
-	serviceStatus, exists := store.serviceStatuses[key]
-	if !exists {
+	serviceStatus := store.GetServiceStatusByKey(key)
+	if serviceStatus == nil {
 		t.Fatalf("Store should've had key '%s', but didn't", key)
 	}
 	if len(serviceStatus.Results) != 2 {
@@ -107,9 +105,6 @@ func TestInMemoryStore_Insert(t *testing.T) {
 		if r.DNSRCode != expectedResult.DNSRCode {
 			t.Errorf("Result at index %d should've had a DNSRCode of %s, but was actually %s", i, expectedResult.DNSRCode, r.DNSRCode)
 		}
-		if len(r.Body) != len(expectedResult.Body) {
-			t.Errorf("Result at index %d should've had a body of length %d, but was actually %d", i, len(expectedResult.Body), len(r.Body))
-		}
 		if r.Hostname != expectedResult.Hostname {
 			t.Errorf("Result at index %d should've had a Hostname of %s, but was actually %s", i, expectedResult.Hostname, r.Hostname)
 		}
@@ -140,8 +135,8 @@ func TestInMemoryStore_Insert(t *testing.T) {
 	}
 }

-func TestInMemoryStore_GetServiceStatus(t *testing.T) {
-	store := NewInMemoryStore()
+func TestStore_GetServiceStatus(t *testing.T) {
+	store, _ := NewStore("")
 	store.Insert(&testService, &testSuccessfulResult)
 	store.Insert(&testService, &testUnsuccessfulResult)

@@ -163,8 +158,8 @@ func TestInMemoryStore_GetServiceStatus(t *testing.T) {
 	}
 }

-func TestInMemoryStore_GetServiceStatusForMissingStatusReturnsNil(t *testing.T) {
-	store := NewInMemoryStore()
+func TestStore_GetServiceStatusForMissingStatusReturnsNil(t *testing.T) {
+	store, _ := NewStore("")
 	store.Insert(&testService, &testSuccessfulResult)

 	serviceStatus := store.GetServiceStatus("nonexistantgroup", "nonexistantname")
@@ -181,8 +176,8 @@ func TestInMemoryStore_GetServiceStatusForMissingStatusReturnsNil(t *testing.T)
 	}
 }

-func TestInMemoryStore_GetServiceStatusByKey(t *testing.T) {
-	store := NewInMemoryStore()
+func TestStore_GetServiceStatusByKey(t *testing.T) {
+	store, _ := NewStore("")
 	store.Insert(&testService, &testSuccessfulResult)
 	store.Insert(&testService, &testUnsuccessfulResult)

@@ -204,8 +199,8 @@ func TestInMemoryStore_GetServiceStatusByKey(t *testing.T) {
 	}
 }

-func TestInMemoryStore_GetAllAsJSON(t *testing.T) {
-	store := NewInMemoryStore()
+func TestStore_GetAllServiceStatusesWithResultPagination(t *testing.T) {
+	store, _ := NewStore("")
 	firstResult := &testSuccessfulResult
 	secondResult := &testUnsuccessfulResult
 	store.Insert(&testService, firstResult)
@@ -213,12 +208,65 @@ func TestInMemoryStore_GetAllAsJSON(t *testing.T) {
 	// Can't be bothered dealing with timezone issues on the worker that runs the automated tests
 	firstResult.Timestamp = time.Time{}
 	secondResult.Timestamp = time.Time{}
-	output, err := store.GetAllAsJSON()
-	if err != nil {
-		t.Fatal("shouldn't have returned an error, got", err.Error())
+	serviceStatuses := store.GetAllServiceStatusesWithResultPagination(1, 20)
+	if len(serviceStatuses) != 1 {
+		t.Fatal("expected 1 service status")
 	}
-	expectedOutput := `{"group_name":{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"errors":null,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}],"uptime":{"7d":0.5,"24h":0.5,"1h":0.5}}}`
-	if string(output) != expectedOutput {
-		t.Errorf("expected:\n %s\n\ngot:\n %s", expectedOutput, string(output))
+	actual, exists := serviceStatuses[util.ConvertGroupAndServiceToKey(testService.Group, testService.Name)]
+	if !exists {
+		t.Fatal("expected service status to exist")
+	}
+	if len(actual.Results) != 2 {
+		t.Error("expected 2 results, got", len(actual.Results))
+	}
+	if len(actual.Events) != 2 {
+		t.Error("expected 2 events, got", len(actual.Events))
+	}
+}
+
+func TestStore_DeleteAllServiceStatusesNotInKeys(t *testing.T) {
+	store, _ := NewStore("")
+	firstService := core.Service{Name: "service-1", Group: "group"}
+	secondService := core.Service{Name: "service-2", Group: "group"}
+	result := &testSuccessfulResult
+	store.Insert(&firstService, result)
+	store.Insert(&secondService, result)
+	if store.cache.Count() != 2 {
+		t.Errorf("expected cache to have 2 keys, got %d", store.cache.Count())
+	}
+	if store.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(firstService.Group, firstService.Name)) == nil {
+		t.Fatal("firstService should exist")
+	}
+	if store.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(secondService.Group, secondService.Name)) == nil {
+		t.Fatal("secondService should exist")
+	}
+	store.DeleteAllServiceStatusesNotInKeys([]string{util.ConvertGroupAndServiceToKey(firstService.Group, firstService.Name)})
+	if store.cache.Count() != 1 {
+		t.Fatalf("expected cache to have 1 keys, got %d", store.cache.Count())
+	}
+	if store.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(firstService.Group, firstService.Name)) == nil {
+		t.Error("secondService should've been deleted")
+	}
+	if store.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(secondService.Group, secondService.Name)) != nil {
+		t.Error("firstService should still exist")
+	}
+}
+
+func TestStore_Save(t *testing.T) {
+	files := []string{
+		"",
+		t.TempDir() + "/test.db",
+	}
+	for _, file := range files {
+		t.Run(file, func(t *testing.T) {
+			store, err := NewStore(file)
+			if err != nil {
+				t.Fatal("expected no error, got", err.Error())
+			}
+			err = store.Save()
+			if err != nil {
+				t.Fatal("expected no error, got", err.Error())
+			}
+		})
 	}
 }
--- a/storage/store/store.go
+++ b/storage/store/store.go
@@ -0,0 +1,38 @@
+package store
+
+import (
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage/store/memory"
+)
+
+// Store is the interface that each stores should implement
+type Store interface {
+	// GetAllAsJSON returns the JSON encoding of all monitored core.ServiceStatus
+	// with a subset of core.Result defined by the page and pageSize parameters
+	GetAllServiceStatusesWithResultPagination(page, pageSize int) map[string]*core.ServiceStatus
+
+	// GetServiceStatus returns the service status for a given service name in the given group
+	GetServiceStatus(groupName, serviceName string) *core.ServiceStatus
+
+	// GetServiceStatusByKey returns the service status for a given key
+	GetServiceStatusByKey(key string) *core.ServiceStatus
+
+	// Insert adds the observed result for the specified service into the store
+	Insert(service *core.Service, result *core.Result)
+
+	// DeleteAllServiceStatusesNotInKeys removes all ServiceStatus that are not within the keys provided
+	//
+	// Used to delete services that have been persisted but are no longer part of the configured services
+	DeleteAllServiceStatusesNotInKeys(keys []string) int
+
+	// Clear deletes everything from the store
+	Clear()
+
+	// Save persists the data if and where it needs to be persisted
+	Save() error
+}
+
+var (
+	// Validate interface implementation on compile
+	_ Store = (*memory.Store)(nil)
+)
--- a/storage/store/store_bench_test.go
+++ b/storage/store/store_bench_test.go
@@ -0,0 +1,137 @@
+package store
+
+import (
+	"testing"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage/store/memory"
+)
+
+var (
+	firstCondition  = core.Condition("[STATUS] == 200")
+	secondCondition = core.Condition("[RESPONSE_TIME] < 500")
+	thirdCondition  = core.Condition("[CERTIFICATE_EXPIRATION] < 72h")
+
+	timestamp = time.Now()
+
+	testService = core.Service{
+		Name:                    "name",
+		Group:                   "group",
+		URL:                     "https://example.org/what/ever",
+		Method:                  "GET",
+		Body:                    "body",
+		Interval:                30 * time.Second,
+		Conditions:              []*core.Condition{&firstCondition, &secondCondition, &thirdCondition},
+		Alerts:                  nil,
+		Insecure:                false,
+		NumberOfFailuresInARow:  0,
+		NumberOfSuccessesInARow: 0,
+	}
+	testSuccessfulResult = core.Result{
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		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 BenchmarkStore_GetAllAsJSON(b *testing.B) {
+	memoryStore, err := memory.NewStore("")
+	if err != nil {
+		b.Fatal("failed to create store:", err.Error())
+	}
+	type Scenario struct {
+		Name  string
+		Store Store
+	}
+	scenarios := []Scenario{
+		{
+			Name:  "memory",
+			Store: memoryStore,
+		},
+	}
+	for _, scenario := range scenarios {
+		scenario.Store.Insert(&testService, &testSuccessfulResult)
+		scenario.Store.Insert(&testService, &testUnsuccessfulResult)
+		b.Run(scenario.Name, func(b *testing.B) {
+			for n := 0; n < b.N; n++ {
+				scenario.Store.GetAllServiceStatusesWithResultPagination(1, 20)
+			}
+			b.ReportAllocs()
+		})
+	}
+}
+
+func BenchmarkStore_Insert(b *testing.B) {
+	memoryStore, err := memory.NewStore("")
+	if err != nil {
+		b.Fatal("failed to create store:", err.Error())
+	}
+	type Scenario struct {
+		Name  string
+		Store Store
+	}
+	scenarios := []Scenario{
+		{
+			Name:  "memory",
+			Store: memoryStore,
+		},
+	}
+	for _, scenario := range scenarios {
+		b.Run(scenario.Name, func(b *testing.B) {
+			for n := 0; n < b.N; n++ {
+				if n%100 == 0 {
+					scenario.Store.Insert(&testService, &testSuccessfulResult)
+				} else {
+					scenario.Store.Insert(&testService, &testUnsuccessfulResult)
+				}
+			}
+			b.ReportAllocs()
+		})
+	}
+}
--- a/vendor/github.com/TwinProduction/gocache/README.md
+++ b/vendor/github.com/TwinProduction/gocache/README.md
@@ -306,9 +306,9 @@ If you do not start the janitor, there will be no passive deletion of expired ke
 For the sake of convenience, a ready-to-go cache server is available 
 through the `gocacheserver` package. 

-The reason why the server is in a different package is because `gocache` does not use 
-any external dependencies, but rather than re-inventing the wheel, the server 
-implementation uses redcon, which is a Redis server framework for Go.
+The reason why the server is in a different package is because `gocache` limit its external dependencies to the strict 
+minimum (e.g. boltdb for persistence), however, rather than re-inventing the wheel, the server implementation uses
+redcon, which is a very good Redis server framework for Go.

 That way, those who desire to use gocache without the server will not add any extra dependencies
 as long as they don't import the `gocacheserver` package. 
@@ -323,7 +323,7 @@ import (

 func main() {
 	cache := gocache.NewCache().WithEvictionPolicy(gocache.LeastRecentlyUsed).WithMaxSize(100000)
-	server := gocacheserver.NewServer(cache)
+	server := gocacheserver.NewServer(cache).WithPort(6379)
 	server.Start()
 }
 ```
@@ -382,43 +382,67 @@ but if you're looking into using a library like gocache, odds are, you want more
 | mem    | 32G DDR4 |

 ```
-BenchmarkMap_Get-8                                                         	95936680	      26.3 ns/op
-BenchmarkMap_SetSmallValue-8                                               	 7738132	       424 ns/op
-BenchmarkMap_SetMediumValue-8                                              	 7766346	       424 ns/op
-BenchmarkMap_SetLargeValue-8                                               	 7947063	       435 ns/op
-BenchmarkCache_Get-8                                                       	54549049	      45.7 ns/op
-BenchmarkCache_SetSmallValue-8                                             	35225013	      69.2 ns/op
-BenchmarkCache_SetMediumValue-8                                            	 5952064	       412 ns/op
-BenchmarkCache_SetLargeValue-8                                             	 5969121	       411 ns/op
-BenchmarkCache_GetUsingLRU-8                                               	54545949	      45.6 ns/op
-BenchmarkCache_SetSmallValueUsingLRU-8                                     	 5909504	       419 ns/op
-BenchmarkCache_SetMediumValueUsingLRU-8                                    	 5910885	       418 ns/op
-BenchmarkCache_SetLargeValueUsingLRU-8                                     	 5867544	       419 ns/op
-BenchmarkCache_SetSmallValueWhenUsingMaxMemoryUsage-8                      	 5477178	       462 ns/op
-BenchmarkCache_SetMediumValueWhenUsingMaxMemoryUsage-8                     	 5417595	       475 ns/op
-BenchmarkCache_SetLargeValueWhenUsingMaxMemoryUsage-8                      	 5215263	       479 ns/op
-BenchmarkCache_SetSmallValueWithMaxSize10-8                                	10115574	       236 ns/op
-BenchmarkCache_SetMediumValueWithMaxSize10-8                               	10242792	       241 ns/op
-BenchmarkCache_SetLargeValueWithMaxSize10-8                                	10201894	       241 ns/op
-BenchmarkCache_SetSmallValueWithMaxSize1000-8                              	 9637113	       253 ns/op
-BenchmarkCache_SetMediumValueWithMaxSize1000-8                             	 9635175	       253 ns/op
-BenchmarkCache_SetLargeValueWithMaxSize1000-8                              	 9598982	       260 ns/op
-BenchmarkCache_SetSmallValueWithMaxSize100000-8                            	 7642584	       337 ns/op
-BenchmarkCache_SetMediumValueWithMaxSize100000-8                           	 7407571	       344 ns/op
-BenchmarkCache_SetLargeValueWithMaxSize100000-8                            	 7071360	       345 ns/op
-BenchmarkCache_SetSmallValueWithMaxSize100000AndLRU-8                      	 7544194	       332 ns/op
-BenchmarkCache_SetMediumValueWithMaxSize100000AndLRU-8                     	 7667004	       344 ns/op
-BenchmarkCache_SetLargeValueWithMaxSize100000AndLRU-8                      	 7357642	       338 ns/op
-BenchmarkCache_GetAndSetMultipleConcurrently-8                             	 1442306	      1684 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndLRU-8                 	 5117271	       477 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndFIFO-8                	 5228412	       475 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndNoEvictionAndLRU-8    	 5139195	       529 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithRandomKeysAndNoEvictionAndFIFO-8   	 5251639	       511 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithFrequentEvictionsAndLRU-8          	 7384626	       334 ns/op
-BenchmarkCache_GetAndSetConcurrentlyWithFrequentEvictionsAndFIFO-8         	 7361985	       332 ns/op
-BenchmarkCache_GetConcurrentlyWithLRU-8                                    	 3370784	       726 ns/op
-BenchmarkCache_GetConcurrentlyWithFIFO-8                                   	 3749994	       681 ns/op
-BenchmarkCache_GetKeysThatDoNotExistConcurrently-8                         	17647344	       143 ns/op
+// Normal map
+BenchmarkMap_Get
+BenchmarkMap_Get-8                                                              46087372  26.7 ns/op
+BenchmarkMap_Set                                                                   
+BenchmarkMap_Set/small_value-8                                                   3841911   389 ns/op
+BenchmarkMap_Set/medium_value-8                                                  3887074   391 ns/op
+BenchmarkMap_Set/large_value-8                                                   3921956   393 ns/op
+// Gocache                                                                         
+BenchmarkCache_Get                                                                 
+BenchmarkCache_Get/FirstInFirstOut-8                                            27273036  46.4 ns/op
+BenchmarkCache_Get/LeastRecentlyUsed-8                                          26648248  46.3 ns/op
+BenchmarkCache_Set                                                              
+BenchmarkCache_Set/FirstInFirstOut_small_value-8                                 2919584   405 ns/op
+BenchmarkCache_Set/FirstInFirstOut_medium_value-8                                2990841   391 ns/op
+BenchmarkCache_Set/FirstInFirstOut_large_value-8                                 2970513   391 ns/op
+BenchmarkCache_Set/LeastRecentlyUsed_small_value-8                               2962939   402 ns/op
+BenchmarkCache_Set/LeastRecentlyUsed_medium_value-8                              2962963   390 ns/op
+BenchmarkCache_Set/LeastRecentlyUsed_large_value-8                               2962928   394 ns/op
+BenchmarkCache_SetUsingMaxMemoryUsage                                           
+BenchmarkCache_SetUsingMaxMemoryUsage/small_value-8                              2683356   447 ns/op
+BenchmarkCache_SetUsingMaxMemoryUsage/medium_value-8                             2637578   441 ns/op
+BenchmarkCache_SetUsingMaxMemoryUsage/large_value-8                              2672434   443 ns/op
+BenchmarkCache_SetWithMaxSize                                                   
+BenchmarkCache_SetWithMaxSize/100_small_value-8                                  4782966   252 ns/op
+BenchmarkCache_SetWithMaxSize/10000_small_value-8                                4067967   296 ns/op
+BenchmarkCache_SetWithMaxSize/100000_small_value-8                               3762055   328 ns/op
+BenchmarkCache_SetWithMaxSize/100_medium_value-8                                 4760479   252 ns/op
+BenchmarkCache_SetWithMaxSize/10000_medium_value-8                               4081050   295 ns/op
+BenchmarkCache_SetWithMaxSize/100000_medium_value-8                              3785050   330 ns/op
+BenchmarkCache_SetWithMaxSize/100_large_value-8                                  4732909   254 ns/op
+BenchmarkCache_SetWithMaxSize/10000_large_value-8                                4079533   297 ns/op
+BenchmarkCache_SetWithMaxSize/100000_large_value-8                               3712820   331 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU                                             
+BenchmarkCache_SetWithMaxSizeAndLRU/100_small_value-8                            4761732   254 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/10000_small_value-8                          4084474   296 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/100000_small_value-8                         3761402   329 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/100_medium_value-8                           4783075   254 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/10000_medium_value-8                         4103980   296 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/100000_medium_value-8                        3646023   331 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/100_large_value-8                            4779025   254 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/10000_large_value-8                          4096192   296 ns/op
+BenchmarkCache_SetWithMaxSizeAndLRU/100000_large_value-8                         3726823   331 ns/op
+BenchmarkCache_GetSetMultipleConcurrent                                         
+BenchmarkCache_GetSetMultipleConcurrent-8                                         707142  1698 ns/op
+BenchmarkCache_GetSetConcurrentWithFrequentEviction
+BenchmarkCache_GetSetConcurrentWithFrequentEviction/FirstInFirstOut-8            3616256   334 ns/op
+BenchmarkCache_GetSetConcurrentWithFrequentEviction/LeastRecentlyUsed-8          3636367   331 ns/op
+BenchmarkCache_GetConcurrentWithLRU                                              
+BenchmarkCache_GetConcurrentWithLRU/FirstInFirstOut-8                            4405557   268 ns/op
+BenchmarkCache_GetConcurrentWithLRU/LeastRecentlyUsed-8                          4445475   269 ns/op
+BenchmarkCache_WithForceNilInterfaceOnNilPointer
+BenchmarkCache_WithForceNilInterfaceOnNilPointer/true_with_nil_struct_pointer-8  6184591   191 ns/op
+BenchmarkCache_WithForceNilInterfaceOnNilPointer/true-8                          6090482   191 ns/op
+BenchmarkCache_WithForceNilInterfaceOnNilPointer/false_with_nil_struct_pointer-8 6184629   187 ns/op
+BenchmarkCache_WithForceNilInterfaceOnNilPointer/false-8                         6281781   186 ns/op
+(Trimmed "BenchmarkCache_" for readability)
+WithForceNilInterfaceOnNilPointerWithConcurrency
+WithForceNilInterfaceOnNilPointerWithConcurrency/true_with_nil_struct_pointer-8  4379564   268 ns/op
+WithForceNilInterfaceOnNilPointerWithConcurrency/true-8                          4379558   265 ns/op
+WithForceNilInterfaceOnNilPointerWithConcurrency/false_with_nil_struct_pointer-8 4444456   261 ns/op
+WithForceNilInterfaceOnNilPointerWithConcurrency/false-8                         4493896   262 ns/op
 ```


--- a/vendor/github.com/TwinProduction/gocache/go.mod
+++ b/vendor/github.com/TwinProduction/gocache/go.mod
@@ -3,9 +3,9 @@ module github.com/TwinProduction/gocache
 go 1.15

 require (
-	github.com/boltdb/bolt v1.3.1
 	github.com/go-redis/redis v6.15.9+incompatible
 	github.com/onsi/ginkgo v1.14.1 // indirect
 	github.com/onsi/gomega v1.10.2 // indirect
 	github.com/tidwall/redcon v1.3.2
+	go.etcd.io/bbolt v1.3.5
 )
--- a/vendor/github.com/TwinProduction/gocache/go.sum
+++ b/vendor/github.com/TwinProduction/gocache/go.sum
@@ -1,5 +1,3 @@
-github.com/boltdb/bolt v1.3.1 h1:JQmyP4ZBrce+ZQu0dY660FMfatumYDLun9hBCUVIkF4=
-github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
@@ -30,6 +28,8 @@ github.com/onsi/gomega v1.10.2 h1:aY/nuoWlKJud2J6U0E3NWsjlg+0GtwXxgEqthRdzlcs=
 github.com/onsi/gomega v1.10.2/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/tidwall/redcon v1.3.2 h1:8INx/Nm3VSUbDUT16TH1rMgYQsbXNqy9xcX70edHXbo=
 github.com/tidwall/redcon v1.3.2/go.mod h1:bdYBm4rlcWpst2XMwKVzWDF9CoUxEbUmM7CQrKeOZas=
+go.etcd.io/bbolt v1.3.5 h1:XAzx9gjCb0Rxj7EoqcClPD1d5ZBxZJk0jbuoPHenBt0=
+go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7 h1:AeiKBIuRw3UomYXSbLy0Mc2dDLfdtbT/IVn4keq83P0=
@@ -40,6 +40,7 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200519105757-fe76b779f299 h1:DYfZAGf2WMFjMxbgTjaC+2HC7NkNAQs+6Q8b9WEB/F4=
 golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
--- a/vendor/github.com/TwinProduction/gocache/gocache.go
+++ b/vendor/github.com/TwinProduction/gocache/gocache.go
@@ -170,7 +170,7 @@ func (cache *Cache) WithEvictionPolicy(policy EvictionPolicy) *Cache {
 //     value, _ := cache.Get("key")
 //     // the following returns true, because the interface{} was forcefully set to nil
 //     if value == nil {}
-//     // the following will panic, because the value has been casted to its type
+//     // the following will panic, because the value has been casted to its type (which is nil)
 //     if value.(*Struct) == nil {}
 //
 // If set to false:
@@ -218,7 +218,8 @@ func (cache *Cache) Set(key string, value interface{}) {
 // The TTL provided must be greater than 0, or NoExpiration (-1). If a negative value that isn't -1 (NoExpiration) is
 // provided, the entry will not be created if the key doesn't exist
 func (cache *Cache) SetWithTTL(key string, value interface{}, ttl time.Duration) {
-	// An interface is only nil if both its value and its type are nil, however, passing a pointer
+	// An interface is only nil if both its value and its type are nil, however, passing a nil pointer as an interface{}
+	// means that the interface itself is not nil, because the interface value is nil but not the type.
 	if cache.forceNilInterfaceOnNilPointer {
 		if value != nil && (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
 			value = nil
@@ -334,6 +335,13 @@ func (cache *Cache) Get(key string) (interface{}, bool) {
 	return entry.Value, true
 }

+// GetValue retrieves an entry using the key passed as parameter
+// Unlike Get, this function only returns the value
+func (cache *Cache) GetValue(key string) interface{} {
+	value, _ := cache.Get(key)
+	return value
+}
+
 // GetByKeys retrieves multiple entries using the keys passed as parameter
 // All keys are returned in the map, regardless of whether they exist or not, however, entries that do not exist in the
 // cache will return nil, meaning that there is no way of determining whether a key genuinely has the value nil, or
--- a/vendor/github.com/TwinProduction/gocache/persistence.go
+++ b/vendor/github.com/TwinProduction/gocache/persistence.go
@@ -8,7 +8,7 @@ import (
 	"sort"
 	"time"

-	"github.com/boltdb/bolt"
+	bolt "go.etcd.io/bbolt"
 )

 // SaveToFile stores the content of the cache to a file so that it can be read using
--- a/vendor/github.com/TwinProduction/gocache/policy.go
+++ b/vendor/github.com/TwinProduction/gocache/policy.go
@@ -3,6 +3,30 @@ package gocache
 type EvictionPolicy string

 var (
+	// LeastRecentlyUsed is an eviction policy that causes the most recently accessed cache entry to be moved to the
+	// head of the cache. Effectively, this causes the cache entries that have not been accessed for some time to
+	// gradually move closer and closer to the tail, and since the tail is the entry that gets deleted when an eviction
+	// is required, it allows less used cache entries to be evicted while keeping recently accessed entries at or close
+	// to the head.
+	//
+	// For instance, creating a Cache with a Cache.MaxSize of 3 and creating the entries 1, 2 and 3 in that order would
+	// put 3 at the head and 1 at the tail:
+	//     3 (head) -> 2 -> 1 (tail)
+	// If the cache entry 1 was then accessed, 1 would become the head and 2 the tail:
+	//     1 (head) -> 3 -> 2 (tail)
+	// If a cache entry 4 was then created, because the Cache.MaxSize is 3, the tail (2) would then be evicted:
+	//     4 (head) -> 1 -> 3 (tail)
 	LeastRecentlyUsed EvictionPolicy = "LeastRecentlyUsed"
-	FirstInFirstOut   EvictionPolicy = "FirstInFirstOut"
+
+	// FirstInFirstOut is an eviction policy that causes cache entries to be evicted in the same order that they are
+	// created.
+	//
+	// For instance, creating a Cache with a Cache.MaxSize of 3 and creating the entries 1, 2 and 3 in that order would
+	// put 3 at the head and 1 at the tail:
+	//     3 (head) -> 2 -> 1 (tail)
+	// If the cache entry 1 was then accessed, unlike with LeastRecentlyUsed, nothing would change:
+	//     3 (head) -> 2 -> 1 (tail)
+	// If a cache entry 4 was then created, because the Cache.MaxSize is 3, the tail (1) would then be evicted:
+	//     4 (head) -> 3 -> 2 (tail)
+	FirstInFirstOut EvictionPolicy = "FirstInFirstOut"
 )
--- a/vendor/github.com/TwinProduction/health/.gitattributes
+++ b/vendor/github.com/TwinProduction/health/.gitattributes
@@ -0,0 +1 @@
+* text=lf
--- a/vendor/github.com/TwinProduction/health/.gitignore
+++ b/vendor/github.com/TwinProduction/health/.gitignore
@@ -0,0 +1,2 @@
+.idea
+*.iml
--- a/vendor/github.com/TwinProduction/health/README.md
+++ b/vendor/github.com/TwinProduction/health/README.md
@@ -0,0 +1,72 @@
+# health
+
+![build](https://github.com/TwinProduction/health/workflows/build/badge.svg?branch=master) 
+[![Go Report Card](https://goreportcard.com/badge/github.com/TwinProduction/health)](https://goreportcard.com/report/github.com/TwinProduction/health)
+[![codecov](https://codecov.io/gh/TwinProduction/health/branch/master/graph/badge.svg)](https://codecov.io/gh/TwinProduction/health)
+[![Go version](https://img.shields.io/github/go-mod/go-version/TwinProduction/health.svg)](https://github.com/TwinProduction/health)
+[![Go Reference](https://pkg.go.dev/badge/github.com/TwinProduction/health.svg)](https://pkg.go.dev/github.com/TwinProduction/health)
+
+Health is a library used for creating a very simple health endpoint.
+
+While implementing a health endpoint is very simple, I've grown tired of implementing 
+it over and over again.
+
+## Installation
+
+```
+go get -u github.com/TwinProduction/health
+```
+
+
+## Usage
+
+To retrieve the handler, you must use `health.Handler()` and are expected to pass it to the router like so:
+```go
+router := http.NewServeMux()
+router.Handle("/health", health.Handler())
+server := &http.Server{
+	Addr:    ":8080",
+	Handler: router,
+}
+```
+
+By default, the handler will return `UP` when the status is down, and `DOWN` when the status is down.
+If you prefer using JSON, however, you may initialize the health handler like so:
+```go
+router.Handle("/health", health.Handler().WithJSON(true))
+```
+The above will cause the response body to become `{"status":"UP"}` and `{"status":"DOWN"}` for both status respectively.
+
+To change the health of the application, you can use `health.SetStatus(<status>)` where `<status>` is one `health.Up`
+or `health.Down`:
+
+```go
+health.SetStatus(health.Up)
+health.SetStatus(health.Down)
+```
+
+### Complete example
+
+```go
+package main
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/TwinProduction/health"
+)
+
+func main() {
+	router := http.NewServeMux()
+	router.Handle("/health", health.Handler())
+	server := &http.Server{
+		Addr:         "0.0.0.0:8080",
+		Handler:      router,
+		ReadTimeout:  15 * time.Second,
+		WriteTimeout: 15 * time.Second,
+		IdleTimeout:  15 * time.Second,
+	}
+	server.ListenAndServe()
+}
+```
--- a/vendor/github.com/TwinProduction/health/go.mod
+++ b/vendor/github.com/TwinProduction/health/go.mod
@@ -0,0 +1,3 @@
+module github.com/TwinProduction/health
+
+go 1.15
--- a/vendor/github.com/TwinProduction/health/health.go
+++ b/vendor/github.com/TwinProduction/health/health.go
@@ -0,0 +1,51 @@
+package health
+
+import "net/http"
+
+var (
+	handler = &healthHandler{
+		useJSON: false,
+		status:  Up,
+	}
+)
+
+type healthHandler struct {
+	useJSON bool
+	status  Status
+}
+
+// WithJSON configures whether the handler should output a response in JSON or in raw text
+//
+// Defaults to false
+func (h *healthHandler) WithJSON(v bool) *healthHandler {
+	h.useJSON = v
+	return h
+}
+
+func (h healthHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
+	var status int
+	var body []byte
+	if h.status == Up {
+		status = http.StatusOK
+	} else {
+		status = http.StatusInternalServerError
+	}
+	if h.useJSON {
+		writer.Header().Set("Content-Type", "application/json")
+		body = []byte(`{"status":"` + h.status + `"}`)
+	} else {
+		body = []byte(h.status)
+	}
+	writer.WriteHeader(status)
+	_, _ = writer.Write(body)
+}
+
+// Handler retrieves the health handler
+func Handler() *healthHandler {
+	return handler
+}
+
+// SetStatus sets the status to be reflected by the health handler
+func SetStatus(status Status) {
+	handler.status = status
+}
--- a/vendor/github.com/TwinProduction/health/status.go
+++ b/vendor/github.com/TwinProduction/health/status.go
@@ -0,0 +1,8 @@
+package health
+
+type Status string
+
+var (
+	Down Status = "DOWN"
+	Up   Status = "UP"
+)
--- a/vendor/github.com/boltdb/bolt/Makefile
+++ b/vendor/github.com/boltdb/bolt/Makefile
@@ -1,18 +0,0 @@
-BRANCH=`git rev-parse --abbrev-ref HEAD`
-COMMIT=`git rev-parse --short HEAD`
-GOLDFLAGS="-X main.branch $(BRANCH) -X main.commit $(COMMIT)"
-
-default: build
-
-race:
-	@go test -v -race -test.run="TestSimulate_(100op|1000op)"
-
-# go get github.com/kisielk/errcheck
-errcheck:
-	@errcheck -ignorepkg=bytes -ignore=os:Remove github.com/boltdb/bolt
-
-test: 
-	@go test -v -cover .
-	@go test -v ./cmd/bolt
-
-.PHONY: fmt test
--- a/vendor/github.com/boltdb/bolt/appveyor.yml
+++ b/vendor/github.com/boltdb/bolt/appveyor.yml
@@ -1,18 +0,0 @@
-version: "{build}"
-
-os: Windows Server 2012 R2
-
-clone_folder: c:\gopath\src\github.com\boltdb\bolt
-
-environment:
-  GOPATH: c:\gopath
-
-install:
-  - echo %PATH%
-  - echo %GOPATH%
-  - go version
-  - go env
-  - go get -v -t ./...
-
-build_script:
-  - go test -v ./...
--- a/vendor/github.com/boltdb/bolt/bolt_arm.go
+++ b/vendor/github.com/boltdb/bolt/bolt_arm.go
@@ -1,28 +0,0 @@
-package bolt
-
-import "unsafe"
-
-// maxMapSize represents the largest mmap size supported by Bolt.
-const maxMapSize = 0x7FFFFFFF // 2GB
-
-// maxAllocSize is the size used when creating array pointers.
-const maxAllocSize = 0xFFFFFFF
-
-// Are unaligned load/stores broken on this arch?
-var brokenUnaligned bool
-
-func init() {
-	// Simple check to see whether this arch handles unaligned load/stores
-	// correctly.
-
-	// ARM9 and older devices require load/stores to be from/to aligned
-	// addresses. If not, the lower 2 bits are cleared and that address is
-	// read in a jumbled up order.
-
-	// See http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.faqs/ka15414.html
-
-	raw := [6]byte{0xfe, 0xef, 0x11, 0x22, 0x22, 0x11}
-	val := *(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&raw)) + 2))
-
-	brokenUnaligned = val != 0x11222211
-}
--- a/vendor/github.com/boltdb/bolt/freelist.go
+++ b/vendor/github.com/boltdb/bolt/freelist.go
@@ -1,252 +0,0 @@
-package bolt
-
-import (
-	"fmt"
-	"sort"
-	"unsafe"
-)
-
-// freelist represents a list of all pages that are available for allocation.
-// It also tracks pages that have been freed but are still in use by open transactions.
-type freelist struct {
-	ids     []pgid          // all free and available free page ids.
-	pending map[txid][]pgid // mapping of soon-to-be free page ids by tx.
-	cache   map[pgid]bool   // fast lookup of all free and pending page ids.
-}
-
-// newFreelist returns an empty, initialized freelist.
-func newFreelist() *freelist {
-	return &freelist{
-		pending: make(map[txid][]pgid),
-		cache:   make(map[pgid]bool),
-	}
-}
-
-// size returns the size of the page after serialization.
-func (f *freelist) size() int {
-	n := f.count()
-	if n >= 0xFFFF {
-		// The first element will be used to store the count. See freelist.write.
-		n++
-	}
-	return pageHeaderSize + (int(unsafe.Sizeof(pgid(0))) * n)
-}
-
-// count returns count of pages on the freelist
-func (f *freelist) count() int {
-	return f.free_count() + f.pending_count()
-}
-
-// free_count returns count of free pages
-func (f *freelist) free_count() int {
-	return len(f.ids)
-}
-
-// pending_count returns count of pending pages
-func (f *freelist) pending_count() int {
-	var count int
-	for _, list := range f.pending {
-		count += len(list)
-	}
-	return count
-}
-
-// copyall copies into dst a list of all free ids and all pending ids in one sorted list.
-// f.count returns the minimum length required for dst.
-func (f *freelist) copyall(dst []pgid) {
-	m := make(pgids, 0, f.pending_count())
-	for _, list := range f.pending {
-		m = append(m, list...)
-	}
-	sort.Sort(m)
-	mergepgids(dst, f.ids, m)
-}
-
-// allocate returns the starting page id of a contiguous list of pages of a given size.
-// If a contiguous block cannot be found then 0 is returned.
-func (f *freelist) allocate(n int) pgid {
-	if len(f.ids) == 0 {
-		return 0
-	}
-
-	var initial, previd pgid
-	for i, id := range f.ids {
-		if id <= 1 {
-			panic(fmt.Sprintf("invalid page allocation: %d", id))
-		}
-
-		// Reset initial page if this is not contiguous.
-		if previd == 0 || id-previd != 1 {
-			initial = id
-		}
-
-		// If we found a contiguous block then remove it and return it.
-		if (id-initial)+1 == pgid(n) {
-			// If we're allocating off the beginning then take the fast path
-			// and just adjust the existing slice. This will use extra memory
-			// temporarily but the append() in free() will realloc the slice
-			// as is necessary.
-			if (i + 1) == n {
-				f.ids = f.ids[i+1:]
-			} else {
-				copy(f.ids[i-n+1:], f.ids[i+1:])
-				f.ids = f.ids[:len(f.ids)-n]
-			}
-
-			// Remove from the free cache.
-			for i := pgid(0); i < pgid(n); i++ {
-				delete(f.cache, initial+i)
-			}
-
-			return initial
-		}
-
-		previd = id
-	}
-	return 0
-}
-
-// free releases a page and its overflow for a given transaction id.
-// If the page is already free then a panic will occur.
-func (f *freelist) free(txid txid, p *page) {
-	if p.id <= 1 {
-		panic(fmt.Sprintf("cannot free page 0 or 1: %d", p.id))
-	}
-
-	// Free page and all its overflow pages.
-	var ids = f.pending[txid]
-	for id := p.id; id <= p.id+pgid(p.overflow); id++ {
-		// Verify that page is not already free.
-		if f.cache[id] {
-			panic(fmt.Sprintf("page %d already freed", id))
-		}
-
-		// Add to the freelist and cache.
-		ids = append(ids, id)
-		f.cache[id] = true
-	}
-	f.pending[txid] = ids
-}
-
-// release moves all page ids for a transaction id (or older) to the freelist.
-func (f *freelist) release(txid txid) {
-	m := make(pgids, 0)
-	for tid, ids := range f.pending {
-		if tid <= txid {
-			// Move transaction's pending pages to the available freelist.
-			// Don't remove from the cache since the page is still free.
-			m = append(m, ids...)
-			delete(f.pending, tid)
-		}
-	}
-	sort.Sort(m)
-	f.ids = pgids(f.ids).merge(m)
-}
-
-// rollback removes the pages from a given pending tx.
-func (f *freelist) rollback(txid txid) {
-	// Remove page ids from cache.
-	for _, id := range f.pending[txid] {
-		delete(f.cache, id)
-	}
-
-	// Remove pages from pending list.
-	delete(f.pending, txid)
-}
-
-// freed returns whether a given page is in the free list.
-func (f *freelist) freed(pgid pgid) bool {
-	return f.cache[pgid]
-}
-
-// read initializes the freelist from a freelist page.
-func (f *freelist) read(p *page) {
-	// If the page.count is at the max uint16 value (64k) then it's considered
-	// an overflow and the size of the freelist is stored as the first element.
-	idx, count := 0, int(p.count)
-	if count == 0xFFFF {
-		idx = 1
-		count = int(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[0])
-	}
-
-	// Copy the list of page ids from the freelist.
-	if count == 0 {
-		f.ids = nil
-	} else {
-		ids := ((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[idx:count]
-		f.ids = make([]pgid, len(ids))
-		copy(f.ids, ids)
-
-		// Make sure they're sorted.
-		sort.Sort(pgids(f.ids))
-	}
-
-	// Rebuild the page cache.
-	f.reindex()
-}
-
-// write writes the page ids onto a freelist page. All free and pending ids are
-// saved to disk since in the event of a program crash, all pending ids will
-// become free.
-func (f *freelist) write(p *page) error {
-	// Combine the old free pgids and pgids waiting on an open transaction.
-
-	// Update the header flag.
-	p.flags |= freelistPageFlag
-
-	// The page.count can only hold up to 64k elements so if we overflow that
-	// number then we handle it by putting the size in the first element.
-	lenids := f.count()
-	if lenids == 0 {
-		p.count = uint16(lenids)
-	} else if lenids < 0xFFFF {
-		p.count = uint16(lenids)
-		f.copyall(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[:])
-	} else {
-		p.count = 0xFFFF
-		((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[0] = pgid(lenids)
-		f.copyall(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[1:])
-	}
-
-	return nil
-}
-
-// reload reads the freelist from a page and filters out pending items.
-func (f *freelist) reload(p *page) {
-	f.read(p)
-
-	// Build a cache of only pending pages.
-	pcache := make(map[pgid]bool)
-	for _, pendingIDs := range f.pending {
-		for _, pendingID := range pendingIDs {
-			pcache[pendingID] = true
-		}
-	}
-
-	// Check each page in the freelist and build a new available freelist
-	// with any pages not in the pending lists.
-	var a []pgid
-	for _, id := range f.ids {
-		if !pcache[id] {
-			a = append(a, id)
-		}
-	}
-	f.ids = a
-
-	// Once the available list is rebuilt then rebuild the free cache so that
-	// it includes the available and pending free pages.
-	f.reindex()
-}
-
-// reindex rebuilds the free cache based on available and pending free lists.
-func (f *freelist) reindex() {
-	f.cache = make(map[pgid]bool, len(f.ids))
-	for _, id := range f.ids {
-		f.cache[id] = true
-	}
-	for _, pendingIDs := range f.pending {
-		for _, pendingID := range pendingIDs {
-			f.cache[pendingID] = true
-		}
-	}
-}
--- a/vendor/github.com/boltdb/bolt/.gitignore
+++ b/vendor/github.com/boltdb/bolt/.gitignore
@@ -2,3 +2,4 @@
 *.test
 *.swp
 /bin/
+cover.out
--- a/vendor/go.etcd.io/bbolt/.travis.yml
+++ b/vendor/go.etcd.io/bbolt/.travis.yml
@@ -0,0 +1,17 @@
+language: go
+go_import_path: go.etcd.io/bbolt
+
+sudo: false
+
+go:
+- 1.12
+
+before_install:
+- go get -v honnef.co/go/tools/...
+- go get -v github.com/kisielk/errcheck
+
+script:
+- make fmt
+- make test
+- make race
+# - make errcheck
--- a/vendor/github.com/boltdb/bolt/LICENSE
+++ b/vendor/github.com/boltdb/bolt/LICENSE
--- a/vendor/go.etcd.io/bbolt/Makefile
+++ b/vendor/go.etcd.io/bbolt/Makefile
@@ -0,0 +1,38 @@
+BRANCH=`git rev-parse --abbrev-ref HEAD`
+COMMIT=`git rev-parse --short HEAD`
+GOLDFLAGS="-X main.branch $(BRANCH) -X main.commit $(COMMIT)"
+
+default: build
+
+race:
+	@TEST_FREELIST_TYPE=hashmap go test -v -race -test.run="TestSimulate_(100op|1000op)"
+	@echo "array freelist test"
+	@TEST_FREELIST_TYPE=array go test -v -race -test.run="TestSimulate_(100op|1000op)"
+
+fmt:
+	!(gofmt -l -s -d $(shell find . -name \*.go) | grep '[a-z]')
+
+# go get honnef.co/go/tools/simple
+gosimple:
+	gosimple ./...
+
+# go get honnef.co/go/tools/unused
+unused:
+	unused ./...
+
+# go get github.com/kisielk/errcheck
+errcheck:
+	@errcheck -ignorepkg=bytes -ignore=os:Remove go.etcd.io/bbolt
+
+test:
+	TEST_FREELIST_TYPE=hashmap go test -timeout 20m -v -coverprofile cover.out -covermode atomic
+	# Note: gets "program not an importable package" in out of path builds
+	TEST_FREELIST_TYPE=hashmap go test -v ./cmd/bbolt
+
+	@echo "array freelist test"
+
+	@TEST_FREELIST_TYPE=array go test -timeout 20m -v -coverprofile cover.out -covermode atomic
+	# Note: gets "program not an importable package" in out of path builds
+	@TEST_FREELIST_TYPE=array go test -v ./cmd/bbolt
+
+.PHONY: race fmt errcheck test gosimple unused
--- a/vendor/github.com/boltdb/bolt/README.md
+++ b/vendor/github.com/boltdb/bolt/README.md
@@ -1,5 +1,18 @@
-Bolt [![Coverage Status](https://coveralls.io/repos/boltdb/bolt/badge.svg?branch=master)](https://coveralls.io/r/boltdb/bolt?branch=master) [![GoDoc](https://godoc.org/github.com/boltdb/bolt?status.svg)](https://godoc.org/github.com/boltdb/bolt) ![Version](https://img.shields.io/badge/version-1.2.1-green.svg)
-====
+bbolt
+=====
+
+[![Go Report Card](https://goreportcard.com/badge/github.com/etcd-io/bbolt?style=flat-square)](https://goreportcard.com/report/github.com/etcd-io/bbolt)
+[![Coverage](https://codecov.io/gh/etcd-io/bbolt/branch/master/graph/badge.svg)](https://codecov.io/gh/etcd-io/bbolt)
+[![Build Status Travis](https://img.shields.io/travis/etcd-io/bboltlabs.svg?style=flat-square&&branch=master)](https://travis-ci.com/etcd-io/bbolt)
+[![Godoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](https://godoc.org/github.com/etcd-io/bbolt)
+[![Releases](https://img.shields.io/github/release/etcd-io/bbolt/all.svg?style=flat-square)](https://github.com/etcd-io/bbolt/releases)
+[![LICENSE](https://img.shields.io/github/license/etcd-io/bbolt.svg?style=flat-square)](https://github.com/etcd-io/bbolt/blob/master/LICENSE)
+
+bbolt is a fork of [Ben Johnson's][gh_ben] [Bolt][bolt] key/value
+store. The purpose of this fork is to provide the Go community with an active
+maintenance and development target for Bolt; the goal is improved reliability
+and stability. bbolt includes bug fixes, performance enhancements, and features
+not found in Bolt while preserving backwards compatibility with the Bolt API.

 Bolt is a pure Go key/value store inspired by [Howard Chu's][hyc_symas]
 [LMDB project][lmdb]. The goal of the project is to provide a simple,
@@ -10,6 +23,8 @@ Since Bolt is meant to be used as such a low-level piece of functionality,
 simplicity is key. The API will be small and only focus on getting values
 and setting values. That's it.

+[gh_ben]: https://github.com/benbjohnson
+[bolt]: https://github.com/boltdb/bolt
 [hyc_symas]: https://twitter.com/hyc_symas
 [lmdb]: http://symas.com/mdb/

@@ -21,36 +36,42 @@ consistency and thread safety. Bolt is currently used in high-load production
 environments serving databases as large as 1TB. Many companies such as
 Shopify and Heroku use Bolt-backed services every day.

+## Project versioning
+
+bbolt uses [semantic versioning](http://semver.org).
+API should not change between patch and minor releases.
+New minor versions may add additional features to the API.
+
 ## Table of Contents

- [Getting Started](#getting-started)
-  - [Installing](#installing)
-  - [Opening a database](#opening-a-database)
-  - [Transactions](#transactions)
-    - [Read-write transactions](#read-write-transactions)
-    - [Read-only transactions](#read-only-transactions)
-    - [Batch read-write transactions](#batch-read-write-transactions)
-    - [Managing transactions manually](#managing-transactions-manually)
-  - [Using buckets](#using-buckets)
-  - [Using key/value pairs](#using-keyvalue-pairs)
-  - [Autoincrementing integer for the bucket](#autoincrementing-integer-for-the-bucket)
-  - [Iterating over keys](#iterating-over-keys)
-    - [Prefix scans](#prefix-scans)
-    - [Range scans](#range-scans)
-    - [ForEach()](#foreach)
-  - [Nested buckets](#nested-buckets)
-  - [Database backups](#database-backups)
-  - [Statistics](#statistics)
-  - [Read-Only Mode](#read-only-mode)
-  - [Mobile Use (iOS/Android)](#mobile-use-iosandroid)
- [Resources](#resources)
- [Comparison with other databases](#comparison-with-other-databases)
-  - [Postgres, MySQL, & other relational databases](#postgres-mysql--other-relational-databases)
-  - [LevelDB, RocksDB](#leveldb-rocksdb)
-  - [LMDB](#lmdb)
- [Caveats & Limitations](#caveats--limitations)
- [Reading the Source](#reading-the-source)
- [Other Projects Using Bolt](#other-projects-using-bolt)
+  - [Getting Started](#getting-started)
+    - [Installing](#installing)
+    - [Opening a database](#opening-a-database)
+    - [Transactions](#transactions)
+      - [Read-write transactions](#read-write-transactions)
+      - [Read-only transactions](#read-only-transactions)
+      - [Batch read-write transactions](#batch-read-write-transactions)
+      - [Managing transactions manually](#managing-transactions-manually)
+    - [Using buckets](#using-buckets)
+    - [Using key/value pairs](#using-keyvalue-pairs)
+    - [Autoincrementing integer for the bucket](#autoincrementing-integer-for-the-bucket)
+    - [Iterating over keys](#iterating-over-keys)
+      - [Prefix scans](#prefix-scans)
+      - [Range scans](#range-scans)
+      - [ForEach()](#foreach)
+    - [Nested buckets](#nested-buckets)
+    - [Database backups](#database-backups)
+    - [Statistics](#statistics)
+    - [Read-Only Mode](#read-only-mode)
+    - [Mobile Use (iOS/Android)](#mobile-use-iosandroid)
+  - [Resources](#resources)
+  - [Comparison with other databases](#comparison-with-other-databases)
+    - [Postgres, MySQL, & other relational databases](#postgres-mysql--other-relational-databases)
+    - [LevelDB, RocksDB](#leveldb-rocksdb)
+    - [LMDB](#lmdb)
+  - [Caveats & Limitations](#caveats--limitations)
+  - [Reading the Source](#reading-the-source)
+  - [Other Projects Using Bolt](#other-projects-using-bolt)

 ## Getting Started

@@ -59,13 +80,28 @@ Shopify and Heroku use Bolt-backed services every day.
 To start using Bolt, install Go and run `go get`:

 ```sh
-$ go get github.com/boltdb/bolt/...
+$ go get go.etcd.io/bbolt/...
 ```

 This will retrieve the library and install the `bolt` command line utility into
 your `$GOBIN` path.


+### Importing bbolt
+
+To use bbolt as an embedded key-value store, import as:
+
+```go
+import bolt "go.etcd.io/bbolt"
+
+db, err := bolt.Open(path, 0666, nil)
+if err != nil {
+  return err
+}
+defer db.Close()
+```
+
+
 ### Opening a database

 The top-level object in Bolt is a `DB`. It is represented as a single file on
@@ -79,7 +115,7 @@ package main
 import (
 	"log"

-	"github.com/boltdb/bolt"
+	bolt "go.etcd.io/bbolt"
 )

 func main() {
@@ -116,11 +152,12 @@ are not thread safe. To work with data in multiple goroutines you must start
 a transaction for each one or use locking to ensure only one goroutine accesses
 a transaction at a time. Creating transaction from the `DB` is thread safe.

-Read-only transactions and read-write transactions should not depend on one
-another and generally shouldn't be opened simultaneously in the same goroutine.
-This can cause a deadlock as the read-write transaction needs to periodically
-re-map the data file but it cannot do so while a read-only transaction is open.
-
+Transactions should not depend on one another and generally shouldn't be opened
+simultaneously in the same goroutine. This can cause a deadlock as the read-write
+transaction needs to periodically re-map the data file but it cannot do so while
+any read-only transaction is open. Even a nested read-only transaction can cause
+a deadlock, as the child transaction can block the parent transaction from releasing
+its resources.

 #### Read-write transactions

@@ -239,7 +276,7 @@ should be writable.
 ### Using buckets

 Buckets are collections of key/value pairs within the database. All keys in a
-bucket must be unique. You can create a bucket using the `DB.CreateBucket()`
+bucket must be unique. You can create a bucket using the `Tx.CreateBucket()`
 function:

 ```go
@@ -522,7 +559,7 @@ this from a read-only transaction, it will perform a hot backup and not block
 your other database reads and writes.

 By default, it will use a regular file handle which will utilize the operating
-system's page cache. See the [`Tx`](https://godoc.org/github.com/boltdb/bolt#Tx)
+system's page cache. See the [`Tx`](https://godoc.org/go.etcd.io/bbolt#Tx)
 documentation for information about optimizing for larger-than-RAM datasets.

 One common use case is to backup over HTTP so you can use tools like `cURL` to
@@ -811,7 +848,7 @@ Here are a few things to note when evaluating and using Bolt:

 ## Reading the Source

-Bolt is a relatively small code base (<3KLOC) for an embedded, serializable,
+Bolt is a relatively small code base (<5KLOC) for an embedded, serializable,
 transactional key/value database so it can be a good starting point for people
 interested in how databases work.

@@ -863,54 +900,58 @@ them via pull request.

 Below is a list of public, open source projects that use Bolt:

-* [BoltDbWeb](https://github.com/evnix/boltdbweb) - A web based GUI for BoltDB files.
-* [Operation Go: A Routine Mission](http://gocode.io) - An online programming game for Golang using Bolt for user accounts and a leaderboard.
+* [Algernon](https://github.com/xyproto/algernon) - A HTTP/2 web server with built-in support for Lua. Uses BoltDB as the default database backend.
 * [Bazil](https://bazil.org/) - A file system that lets your data reside where it is most convenient for it to reside.
-* [DVID](https://github.com/janelia-flyem/dvid) - Added Bolt as optional storage engine and testing it against Basho-tuned leveldb.
-* [Skybox Analytics](https://github.com/skybox/skybox) - A standalone funnel analysis tool for web analytics.
-* [Scuttlebutt](https://github.com/benbjohnson/scuttlebutt) - Uses Bolt to store and process all Twitter mentions of GitHub projects.
-* [Wiki](https://github.com/peterhellberg/wiki) - A tiny wiki using Goji, BoltDB and Blackfriday.
-* [ChainStore](https://github.com/pressly/chainstore) - Simple key-value interface to a variety of storage engines organized as a chain of operations.
-* [MetricBase](https://github.com/msiebuhr/MetricBase) - Single-binary version of Graphite.
-* [Gitchain](https://github.com/gitchain/gitchain) - Decentralized, peer-to-peer Git repositories aka "Git meets Bitcoin".
-* [event-shuttle](https://github.com/sclasen/event-shuttle) - A Unix system service to collect and reliably deliver messages to Kafka.
-* [ipxed](https://github.com/kelseyhightower/ipxed) - Web interface and api for ipxed.
+* [bolter](https://github.com/hasit/bolter) - Command-line app for viewing BoltDB file in your terminal.
+* [boltcli](https://github.com/spacewander/boltcli) - the redis-cli for boltdb with Lua script support.
+* [BoltHold](https://github.com/timshannon/bolthold) - An embeddable NoSQL store for Go types built on BoltDB
 * [BoltStore](https://github.com/yosssi/boltstore) - Session store using Bolt.
-* [photosite/session](https://godoc.org/bitbucket.org/kardianos/photosite/session) - Sessions for a photo viewing site.
-* [LedisDB](https://github.com/siddontang/ledisdb) - A high performance NoSQL, using Bolt as optional storage.
-* [ipLocator](https://github.com/AndreasBriese/ipLocator) - A fast ip-geo-location-server using bolt with bloom filters.
-* [cayley](https://github.com/google/cayley) - Cayley is an open-source graph database using Bolt as optional backend.
+* [Boltdb Boilerplate](https://github.com/bobintornado/boltdb-boilerplate) - Boilerplate wrapper around bolt aiming to make simple calls one-liners.
+* [BoltDbWeb](https://github.com/evnix/boltdbweb) - A web based GUI for BoltDB files.
 * [bleve](http://www.blevesearch.com/) - A pure Go search engine similar to ElasticSearch that uses Bolt as the default storage backend.
-* [tentacool](https://github.com/optiflows/tentacool) - REST api server to manage system stuff (IP, DNS, Gateway...) on a linux server.
-* [Seaweed File System](https://github.com/chrislusf/seaweedfs) - Highly scalable distributed key~file system with O(1) disk read.
-* [InfluxDB](https://influxdata.com) - Scalable datastore for metrics, events, and real-time analytics.
-* [Freehold](http://tshannon.bitbucket.org/freehold/) - An open, secure, and lightweight platform for your files and data.
-* [Prometheus Annotation Server](https://github.com/oliver006/prom_annotation_server) - Annotation server for PromDash & Prometheus service monitoring system.
-* [Consul](https://github.com/hashicorp/consul) - Consul is service discovery and configuration made easy. Distributed, highly available, and datacenter-aware.
-* [Kala](https://github.com/ajvb/kala) - Kala is a modern job scheduler optimized to run on a single node. It is persistent, JSON over HTTP API, ISO 8601 duration notation, and dependent jobs.
-* [drive](https://github.com/odeke-em/drive) - drive is an unofficial Google Drive command line client for \*NIX operating systems.
-* [stow](https://github.com/djherbis/stow) -  a persistence manager for objects
-  backed by boltdb.
+* [btcwallet](https://github.com/btcsuite/btcwallet) - A bitcoin wallet.
 * [buckets](https://github.com/joyrexus/buckets) - a bolt wrapper streamlining
  simple tx and key scans.
-* [mbuckets](https://github.com/abhigupta912/mbuckets) - A Bolt wrapper that allows easy operations on multi level (nested) buckets.
-* [Request Baskets](https://github.com/darklynx/request-baskets) - A web service to collect arbitrary HTTP requests and inspect them via REST API or simple web UI, similar to [RequestBin](http://requestb.in/) service
-* [Go Report Card](https://goreportcard.com/) - Go code quality report cards as a (free and open source) service.
-* [Boltdb Boilerplate](https://github.com/bobintornado/boltdb-boilerplate) - Boilerplate wrapper around bolt aiming to make simple calls one-liners.
-* [lru](https://github.com/crowdriff/lru) - Easy to use Bolt-backed Least-Recently-Used (LRU) read-through cache with chainable remote stores.
-* [Storm](https://github.com/asdine/storm) - Simple and powerful ORM for BoltDB.
-* [GoWebApp](https://github.com/josephspurrier/gowebapp) - A basic MVC web application in Go using BoltDB.
-* [SimpleBolt](https://github.com/xyproto/simplebolt) - A simple way to use BoltDB. Deals mainly with strings.
-* [Algernon](https://github.com/xyproto/algernon) - A HTTP/2 web server with built-in support for Lua. Uses BoltDB as the default database backend.
-* [MuLiFS](https://github.com/dankomiocevic/mulifs) - Music Library Filesystem creates a filesystem to organise your music files.
-* [GoShort](https://github.com/pankajkhairnar/goShort) - GoShort is a URL shortener written in Golang and BoltDB for persistent key/value storage and for routing it's using high performent HTTPRouter.
-* [torrent](https://github.com/anacrolix/torrent) - Full-featured BitTorrent client package and utilities in Go. BoltDB is a storage backend in development.
-* [gopherpit](https://github.com/gopherpit/gopherpit) - A web service to manage Go remote import paths with custom domains
-* [bolter](https://github.com/hasit/bolter) - Command-line app for viewing BoltDB file in your terminal.
-* [btcwallet](https://github.com/btcsuite/btcwallet) - A bitcoin wallet.
+* [cayley](https://github.com/google/cayley) - Cayley is an open-source graph database using Bolt as optional backend.
+* [ChainStore](https://github.com/pressly/chainstore) - Simple key-value interface to a variety of storage engines organized as a chain of operations.
+* [Consul](https://github.com/hashicorp/consul) - Consul is service discovery and configuration made easy. Distributed, highly available, and datacenter-aware.
+* [DVID](https://github.com/janelia-flyem/dvid) - Added Bolt as optional storage engine and testing it against Basho-tuned leveldb.
 * [dcrwallet](https://github.com/decred/dcrwallet) - A wallet for the Decred cryptocurrency.
+* [drive](https://github.com/odeke-em/drive) - drive is an unofficial Google Drive command line client for \*NIX operating systems.
+* [event-shuttle](https://github.com/sclasen/event-shuttle) - A Unix system service to collect and reliably deliver messages to Kafka.
+* [Freehold](http://tshannon.bitbucket.org/freehold/) - An open, secure, and lightweight platform for your files and data.
+* [Go Report Card](https://goreportcard.com/) - Go code quality report cards as a (free and open source) service.
+* [GoWebApp](https://github.com/josephspurrier/gowebapp) - A basic MVC web application in Go using BoltDB.
+* [GoShort](https://github.com/pankajkhairnar/goShort) - GoShort is a URL shortener written in Golang and BoltDB for persistent key/value storage and for routing it's using high performent HTTPRouter.
+* [gopherpit](https://github.com/gopherpit/gopherpit) - A web service to manage Go remote import paths with custom domains
+* [gokv](https://github.com/philippgille/gokv) - Simple key-value store abstraction and implementations for Go (Redis, Consul, etcd, bbolt, BadgerDB, LevelDB, Memcached, DynamoDB, S3, PostgreSQL, MongoDB, CockroachDB and many more)
+* [Gitchain](https://github.com/gitchain/gitchain) - Decentralized, peer-to-peer Git repositories aka "Git meets Bitcoin".
+* [InfluxDB](https://influxdata.com) - Scalable datastore for metrics, events, and real-time analytics.
+* [ipLocator](https://github.com/AndreasBriese/ipLocator) - A fast ip-geo-location-server using bolt with bloom filters.
+* [ipxed](https://github.com/kelseyhightower/ipxed) - Web interface and api for ipxed.
 * [Ironsmith](https://github.com/timshannon/ironsmith) - A simple, script-driven continuous integration (build - > test -> release) tool, with no external dependencies
-* [BoltHold](https://github.com/timshannon/bolthold) - An embeddable NoSQL store for Go types built on BoltDB
-* [Ponzu CMS](https://ponzu-cms.org) - Headless CMS + automatic JSON API with auto-HTTPS, HTTP/2 Server Push, and flexible server framework.
+* [Kala](https://github.com/ajvb/kala) - Kala is a modern job scheduler optimized to run on a single node. It is persistent, JSON over HTTP API, ISO 8601 duration notation, and dependent jobs.
+* [Key Value Access Langusge (KVAL)](https://github.com/kval-access-language) - A proposed grammar for key-value datastores offering a bbolt binding.
+* [LedisDB](https://github.com/siddontang/ledisdb) - A high performance NoSQL, using Bolt as optional storage.
+* [lru](https://github.com/crowdriff/lru) - Easy to use Bolt-backed Least-Recently-Used (LRU) read-through cache with chainable remote stores.
+* [mbuckets](https://github.com/abhigupta912/mbuckets) - A Bolt wrapper that allows easy operations on multi level (nested) buckets.
+* [MetricBase](https://github.com/msiebuhr/MetricBase) - Single-binary version of Graphite.
+* [MuLiFS](https://github.com/dankomiocevic/mulifs) - Music Library Filesystem creates a filesystem to organise your music files.
+* [NATS](https://github.com/nats-io/nats-streaming-server) - NATS Streaming uses bbolt for message and metadata storage.
+* [Operation Go: A Routine Mission](http://gocode.io) - An online programming game for Golang using Bolt for user accounts and a leaderboard.
+* [photosite/session](https://godoc.org/bitbucket.org/kardianos/photosite/session) - Sessions for a photo viewing site.
+* [Prometheus Annotation Server](https://github.com/oliver006/prom_annotation_server) - Annotation server for PromDash & Prometheus service monitoring system.
+* [reef-pi](https://github.com/reef-pi/reef-pi) - reef-pi is an award winning, modular, DIY reef tank controller using easy to learn electronics based on a Raspberry Pi.
+* [Request Baskets](https://github.com/darklynx/request-baskets) - A web service to collect arbitrary HTTP requests and inspect them via REST API or simple web UI, similar to [RequestBin](http://requestb.in/) service
+* [Seaweed File System](https://github.com/chrislusf/seaweedfs) - Highly scalable distributed key~file system with O(1) disk read.
+* [stow](https://github.com/djherbis/stow) -  a persistence manager for objects
+  backed by boltdb.
+* [Storm](https://github.com/asdine/storm) - Simple and powerful ORM for BoltDB.
+* [SimpleBolt](https://github.com/xyproto/simplebolt) - A simple way to use BoltDB. Deals mainly with strings.
+* [Skybox Analytics](https://github.com/skybox/skybox) - A standalone funnel analysis tool for web analytics.
+* [Scuttlebutt](https://github.com/benbjohnson/scuttlebutt) - Uses Bolt to store and process all Twitter mentions of GitHub projects.
+* [tentacool](https://github.com/optiflows/tentacool) - REST api server to manage system stuff (IP, DNS, Gateway...) on a linux server.
+* [torrent](https://github.com/anacrolix/torrent) - Full-featured BitTorrent client package and utilities in Go. BoltDB is a storage backend in development.
+* [Wiki](https://github.com/peterhellberg/wiki) - A tiny wiki using Goji, BoltDB and Blackfriday.

 If you are using Bolt in a project please send a pull request to add it to the list.
--- a/vendor/github.com/boltdb/bolt/bolt_386.go
+++ b/vendor/github.com/boltdb/bolt/bolt_386.go
@@ -1,10 +1,7 @@
-package bolt
+package bbolt

 // maxMapSize represents the largest mmap size supported by Bolt.
 const maxMapSize = 0x7FFFFFFF // 2GB

 // maxAllocSize is the size used when creating array pointers.
 const maxAllocSize = 0xFFFFFFF
-
-// Are unaligned load/stores broken on this arch?
-var brokenUnaligned = false
--- a/vendor/go.etcd.io/bbolt/bolt_amd64.go
+++ b/vendor/go.etcd.io/bbolt/bolt_amd64.go
@@ -0,0 +1,7 @@
+package bbolt
+
+// maxMapSize represents the largest mmap size supported by Bolt.
+const maxMapSize = 0xFFFFFFFFFFFF // 256TB
+
+// maxAllocSize is the size used when creating array pointers.
+const maxAllocSize = 0x7FFFFFFF
--- a/vendor/go.etcd.io/bbolt/bolt_arm.go
+++ b/vendor/go.etcd.io/bbolt/bolt_arm.go
@@ -0,0 +1,7 @@
+package bbolt
+
+// maxMapSize represents the largest mmap size supported by Bolt.
+const maxMapSize = 0x7FFFFFFF // 2GB
+
+// maxAllocSize is the size used when creating array pointers.
+const maxAllocSize = 0xFFFFFFF
--- a/vendor/github.com/boltdb/bolt/bolt_arm64.go
+++ b/vendor/github.com/boltdb/bolt/bolt_arm64.go
@@ -1,12 +1,9 @@
 // +build arm64

-package bolt
+package bbolt

 // maxMapSize represents the largest mmap size supported by Bolt.
 const maxMapSize = 0xFFFFFFFFFFFF // 256TB

 // maxAllocSize is the size used when creating array pointers.
 const maxAllocSize = 0x7FFFFFFF
-
-// Are unaligned load/stores broken on this arch?
-var brokenUnaligned = false
--- a/vendor/github.com/boltdb/bolt/bolt_linux.go
+++ b/vendor/github.com/boltdb/bolt/bolt_linux.go
@@ -1,4 +1,4 @@
-package bolt
+package bbolt

 import (
 	"syscall"
--- a/vendor/go.etcd.io/bbolt/bolt_mips64x.go
+++ b/vendor/go.etcd.io/bbolt/bolt_mips64x.go
@@ -0,0 +1,9 @@
+// +build mips64 mips64le
+
+package bbolt
+
+// maxMapSize represents the largest mmap size supported by Bolt.
+const maxMapSize = 0x8000000000 // 512GB
+
+// maxAllocSize is the size used when creating array pointers.
+const maxAllocSize = 0x7FFFFFFF
--- a/vendor/go.etcd.io/bbolt/bolt_mipsx.go
+++ b/vendor/go.etcd.io/bbolt/bolt_mipsx.go
@@ -0,0 +1,9 @@
+// +build mips mipsle
+
+package bbolt
+
+// maxMapSize represents the largest mmap size supported by Bolt.
+const maxMapSize = 0x40000000 // 1GB
+
+// maxAllocSize is the size used when creating array pointers.
+const maxAllocSize = 0xFFFFFFF
--- a/vendor/github.com/boltdb/bolt/bolt_openbsd.go
+++ b/vendor/github.com/boltdb/bolt/bolt_openbsd.go
@@ -1,4 +1,4 @@
-package bolt
+package bbolt

 import (
 	"syscall"
--- a/vendor/github.com/boltdb/bolt/bolt_ppc.go
+++ b/vendor/github.com/boltdb/bolt/bolt_ppc.go
@@ -1,6 +1,6 @@
 // +build ppc

-package bolt
+package bbolt

 // maxMapSize represents the largest mmap size supported by Bolt.
 const maxMapSize = 0x7FFFFFFF // 2GB
--- a/vendor/github.com/boltdb/bolt/bolt_ppc64.go
+++ b/vendor/github.com/boltdb/bolt/bolt_ppc64.go
@@ -1,12 +1,9 @@
 // +build ppc64

-package bolt
+package bbolt

 // maxMapSize represents the largest mmap size supported by Bolt.
 const maxMapSize = 0xFFFFFFFFFFFF // 256TB

 // maxAllocSize is the size used when creating array pointers.
 const maxAllocSize = 0x7FFFFFFF
-
-// Are unaligned load/stores broken on this arch?
-var brokenUnaligned = false
--- a/vendor/github.com/boltdb/bolt/bolt_ppc64le.go
+++ b/vendor/github.com/boltdb/bolt/bolt_ppc64le.go
@@ -1,12 +1,9 @@
 // +build ppc64le

-package bolt
+package bbolt

 // maxMapSize represents the largest mmap size supported by Bolt.
 const maxMapSize = 0xFFFFFFFFFFFF // 256TB

 // maxAllocSize is the size used when creating array pointers.
 const maxAllocSize = 0x7FFFFFFF
-
-// Are unaligned load/stores broken on this arch?
-var brokenUnaligned = false
--- a/vendor/github.com/boltdb/bolt/bolt_amd64.go
+++ b/vendor/github.com/boltdb/bolt/bolt_amd64.go
@@ -1,10 +1,9 @@
-package bolt
+// +build riscv64
+
+package bbolt

 // maxMapSize represents the largest mmap size supported by Bolt.
 const maxMapSize = 0xFFFFFFFFFFFF // 256TB

 // maxAllocSize is the size used when creating array pointers.
 const maxAllocSize = 0x7FFFFFFF
-
-// Are unaligned load/stores broken on this arch?
-var brokenUnaligned = false
--- a/vendor/github.com/boltdb/bolt/bolt_s390x.go
+++ b/vendor/github.com/boltdb/bolt/bolt_s390x.go
@@ -1,12 +1,9 @@
 // +build s390x

-package bolt
+package bbolt

 // maxMapSize represents the largest mmap size supported by Bolt.
 const maxMapSize = 0xFFFFFFFFFFFF // 256TB

 // maxAllocSize is the size used when creating array pointers.
 const maxAllocSize = 0x7FFFFFFF
-
-// Are unaligned load/stores broken on this arch?
-var brokenUnaligned = false
--- a/vendor/github.com/boltdb/bolt/bolt_unix.go
+++ b/vendor/github.com/boltdb/bolt/bolt_unix.go
@@ -1,41 +1,43 @@
-// +build !windows,!plan9,!solaris
+// +build !windows,!plan9,!solaris,!aix

-package bolt
+package bbolt

 import (
 	"fmt"
-	"os"
 	"syscall"
 	"time"
 	"unsafe"
 )

 // flock acquires an advisory lock on a file descriptor.
-func flock(db *DB, mode os.FileMode, exclusive bool, timeout time.Duration) error {
+func flock(db *DB, exclusive bool, timeout time.Duration) error {
 	var t time.Time
+	if timeout != 0 {
+		t = time.Now()
+	}
+	fd := db.file.Fd()
+	flag := syscall.LOCK_NB
+	if exclusive {
+		flag |= syscall.LOCK_EX
+	} else {
+		flag |= syscall.LOCK_SH
+	}
 	for {
-		// If we're beyond our timeout then return an error.
-		// This can only occur after we've attempted a flock once.
-		if t.IsZero() {
-			t = time.Now()
-		} else if timeout > 0 && time.Since(t) > timeout {
-			return ErrTimeout
-		}
-		flag := syscall.LOCK_SH
-		if exclusive {
-			flag = syscall.LOCK_EX
-		}
-
-		// Otherwise attempt to obtain an exclusive lock.
-		err := syscall.Flock(int(db.file.Fd()), flag|syscall.LOCK_NB)
+		// Attempt to obtain an exclusive lock.
+		err := syscall.Flock(int(fd), flag)
 		if err == nil {
 			return nil
 		} else if err != syscall.EWOULDBLOCK {
 			return err
 		}

+		// If we timed out then return an error.
+		if timeout != 0 && time.Since(t) > timeout-flockRetryTimeout {
+			return ErrTimeout
+		}
+
 		// Wait for a bit and try again.
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(flockRetryTimeout)
 	}
 }

@@ -53,7 +55,9 @@ func mmap(db *DB, sz int) error {
 	}

 	// Advise the kernel that the mmap is accessed randomly.
-	if err := madvise(b, syscall.MADV_RANDOM); err != nil {
+	err = madvise(b, syscall.MADV_RANDOM)
+	if err != nil && err != syscall.ENOSYS {
+		// Ignore not implemented error in kernel because it still works.
 		return fmt.Errorf("madvise: %s", err)
 	}

--- a/vendor/go.etcd.io/bbolt/bolt_unix_aix.go
+++ b/vendor/go.etcd.io/bbolt/bolt_unix_aix.go
@@ -0,0 +1,90 @@
+// +build aix
+
+package bbolt
+
+import (
+	"fmt"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+// flock acquires an advisory lock on a file descriptor.
+func flock(db *DB, exclusive bool, timeout time.Duration) error {
+	var t time.Time
+	if timeout != 0 {
+		t = time.Now()
+	}
+	fd := db.file.Fd()
+	var lockType int16
+	if exclusive {
+		lockType = syscall.F_WRLCK
+	} else {
+		lockType = syscall.F_RDLCK
+	}
+	for {
+		// Attempt to obtain an exclusive lock.
+		lock := syscall.Flock_t{Type: lockType}
+		err := syscall.FcntlFlock(fd, syscall.F_SETLK, &lock)
+		if err == nil {
+			return nil
+		} else if err != syscall.EAGAIN {
+			return err
+		}
+
+		// If we timed out then return an error.
+		if timeout != 0 && time.Since(t) > timeout-flockRetryTimeout {
+			return ErrTimeout
+		}
+
+		// Wait for a bit and try again.
+		time.Sleep(flockRetryTimeout)
+	}
+}
+
+// funlock releases an advisory lock on a file descriptor.
+func funlock(db *DB) error {
+	var lock syscall.Flock_t
+	lock.Start = 0
+	lock.Len = 0
+	lock.Type = syscall.F_UNLCK
+	lock.Whence = 0
+	return syscall.FcntlFlock(uintptr(db.file.Fd()), syscall.F_SETLK, &lock)
+}
+
+// mmap memory maps a DB's data file.
+func mmap(db *DB, sz int) error {
+	// Map the data file to memory.
+	b, err := unix.Mmap(int(db.file.Fd()), 0, sz, syscall.PROT_READ, syscall.MAP_SHARED|db.MmapFlags)
+	if err != nil {
+		return err
+	}
+
+	// Advise the kernel that the mmap is accessed randomly.
+	if err := unix.Madvise(b, syscall.MADV_RANDOM); err != nil {
+		return fmt.Errorf("madvise: %s", err)
+	}
+
+	// Save the original byte slice and convert to a byte array pointer.
+	db.dataref = b
+	db.data = (*[maxMapSize]byte)(unsafe.Pointer(&b[0]))
+	db.datasz = sz
+	return nil
+}
+
+// munmap unmaps a DB's data file from memory.
+func munmap(db *DB) error {
+	// Ignore the unmap if we have no mapped data.
+	if db.dataref == nil {
+		return nil
+	}
+
+	// Unmap using the original byte slice.
+	err := unix.Munmap(db.dataref)
+	db.dataref = nil
+	db.data = nil
+	db.datasz = 0
+	return err
+}
--- a/vendor/github.com/boltdb/bolt/bolt_unix_solaris.go
+++ b/vendor/github.com/boltdb/bolt/bolt_unix_solaris.go
@@ -1,8 +1,7 @@
-package bolt
+package bbolt

 import (
 	"fmt"
-	"os"
 	"syscall"
 	"time"
 	"unsafe"
@@ -11,36 +10,35 @@ import (
 )

 // flock acquires an advisory lock on a file descriptor.
-func flock(db *DB, mode os.FileMode, exclusive bool, timeout time.Duration) error {
+func flock(db *DB, exclusive bool, timeout time.Duration) error {
 	var t time.Time
+	if timeout != 0 {
+		t = time.Now()
+	}
+	fd := db.file.Fd()
+	var lockType int16
+	if exclusive {
+		lockType = syscall.F_WRLCK
+	} else {
+		lockType = syscall.F_RDLCK
+	}
 	for {
-		// If we're beyond our timeout then return an error.
-		// This can only occur after we've attempted a flock once.
-		if t.IsZero() {
-			t = time.Now()
-		} else if timeout > 0 && time.Since(t) > timeout {
-			return ErrTimeout
-		}
-		var lock syscall.Flock_t
-		lock.Start = 0
-		lock.Len = 0
-		lock.Pid = 0
-		lock.Whence = 0
-		lock.Pid = 0
-		if exclusive {
-			lock.Type = syscall.F_WRLCK
-		} else {
-			lock.Type = syscall.F_RDLCK
-		}
-		err := syscall.FcntlFlock(db.file.Fd(), syscall.F_SETLK, &lock)
+		// Attempt to obtain an exclusive lock.
+		lock := syscall.Flock_t{Type: lockType}
+		err := syscall.FcntlFlock(fd, syscall.F_SETLK, &lock)
 		if err == nil {
 			return nil
 		} else if err != syscall.EAGAIN {
 			return err
 		}

+		// If we timed out then return an error.
+		if timeout != 0 && time.Since(t) > timeout-flockRetryTimeout {
+			return ErrTimeout
+		}
+
 		// Wait for a bit and try again.
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(flockRetryTimeout)
 	}
 }

--- a/vendor/github.com/boltdb/bolt/bolt_windows.go
+++ b/vendor/github.com/boltdb/bolt/bolt_windows.go
@@ -1,4 +1,4 @@
-package bolt
+package bbolt

 import (
 	"fmt"
@@ -16,8 +16,6 @@ var (
 )

 const (
-	lockExt = ".lock"
-
 	// see https://msdn.microsoft.com/en-us/library/windows/desktop/aa365203(v=vs.85).aspx
 	flagLockExclusive       = 2
 	flagLockFailImmediately = 1
@@ -48,48 +46,47 @@ func fdatasync(db *DB) error {
 }

 // flock acquires an advisory lock on a file descriptor.
-func flock(db *DB, mode os.FileMode, exclusive bool, timeout time.Duration) error {
-	// Create a separate lock file on windows because a process
-	// cannot share an exclusive lock on the same file. This is
-	// needed during Tx.WriteTo().
-	f, err := os.OpenFile(db.path+lockExt, os.O_CREATE, mode)
-	if err != nil {
-		return err
-	}
-	db.lockfile = f
-
+func flock(db *DB, exclusive bool, timeout time.Duration) error {
 	var t time.Time
+	if timeout != 0 {
+		t = time.Now()
+	}
+	var flag uint32 = flagLockFailImmediately
+	if exclusive {
+		flag |= flagLockExclusive
+	}
 	for {
-		// If we're beyond our timeout then return an error.
-		// This can only occur after we've attempted a flock once.
-		if t.IsZero() {
-			t = time.Now()
-		} else if timeout > 0 && time.Since(t) > timeout {
-			return ErrTimeout
-		}
+		// Fix for https://github.com/etcd-io/bbolt/issues/121. Use byte-range
+		// -1..0 as the lock on the database file.
+		var m1 uint32 = (1 << 32) - 1 // -1 in a uint32
+		err := lockFileEx(syscall.Handle(db.file.Fd()), flag, 0, 1, 0, &syscall.Overlapped{
+			Offset:     m1,
+			OffsetHigh: m1,
+		})

-		var flag uint32 = flagLockFailImmediately
-		if exclusive {
-			flag |= flagLockExclusive
-		}
-
-		err := lockFileEx(syscall.Handle(db.lockfile.Fd()), flag, 0, 1, 0, &syscall.Overlapped{})
 		if err == nil {
 			return nil
 		} else if err != errLockViolation {
 			return err
 		}

+		// If we timed oumercit then return an error.
+		if timeout != 0 && time.Since(t) > timeout-flockRetryTimeout {
+			return ErrTimeout
+		}
+
 		// Wait for a bit and try again.
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(flockRetryTimeout)
 	}
 }

 // funlock releases an advisory lock on a file descriptor.
 func funlock(db *DB) error {
-	err := unlockFileEx(syscall.Handle(db.lockfile.Fd()), 0, 1, 0, &syscall.Overlapped{})
-	db.lockfile.Close()
-	os.Remove(db.path + lockExt)
+	var m1 uint32 = (1 << 32) - 1 // -1 in a uint32
+	err := unlockFileEx(syscall.Handle(db.file.Fd()), 0, 1, 0, &syscall.Overlapped{
+		Offset:     m1,
+		OffsetHigh: m1,
+	})
 	return err
 }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
TwinProduction	e46acb885c	Add missing newline	2021-03-30 20:01:22 -04:00
Jonah	24da853820	Add Telegram Alerting (#102 )	2021-03-30 19:38:34 -04:00
TwinProduction	4e5a86031f	Add comment for future breaking change	2021-03-27 21:22:34 -04:00
TwinProduction	7f6f127f4f	Default showAverageResponseTime to true in details page too	2021-03-26 18:28:41 -04:00
TwinProduction	12c352254f	Implement toggleable average response time (frontend) + Persist refresh interval (frontend) + Update dependencies (frontend)	2021-03-25 21:01:03 -04:00
TwinProduction	2b9d986932	Update date in LICENSE.md	2021-03-23 19:53:49 -04:00
TwinProduction	cdbf5f6c6f	Update Go to 1.16	2021-03-21 19:37:17 -04:00
David Chidell	33562e97f4	Add API capabilities to docs (#101 )	2021-03-19 21:33:46 -04:00
TwinProduction	c9acc83141	Extract magic number into a constant	2021-03-14 16:52:59 -04:00
TwinProduction	8c4c360472	Minor update	2021-03-14 13:36:54 -04:00
David Chidell	2c8714f1fa	Truncate long string when using pattern function (#100 ) - Omits verbose responses when using pattern match - Change contains to match prefix and suffix, add 2nd test	2021-03-14 13:05:16 -04:00
TwinProduction	8ec256edbf	Implement has() function to determine if an element at a JSONPath exists	2021-03-10 21:49:13 -05:00
TwinProduction	a48ec41bca	Add test for invalid path	2021-03-09 19:39:22 -05:00
TwinProduction	541e0264ab	Don't export, persist or retain result body after evaluation	2021-03-08 21:30:11 -05:00
TwinProduction	f945e4b8a2	#93 : Gracefully handle breaking change to uptime maps by renaming variables	2021-03-06 15:19:35 -05:00
TwinProduction	076b92a2b4	Minor update	2021-03-05 20:33:06 -05:00
TwinProduction	02e9f74a04	Move alerting configuration documentation under Alerting	2021-03-05 20:25:20 -05:00
TwinProduction	b37dd5e819	Minor update	2021-03-05 00:50:24 -05:00
TwinProduction	1775f80ffe	Back to alpine/1.16 (the change in reflected memory usage was due to 1.16's MADV_FREE change after all)	2021-03-05 00:49:58 -05:00
TwinProduction	3187db1e9a	Switch gocache to FIFO instead of LRU	2021-03-05 00:40:11 -05:00
TwinProduction	932eab00a0	Test using Docker image with Go 1.15 instead of alpine, which has 1.16	2021-03-05 00:38:40 -05:00
TwinProduction	c842ac2343	Fix memory issue caused by previous shallow copy	2021-03-05 00:19:21 -05:00
TwinProduction	6320237326	Significantly improve uptime calculation	2021-03-04 23:00:30 -05:00
TwinProduction	8fe9d013b5	Close #48 : Implement Discord alerting providers	2021-03-04 21:26:17 -05:00
TwinProduction	c094c06e56	Minor update	2021-03-03 22:31:55 -05:00
TwinProduction	f961bf961e	Update documentation on alerting providers	2021-03-03 22:30:50 -05:00
TwinProduction	404a3cea64	Remove useless os.Kill because it cannot be caught	2021-03-01 22:35:32 -05:00
TwinProduction	d000460a99	Regenerate static files	2021-02-25 23:14:11 -05:00
TwinProduction	455fae05c1	Minor visual changes on pagination component	2021-02-25 23:11:25 -05:00
Chris C	85dff34350	Merge pull request #90 from TwinProduction/longer-result-history First implementation of longer result history	2021-02-25 22:47:55 -05:00
TwinProduction	99fa632021	Increase test coverage	2021-02-25 19:02:02 -05:00
TwinProduction	cafcc9d45b	Increase test coverage	2021-02-24 23:26:13 -05:00
TwinProduction	dc929dac70	#89 : First implementation of longer result history	2021-02-24 22:41:36 -05:00
TwinProduction	42825b62fb	Update documentation	2021-02-20 19:00:54 -05:00
TwinProduction	a89bb392ed	Minor fix	2021-02-20 19:00:47 -05:00
TwinProduction	e7c4d03c22	Regenerate static files	2021-02-20 18:11:55 -05:00
TwinProduction	4e6bf91651	Update test step	2021-02-20 18:11:29 -05:00
TwinProduction	de31a7a62e	Minor improvements	2021-02-20 18:08:00 -05:00
TwinProduction	7f0543ebd2	Minor improvements	2021-02-20 12:52:21 -05:00
TwinProduction	9b893aa4e0	Minor improvements	2021-02-19 20:34:35 -05:00
TwinProduction	50435f4030	Improve tests for alerting providers	2021-02-19 19:06:20 -05:00
TwinProduction	9649d80388	Update description	2021-02-19 18:52:37 -05:00
TwinProduction	8c3ab1eac2	Fix typo for colleague	2021-02-19 09:17:25 -05:00
TwinProduction	cdb5ba080a	Minor fix	2021-02-18 23:47:53 -05:00
TwinProduction	0a145da912	Add documentation for the custom alert provider placeholders	2021-02-18 23:18:14 -05:00
TwinProduction	b603cdb0ea	Minor changes to the custom alert provider placeholders	2021-02-18 23:17:51 -05:00
TwinProduction	11d1f24ceb	Fix typo	2021-02-18 22:28:21 -05:00
Chris C	c74472d332	Merge pull request #85 from roberth1988/ISSUE73-ALERT_TRIGGERED_OR_RESOLVED-Placeholder Make ALERT_TRIGGERED_OR_RESOLVED placeholder values configurable	2021-02-18 22:28:14 -05:00
Chris C	78a1262e7c	Merge pull request #87 from avakarev/respec-system-proxy Respect system proxy	2021-02-18 22:07:06 -05:00
Andrii Vakarev	7ff8907eda	Respect system proxy	2021-02-19 01:03:38 +01:00
Robert Hoppe	1d21f5889d	Move away from generic solution to a fixed one	2021-02-18 19:03:12 +01:00
Robert Hoppe	d7d904ae5f	Bump up test coverage	2021-02-17 13:45:22 +01:00
Robert Hoppe	7390895514	Extend also tests on config	2021-02-17 13:27:11 +01:00
Robert Hoppe	2873d96b9f	Introduce configureable place holders for alerting	2021-02-17 12:39:17 +01:00
TwinProduction	ea9623f695	Use TwinProduction/health for health endpoint	2021-02-12 23:29:21 -05:00
TwinProduction	9cdef02bdc	Fix min/max response time issue caused by previous commit	2021-02-12 23:29:07 -05:00
TwinProduction	16229592a2	Fix small issue with min/max response times getting floored instead of rounded	2021-02-12 23:16:23 -05:00
TwinProduction	52ad4ee9e5	Update gocache to v1.2.1	2021-02-05 22:11:25 -05:00
TwinProduction	b47c6dc408	Merge branch 'master' of https://github.com/TwinProduction/gatus into persistence	2021-02-05 20:46:10 -05:00
TwinProduction	8e2a2c4dbc	Implement graceful shutdown - Shutdown the HTTP server before exiting - Persist data to store before exiting, if applicable	2021-02-05 20:45:28 -05:00
TwinProduction	8698736e7d	Add .svg suffix to badge image url	2021-02-05 19:58:20 -05:00
Chris C	cd1430f043	Merge pull request #83 from TwinProduction/persistence Implement persistence	2021-02-02 23:23:43 -05:00
TwinProduction	79bef8d391	Implement persistence	2021-02-02 23:06:34 -05:00
TwinProduction	9196f57487	Add several tests	2021-02-01 01:37:56 -05:00
TwinProduction	1e0d9e184c	Fix typo	2021-01-31 23:29:48 -05:00
Chris C	bc42497cb7	Merge pull request #81 from menduz/patch-1 fix: metrics were not working	2021-01-31 22:35:27 -05:00
Agustin Mendez	b0b0ab574d	fix: metrics were not working	2021-01-31 23:45:32 -03:00
TwinProduction	e369484e5f	Fix issue with event icons not displaying on mobile	2021-01-31 20:38:05 -05:00
TwinProduction	d18618449f	Rebuild static files	2021-01-31 18:04:22 -05:00
TwinProduction	9186049589	Minor responsiveness improvements	2021-01-31 18:02:13 -05:00
TwinProduction	4362831f71	Improve responsiveness on smaller screens	2021-01-31 17:55:04 -05:00
TwinProduction	99f558d43e	Fix minor responsiveness issue	2021-01-31 17:54:14 -05:00
TwinProduction	4a3d5944b6	Initialize Tooltip with hidden set to true	2021-01-31 17:01:02 -05:00
TwinProduction	688456d7cf	Minor fix	2021-01-31 16:47:40 -05:00
TwinProduction	431fb3e9f2	Make title smaller on smaller screens	2021-01-31 16:47:31 -05:00