Improve documentation

Add Microsoft Teams alerting provider

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [TwinProduction]

.github/assets/gatus-diagram.drawio

@@ -0,0 +1 @@
+<mxfile host="app.diagrams.net" modified="2021-07-30T04:27:17.723Z" agent="5.0 (Windows)" etag="hZKgW5ZLl0WUgYrCJXa4" version="14.9.2" type="device"><diagram id="1euQ5oT3BAcxlUCibzft" name="Page-1">7VvbcpswEP0aP6YDSPjy2MRum5lmptMkk+ZRARXUCtYV8oV+fUUsDLYSh07TLDP2k9FKWOKcw2q1EgNyka0/KjZPryDmchB48XpApoMg8IlHzE9lKTeWERlvDIkSsW3UGK7Fb26NnrUuRMyLnYYaQGox3zVGkOc80js2phSsdpt9B7nb65wl3DFcR0y61jsR63RjHYdeY//ERZLWPfuerclY3dgaipTFsGqZyGxALhSA3lxl6wsuK/BqXDb3fXimdjswxXPd5Yazebia3Z1ffuJfy+VwJm9K//ZsuPmXJZML+8B2sLqsEeCxAcQWQekUEsiZnDXWcwWLPOZVN54pNW0+A8yN0TfGH1zr0rLLFhqMKdWZtLWbPquOnn02aypgoSJ+4IFqjTCVcH2gXbhlwEiXQ8a1Ks19ikumxXJ3HMxqKNm2a2A2Fxbpv0Ddd1A3elNa5ImDfoNtBdQqFZpfz9kjBCvzxj2F49L8FV8fRtJ9cntDMLZyte+rX8t31ah/a0tbyh96/wksiqFIg5Yqv9n7Hwv3VeFdWBen63bltLSlV1Ry0FHJBFPJwfDEzkF2nnnb3oadeq7FYqch5L5d1x92yAj15XGmgRXTURoD/jSwDWPsNBCE2NMA8R1QjsPTkI5a3oRuaK7G0XKhQVXBNbaU9yMaMsaW8tjB6kilHXadRL2nGX6jaP1YY5yu9ExQ2Rmd2DnIDmqI409O7Bx2baiz9jY3daLnGXooalB1oucFelCTH5Sc6DlID0WN2+ixZg4704M699hRtlZBcwVLEXPl0PbCInF3RTn49yUjHfYtCT5ywLriRWGW1w9Cxeh4jfayRZNhN7iC/wXXxIHrWrLoZ++A8kNspOp91hZUX4ys1HShy/7BFaDD5eZsB8FQmm7PY7E0l0l1ecNZVtR200+rqn+YjtExdXOHV0xrrjIodO/wGo6w4aIOXDdc8kSxrHdgBT62uIJjTQ8F1lO9vG+AehQiONYEUXd+xqj8uBNetbGDv62zH6Pjb+sE7oqm+CUNDr1zyxTfLbt7YCLPeAaqf1EnGVNktAiyk9w9x+G9nZMko65OEtNHEnd1XnC1FBEvKiAqsxkF5Og+c/9UB35eg7rLz6koIuhhUqM+TIXmBag7Fd+shBTQO6gCGmJjhbxnj3byjXZN/uLunLihUgQGEpDyifQv9okhOkF3k8gHOdFWSbRrAEBRV7HUjQBuL9F1vD/d4+s4dKd7DGG/pkAnXQWKeg6nHmZboMUTrrZI2by6XGTyfWTW+QasSoIiMuiyBy6/QCEeQ1kyfQCtIWs1eC9FUlVo2JMyLLQUOb/YfqLlvZKfflne5HXUbYrNh1qPda3P3cjsDw==</diagram></mxfile>

.github/workflows/build.yml

@@ -28,6 +28,6 @@ jobs:
         # 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
+        uses: codecov/codecov-action@v1.5.2
         with:
           file: ./coverage.txt

.github/workflows/publish-latest.yml

@@ -0,0 +1,34 @@
+name: publish-latest
+on:
+  workflow_run:
+    workflows: ["build"]
+    branches: [master]
+    types: [completed]
+jobs:
+  publish-latest:
+    name: Publish latest
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    timeout-minutes: 30
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v2
+      - name: Get image repository
+        run: echo IMAGE_REPOSITORY=$(echo ${{ github.repository }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+      - name: Login to Docker Registry
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Build and push docker image
+        uses: docker/build-push-action@v2
+        with:
+          platforms: linux/amd64
+          pull: true
+          push: true
+          tags: |
+            ${{ env.IMAGE_REPOSITORY }}:latest

.github/workflows/publish-release.yml

@@ -1,10 +1,10 @@
-name: publish
+name: publish-release
 on:
   release:
     types: [published]
 jobs:
-  build:
-    name: Publish
+  publish-release:
+    name: Publish release
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:

.gitignore

@@ -2,4 +2,6 @@
 .vscode
 gatus
 db.db
-config/config.yml
+config/config.yml
+db.db-shm
+db.db-wal

README.md

@@ -10,14 +10,22 @@
 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.
+checks can be paired with alerting via Slack, PagerDuty, Discord 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/
 
+<details>
+  <summary><b>Quick start</b></summary>
+
+```
+docker run -p 8080:8080 --name gatus twinproduction/gatus
+```
+For more details, see [Usage](#usage)
+</details>
+
 
 ## Table of Contents
-
 - [Why Gatus?](#why-gatus)
 - [Features](#features)
 - [Usage](#usage)
@@ -25,19 +33,25 @@ core applications: https://status.twinnation.org/
   - [Conditions](#conditions)
     - [Placeholders](#placeholders)
     - [Functions](#functions)
+  - [Storage](#storage)
+  - [Client configuration](#client-configuration)
   - [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 Messagebird alerts](#configuring-messagebird-alerts)
+    - [Configuring PagerDuty alerts](#configuring-pagerduty-alerts)
+    - [Configuring Slack alerts](#configuring-slack-alerts)
+    - [Configuring Teams alerts](#configuring-teams-alerts)
     - [Configuring Telegram alerts](#configuring-telegram-alerts)
+    - [Configuring Twilio alerts](#configuring-twilio-alerts)
     - [Configuring custom alerts](#configuring-custom-alerts)
+    - [Setting a default alert](#setting-a-default-alert)
   - [Kubernetes (ALPHA)](#kubernetes-alpha)
     - [Auto Discovery](#auto-discovery)
-    - [Deploying](#deploying)
-- [Docker](#docker)
+- [Deployment](#deployment)
+  - [Docker](#docker)
+  - [Helm Chart](#helm-chart)
+  - [Terraform](#terraform)
 - [Running the tests](#running-the-tests)
 - [Using in Production](#using-in-production)
 - [FAQ](#faq)
@@ -47,6 +61,7 @@ core applications: https://status.twinnation.org/
   - [Monitoring a TCP service](#monitoring-a-tcp-service)
   - [Monitoring a service using ICMP](#monitoring-a-service-using-icmp)
   - [Monitoring a service using DNS queries](#monitoring-a-service-using-dns-queries)
+  - [Monitoring a service using STARTTLS](#monitoring-a-service-using-starttls)
   - [Basic authentication](#basic-authentication)
   - [disable-monitoring-lock](#disable-monitoring-lock)
   - [Reloading configuration on the fly](#reloading-configuration-on-the-fly)
@@ -54,10 +69,10 @@ core applications: https://status.twinnation.org/
   - [Exposing Gatus on a custom port](#exposing-gatus-on-a-custom-port)
   - [Uptime Badges (ALPHA)](#uptime-badges)
   - [API](#API)
-
+  - [High level design overview](#high-level-design-overview)
+- [Sponsors](#sponsors)
 
 ## Why Gatus?
-
 Before getting into the specifics, I want to address the most common question:
 > Why would I use Gatus when I can just use Prometheus’ Alertmanager, Cloudwatch or even Splunk?
 
@@ -76,20 +91,19 @@ fixing the issue before they even know about it.
 
 
 ## Features
+![Gatus dark mode](.github/assets/dark-mode.png)
 
 The main features of Gatus are:
 - **Highly flexible health check conditions**: While checking the response status may be enough for some use cases, Gatus goes much further and allows you to add conditions on the response time, the response body and even the IP address.
 - **Ability to use Gatus for user acceptance tests**: Thanks to the point above, you can leverage this application to create automated user acceptance tests.
 - **Very easy to configure**: Not only is the configuration designed to be as readable as possible, it's also extremely easy to add a new service or a new endpoint to monitor.
-- **Alerting**: While having a pretty visual dashboard is useful to keep track of the state of your application(s), you probably don't want to stare at it all day. Thus, notifications via Slack, Mattermost, Messagebird, PagerDuty and Twilio are supported out of the box with the ability to configure a custom alerting provider for any needs you might have, whether it be a different provider or a custom application that manages automated rollbacks. 
+- **Alerting**: While having a pretty visual dashboard is useful to keep track of the state of your application(s), you probably don't want to stare at it all day. Thus, notifications via Slack, Mattermost, Messagebird, PagerDuty, Twilio and Teams are supported out of the box with the ability to configure a custom alerting provider for any needs you might have, whether it be a different provider or a custom application that manages automated rollbacks.
 - **Metrics**
 - **Low resource consumption**: As with most Go applications, the resource footprint that this application requires is negligibly small.
 - **GitHub uptime badges**: ![Uptime 1h](https://status.twinnation.org/api/v1/badges/uptime/1h/core_twinnation-external.svg) ![Uptime 24h](https://status.twinnation.org/api/v1/badges/uptime/24h/core_twinnation-external.svg) ![Uptime 7d](https://status.twinnation.org/api/v1/badges/uptime/7d/core_twinnation-external.svg)
-- **Service auto discovery in Kubernetes** (ALPHA)
 
 
 ## Usage
-
 By default, the configuration file is expected to be at `config/config.yaml`.
 
 You can specify a custom path by setting the `GATUS_CONFIG_FILE` environment variable.
@@ -119,52 +133,50 @@ This example would look like this:
 
 Note that you can also use environment variables in the configuration file (e.g. `$DOMAIN`, `${DOMAIN}`)
 
+If you want to test it locally, see [Docker](#docker).
+
 
 ## 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 `[]`  |
+| `debug`                                  | Whether to enable debug logs.                                                 | `false`        |
+| `metrics`                                | Whether to expose metrics at /metrics.                                        | `false`        |
+| `storage`                                | Storage configuration. See [Storage](#storage).                               | `{}`           |
+| `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[].url`                         | URL to send the request to.                                                   | Required `""`  |
+| `services[].method`                      | Request method.                                                               | `GET`          |
 | `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[].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 a service using DNS queries](#monitoring-a-service-using-dns-queries). | `""`           |
-| `services[].dns.query-type`              | Query type for DNS service                                                    | `""`           |
-| `services[].dns.query-name`              | Query name for DNS service                                                    | `""`           |
-| `services[].alerts[].type`               | Type of alert. Valid types: `slack`, `discord`, `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                  | `""`           |
+| `services[].dns.query-type`              | Query type for DNS service.                                                   | `""`           |
+| `services[].dns.query-name`              | Query name for DNS service.                                                   | `""`           |
+| `services[].alerts[].type`               | Type of alert. Valid types: `slack`, `discord`, `pagerduty`, `twilio`, `mattermost`, `messagebird`, `teams` `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.                 | `""`           |
+| `services[].client`                      | Client configuration. See [Client configuration](#client-configuration).      | `{}`           |
 | `alerting`                               | Configuration for alerting. See [Alerting](#alerting).                        | `{}`           |
-| `security`                               | Security configuration                                                        | `{}`           |
-| `security.basic`                         | Basic authentication security configuration                                   | `{}`           |
-| `security.basic.username`                | Username for Basic authentication                                             | Required `""`  |
-| `security.basic.password-sha512`         | Password's SHA512 hash for Basic authentication                               | Required `""`  |
-| `disable-monitoring-lock`                | Whether to [disable the monitoring lock](#disable-monitoring-lock)            | `false`        |
-| `skip-invalid-config-update`             | Whether to ignore invalid configuration update. See [Reloading configuration on the fly](#reloading-configuration-on-the-fly).
-| `web`                                    | Web configuration                                                             | `{}`           |
-| `web.address`                            | Address to listen on                                                          | `0.0.0.0`      |
-| `web.port`                               | Port to listen on                                                             | `8080`         |
+| `security`                               | Security configuration.                                                       | `{}`           |
+| `security.basic`                         | Basic authentication security configuration.                                  | `{}`           |
+| `security.basic.username`                | Username for Basic authentication.                                            | Required `""`  |
+| `security.basic.password-sha512`         | Password's SHA512 hash for Basic authentication.                              | Required `""`  |
+| `disable-monitoring-lock`                | Whether to [disable the monitoring lock](#disable-monitoring-lock).           | `false`        |
+| `skip-invalid-config-update`             | Whether to ignore invalid configuration update. See [Reloading configuration on the fly](#reloading-configuration-on-the-fly). | `false` |
+| `web`                                    | Web configuration.                                                            | `{}`           |
+| `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 alerting configuration, see [Alerting](#alerting).
+For Kubernetes configuration, see [Kubernetes](#kubernetes-alpha).
 
 
 ### Conditions
-
 Here are some examples of conditions you can use:
 
 | Condition                    | Description                                             | Passing values             | Failing values |
@@ -191,7 +203,6 @@ Here are some examples of conditions you can use:
 
 
 #### Placeholders
-
 | Placeholder                | Description                                                     | Example of resolved value |
 |:-------------------------- |:--------------------------------------------------------------- |:------------------------- |
 | `[STATUS]`                 | Resolves into the HTTP status of the request                    | 404
@@ -204,7 +215,6 @@ Here are some examples of conditions you can use:
 
 
 #### Functions
-
 | Function   | Description                                                                                                      | Example                    |
 |:-----------|:---------------------------------------------------------------------------------------------------------------- |:-------------------------- |
 | `len`      | Returns the length of the object/slice. Works only with the `[BODY]` placeholder.                                | `len([BODY].username) > 8`
@@ -215,83 +225,86 @@ Here are some examples of conditions you can use:
 **NOTE**: Use `pat` only when you need to. `[STATUS] == pat(2*)` is a lot more expensive than `[STATUS] < 300`.
 
 
-### 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                                               | `{}`           |
-| `alerting.*.default-alert.enabled`            | Whether to enable the alert                                                   | N/A       |
-| `alerting.*.default-alert.failure-threshold`  | Number of failures in a row needed before triggering the alert                | N/A       |
-| `alerting.*.default-alert.success-threshold`  | Number of successes in a row before an ongoing incident is marked as resolved | N/A       |
-| `alerting.*.default-alert.send-on-resolved`   | Whether to send a notification once a triggered alert is marked as resolved   | N/A       |
-| `alerting.*.default-alert.description`        | Description of the alert. Will be included in the alert sent                  | N/A       |
-
-
-#### Configuring Slack alerts
+### Storage
+| Parameter          | Description                                                                            | Default        |
+|:------------------ |:-------------------------------------------------------------------------------------- |:-------------- |
+| `storage`          | Storage configuration                                                                  | `{}`           |
+| `storage.file`     | File to persist the data in. If the type is `inmemory`, data is persisted on interval. | `""`           |
+| `storage.type`     | Type of storage. Valid types: `inmemory`, `sqlite`.                                    | `"inmemory"`   |
 
+- If `storage.type` is `inmemory` (default) and `storage.file` is set to a non-blank value.
+  Furthermore, the data is periodically persisted, but everything remains in memory.
+- If `storage.type` is `sqlite`, `storage.file` must not be blank.
 ```yaml
-alerting:
-  slack: 
-    webhook-url: "https://hooks.slack.com/services/**********/**********/**********"
+storage:
+  type: sqlite
+  file: data.db
+```
+See [examples/docker-compose-sqlite-storage](examples/docker-compose-sqlite-storage) for an example.
 
+
+### Client configuration
+In order to support a wide range of environments, each monitored service has a unique configuration for 
+the client used to send the request.
+
+| Parameter                | Description                                                                   | Default        |
+|:-------------------------|:----------------------------------------------------------------------------- |:-------------- |
+| `client.insecure`        | Whether to skip verifying the server's certificate chain and host name.       | `false`        |
+| `client.ignore-redirect` | Whether to ignore redirects (true) or follow them (false, default).           | `false`        |
+| `client.timeout`         | Duration before timing out.                                                   | `10s`          |
+
+Note that some of these parameters are ignored based on the type of service. For instance, there's no certificate involved
+in ICMP requests (ping), therefore, setting `client.insecure` to `true` for a service of that type will not do anything.
+
+This default configuration is as follows:
+```yaml
+client:
+  insecure: false
+  ignore-redirect: false
+  timeout: 10s
+```
+Note that this configuration is only available under `services[]`, `alerting.mattermost` and `alerting.custom`.
+
+Here's an example with the client configuration under `service[]`:
+```yaml
 services:
   - name: twinnation
     url: "https://twinnation.org/health"
-    interval: 30s
-    alerts:
-      - type: slack
-        enabled: true
-        description: "healthcheck failed 3 times in a row"
-        send-on-resolved: true
-      - type: slack
-        enabled: true
-        failure-threshold: 5
-        description: "healthcheck failed 5 times in a row"
-        send-on-resolved: true
+    client:
+      insecure: false
+      ignore-redirect: false
+      timeout: 10s
     conditions:
       - "[STATUS] == 200"
-      - "[BODY].status == UP"
-      - "[RESPONSE_TIME] < 300"
 ```
 
-Here's an example of what the notifications look like:
 
-![Slack notifications](.github/assets/slack-alerts.png)
+### 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 properly configured, all alerts configured with the provider's type will be
+ignored.
+
+| Parameter              | Description                                                                                                            | Default        |
+|:-----------------------|:---------------------------------------------------------------------------------------------------------------------- |:-------|
+| `alerting.discord`     | Configuration for alerts of type `discord`. See [Configuring Discord alerts](#configuring-discord-alerts).             | `{}`   |
+| `alerting.mattermost`  | Configuration for alerts of type `mattermost`.  See [Configuring Mattermost alerts](#configuring-mattermost-alerts).   | `{}`   |
+| `alerting.messagebird` | Configuration for alerts of type `messagebird`. See [Configuring Messagebird alerts](#configuring-messagebird-alerts). | `{}`   |
+| `alerting.pagerduty`   | Configuration for alerts of type `pagerduty`. See [Configuring PagerDuty alerts](#configuring-pagerduty-alerts).       | `{}`   |
+| `alerting.slack`       | Configuration for alerts of type `slack`. See [Configuring Slack alerts](#configuring-slack-alerts).                   | `{}`   |
+| `alerting.teams`       | Configuration for alerts of type `teams`. See [Configuring Teams alerts](#configuring-teams-alerts).                   | `{}`   |
+| `alerting.telegram`    | Configuration for alerts of type `telegram`. See [Configuring Telegram alerts](#configuring-telegram-alerts).          | `{}`   |
+| `alerting.twilio`      | Settings for alerts of type `twilio`. See [Configuring Twilio alerts](#configuring-twilio-alerts).                     | `{}`   |
+| `alerting.custom`      | Configuration for custom actions on failure or alerts. See [Configuring Custom alerts](#configuring-custom-alerts).    | `{}`   |
 
 
 #### Configuring Discord alerts
+| Parameter                                | Description                                  | Default        |
+|:---------------------------------------- |:-------------------------------------------- |:-------------- |
+| `alerting.discord`                       | Configuration for alerts of type `discord`   | `{}`           |
+| `alerting.discord.webhook-url`           | Discord Webhook URL                          | Required `""`  |
+| `alerting.discord.default-alert`         | Default alert configuration. See [Setting a default alert](#setting-a-default-alert) | N/A       |
 
 ```yaml
 alerting:
@@ -302,24 +315,97 @@ services:
   - name: twinnation
     url: "https://twinnation.org/health"
     interval: 30s
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 300"
     alerts:
       - type: discord
         enabled: true
         description: "healthcheck failed"
         send-on-resolved: true
+```
+
+
+#### Configuring Mattermost alerts
+| Parameter                                | Description                                                                   | Default        |
+|:---------------------------------------- |:----------------------------------------------------------------------------- |:-------------- |
+| `alerting.mattermost`                    | Configuration for alerts of type `mattermost`                                 | `{}`           |
+| `alerting.mattermost.webhook-url`        | Mattermost Webhook URL                                                        | Required `""`  |
+| `alerting.mattermost.client`             | Client configuration. See [Client configuration](#client-configuration).      | `{}`           |
+| `alerting.mattermost.default-alert`         | Default alert configuration. See [Setting a default alert](#setting-a-default-alert) | N/A       |
+
+```yaml
+alerting:
+  mattermost: 
+    webhook-url: "http://**********/hooks/**********"
+    client:
+      insecure: true
+
+services:
+  - name: twinnation
+    url: "https://twinnation.org/health"
+    interval: 30s
     conditions:
       - "[STATUS] == 200"
       - "[BODY].status == UP"
       - "[RESPONSE_TIME] < 300"
+    alerts:
+      - type: mattermost
+        enabled: true
+        description: "healthcheck failed"
+        send-on-resolved: true
+```
+
+Here's an example of what the notifications look like:
+
+![Mattermost notifications](.github/assets/mattermost-alerts.png)
+
+
+#### Configuring Messagebird alerts
+| Parameter                                | Description                                                                   | Default        |
+|:---------------------------------------- |:----------------------------------------------------------------------------- |:-------------- |
+| `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.messagebird.default-alert`         | Default alert configuration. See [Setting a default alert](#setting-a-default-alert) | N/A       |
+
+Example of sending **SMS** text message alert using Messagebird:
+```yaml
+alerting:
+  messagebird:
+    access-key: "..."
+    originator: "31619191918"
+    recipients: "31619191919,31619191920"
+services:
+  - name: twinnation
+    interval: 30s
+    url: "https://twinnation.org/health"
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 300"
+    alerts:
+      - type: messagebird
+        enabled: true
+        failure-threshold: 3
+        send-on-resolved: true
+        description: "healthcheck failed"
 ```
 
 
 #### Configuring PagerDuty alerts
+| Parameter                                | Description                                                                   | Default        |
+|:---------------------------------------- |:----------------------------------------------------------------------------- |:-------------- |
+| `alerting.pagerduty`                     | Configuration for alerts of type `pagerduty`                                  | `{}`           |
+| `alerting.pagerduty.integration-key`     | PagerDuty Events API v2 integration key.                                      | Required `""`  |
+| `alerting.pagerduty.default-alert`       | Default alert configuration. See [Setting a default alert](#setting-a-default-alert) | N/A       |
 
-It is highly recommended to set `services[].alerts[].send-on-resolved` to `true` for alerts 
-of type `pagerduty`, because unlike other alerts, the operation resulting from setting said 
-parameter to `true` will not create another incident, but mark the incident as resolved on 
-PagerDuty instead. 
+It is highly recommended to set `services[].alerts[].send-on-resolved` to `true` for alerts
+of type `pagerduty`, because unlike other alerts, the operation resulting from setting said
+parameter to `true` will not create another incident, but mark the incident as resolved on
+PagerDuty instead.
 
 ```yaml
 alerting:
@@ -330,6 +416,10 @@ services:
   - name: twinnation
     url: "https://twinnation.org/health"
     interval: 30s
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 300"
     alerts:
       - type: pagerduty
         enabled: true
@@ -337,14 +427,118 @@ services:
         success-threshold: 5
         send-on-resolved: true
         description: "healthcheck failed"
+```
+
+
+#### Configuring Slack alerts
+| Parameter                        | Description                                                                   | Default        |
+|:-------------------------------- |:----------------------------------------------------------------------------- |:-------------- |
+| `alerting.slack`                 | Configuration for alerts of type `slack`                                      | `{}`           |
+| `alerting.slack.webhook-url`     | Slack Webhook URL                                                             | Required `""`  |
+| `alerting.slack.default-alert`   | Default alert configuration. See [Setting a default alert](#setting-a-default-alert) | N/A       |
+
+```yaml
+alerting:
+  slack: 
+    webhook-url: "https://hooks.slack.com/services/**********/**********/**********"
+
+services:
+  - name: twinnation
+    url: "https://twinnation.org/health"
+    interval: 30s
     conditions:
       - "[STATUS] == 200"
       - "[BODY].status == UP"
       - "[RESPONSE_TIME] < 300"
+    alerts:
+      - type: slack
+        enabled: true
+        description: "healthcheck failed 3 times in a row"
+        send-on-resolved: true
+      - type: slack
+        enabled: true
+        failure-threshold: 5
+        description: "healthcheck failed 5 times in a row"
+        send-on-resolved: true
 ```
 
+Here's an example of what the notifications look like:
+
+![Slack notifications](.github/assets/slack-alerts.png)
+
+
+#### Configuring Teams alerts
+| Parameter                        | Description                                                                   | Default        |
+|:-------------------------------- |:----------------------------------------------------------------------------- |:-------------- |
+| `alerting.teams`                 | Configuration for alerts of type `teams`                                      | `{}`           |
+| `alerting.teams.webhook-url`     | Teams Webhook URL                                                             | Required `""`  |
+| `alerting.teams.default-alert`   | Default alert configuration. See [Setting a default alert](#setting-a-default-alert) | N/A       |
+
+```yaml
+alerting:
+  teams:
+    webhook-url: "https://********.webhook.office.com/webhookb2/************"
+
+services:
+  - name: twinnation
+    url: "https://twinnation.org/health"
+    interval: 30s
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 300"
+    alerts:
+      - type: teams
+        enabled: true
+        description: "healthcheck failed"
+        send-on-resolved: true
+```
+
+Here's an example of what the notifications look like:
+
+![Teams notifications](.github/assets/teams-alerts.png)
+
+#### Configuring Telegram alerts
+| Parameter                           | Description                                                                   | Default        |
+|:----------------------------------- |:----------------------------------------------------------------------------- |:-------------- |
+| `alerting.telegram`                 | Configuration for alerts of type `telegram`                                   | `{}`           |
+| `alerting.telegram.token`           | Telegram Bot Token                                                            | Required `""`  |
+| `alerting.telegram.id`              | Telegram User ID                                                              | Required `""`  |
+| `alerting.telegram.default-alert`   | Default alert configuration. See [Setting a default alert](#setting-a-default-alert) | N/A       |
+
+```yaml
+alerting:
+  telegram: 
+    token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"
+    id: "0123456789"
+
+services:
+  - name: twinnation
+    url: "https://twinnation.org/health"
+    interval: 30s
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+    alerts:
+      - type: telegram
+        enabled: true
+        send-on-resolved: true
+```
+
+Here's an example of what the notifications look like:
+
+![Telegram notifications](.github/assets/telegram-alerts.png)
+
 
 #### Configuring Twilio alerts
+| Parameter                         | Description                                                                   | Default        |
+|:--------------------------------- |:----------------------------------------------------------------------------- |:-------------- |
+| `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.twilio.default-alert`   | Default alert configuration. See [Setting a default alert](#setting-a-default-alert) | N/A       |
 
 ```yaml
 alerting:
@@ -358,101 +552,29 @@ services:
   - name: twinnation
     interval: 30s
     url: "https://twinnation.org/health"
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 300"
     alerts:
       - type: twilio
         enabled: true
         failure-threshold: 5
         send-on-resolved: true
         description: "healthcheck failed"
-    conditions:
-      - "[STATUS] == 200"
-      - "[BODY].status == UP"
-      - "[RESPONSE_TIME] < 300"
 ```
 
 
-#### Configuring Mattermost alerts
-
-```yaml
-alerting:
-  mattermost: 
-    webhook-url: "http://**********/hooks/**********"
-    insecure: true
-
-services:
-  - name: twinnation
-    url: "https://twinnation.org/health"
-    interval: 30s
-    alerts:
-      - type: mattermost
-        enabled: true
-        description: "healthcheck failed"
-        send-on-resolved: true
-    conditions:
-      - "[STATUS] == 200"
-      - "[BODY].status == UP"
-      - "[RESPONSE_TIME] < 300"
-```
-
-Here's an example of what the notifications look like:
-
-![Mattermost notifications](.github/assets/mattermost-alerts.png)
-
-
-#### Configuring Messagebird alerts
-
-Example of sending **SMS** text message alert using Messagebird:
-
-```yaml
-alerting:
-  messagebird:
-    access-key: "..."
-    originator: "31619191918"
-    recipients: "31619191919,31619191920"
-services:
-  - name: twinnation
-    interval: 30s
-    url: "https://twinnation.org/health"
-    alerts:
-      - type: messagebird
-        enabled: true
-        failure-threshold: 3
-        send-on-resolved: true
-        description: "healthcheck failed"
-    conditions:
-      - "[STATUS] == 200"
-      - "[BODY].status == UP"
-      - "[RESPONSE_TIME] < 300"
-```
-
-
-#### 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
+| Parameter                         | Description                                                                   | Default        |
+|:----------------------------------|:----------------------------------------------------------------------------- |:-------------- |
+| `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.body`            | Custom alerting request body.                                                 | `""`           |
+| `alerting.custom.headers`         | Custom alerting request headers                                               | `{}`           |
+| `alerting.custom.client`          | Client configuration. See [Client configuration](#client-configuration).      | `{}`           |
+| `alerting.custom.default-alert`   | Default alert configuration. See [Setting a default alert](#setting-a-default-alert) | N/A       |
 
 While they're called alerts, you can use this feature to call anything. 
 
@@ -475,7 +597,6 @@ alerting:
   custom:
     url: "https://hooks.slack.com/services/**********/**********/**********"
     method: "POST"
-    insecure: true
     body: |
       {
         "text": "[ALERT_TRIGGERED_OR_RESOLVED]: [SERVICE_NAME] - [ALERT_DESCRIPTION]"
@@ -484,6 +605,10 @@ services:
   - name: twinnation
     url: "https://twinnation.org/health"
     interval: 30s
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 300"
     alerts:
       - type: custom
         enabled: true
@@ -491,10 +616,6 @@ services:
         success-threshold: 3
         send-on-resolved: true
         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:
@@ -510,7 +631,14 @@ As a result, the `[ALERT_TRIGGERED_OR_RESOLVED]` in the body of first example of
 `partial_outage` when an alert is triggered and `operational` when an alert is resolved.
 
 
-#### Setting a default provider alert
+#### Setting a default alert
+| Parameter                                     | Description                                                                   | Default |
+|:----------------------------------------------|:------------------------------------------------------------------------------|:--------|
+| `alerting.*.default-alert.enabled`            | Whether to enable the alert                                                   | N/A     |
+| `alerting.*.default-alert.failure-threshold`  | Number of failures in a row needed before triggering the alert                | N/A     |
+| `alerting.*.default-alert.success-threshold`  | Number of successes in a row before an ongoing incident is marked as resolved | N/A     |
+| `alerting.*.default-alert.send-on-resolved`   | Whether to send a notification once a triggered alert is marked as resolved   | N/A     |
+| `alerting.*.default-alert.description`        | Description of the alert. Will be included in the alert sent                  | N/A     |
 
 While you can specify the alert configuration directly in the service definition, it's tedious and may lead to a very
 long configuration file.
@@ -533,24 +661,26 @@ As a result, your service configuration looks a lot tidier:
 services:
   - name: example
     url: "https://example.org"
-    alerts:
-      - type: slack
     conditions:
       - "[STATUS] == 200"
+    alerts:
+      - type: slack
 
   - name: other-example
     url: "https://example.com"
-    alerts:
-      - type: slack
     conditions:
       - "[STATUS] == 200"
+    alerts:
+      - type: slack
 ```
 
 It also allows you to do things like this:
 ```yaml
 services:
-  - name: twinnation
-    url: "https://twinnation.org/health"
+  - name: example
+    url: "https://example.org"
+    conditions:
+      - "[STATUS] == 200"
     alerts:
       - type: slack
         failure-threshold: 5
@@ -558,15 +688,46 @@ services:
         failure-threshold: 10
       - type: slack
         failure-threshold: 15
+```
+
+Of course, you can also mix alert types:
+```yaml
+alerting:
+  slack:
+    webhook-url: "https://hooks.slack.com/services/**********/**********/**********"
+    default-alert:
+      enabled: true
+      failure-threshold: 3
+  pagerduty:
+    integration-key: "********************************"
+    default-alert:
+      enabled: true
+      failure-threshold: 5
+
+services:
+  - name: service-1
+    url: "https://example.org"
     conditions:
       - "[STATUS] == 200"
+    alerts:
+      - type: slack
+      - type: pagerduty
+
+  - name: service-2
+    url: "https://example.org"
+    conditions:
+      - "[STATUS] == 200"
+    alerts:
+      - type: slack
+      - type: pagerduty
 ```
 
 
 ### Kubernetes (ALPHA)
-
 > **WARNING**: This feature is in ALPHA. This means that it is very likely to change in the near future, which means that
 > while you can use this feature as you see fit, there may be breaking changes in future releases.
+> 
+> **NOTICE**: This feature may be removed. To give your opinion on the subject, see https://github.com/TwinProduction/gatus/discussions/135. 
 
 | Parameter                                   | Description                                                                   | Default        |
 |:------------------------------------------- |:----------------------------------------------------------------------------- |:-------------- |
@@ -583,7 +744,6 @@ services:
 
 
 #### Auto Discovery
-
 Auto discovery works by reading all `Service` resources from the configured `namespaces` and appending the `hostname-suffix` as 
 well as the configured `target-path` to the service name and making an HTTP call.
 
@@ -622,15 +782,21 @@ Note that `hostname-suffix` could also be something like `.yourdomain.com`, in w
 monitored would be `potato.example.com/health`, assuming you have a service named `potato` and a matching ingress
 to map `potato.example.com` to the `potato` service.
 
-#### Deploying
-
-See [example/kubernetes-with-auto-discovery](example/kubernetes-with-auto-discovery)
+For a full example, see [examples/kubernetes-with-auto-discovery](examples/kubernetes-with-auto-discovery)
 
 
-## Docker
+## Deployment
+Many examples can be found in the [examples](examples) folder, but this section will focus on the most popular ways of deploying Gatus.
+
+
+### Docker
+To run Gatus locally with Docker:
+```
+docker run -p 8080:8080 --name gatus twinproduction/gatus
+```
 
 Other than using one of the examples provided in the `examples` folder, you can also try it out locally by 
-creating a configuration file - we'll call it `config.yaml` for this example - and running the following 
+creating a configuration file, we'll call it `config.yaml` for this example, and running the following 
 command:
 ```
 docker run -p 8080:8080 --mount type=bind,source="$(pwd)"/config.yaml,target=/config/config.yaml --name gatus twinproduction/gatus
@@ -647,22 +813,37 @@ docker build . -t twinproduction/gatus
 ```
 
 
-## Running the tests
+### Helm Chart
+[Helm](https://helm.sh) must be installed to use the chart.
+Please refer to Helm's [documentation](https://helm.sh/docs/) to get started.
 
+Once Helm is set up properly, add the repository as follows:
+
+```console
+helm repo add gatus https://avakarev.github.io/gatus-chart
+```
+
+To get more details, please check chart's [configuration](https://github.com/avakarev/gatus-chart#configuration)
+and [helmfile example](https://github.com/avakarev/gatus-chart#helmfileyaml-example)
+
+
+### Terraform
+Gatus can be deployed on Terraform by using the following module: [terraform-kubernetes-gatus](https://github.com/TwinProduction/terraform-kubernetes-gatus).
+
+
+
+## Running the tests
 ```
 go test ./... -mod vendor
 ```
 
 
 ## Using in Production
-
-See the [example](example) folder.
+See the [Deployment](#deployment) section.
 
 
 ## FAQ
-
 ### Sending a GraphQL request
-
 By setting `services[].graphql` to true, the body will automatically be wrapped by the standard GraphQL `query` parameter.
 
 For instance, the following configuration:
@@ -693,9 +874,8 @@ will send a `POST` request to `http://localhost:8080/playground` with the follow
 
 
 ### Recommended interval
-
-**NOTE**: This does not _really_ apply if `disable-monitoring-lock` is set to `true`, as the monitoring lock is what
-tells Gatus to only evaluate one service at a time.
+> **NOTE**: This does not _really_ apply if `disable-monitoring-lock` is set to `true`, as the monitoring lock is what
+> tells Gatus to only evaluate one service at a time.
 
 To ensure that Gatus provides reliable and accurate results (i.e. response time), Gatus only evaluates one service at a time
 In other words, even if you have multiple services with the exact same interval, they will not execute at the same time.
@@ -705,7 +885,7 @@ such as 1ms. You'll notice that the response time does not fluctuate - that is b
 different goroutines, there's a global lock that prevents multiple services from running at the same time.
 
 Unfortunately, there is a drawback. If you have a lot of services, including some that are very slow or prone to time out (the default
-time out is 10s for HTTP and 5s for TCP), then it means that for the entire duration of the request, no other services can be evaluated.
+timeout is 10s), then it means that for the entire duration of the request, no other services can be evaluated.
 
 **This does mean that Gatus will be unable to evaluate the health of other services**. 
 The interval does not include the duration of the request itself, which means that if a service has an interval of 30s 
@@ -725,15 +905,16 @@ simple health checks used for alerting (PagerDuty/Twilio) to `30s`.
 
 
 ### Default timeouts
-
 | Protocol | Timeout |
 |:-------- |:------- |
 | HTTP     | 10s
-| TCP      | 5s
+| TCP      | 10s
+| ICMP     | 10s
+
+To modify the timeout, see [Client configuration](#client-configuration).
 
 
 ### Monitoring a TCP service
-
 By prefixing `services[].url` with `tcp:\\`, you can monitor TCP services at a very basic level:
 
 ```yaml
@@ -754,7 +935,6 @@ established.
 
 
 ### Monitoring a service using ICMP
-
 By prefixing `services[].url` with `icmp:\\`, you can monitor services at a very basic level using ICMP, or more 
 commonly known as "ping" or "echo":
 
@@ -771,7 +951,6 @@ You can specify a domain prefixed by `icmp://`, or an IP address prefixed by `ic
 
 
 ### Monitoring a service using DNS queries
-
 Defining a `dns` configuration in a service will automatically mark that service as a service of type DNS:
 ```yaml
 services:
@@ -792,10 +971,22 @@ There are two placeholders that can be used in the conditions for services of ty
 `NOERROR`, `FORMERR`, `SERVFAIL`, `NXDOMAIN`, etc.
 
 
+### Monitoring a service using STARTTLS
+If you have an email server that you want to ensure there are no problems with, monitoring it through STARTTLS 
+will serve as a good initial indicator:
+```yaml
+services:
+  - name: starttls-smtp-example
+    url: "starttls://smtp.gmail.com:587"
+    interval: 30m
+    conditions:
+      - "[CONNECTED] == true"
+      - "[CERTIFICATE_EXPIRATION] > 48h"
+```
+
+
 ### Basic authentication
-
 You can require Basic authentication by leveraging the `security.basic` configuration:
-
 ```yaml
 security:
   basic:
@@ -807,7 +998,6 @@ The example above will require that you authenticate with the username `john.doe
 
 
 ### disable-monitoring-lock
-
 Setting `disable-monitoring-lock` to `true` means that multiple services could be monitored at the same time.
 
 While this behavior wouldn't generally be harmful, conditions using the `[RESPONSE_TIME]` placeholder could be impacted 
@@ -821,7 +1011,6 @@ technically, if you create 100 services with a 1 seconds interval, Gatus will se
 
 
 ### Reloading configuration on the fly
-
 For the sake on convenience, Gatus automatically reloads the configuration on the fly if the loaded configuration file
 is updated while Gatus is running.
 
@@ -845,7 +1034,6 @@ the same as restarting the application.
 
 
 ### Service groups
-
 Service groups are used for grouping multiple services together on the dashboard.
 
 ```yaml
@@ -891,7 +1079,6 @@ The configuration above will result in a dashboard that looks like this:
 
 
 ### Exposing Gatus on a custom port
-
 By default, Gatus is exposed on port `8080`, but you may specify a different port by setting the `web.port` parameter:
 ```yaml
 web:
@@ -961,3 +1148,13 @@ Gzip compression will be used if the `Accept-Encoding` HTTP header contains `gzi
 
 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.
+
+
+### High level design overview
+![Gatus diagram](.github/assets/gatus-diagram.png)
+
+
+## Sponsors
+You can find the full list of sponsors [here](https://github.com/sponsors/TwinProduction).
+
+[<img src="https://github.com/math280h.png" width="35" />](https://github.com/math280h)

alerting/alert/type.go

@@ -23,6 +23,9 @@ const (
 	// TypeSlack is the Type for the slack alerting provider
 	TypeSlack Type = "slack"
 
+	// TypeTeams is the Type for the teams alerting provider
+	TypeTeams Type = "teams"
+
 	// TypeTelegram is the Type for the telegram alerting provider
 	TypeTelegram Type = "telegram"
 

alerting/config.go

@@ -9,6 +9,7 @@ import (
 	"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/teams"
 	"github.com/TwinProduction/gatus/alerting/provider/telegram"
 	"github.com/TwinProduction/gatus/alerting/provider/twilio"
 )
@@ -33,6 +34,9 @@ type Config struct {
 	// Slack is the configuration for the slack alerting provider
 	Slack *slack.AlertProvider `yaml:"slack"`
 
+	// Teams is the configuration for the teams alerting provider
+	Teams *teams.AlertProvider `yaml:"teams"`
+
 	// Telegram is the configuration for the telegram alerting provider
 	Telegram *telegram.AlertProvider `yaml:"telegram"`
 
@@ -79,6 +83,12 @@ func (config Config) GetAlertingProviderByAlertType(alertType alert.Type) provid
 			return nil
 		}
 		return config.Slack
+	case alert.TypeTeams:
+		if config.Teams == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Teams
 	case alert.TypeTelegram:
 		if config.Telegram == nil {
 			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil

alerting/provider/custom/custom.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"io/ioutil"
+	"log"
 	"net/http"
 	"os"
 	"strings"
@@ -19,18 +20,29 @@ import (
 type AlertProvider struct {
 	URL          string                       `yaml:"url"`
 	Method       string                       `yaml:"method,omitempty"`
-	Insecure     bool                         `yaml:"insecure,omitempty"`
+	Insecure     bool                         `yaml:"insecure,omitempty"` // deprecated
 	Body         string                       `yaml:"body,omitempty"`
 	Headers      map[string]string            `yaml:"headers,omitempty"`
 	Placeholders map[string]map[string]string `yaml:"placeholders,omitempty"`
 
+	// ClientConfig is the configuration of the client used to communicate with the provider's target
+	ClientConfig *client.Config `yaml:"client"`
+
 	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
 	DefaultAlert *alert.Alert `yaml:"default-alert"`
 }
 
 // IsValid returns whether the provider's configuration is valid
 func (provider *AlertProvider) IsValid() bool {
-	return len(provider.URL) > 0
+	if provider.ClientConfig == nil {
+		provider.ClientConfig = client.GetDefaultConfig()
+		// XXX: remove the next 4 lines in v3.0.0
+		if provider.Insecure {
+			log.Println("WARNING: alerting.*.insecure has been deprecated and will be removed in v3.0.0 in favor of alerting.*.client.insecure")
+			provider.ClientConfig.Insecure = true
+		}
+	}
+	return len(provider.URL) > 0 && provider.ClientConfig != nil
 }
 
 // ToCustomAlertProvider converts the provider into a custom.AlertProvider
@@ -103,7 +115,7 @@ func (provider *AlertProvider) Send(serviceName, alertDescription string, resolv
 		return []byte("{}"), nil
 	}
 	request := provider.buildHTTPRequest(serviceName, alertDescription, resolved)
-	response, err := client.GetHTTPClient(provider.Insecure).Do(request)
+	response, err := client.GetHTTPClient(provider.ClientConfig).Do(request)
 	if err != nil {
 		return nil, err
 	}

alerting/provider/discord/discord.go

@@ -42,6 +42,10 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		}
 		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
 	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = ":\\n> " + alertDescription
+	}
 	return &custom.AlertProvider{
 		URL:    provider.WebhookURL,
 		Method: http.MethodPost,
@@ -50,7 +54,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
   "embeds": [
     {
       "title": ":helmet_with_white_cross: Gatus",
-      "description": "%s:\n> %s",
+      "description": "%s%s",
       "color": %d,
       "fields": [
         {
@@ -61,7 +65,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
       ]
     }
   ]
-}`, message, alert.GetDescription(), colorCode, results),
+}`, message, description, colorCode, results),
 		Headers: map[string]string{"Content-Type": "application/json"},
 	}
 }

alerting/provider/discord/discord_test.go

@@ -23,7 +23,8 @@ func TestAlertProvider_IsValid(t *testing.T) {
 
 func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	provider := AlertProvider{WebhookURL: "http://example.com"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	alertDescription := "test"
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
 	if customAlertProvider == nil {
 		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
@@ -41,6 +42,9 @@ func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	if err != nil {
 		t.Error("expected body to be valid JSON, got error:", err.Error())
 	}
+	if expected := "An alert for **svc** has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["embeds"].([]interface{})[0].(map[string]interface{})["description"] {
+		t.Errorf("expected $.embeds[0].description to be %s, got %s", expected, body["embeds"].([]interface{})[0].(map[string]interface{})["description"])
+	}
 }
 
 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {

alerting/provider/mattermost/mattermost.go

@@ -2,17 +2,22 @@ package mattermost
 
 import (
 	"fmt"
+	"log"
 	"net/http"
 
 	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/client"
 	"github.com/TwinProduction/gatus/core"
 )
 
 // AlertProvider is the configuration necessary for sending an alert using Mattermost
 type AlertProvider struct {
 	WebhookURL string `yaml:"webhook-url"`
-	Insecure   bool   `yaml:"insecure,omitempty"`
+	Insecure   bool   `yaml:"insecure,omitempty"` // deprecated
+
+	// ClientConfig is the configuration of the client used to communicate with the provider's target
+	ClientConfig *client.Config `yaml:"client"`
 
 	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
 	DefaultAlert *alert.Alert `yaml:"default-alert"`
@@ -20,6 +25,14 @@ type AlertProvider struct {
 
 // IsValid returns whether the provider's configuration is valid
 func (provider *AlertProvider) IsValid() bool {
+	if provider.ClientConfig == nil {
+		provider.ClientConfig = client.GetDefaultConfig()
+		// XXX: remove the next 3 lines in v3.0.0
+		if provider.Insecure {
+			log.Println("WARNING: alerting.mattermost.insecure has been deprecated and will be removed in v3.0.0 in favor of alerting.mattermost.client.insecure")
+			provider.ClientConfig.Insecure = true
+		}
+	}
 	return len(provider.WebhookURL) > 0
 }
 
@@ -44,10 +57,14 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		}
 		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
 	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = ":\\n> " + alertDescription
+	}
 	return &custom.AlertProvider{
-		URL:      provider.WebhookURL,
-		Method:   http.MethodPost,
-		Insecure: provider.Insecure,
+		URL:          provider.WebhookURL,
+		Method:       http.MethodPost,
+		ClientConfig: provider.ClientConfig,
 		Body: fmt.Sprintf(`{
   "text": "",
   "username": "gatus",
@@ -56,7 +73,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
     {
       "title": ":rescue_worker_helmet: Gatus",
       "fallback": "Gatus - %s",
-      "text": "%s:\n> %s",
+      "text": "%s%s",
       "short": false,
       "color": "%s",
       "fields": [
@@ -73,7 +90,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
       ]
     }
   ]
-}`, message, message, alert.GetDescription(), color, service.URL, results),
+}`, message, message, description, color, service.URL, results),
 		Headers: map[string]string{"Content-Type": "application/json"},
 	}
 }

alerting/provider/mattermost/mattermost_test.go

@@ -23,7 +23,8 @@ func TestAlertProvider_IsValid(t *testing.T) {
 
 func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	provider := AlertProvider{WebhookURL: "http://example.org"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	alertDescription := "test"
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
 	if customAlertProvider == nil {
 		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
@@ -41,6 +42,9 @@ func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	if err != nil {
 		t.Error("expected body to be valid JSON, got error:", err.Error())
 	}
+	if expected := "An alert for *svc* has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["attachments"].([]interface{})[0].(map[string]interface{})["text"] {
+		t.Errorf("expected $.attachments[0].description to be %s, got %s", expected, body["attachments"].([]interface{})[0].(map[string]interface{})["text"])
+	}
 }
 
 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {

alerting/provider/pagerduty/pagerduty.go

@@ -9,6 +9,10 @@ import (
 	"github.com/TwinProduction/gatus/core"
 )
 
+const (
+	restAPIURL = "https://events.pagerduty.com/v2/enqueue"
+)
+
 // AlertProvider is the configuration necessary for sending an alert using PagerDuty
 type AlertProvider struct {
 	IntegrationKey string `yaml:"integration-key"`
@@ -37,7 +41,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		resolveKey = ""
 	}
 	return &custom.AlertProvider{
-		URL:    "https://events.pagerduty.com/v2/enqueue",
+		URL:    restAPIURL,
 		Method: http.MethodPost,
 		Body: fmt.Sprintf(`{
   "routing_key": "%s",

alerting/provider/provider.go

@@ -8,6 +8,7 @@ import (
 	"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/teams"
 	"github.com/TwinProduction/gatus/alerting/provider/telegram"
 	"github.com/TwinProduction/gatus/alerting/provider/twilio"
 	"github.com/TwinProduction/gatus/core"
@@ -55,6 +56,7 @@ var (
 	_ AlertProvider = (*messagebird.AlertProvider)(nil)
 	_ AlertProvider = (*pagerduty.AlertProvider)(nil)
 	_ AlertProvider = (*slack.AlertProvider)(nil)
+	_ AlertProvider = (*teams.AlertProvider)(nil)
 	_ AlertProvider = (*telegram.AlertProvider)(nil)
 	_ AlertProvider = (*twilio.AlertProvider)(nil)
 )

alerting/provider/slack/slack.go

@@ -41,6 +41,10 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
 		}
 		results += fmt.Sprintf("%s - `%s`\\n", prefix, conditionResult.Condition)
 	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = ":\\n> " + alertDescription
+	}
 	return &custom.AlertProvider{
 		URL:    provider.WebhookURL,
 		Method: http.MethodPost,
@@ -49,7 +53,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
   "attachments": [
     {
       "title": ":helmet_with_white_cross: Gatus",
-      "text": "%s:\n> %s",
+      "text": "%s%s",
       "short": false,
       "color": "%s",
       "fields": [
@@ -61,7 +65,7 @@ func (provider *AlertProvider) ToCustomAlertProvider(service *core.Service, aler
       ]
     }
   ]
-}`, message, alert.GetDescription(), color, results),
+}`, message, description, color, results),
 		Headers: map[string]string{"Content-Type": "application/json"},
 	}
 }

alerting/provider/slack/slack_test.go

@@ -23,7 +23,8 @@ func TestAlertProvider_IsValid(t *testing.T) {
 
 func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	provider := AlertProvider{WebhookURL: "http://example.com"}
-	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	alertDescription := "test"
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
 	if customAlertProvider == nil {
 		t.Fatal("customAlertProvider shouldn't have been nil")
 	}
@@ -41,6 +42,9 @@ func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
 	if err != nil {
 		t.Error("expected body to be valid JSON, got error:", err.Error())
 	}
+	if expected := "An alert for *svc* has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["attachments"].([]interface{})[0].(map[string]interface{})["text"] {
+		t.Errorf("expected $.attachments[0].description to be %s, got %s", expected, body["attachments"].([]interface{})[0].(map[string]interface{})["text"])
+	}
 }
 
 func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {

alerting/provider/teams/teams.go

@@ -0,0 +1,77 @@
+package teams
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/TwinProduction/gatus/alerting/alert"
+	"github.com/TwinProduction/gatus/alerting/provider/custom"
+	"github.com/TwinProduction/gatus/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Teams
+type AlertProvider struct {
+	WebhookURL string `yaml:"webhook-url"`
+
+	// DefaultAlert is the default alert configuration to use for services with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+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 *alert.Alert, result *core.Result, resolved bool) *custom.AlertProvider {
+	var message string
+	var color string
+	if resolved {
+		message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", service.Name, alert.SuccessThreshold)
+		color = "#36A64F"
+	} else {
+		message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", service.Name, alert.FailureThreshold)
+		color = "#DD0000"
+	}
+	var results string
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = "✅"
+		} else {
+			prefix = "❌"
+		}
+		results += fmt.Sprintf("%s - `%s`<br/>", prefix, conditionResult.Condition)
+	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = ":\\n> " + alertDescription
+	}
+	return &custom.AlertProvider{
+		URL:    provider.WebhookURL,
+		Method: http.MethodPost,
+		Body: fmt.Sprintf(`{
+  "@type": "MessageCard",
+  "@context": "http://schema.org/extensions",
+  "themeColor": "%s",
+  "title": "&#x1F6A8; Gatus",
+  "text": "%s%s",
+  "sections": [
+    {
+      "activityTitle": "URL",
+      "text": "%s"
+    },
+    {
+      "activityTitle": "Condition results",
+      "text": "%s"
+    }
+  ]
+}`, color, message, description, service.URL, results),
+		Headers: map[string]string{"Content-Type": "application/json"},
+	}
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}

alerting/provider/teams/teams_test.go

@@ -0,0 +1,70 @@
+package teams
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/TwinProduction/gatus/alerting/alert"
+	"github.com/TwinProduction/gatus/core"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{WebhookURL: ""}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{WebhookURL: "http://example.com"}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithResolvedAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.org"}
+	alertDescription := "test"
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{Name: "svc"}, &alert.Alert{Description: &alertDescription}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "SUCCESSFUL_CONDITION", Success: true}}}, true)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "resolved") {
+		t.Error("customAlertProvider.Body should've contained the substring resolved")
+	}
+	if customAlertProvider.URL != "http://example.org" {
+		t.Errorf("expected URL to be %s, got %s", "http://example.org", customAlertProvider.URL)
+	}
+	if customAlertProvider.Method != http.MethodPost {
+		t.Errorf("expected method to be %s, got %s", http.MethodPost, customAlertProvider.Method)
+	}
+	body := make(map[string]interface{})
+	err := json.Unmarshal([]byte(customAlertProvider.Body), &body)
+	if err != nil {
+		t.Error("expected body to be valid JSON, got error:", err.Error())
+	}
+	if expected := "An alert for *svc* has been resolved after passing successfully 0 time(s) in a row:\n> test"; expected != body["text"] {
+		t.Errorf("expected $.text to be %s, got %s", expected, body["text"])
+	}
+}
+
+func TestAlertProvider_ToCustomAlertProviderWithTriggeredAlert(t *testing.T) {
+	provider := AlertProvider{WebhookURL: "http://example.org"}
+	customAlertProvider := provider.ToCustomAlertProvider(&core.Service{}, &alert.Alert{}, &core.Result{ConditionResults: []*core.ConditionResult{{Condition: "UNSUCCESSFUL_CONDITION", Success: false}}}, false)
+	if customAlertProvider == nil {
+		t.Fatal("customAlertProvider shouldn't have been nil")
+	}
+	if !strings.Contains(customAlertProvider.Body, "triggered") {
+		t.Error("customAlertProvider.Body should've contained the substring triggered")
+	}
+	if customAlertProvider.URL != "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())
+	}
+}

client/client.go

@@ -2,71 +2,29 @@ package client
 
 import (
 	"crypto/tls"
+	"crypto/x509"
+	"errors"
 	"net"
 	"net/http"
-	"os"
-	"strconv"
+	"net/smtp"
+	"runtime"
+	"strings"
 	"time"
 
 	"github.com/go-ping/ping"
 )
 
-var (
-	secureHTTPClient   *http.Client
-	insecureHTTPClient *http.Client
-
-	// pingTimeout is the timeout for the Ping function
-	// This is mainly exposed for testing purposes
-	pingTimeout = 5 * time.Second
-
-	// httpTimeout is the timeout for secureHTTPClient and insecureHTTPClient
-	httpTimeout = 10 * time.Second
-)
-
-func init() {
-	// XXX: This is an undocumented feature. See https://github.com/TwinProduction/gatus/issues/104.
-	httpTimeoutInSecondsFromEnvironmentVariable := os.Getenv("HTTP_CLIENT_TIMEOUT_IN_SECONDS")
-	if len(httpTimeoutInSecondsFromEnvironmentVariable) > 0 {
-		if httpTimeoutInSeconds, err := strconv.Atoi(httpTimeoutInSecondsFromEnvironmentVariable); err == nil {
-			httpTimeout = time.Duration(httpTimeoutInSeconds) * time.Second
-		}
-	}
-}
-
 // GetHTTPClient returns the shared HTTP client
-func GetHTTPClient(insecure bool) *http.Client {
-	if insecure {
-		if insecureHTTPClient == nil {
-			insecureHTTPClient = &http.Client{
-				Timeout: httpTimeout,
-				Transport: &http.Transport{
-					MaxIdleConns:        100,
-					MaxIdleConnsPerHost: 20,
-					Proxy:               http.ProxyFromEnvironment,
-					TLSClientConfig: &tls.Config{
-						InsecureSkipVerify: true,
-					},
-				},
-			}
-		}
-		return insecureHTTPClient
+func GetHTTPClient(config *Config) *http.Client {
+	if config == nil {
+		return defaultConfig.getHTTPClient()
 	}
-	if secureHTTPClient == nil {
-		secureHTTPClient = &http.Client{
-			Timeout: httpTimeout,
-			Transport: &http.Transport{
-				MaxIdleConns:        100,
-				MaxIdleConnsPerHost: 20,
-				Proxy:               http.ProxyFromEnvironment,
-			},
-		}
-	}
-	return secureHTTPClient
+	return config.getHTTPClient()
 }
 
 // CanCreateTCPConnection checks whether a connection can be established with a TCP service
-func CanCreateTCPConnection(address string) bool {
-	conn, err := net.DialTimeout("tcp", address, 5*time.Second)
+func CanCreateTCPConnection(address string, config *Config) bool {
+	conn, err := net.DialTimeout("tcp", address, config.Timeout)
 	if err != nil {
 		return false
 	}
@@ -74,17 +32,44 @@ func CanCreateTCPConnection(address string) bool {
 	return true
 }
 
+// CanPerformStartTLS checks whether a connection can be established to an address using the STARTTLS protocol
+func CanPerformStartTLS(address string, config *Config) (connected bool, certificate *x509.Certificate, err error) {
+	hostAndPort := strings.Split(address, ":")
+	if len(hostAndPort) != 2 {
+		return false, nil, errors.New("invalid address for starttls, format must be host:port")
+	}
+	smtpClient, err := smtp.Dial(address)
+	if err != nil {
+		return
+	}
+	err = smtpClient.StartTLS(&tls.Config{
+		InsecureSkipVerify: config.Insecure,
+		ServerName:         hostAndPort[0],
+	})
+	if err != nil {
+		return
+	}
+	if state, ok := smtpClient.TLSConnectionState(); ok {
+		certificate = state.PeerCertificates[0]
+	} else {
+		return false, nil, errors.New("could not get TLS connection state")
+	}
+	return true, certificate, nil
+}
+
 // Ping checks if an address can be pinged and returns the round-trip time if the address can be pinged
 //
 // Note that this function takes at least 100ms, even if the address is 127.0.0.1
-func Ping(address string) (bool, time.Duration) {
+func Ping(address string, config *Config) (bool, time.Duration) {
 	pinger, err := ping.NewPinger(address)
 	if err != nil {
 		return false, 0
 	}
 	pinger.Count = 1
-	pinger.Timeout = pingTimeout
-	pinger.SetPrivileged(true)
+	pinger.Timeout = config.Timeout
+	// Set the pinger's privileged mode to true for every operating system except darwin
+	// https://github.com/TwinProduction/gatus/issues/132
+	pinger.SetPrivileged(runtime.GOOS != "darwin")
 	err = pinger.Run()
 	if err != nil {
 		return false, 0

client/client_test.go

@@ -6,46 +6,93 @@ import (
 )
 
 func TestGetHTTPClient(t *testing.T) {
-	if secureHTTPClient != nil {
-		t.Error("secureHTTPClient should've been nil since it hasn't been called a single time yet")
+	cfg := &Config{
+		Insecure:       false,
+		IgnoreRedirect: false,
+		Timeout:        0,
 	}
-	if insecureHTTPClient != nil {
-		t.Error("insecureHTTPClient should've been nil since it hasn't been called a single time yet")
+	cfg.ValidateAndSetDefaults()
+	if GetHTTPClient(cfg) == nil {
+		t.Error("expected client to not be nil")
 	}
-	_ = GetHTTPClient(false)
-	if secureHTTPClient == nil {
-		t.Error("secureHTTPClient shouldn't have been nil, since it has been called once")
-	}
-	if insecureHTTPClient != nil {
-		t.Error("insecureHTTPClient should've been nil since it hasn't been called a single time yet")
-	}
-	_ = GetHTTPClient(true)
-	if secureHTTPClient == nil {
-		t.Error("secureHTTPClient shouldn't have been nil, since it has been called once")
-	}
-	if insecureHTTPClient == nil {
-		t.Error("insecureHTTPClient shouldn't have been nil, since it has been called once")
+	if GetHTTPClient(nil) == nil {
+		t.Error("expected client to not be nil")
 	}
 }
 
 func TestPing(t *testing.T) {
-	pingTimeout = 500 * time.Millisecond
-	if success, rtt := Ping("127.0.0.1"); !success {
+	if success, rtt := Ping("127.0.0.1", &Config{Timeout: 500 * time.Millisecond}); !success {
 		t.Error("expected true")
 		if rtt == 0 {
 			t.Error("Round-trip time returned on success should've higher than 0")
 		}
 	}
-	if success, rtt := Ping("256.256.256.256"); success {
+	if success, rtt := Ping("256.256.256.256", &Config{Timeout: 500 * time.Millisecond}); success {
 		t.Error("expected false, because the IP is invalid")
 		if rtt != 0 {
 			t.Error("Round-trip time returned on failure should've been 0")
 		}
 	}
-	if success, rtt := Ping("192.168.152.153"); success {
+	if success, rtt := Ping("192.168.152.153", &Config{Timeout: 500 * time.Millisecond}); success {
 		t.Error("expected false, because the IP is valid but the host should be unreachable")
 		if rtt != 0 {
 			t.Error("Round-trip time returned on failure should've been 0")
 		}
 	}
 }
+
+func TestCanPerformStartTLS(t *testing.T) {
+	type args struct {
+		address  string
+		insecure bool
+	}
+	tests := []struct {
+		name          string
+		args          args
+		wantConnected bool
+		wantErr       bool
+	}{
+		{
+			name: "invalid address",
+			args: args{
+				address: "test",
+			},
+			wantConnected: false,
+			wantErr:       true,
+		},
+		{
+			name: "error dial",
+			args: args{
+				address: "test:1234",
+			},
+			wantConnected: false,
+			wantErr:       true,
+		},
+		{
+			name: "valid starttls",
+			args: args{
+				address: "smtp.gmail.com:587",
+			},
+			wantConnected: true,
+			wantErr:       false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			connected, _, err := CanPerformStartTLS(tt.args.address, &Config{Insecure: tt.args.insecure, Timeout: 5 * time.Second})
+			if (err != nil) != tt.wantErr {
+				t.Errorf("CanPerformStartTLS() err=%v, wantErr=%v", err, tt.wantErr)
+				return
+			}
+			if connected != tt.wantConnected {
+				t.Errorf("CanPerformStartTLS() connected=%v, wantConnected=%v", connected, tt.wantConnected)
+			}
+		})
+	}
+}
+
+func TestCanCreateTCPConnection(t *testing.T) {
+	if CanCreateTCPConnection("127.0.0.1", &Config{Timeout: 5 * time.Second}) {
+		t.Error("should've failed, because there's no port in the address")
+	}
+}

client/config.go

@@ -0,0 +1,73 @@
+package client
+
+import (
+	"crypto/tls"
+	"net/http"
+	"time"
+)
+
+const (
+	defaultHTTPTimeout = 10 * time.Second
+)
+
+var (
+	// DefaultConfig is the default client configuration
+	defaultConfig = Config{
+		Insecure:       false,
+		IgnoreRedirect: false,
+		Timeout:        defaultHTTPTimeout,
+	}
+)
+
+// GetDefaultConfig returns a copy of the default configuration
+func GetDefaultConfig() *Config {
+	cfg := defaultConfig
+	return &cfg
+}
+
+// Config is the configuration for clients
+type Config struct {
+	// Insecure determines whether to skip verifying the server's certificate chain and host name
+	Insecure bool `yaml:"insecure"`
+
+	// IgnoreRedirect determines whether to ignore redirects (true) or follow them (false, default)
+	IgnoreRedirect bool `yaml:"ignore-redirect"`
+
+	// Timeout for the client
+	Timeout time.Duration `yaml:"timeout"`
+
+	httpClient *http.Client
+}
+
+// ValidateAndSetDefaults validates the client configuration and sets the default values if necessary
+func (c *Config) ValidateAndSetDefaults() {
+	if c.Timeout < time.Millisecond {
+		c.Timeout = 10 * time.Second
+	}
+}
+
+// GetHTTPClient return a HTTP client matching the Config's parameters.
+func (c *Config) getHTTPClient() *http.Client {
+	if c.httpClient == nil {
+		c.httpClient = &http.Client{
+			Timeout: c.Timeout,
+			Transport: &http.Transport{
+				MaxIdleConns:        100,
+				MaxIdleConnsPerHost: 20,
+				Proxy:               http.ProxyFromEnvironment,
+				TLSClientConfig: &tls.Config{
+					InsecureSkipVerify: c.Insecure,
+				},
+			},
+			CheckRedirect: func(req *http.Request, via []*http.Request) error {
+				if c.IgnoreRedirect {
+					// Don't follow redirects
+					return http.ErrUseLastResponse
+				}
+				// Follow redirects
+				return nil
+			},
+		}
+	}
+	return c.httpClient
+}

client/config_test.go

@@ -0,0 +1,37 @@
+package client
+
+import (
+	"net/http"
+	"testing"
+	"time"
+)
+
+func TestConfig_getHTTPClient(t *testing.T) {
+	insecureConfig := &Config{Insecure: true}
+	insecureConfig.ValidateAndSetDefaults()
+	insecureClient := insecureConfig.getHTTPClient()
+	if !(insecureClient.Transport).(*http.Transport).TLSClientConfig.InsecureSkipVerify {
+		t.Error("expected Config.Insecure set to true to cause the HTTP client to skip certificate verification")
+	}
+	if insecureClient.Timeout != defaultHTTPTimeout {
+		t.Error("expected Config.Timeout to default the HTTP client to a timeout of 10s")
+	}
+	request, _ := http.NewRequest("GET", "", nil)
+	if err := insecureClient.CheckRedirect(request, nil); err != nil {
+		t.Error("expected Config.IgnoreRedirect set to false to cause the HTTP client's CheckRedirect to return nil")
+	}
+
+	secureConfig := &Config{IgnoreRedirect: true, Timeout: 5 * time.Second}
+	secureConfig.ValidateAndSetDefaults()
+	secureClient := secureConfig.getHTTPClient()
+	if (secureClient.Transport).(*http.Transport).TLSClientConfig.InsecureSkipVerify {
+		t.Error("expected Config.Insecure set to false to cause the HTTP client to not skip certificate verification")
+	}
+	if secureClient.Timeout != 5*time.Second {
+		t.Error("expected Config.Timeout to cause the HTTP client to have a timeout of 5s")
+	}
+	request, _ = http.NewRequest("GET", "", nil)
+	if err := secureClient.CheckRedirect(request, nil); err != http.ErrUseLastResponse {
+		t.Error("expected Config.IgnoreRedirect set to true to cause the HTTP client's CheckRedirect to return http.ErrUseLastResponse")
+	}
+}

config.yaml

@@ -10,14 +10,15 @@ services:
 
   - name: back-end
     group: core
-    url: "http://example.org/"
+    url: "https://example.org/"
     interval: 5m
     conditions:
       - "[STATUS] == 200"
+      - "[CERTIFICATE_EXPIRATION] > 48h"
 
   - name: monitoring
     group: internal
-    url: "http://example.com/"
+    url: "https://example.org/"
     interval: 5m
     conditions:
       - "[STATUS] == 200"
@@ -29,14 +30,6 @@ services:
     conditions:
       - "[STATUS] == 200"
 
-  - name: cat-fact
-    url: "https://cat-fact.herokuapp.com/facts/random"
-    interval: 5m
-    conditions:
-      - "[STATUS] == 200"
-      - "[BODY].deleted == false"
-      - "len([BODY].text) > 0"
-
   - name: example-dns-query
     url: "8.8.8.8" # Address of the DNS server to use
     interval: 5m

config/config.go

@@ -14,7 +14,6 @@ import (
 	"github.com/TwinProduction/gatus/k8s"
 	"github.com/TwinProduction/gatus/security"
 	"github.com/TwinProduction/gatus/storage"
-	"github.com/TwinProduction/gatus/util"
 	"gopkg.in/yaml.v2"
 )
 
@@ -177,7 +176,9 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 
 func validateStorageConfig(config *Config) error {
 	if config.Storage == nil {
-		config.Storage = &storage.Config{}
+		config.Storage = &storage.Config{
+			Type: storage.TypeInMemory,
+		}
 	}
 	err := storage.Initialize(config.Storage)
 	if err != nil {
@@ -186,7 +187,7 @@ func validateStorageConfig(config *Config) error {
 	// 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))
+		keys = append(keys, service.Key())
 	}
 	numberOfServiceStatusesDeleted := storage.Get().DeleteAllServiceStatusesNotInKeys(keys)
 	if numberOfServiceStatusesDeleted > 0 {
@@ -208,6 +209,7 @@ func validateWebConfig(config *Config) error {
 // I don't like the current implementation.
 func validateKubernetesConfig(config *Config) error {
 	if config.Kubernetes != nil && config.Kubernetes.AutoDiscover {
+		log.Println("WARNING - The Kubernetes integration is planned to be removed in v3.0.0. If you're seeing this message, it's because you're currently using it, and you may want to give your opinion at https://github.com/TwinProduction/gatus/discussions/135")
 		if config.Kubernetes.ServiceTemplate == nil {
 			return errors.New("kubernetes.service-template cannot be nil")
 		}
@@ -268,6 +270,7 @@ func validateAlertingConfig(alertingConfig *alerting.Config, services []*core.Se
 		alert.TypeMessagebird,
 		alert.TypePagerDuty,
 		alert.TypeSlack,
+		alert.TypeTeams,
 		alert.TypeTelegram,
 		alert.TypeTwilio,
 	}

config/config_test.go

@@ -16,6 +16,8 @@ import (
 	"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/alerting/provider/teams"
+	"github.com/TwinProduction/gatus/client"
 	"github.com/TwinProduction/gatus/core"
 	"github.com/TwinProduction/gatus/k8stest"
 	v1 "k8s.io/api/core/v1"
@@ -40,17 +42,31 @@ func TestParseAndValidateConfigBytes(t *testing.T) {
 	config, err := parseAndValidateConfigBytes([]byte(fmt.Sprintf(`
 storage:
   file: %s
+
 services:
   - name: twinnation
     url: https://twinnation.org/health
     interval: 15s
     conditions:
       - "[STATUS] == 200"
+
   - name: github
     url: https://api.github.com/healthz
+    client:
+      insecure: true
+      ignore-redirect: true
+      timeout: 5s
     conditions:
       - "[STATUS] != 400"
       - "[STATUS] != 500"
+
+  - name: example
+    url: https://example.com/
+    interval: 30m
+    client:
+      insecure: true
+    conditions:
+      - "[STATUS] == 200"
 `, file)))
 	if err != nil {
 		t.Error("expected no error, got", err.Error())
@@ -58,33 +74,75 @@ services:
 	if config == nil {
 		t.Fatal("Config shouldn't have been nil")
 	}
-	if len(config.Services) != 2 {
+	if len(config.Services) != 3 {
 		t.Error("Should have returned two services")
 	}
+
 	if config.Services[0].URL != "https://twinnation.org/health" {
 		t.Errorf("URL should have been %s", "https://twinnation.org/health")
 	}
-	if config.Services[1].URL != "https://api.github.com/healthz" {
-		t.Errorf("URL should have been %s", "https://api.github.com/healthz")
-	}
 	if config.Services[0].Method != "GET" {
 		t.Errorf("Method should have been %s (default)", "GET")
 	}
-	if config.Services[1].Method != "GET" {
-		t.Errorf("Method should have been %s (default)", "GET")
-	}
 	if config.Services[0].Interval != 15*time.Second {
 		t.Errorf("Interval should have been %s", 15*time.Second)
 	}
-	if config.Services[1].Interval != 60*time.Second {
-		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
+	if config.Services[0].ClientConfig.Insecure != client.GetDefaultConfig().Insecure {
+		t.Errorf("ClientConfig.Insecure should have been %v, got %v", true, config.Services[0].ClientConfig.Insecure)
+	}
+	if config.Services[0].ClientConfig.IgnoreRedirect != client.GetDefaultConfig().IgnoreRedirect {
+		t.Errorf("ClientConfig.IgnoreRedirect should have been %v, got %v", true, config.Services[0].ClientConfig.IgnoreRedirect)
+	}
+	if config.Services[0].ClientConfig.Timeout != client.GetDefaultConfig().Timeout {
+		t.Errorf("ClientConfig.Timeout should have been %v, got %v", client.GetDefaultConfig().Timeout, config.Services[0].ClientConfig.Timeout)
 	}
 	if len(config.Services[0].Conditions) != 1 {
 		t.Errorf("There should have been %d conditions", 1)
 	}
+
+	if config.Services[1].URL != "https://api.github.com/healthz" {
+		t.Errorf("URL should have been %s", "https://api.github.com/healthz")
+	}
+	if config.Services[1].Method != "GET" {
+		t.Errorf("Method should have been %s (default)", "GET")
+	}
+	if config.Services[1].Interval != 60*time.Second {
+		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
+	}
+	if !config.Services[1].ClientConfig.Insecure {
+		t.Errorf("ClientConfig.Insecure should have been %v, got %v", true, config.Services[1].ClientConfig.Insecure)
+	}
+	if !config.Services[1].ClientConfig.IgnoreRedirect {
+		t.Errorf("ClientConfig.IgnoreRedirect should have been %v, got %v", true, config.Services[1].ClientConfig.IgnoreRedirect)
+	}
+	if config.Services[1].ClientConfig.Timeout != 5*time.Second {
+		t.Errorf("ClientConfig.Timeout should have been %v, got %v", 5*time.Second, config.Services[1].ClientConfig.Timeout)
+	}
 	if len(config.Services[1].Conditions) != 2 {
 		t.Errorf("There should have been %d conditions", 2)
 	}
+
+	if config.Services[2].URL != "https://example.com/" {
+		t.Errorf("URL should have been %s", "https://example.com/")
+	}
+	if config.Services[2].Method != "GET" {
+		t.Errorf("Method should have been %s (default)", "GET")
+	}
+	if config.Services[2].Interval != 30*time.Minute {
+		t.Errorf("Interval should have been %s, because it is the default value", 30*time.Minute)
+	}
+	if !config.Services[2].ClientConfig.Insecure {
+		t.Errorf("ClientConfig.Insecure should have been %v, got %v", true, config.Services[2].ClientConfig.Insecure)
+	}
+	if config.Services[2].ClientConfig.IgnoreRedirect {
+		t.Errorf("ClientConfig.IgnoreRedirect should have been %v by default, got %v", false, config.Services[2].ClientConfig.IgnoreRedirect)
+	}
+	if config.Services[2].ClientConfig.Timeout != 10*time.Second {
+		t.Errorf("ClientConfig.Timeout should have been %v by default, got %v", 10*time.Second, config.Services[2].ClientConfig.Timeout)
+	}
+	if len(config.Services[2].Conditions) != 1 {
+		t.Errorf("There should have been %d conditions", 1)
+	}
 }
 
 func TestParseAndValidateConfigBytesDefault(t *testing.T) {
@@ -104,17 +162,26 @@ services:
 	if config.Metrics {
 		t.Error("Metrics should've been false by default")
 	}
+	if config.Web.Address != DefaultAddress {
+		t.Errorf("Bind address should have been %s, because it is the default value", DefaultAddress)
+	}
+	if config.Web.Port != DefaultPort {
+		t.Errorf("Port should have been %d, because it is the default value", DefaultPort)
+	}
 	if config.Services[0].URL != "https://twinnation.org/health" {
 		t.Errorf("URL should have been %s", "https://twinnation.org/health")
 	}
 	if config.Services[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
 	}
-	if config.Web.Address != DefaultAddress {
-		t.Errorf("Bind address should have been %s, because it is the default value", DefaultAddress)
+	if config.Services[0].ClientConfig.Insecure != client.GetDefaultConfig().Insecure {
+		t.Errorf("ClientConfig.Insecure should have been %v by default, got %v", true, config.Services[0].ClientConfig.Insecure)
 	}
-	if config.Web.Port != DefaultPort {
-		t.Errorf("Port should have been %d, because it is the default value", DefaultPort)
+	if config.Services[0].ClientConfig.IgnoreRedirect != client.GetDefaultConfig().IgnoreRedirect {
+		t.Errorf("ClientConfig.IgnoreRedirect should have been %v by default, got %v", true, config.Services[0].ClientConfig.IgnoreRedirect)
+	}
+	if config.Services[0].ClientConfig.Timeout != client.GetDefaultConfig().Timeout {
+		t.Errorf("ClientConfig.Timeout should have been %v by default, got %v", client.GetDefaultConfig().Timeout, config.Services[0].ClientConfig.Timeout)
 	}
 }
 
@@ -143,11 +210,9 @@ 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.Web.Address != "127.0.0.1" {
 		t.Errorf("Bind address should have been %s, because it is specified in config", "127.0.0.1")
 	}
-
 	if config.Web.Port != DefaultPort {
 		t.Errorf("Port should have been %d, because it is the default value", DefaultPort)
 	}
@@ -339,6 +404,8 @@ alerting:
     integration-key: "00000000000000000000000000000000"
   mattermost:
     webhook-url: "http://example.com"
+    client:
+      insecure: true
   messagebird:
     access-key: "1"
     originator: "31619191918"
@@ -351,6 +418,8 @@ alerting:
     token: "5678"
     from: "+1-234-567-8901"
     to: "+1-234-567-8901"
+  teams:
+    webhook-url: "http://example.com"
 
 services:
   - name: twinnation
@@ -375,6 +444,8 @@ services:
         enabled: true
         failure-threshold: 12
         success-threshold: 15
+      - type: teams
+        enabled: true
     conditions:
       - "[STATUS] == 200"
 `))
@@ -401,8 +472,8 @@ services:
 	if config.Services[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
 	}
-	if len(config.Services[0].Alerts) != 7 {
-		t.Fatal("There should've been 7 alerts configured")
+	if len(config.Services[0].Alerts) != 8 {
+		t.Fatal("There should've been 8 alerts configured")
 	}
 
 	if config.Services[0].Alerts[0].Type != alert.TypeSlack {
@@ -489,6 +560,19 @@ services:
 	if config.Services[0].Alerts[6].SuccessThreshold != 15 {
 		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 15, config.Services[0].Alerts[6].SuccessThreshold)
 	}
+
+	if config.Services[0].Alerts[7].Type != alert.TypeTeams {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeTeams, config.Services[0].Alerts[7].Type)
+	}
+	if !config.Services[0].Alerts[7].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[7].FailureThreshold != 3 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 3, config.Services[0].Alerts[7].FailureThreshold)
+	}
+	if config.Services[0].Alerts[7].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[7].SuccessThreshold)
+	}
 }
 
 func TestParseAndValidateConfigBytesWithAlertingAndDefaultAlert(t *testing.T) {
@@ -538,6 +622,10 @@ alerting:
       enabled: true
       failure-threshold: 12
       success-threshold: 15
+  teams:
+    webhook-url: "http://example.com"
+    default-alert:
+      enabled: true
 
 services:
  - name: twinnation
@@ -551,6 +639,7 @@ services:
        success-threshold: 2 # test service alert override
      - type: telegram
      - type: twilio
+     - type: teams
    conditions:
      - "[STATUS] == 200"
 `))
@@ -642,6 +731,14 @@ services:
 	if config.Alerting.Twilio.GetDefaultAlert() == nil {
 		t.Fatal("Twilio.GetDefaultAlert() shouldn't have returned nil")
 	}
+
+	if config.Alerting.Teams == nil || !config.Alerting.Teams.IsValid() {
+		t.Fatal("Teams alerting config should've been valid")
+	}
+	if config.Alerting.Teams.GetDefaultAlert() == nil {
+		t.Fatal("Teams.GetDefaultAlert() shouldn't have returned nil")
+	}
+
 	// Services
 	if len(config.Services) != 1 {
 		t.Error("There should've been 1 service")
@@ -652,8 +749,8 @@ services:
 	if config.Services[0].Interval != 60*time.Second {
 		t.Errorf("Interval should have been %s, because it is the default value", 60*time.Second)
 	}
-	if len(config.Services[0].Alerts) != 7 {
-		t.Fatal("There should've been 7 alerts configured")
+	if len(config.Services[0].Alerts) != 8 {
+		t.Fatal("There should've been 8 alerts configured")
 	}
 
 	if config.Services[0].Alerts[0].Type != alert.TypeSlack {
@@ -743,6 +840,20 @@ services:
 	if config.Services[0].Alerts[6].SuccessThreshold != 15 {
 		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 15, config.Services[0].Alerts[6].SuccessThreshold)
 	}
+
+	if config.Services[0].Alerts[7].Type != alert.TypeTeams {
+		t.Errorf("The type of the alert should've been %s, but it was %s", alert.TypeTeams, config.Services[0].Alerts[7].Type)
+	}
+	if !config.Services[0].Alerts[7].IsEnabled() {
+		t.Error("The alert should've been enabled")
+	}
+	if config.Services[0].Alerts[7].FailureThreshold != 3 {
+		t.Errorf("The default failure threshold of the alert should've been %d, but it was %d", 3, config.Services[0].Alerts[7].FailureThreshold)
+	}
+	if config.Services[0].Alerts[7].SuccessThreshold != 2 {
+		t.Errorf("The default success threshold of the alert should've been %d, but it was %d", 2, config.Services[0].Alerts[7].SuccessThreshold)
+	}
+
 }
 
 func TestParseAndValidateConfigBytesWithAlertingAndDefaultAlertAndMultipleAlertsOfSameTypeWithOverriddenParameters(t *testing.T) {
@@ -895,6 +1006,9 @@ services:
 	if config.Alerting.Custom.Insecure {
 		t.Fatal("config.Alerting.Custom.Insecure shouldn't have been true")
 	}
+	if config.Alerting.Custom.ClientConfig.Insecure {
+		t.Errorf("ClientConfig.Insecure should have been %v, got %v", false, config.Alerting.Custom.ClientConfig.Insecure)
+	}
 }
 
 func TestParseAndValidateConfigBytesWithCustomAlertingConfigAndCustomPlaceholderValues(t *testing.T) {
@@ -1028,6 +1142,49 @@ services:
 	}
 }
 
+func TestParseAndValidateConfigBytesWithInvalidServiceName(t *testing.T) {
+	_, err := parseAndValidateConfigBytes([]byte(`
+services:
+  - name: ""
+    url: https://twinnation.org/health
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err != core.ErrServiceWithNoName {
+		t.Error("should've returned an error")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithInvalidStorageConfig(t *testing.T) {
+	_, err := parseAndValidateConfigBytes([]byte(`
+storage:
+  type: sqlite
+services:
+  - name: example
+    url: https://example.org
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err == nil {
+		t.Error("should've returned an error, because a file must be specified for a storage of type sqlite")
+	}
+}
+
+func TestParseAndValidateConfigBytesWithInvalidYAML(t *testing.T) {
+	_, err := parseAndValidateConfigBytes([]byte(`
+storage:
+  invalid yaml
+services:
+  - name: example
+    url: https://example.org
+    conditions:
+      - "[STATUS] == 200"
+`))
+	if err == nil {
+		t.Error("should've returned an error")
+	}
+}
+
 func TestParseAndValidateConfigBytesWithInvalidSecurityConfig(t *testing.T) {
 	_, err := parseAndValidateConfigBytes([]byte(`
 security:
@@ -1041,7 +1198,7 @@ services:
       - "[STATUS] == 200"
 `))
 	if err == nil {
-		t.Error("Function should've returned an error")
+		t.Error("should've returned an error")
 	}
 }
 
@@ -1173,7 +1330,7 @@ kubernetes:
       target-path: "/health"
 `))
 	if err == nil {
-		t.Error("Function should've returned an error because providing a service-template is mandatory")
+		t.Error("should've returned an error because providing a service-template is mandatory")
 	}
 }
 
@@ -1192,7 +1349,7 @@ kubernetes:
       target-path: "/health"
 `))
 	if err == nil {
-		t.Error("Function should've returned an error because testing with ClusterModeIn isn't supported")
+		t.Error("should've returned an error because testing with ClusterModeIn isn't supported")
 	}
 }
 
@@ -1206,6 +1363,7 @@ func TestGetAlertingProviderByAlertType(t *testing.T) {
 		Slack:       &slack.AlertProvider{},
 		Telegram:    &telegram.AlertProvider{},
 		Twilio:      &twilio.AlertProvider{},
+		Teams:      &teams.AlertProvider{},
 	}
 	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeCustom) != alertingConfig.Custom {
 		t.Error("expected Custom configuration")
@@ -1231,4 +1389,7 @@ func TestGetAlertingProviderByAlertType(t *testing.T) {
 	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeTwilio) != alertingConfig.Twilio {
 		t.Error("expected Twilio configuration")
 	}
+	if alertingConfig.GetAlertingProviderByAlertType(alert.TypeTeams) != alertingConfig.Teams {
+		t.Error("expected Teams configuration")
+	}
 }

controller/badge.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/TwinProduction/gatus/core"
 	"github.com/TwinProduction/gatus/storage"
+	"github.com/TwinProduction/gatus/storage/store/paging"
 	"github.com/gorilla/mux"
 )
 
@@ -25,7 +26,7 @@ func badgeHandler(writer http.ResponseWriter, request *http.Request) {
 	}
 	identifier := variables["identifier"]
 	key := strings.TrimSuffix(identifier, ".svg")
-	serviceStatus := storage.Get().GetServiceStatusByKey(key)
+	serviceStatus := storage.Get().GetServiceStatusByKey(key, paging.NewServiceStatusParams().WithUptime())
 	if serviceStatus == nil {
 		writer.WriteHeader(http.StatusNotFound)
 		_, _ = writer.Write([]byte("Requested service not found"))

controller/controller.go

@@ -13,8 +13,10 @@ import (
 	"time"
 
 	"github.com/TwinProduction/gatus/config"
+	"github.com/TwinProduction/gatus/core"
 	"github.com/TwinProduction/gatus/security"
 	"github.com/TwinProduction/gatus/storage"
+	"github.com/TwinProduction/gatus/storage/store/paging"
 	"github.com/TwinProduction/gocache"
 	"github.com/TwinProduction/health"
 	"github.com/gorilla/mux"
@@ -37,12 +39,6 @@ var (
 	server *http.Server
 )
 
-func init() {
-	if err := cache.StartJanitor(); err != nil {
-		log.Fatal("[controller][init] Failed to start cache janitor:", err.Error())
-	}
-}
-
 // Handle creates the router and starts the server
 func Handle(securityConfig *security.Config, webConfig *config.WebConfig, enableMetrics bool) {
 	var router http.Handler = CreateRouter(securityConfig, enableMetrics)
@@ -115,7 +111,7 @@ func serviceStatusesHandler(writer http.ResponseWriter, r *http.Request) {
 		var err error
 		buffer := &bytes.Buffer{}
 		gzipWriter := gzip.NewWriter(buffer)
-		data, err = json.Marshal(storage.Get().GetAllServiceStatusesWithResultPagination(page, pageSize))
+		data, err = json.Marshal(storage.Get().GetAllServiceStatuses(paging.NewServiceStatusParams().WithResults(page, pageSize)))
 		if err != nil {
 			log.Printf("[controller][serviceStatusesHandler] Unable to marshal object to JSON: %s", err.Error())
 			writer.WriteHeader(http.StatusInternalServerError)
@@ -142,7 +138,7 @@ func serviceStatusesHandler(writer http.ResponseWriter, r *http.Request) {
 func serviceStatusHandler(writer http.ResponseWriter, r *http.Request) {
 	page, pageSize := extractPageAndPageSizeFromRequest(r)
 	vars := mux.Vars(r)
-	serviceStatus := storage.Get().GetServiceStatusByKey(vars["key"])
+	serviceStatus := storage.Get().GetServiceStatusByKey(vars["key"], paging.NewServiceStatusParams().WithResults(page, pageSize).WithEvents(1, core.MaximumNumberOfEvents).WithUptime())
 	if serviceStatus == nil {
 		log.Printf("[controller][serviceStatusHandler] Service with key=%s not found", vars["key"])
 		writer.WriteHeader(http.StatusNotFound)
@@ -150,7 +146,7 @@ func serviceStatusHandler(writer http.ResponseWriter, r *http.Request) {
 		return
 	}
 	data := map[string]interface{}{
-		"serviceStatus": serviceStatus.WithResultPagination(page, pageSize),
+		"serviceStatus": serviceStatus,
 		// The following fields, while present on core.ServiceStatus, are annotated to remain hidden so that we can
 		// expose only the necessary data on /api/v1/statuses.
 		// Since the /api/v1/statuses/{key} endpoint does need this data, however, we explicitly expose it here

controller/controller_test.go

@@ -30,7 +30,6 @@ var (
 		Interval:                30 * time.Second,
 		Conditions:              []*core.Condition{&firstCondition, &secondCondition, &thirdCondition},
 		Alerts:                  nil,
-		Insecure:                false,
 		NumberOfFailuresInARow:  0,
 		NumberOfSuccessesInARow: 0,
 	}

controller/util.go

@@ -3,6 +3,8 @@ package controller
 import (
 	"net/http"
 	"strconv"
+
+	"github.com/TwinProduction/gatus/core"
 )
 
 const (
@@ -13,7 +15,7 @@ const (
 	DefaultPageSize = 20
 
 	// MaximumPageSize is the maximum page size allowed
-	MaximumPageSize = 100
+	MaximumPageSize = core.MaximumNumberOfResults
 )
 
 func extractPageAndPageSizeFromRequest(r *http.Request) (page int, pageSize int) {

core/condition.go

@@ -126,7 +126,7 @@ func (c Condition) evaluate(result *Result) bool {
 			conditionToDisplay = prettifyNumericalParameters(parameters, resolvedParameters, "<")
 		}
 	} else {
-		result.Errors = append(result.Errors, fmt.Sprintf("invalid condition '%s' has been provided", condition))
+		result.AddError(fmt.Sprintf("invalid condition '%s' has been provided", condition))
 		return false
 	}
 	if !success {
@@ -242,7 +242,7 @@ func sanitizeAndResolve(elements []string, result *Result) ([]string, []string)
 				} else {
 					if err != nil {
 						if err.Error() != "unexpected end of JSON input" {
-							result.Errors = append(result.Errors, err.Error())
+							result.AddError(err.Error())
 						}
 						if checkingForLength {
 							element = LengthFunctionPrefix + element + FunctionSuffix + " " + InvalidConditionElementSuffix

core/condition_bench_test.go

@@ -38,6 +38,15 @@ func BenchmarkCondition_evaluateWithBodyStringFailure(b *testing.B) {
 	b.ReportAllocs()
 }
 
+func BenchmarkCondition_evaluateWithBodyStringFailureInvalidPath(b *testing.B) {
+	condition := Condition("[BODY].user.name == bob.doe")
+	for n := 0; n < b.N; n++ {
+		result := &Result{body: []byte("{\"name\": \"bob.doe\"}")}
+		condition.evaluate(result)
+	}
+	b.ReportAllocs()
+}
+
 func BenchmarkCondition_evaluateWithBodyStringLen(b *testing.B) {
 	condition := Condition("len([BODY].name) == 8")
 	for n := 0; n < b.N; n++ {

core/dns.go

@@ -52,7 +52,7 @@ func (d *DNS) query(url string, result *Result) {
 	m.SetQuestion(d.QueryName, queryType)
 	r, _, err := c.Exchange(m, url)
 	if err != nil {
-		result.Errors = append(result.Errors, err.Error())
+		result.AddError(err.Error())
 		return
 	}
 	result.Connected = true

core/event.go

@@ -24,3 +24,14 @@ var (
 	// EventUnhealthy is a type of event that represents a service failing one or more of its conditions
 	EventUnhealthy EventType = "UNHEALTHY"
 )
+
+// NewEventFromResult creates an Event from a Result
+func NewEventFromResult(result *Result) *Event {
+	event := &Event{Timestamp: result.Timestamp}
+	if result.Success {
+		event.Type = EventHealthy
+	} else {
+		event.Type = EventUnhealthy
+	}
+	return event
+}

core/result.go

@@ -46,3 +46,15 @@ type Result struct {
 	// and sets it to nil after the evaluation has been completed.
 	body []byte
 }
+
+// AddError adds an error to the result's list of errors.
+// It also ensures that there are no duplicates.
+func (r *Result) AddError(error string) {
+	for _, resultError := range r.Errors {
+		if resultError == error {
+			// If the error already exists, don't add it
+			return
+		}
+	}
+	r.Errors = append(r.Errors, error)
+}

core/result_test.go

@@ -0,0 +1,21 @@
+package core
+
+import (
+	"testing"
+)
+
+func TestResult_AddError(t *testing.T) {
+	result := &Result{}
+	result.AddError("potato")
+	if len(result.Errors) != 1 {
+		t.Error("should've had 1 error")
+	}
+	result.AddError("potato")
+	if len(result.Errors) != 1 {
+		t.Error("should've still had 1 error, because a duplicate error was added")
+	}
+	result.AddError("tomato")
+	if len(result.Errors) != 2 {
+		t.Error("should've had 2 error")
+	}
+}

core/service-status.go

@@ -1,114 +0,0 @@
-package core
-
-import (
-	"time"
-
-	"github.com/TwinProduction/gatus/util"
-)
-
-const (
-	// MaximumNumberOfResults is the maximum number of results that ServiceStatus.Results can have
-	MaximumNumberOfResults = 100
-
-	// MaximumNumberOfEvents is the maximum number of events that ServiceStatus.Events can have
-	MaximumNumberOfEvents = 50
-)
-
-// ServiceStatus contains the evaluation Results of a Service
-type ServiceStatus struct {
-	// Name of the service
-	Name string `json:"name,omitempty"`
-
-	// Group the service is a part of. Used for grouping multiple services together on the front end.
-	Group string `json:"group,omitempty"`
-
-	// Key is the key representing the ServiceStatus
-	Key string `json:"key"`
-
-	// Results is the list of service evaluation results
-	Results []*Result `json:"results"`
-
-	// Events is a list of events
-	//
-	// We don't expose this through JSON, because the main dashboard doesn't need to have this data.
-	// However, the detailed service page does leverage this by including it to a map that will be
-	// marshalled alongside the ServiceStatus.
-	Events []*Event `json:"-"`
-
-	// Uptime information on the service's uptime
-	//
-	// We don't expose this through JSON, because the main dashboard doesn't need to have this data.
-	// However, the detailed service page does leverage this by including it to a map that will be
-	// marshalled alongside the ServiceStatus.
-	Uptime *Uptime `json:"-"`
-}
-
-// NewServiceStatus creates a new ServiceStatus
-func NewServiceStatus(service *Service) *ServiceStatus {
-	return &ServiceStatus{
-		Name:    service.Name,
-		Group:   service.Group,
-		Key:     util.ConvertGroupAndServiceToKey(service.Group, service.Name),
-		Results: make([]*Result, 0),
-		Events: []*Event{{
-			Type:      EventStart,
-			Timestamp: time.Now(),
-		}},
-		Uptime: NewUptime(),
-	}
-}
-
-// WithResultPagination returns a shallow copy of the ServiceStatus with only the results
-// within the range defined by the page and pageSize parameters
-func (ss ServiceStatus) WithResultPagination(page, pageSize int) *ServiceStatus {
-	shallowCopy := ss
-	numberOfResults := len(shallowCopy.Results)
-	start := numberOfResults - (page * pageSize)
-	end := numberOfResults - ((page - 1) * pageSize)
-	if start > numberOfResults {
-		start = -1
-	} else if start < 0 {
-		start = 0
-	}
-	if end > numberOfResults {
-		end = numberOfResults
-	}
-	if start < 0 || end < 0 {
-		shallowCopy.Results = []*Result{}
-	} else {
-		shallowCopy.Results = shallowCopy.Results[start:end]
-	}
-	return &shallowCopy
-}
-
-// AddResult adds a Result to ServiceStatus.Results and makes sure that there are
-// no more than 20 results in the Results slice
-func (ss *ServiceStatus) AddResult(result *Result) {
-	if len(ss.Results) > 0 {
-		// Check if there's any change since the last result
-		// OR there's only 1 event, which only happens when there's a start event
-		if ss.Results[len(ss.Results)-1].Success != result.Success || len(ss.Events) == 1 {
-			event := &Event{Timestamp: result.Timestamp}
-			if result.Success {
-				event.Type = EventHealthy
-			} else {
-				event.Type = EventUnhealthy
-			}
-			ss.Events = append(ss.Events, event)
-			if len(ss.Events) > MaximumNumberOfEvents {
-				// Doing ss.Events[1:] would usually be sufficient, but in the case where for some reason, the slice has
-				// more than one extra element, we can get rid of all of them at once and thus returning the slice to a
-				// length of MaximumNumberOfEvents by using ss.Events[len(ss.Events)-MaximumNumberOfEvents:] instead
-				ss.Events = ss.Events[len(ss.Events)-MaximumNumberOfEvents:]
-			}
-		}
-	}
-	ss.Results = append(ss.Results, result)
-	if len(ss.Results) > MaximumNumberOfResults {
-		// Doing ss.Results[1:] would usually be sufficient, but in the case where for some reason, the slice has more
-		// than one extra element, we can get rid of all of them at once and thus returning the slice to a length of
-		// MaximumNumberOfResults by using ss.Results[len(ss.Results)-MaximumNumberOfResults:] instead
-		ss.Results = ss.Results[len(ss.Results)-MaximumNumberOfResults:]
-	}
-	ss.Uptime.ProcessResult(result)
-}

core/service-status_bench_test.go

@@ -1,92 +0,0 @@
-package core
-
-import (
-	"testing"
-	"time"
-)
-
-var (
-	firstCondition  = Condition("[STATUS] == 200")
-	secondCondition = Condition("[RESPONSE_TIME] < 500")
-	thirdCondition  = Condition("[CERTIFICATE_EXPIRATION] < 72h")
-
-	timestamp = time.Now()
-
-	testService = Service{
-		Name:                    "name",
-		Group:                   "group",
-		URL:                     "https://example.org/what/ever",
-		Method:                  "GET",
-		Body:                    "body",
-		Interval:                30 * time.Second,
-		Conditions:              []*Condition{&firstCondition, &secondCondition, &thirdCondition},
-		Alerts:                  nil,
-		Insecure:                false,
-		NumberOfFailuresInARow:  0,
-		NumberOfSuccessesInARow: 0,
-	}
-	testSuccessfulResult = Result{
-		Hostname:              "example.org",
-		IP:                    "127.0.0.1",
-		HTTPStatus:            200,
-		body:                  []byte("body"),
-		Errors:                nil,
-		Connected:             true,
-		Success:               true,
-		Timestamp:             timestamp,
-		Duration:              150 * time.Millisecond,
-		CertificateExpiration: 10 * time.Hour,
-		ConditionResults: []*ConditionResult{
-			{
-				Condition: "[STATUS] == 200",
-				Success:   true,
-			},
-			{
-				Condition: "[RESPONSE_TIME] < 500",
-				Success:   true,
-			},
-			{
-				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
-				Success:   true,
-			},
-		},
-	}
-	testUnsuccessfulResult = Result{
-		Hostname:              "example.org",
-		IP:                    "127.0.0.1",
-		HTTPStatus:            200,
-		body:                  []byte("body"),
-		Errors:                []string{"error-1", "error-2"},
-		Connected:             true,
-		Success:               false,
-		Timestamp:             timestamp,
-		Duration:              750 * time.Millisecond,
-		CertificateExpiration: 10 * time.Hour,
-		ConditionResults: []*ConditionResult{
-			{
-				Condition: "[STATUS] == 200",
-				Success:   true,
-			},
-			{
-				Condition: "[RESPONSE_TIME] < 500",
-				Success:   false,
-			},
-			{
-				Condition: "[CERTIFICATE_EXPIRATION] < 72h",
-				Success:   false,
-			},
-		},
-	}
-)
-
-func BenchmarkServiceStatus_WithResultPagination(b *testing.B) {
-	service := &testService
-	serviceStatus := NewServiceStatus(service)
-	for i := 0; i < MaximumNumberOfResults; i++ {
-		serviceStatus.AddResult(&testSuccessfulResult)
-	}
-	for n := 0; n < b.N; n++ {
-		serviceStatus.WithResultPagination(1, 20)
-	}
-	b.ReportAllocs()
-}

core/service-status_test.go

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

core/service.go

@@ -2,9 +2,11 @@ package core
 
 import (
 	"bytes"
+	"crypto/x509"
 	"encoding/json"
 	"errors"
 	"io/ioutil"
+	"log"
 	"net"
 	"net/http"
 	"net/url"
@@ -13,6 +15,7 @@ import (
 
 	"github.com/TwinProduction/gatus/alerting/alert"
 	"github.com/TwinProduction/gatus/client"
+	"github.com/TwinProduction/gatus/util"
 )
 
 const (
@@ -76,8 +79,13 @@ type Service struct {
 	Alerts []*alert.Alert `yaml:"alerts"`
 
 	// Insecure is whether to skip verifying the server's certificate chain and host name
+	//
+	// deprecated
 	Insecure bool `yaml:"insecure,omitempty"`
 
+	// ClientConfig is the configuration of the client used to communicate with the service's target
+	ClientConfig *client.Config `yaml:"client"`
+
 	// NumberOfFailuresInARow is the number of unsuccessful evaluations in a row
 	NumberOfFailuresInARow int
 
@@ -88,6 +96,16 @@ type Service struct {
 // ValidateAndSetDefaults validates the service's configuration and sets the default value of fields that have one
 func (service *Service) ValidateAndSetDefaults() error {
 	// Set default values
+	if service.ClientConfig == nil {
+		service.ClientConfig = client.GetDefaultConfig()
+		// XXX: remove the next 3 lines in v3.0.0
+		if service.Insecure {
+			log.Println("WARNING: services[].insecure has been deprecated and will be removed in v3.0.0 in favor of services[].client.insecure")
+			service.ClientConfig.Insecure = true
+		}
+	} else {
+		service.ClientConfig.ValidateAndSetDefaults()
+	}
 	if service.Interval == 0 {
 		service.Interval = 1 * time.Minute
 	}
@@ -134,6 +152,11 @@ func (service *Service) ValidateAndSetDefaults() error {
 	return nil
 }
 
+// Key returns the unique key for the Service
+func (service Service) Key() string {
+	return util.ConvertGroupAndServiceToKey(service.Group, service.Name)
+}
+
 // EvaluateHealth sends a request to the service's URL and evaluates the conditions of the service.
 func (service *Service) EvaluateHealth() *Result {
 	result := &Result{Success: true, Errors: []string{}}
@@ -155,35 +178,20 @@ func (service *Service) EvaluateHealth() *Result {
 	return result
 }
 
-// GetAlertsTriggered returns a slice of alerts that have been triggered
-func (service *Service) GetAlertsTriggered() []alert.Alert {
-	var alerts []alert.Alert
-	if service.NumberOfFailuresInARow == 0 {
-		return alerts
-	}
-	for _, alert := range service.Alerts {
-		if alert.IsEnabled() && alert.FailureThreshold == service.NumberOfFailuresInARow {
-			alerts = append(alerts, *alert)
-			continue
-		}
-	}
-	return alerts
-}
-
 func (service *Service) getIP(result *Result) {
 	if service.DNS != nil {
 		result.Hostname = strings.TrimSuffix(service.URL, ":53")
 	} else {
 		urlObject, err := url.Parse(service.URL)
 		if err != nil {
-			result.Errors = append(result.Errors, err.Error())
+			result.AddError(err.Error())
 			return
 		}
 		result.Hostname = urlObject.Hostname()
 	}
 	ips, err := net.LookupIP(result.Hostname)
 	if err != nil {
-		result.Errors = append(result.Errors, err.Error())
+		result.AddError(err.Error())
 		return
 	}
 	result.IP = ips[0].String()
@@ -193,10 +201,12 @@ func (service *Service) call(result *Result) {
 	var request *http.Request
 	var response *http.Response
 	var err error
+	var certificate *x509.Certificate
 	isServiceDNS := service.DNS != nil
 	isServiceTCP := strings.HasPrefix(service.URL, "tcp://")
 	isServiceICMP := strings.HasPrefix(service.URL, "icmp://")
-	isServiceHTTP := !isServiceDNS && !isServiceTCP && !isServiceICMP
+	isServiceStartTLS := strings.HasPrefix(service.URL, "starttls://")
+	isServiceHTTP := !isServiceDNS && !isServiceTCP && !isServiceICMP && !isServiceStartTLS
 	if isServiceHTTP {
 		request = service.buildHTTPRequest()
 	}
@@ -204,21 +214,29 @@ func (service *Service) call(result *Result) {
 	if isServiceDNS {
 		service.DNS.query(service.URL, result)
 		result.Duration = time.Since(startTime)
+	} else if isServiceStartTLS {
+		result.Connected, certificate, err = client.CanPerformStartTLS(strings.TrimPrefix(service.URL, "starttls://"), service.ClientConfig)
+		if err != nil {
+			result.AddError(err.Error())
+			return
+		}
+		result.Duration = time.Since(startTime)
+		result.CertificateExpiration = time.Until(certificate.NotAfter)
 	} else if isServiceTCP {
-		result.Connected = client.CanCreateTCPConnection(strings.TrimPrefix(service.URL, "tcp://"))
+		result.Connected = client.CanCreateTCPConnection(strings.TrimPrefix(service.URL, "tcp://"), service.ClientConfig)
 		result.Duration = time.Since(startTime)
 	} else if isServiceICMP {
-		result.Connected, result.Duration = client.Ping(strings.TrimPrefix(service.URL, "icmp://"))
+		result.Connected, result.Duration = client.Ping(strings.TrimPrefix(service.URL, "icmp://"), service.ClientConfig)
 	} else {
-		response, err = client.GetHTTPClient(service.Insecure).Do(request)
+		response, err = client.GetHTTPClient(service.ClientConfig).Do(request)
 		result.Duration = time.Since(startTime)
 		if err != nil {
-			result.Errors = append(result.Errors, err.Error())
+			result.AddError(err.Error())
 			return
 		}
 		defer response.Body.Close()
 		if response.TLS != nil && len(response.TLS.PeerCertificates) > 0 {
-			certificate := response.TLS.PeerCertificates[0]
+			certificate = response.TLS.PeerCertificates[0]
 			result.CertificateExpiration = time.Until(certificate.NotAfter)
 		}
 		result.HTTPStatus = response.StatusCode
@@ -227,7 +245,7 @@ func (service *Service) call(result *Result) {
 		if service.needsToReadBody() {
 			result.body, err = ioutil.ReadAll(response.Body)
 			if err != nil {
-				result.Errors = append(result.Errors, err.Error())
+				result.AddError(err.Error())
 			}
 		}
 	}

core/service_status.go

@@ -0,0 +1,50 @@
+package core
+
+const (
+	// MaximumNumberOfResults is the maximum number of results that ServiceStatus.Results can have
+	MaximumNumberOfResults = 100
+
+	// MaximumNumberOfEvents is the maximum number of events that ServiceStatus.Events can have
+	MaximumNumberOfEvents = 50
+)
+
+// ServiceStatus contains the evaluation Results of a Service
+type ServiceStatus struct {
+	// Name of the service
+	Name string `json:"name,omitempty"`
+
+	// Group the service is a part of. Used for grouping multiple services together on the front end.
+	Group string `json:"group,omitempty"`
+
+	// Key is the key representing the ServiceStatus
+	Key string `json:"key"`
+
+	// Results is the list of service evaluation results
+	Results []*Result `json:"results"`
+
+	// Events is a list of events
+	//
+	// We don't expose this through JSON, because the main dashboard doesn't need to have this data.
+	// However, the detailed service page does leverage this by including it to a map that will be
+	// marshalled alongside the ServiceStatus.
+	Events []*Event `json:"-"`
+
+	// Uptime information on the service's uptime
+	//
+	// We don't expose this through JSON, because the main dashboard doesn't need to have this data.
+	// However, the detailed service page does leverage this by including it to a map that will be
+	// marshalled alongside the ServiceStatus.
+	Uptime *Uptime `json:"-"`
+}
+
+// NewServiceStatus creates a new ServiceStatus
+func NewServiceStatus(serviceKey, serviceGroup, serviceName string) *ServiceStatus {
+	return &ServiceStatus{
+		Name:    serviceName,
+		Group:   serviceGroup,
+		Key:     serviceKey,
+		Results: make([]*Result, 0),
+		Events:  make([]*Event, 0),
+		Uptime:  NewUptime(),
+	}
+}

core/service_status_test.go

@@ -0,0 +1,19 @@
+package core
+
+import (
+	"testing"
+)
+
+func TestNewServiceStatus(t *testing.T) {
+	service := &Service{Name: "name", Group: "group"}
+	serviceStatus := NewServiceStatus(service.Key(), service.Group, service.Name)
+	if serviceStatus.Name != service.Name {
+		t.Errorf("expected %s, got %s", service.Name, serviceStatus.Name)
+	}
+	if serviceStatus.Group != service.Group {
+		t.Errorf("expected %s, got %s", service.Group, serviceStatus.Group)
+	}
+	if serviceStatus.Key != "group_name" {
+		t.Errorf("expected %s, got %s", "group_name", serviceStatus.Key)
+	}
+}

core/service_test.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/TwinProduction/gatus/alerting/alert"
+	"github.com/TwinProduction/gatus/client"
 )
 
 func TestService_ValidateAndSetDefaults(t *testing.T) {
@@ -18,6 +19,19 @@ func TestService_ValidateAndSetDefaults(t *testing.T) {
 		Alerts:     []*alert.Alert{{Type: alert.TypePagerDuty}},
 	}
 	service.ValidateAndSetDefaults()
+	if service.ClientConfig == nil {
+		t.Error("client configuration should've been set to the default configuration")
+	} else {
+		if service.ClientConfig.Insecure != client.GetDefaultConfig().Insecure {
+			t.Errorf("Default client configuration should've set Insecure to %v, got %v", client.GetDefaultConfig().Insecure, service.ClientConfig.Insecure)
+		}
+		if service.ClientConfig.IgnoreRedirect != client.GetDefaultConfig().IgnoreRedirect {
+			t.Errorf("Default client configuration should've set IgnoreRedirect to %v, got %v", client.GetDefaultConfig().IgnoreRedirect, service.ClientConfig.IgnoreRedirect)
+		}
+		if service.ClientConfig.Timeout != client.GetDefaultConfig().Timeout {
+			t.Errorf("Default client configuration should've set Timeout to %v, got %v", client.GetDefaultConfig().Timeout, service.ClientConfig.Timeout)
+		}
+	}
 	if service.Method != "GET" {
 		t.Error("Service method should've defaulted to GET")
 	}
@@ -41,6 +55,34 @@ func TestService_ValidateAndSetDefaults(t *testing.T) {
 	}
 }
 
+func TestService_ValidateAndSetDefaultsWithClientConfig(t *testing.T) {
+	condition := Condition("[STATUS] == 200")
+	service := Service{
+		Name:       "twinnation-health",
+		URL:        "https://twinnation.org/health",
+		Conditions: []*Condition{&condition},
+		ClientConfig: &client.Config{
+			Insecure:       true,
+			IgnoreRedirect: true,
+			Timeout:        0,
+		},
+	}
+	service.ValidateAndSetDefaults()
+	if service.ClientConfig == nil {
+		t.Error("client configuration should've been set to the default configuration")
+	} else {
+		if !service.ClientConfig.Insecure {
+			t.Error("service.ClientConfig.Insecure should've been set to true")
+		}
+		if !service.ClientConfig.IgnoreRedirect {
+			t.Error("service.ClientConfig.IgnoreRedirect should've been set to true")
+		}
+		if service.ClientConfig.Timeout != client.GetDefaultConfig().Timeout {
+			t.Error("service.ClientConfig.Timeout should've been set to 10s, because the timeout value entered is not set or invalid")
+		}
+	}
+}
+
 func TestService_ValidateAndSetDefaultsWithNoName(t *testing.T) {
 	defer func() { recover() }()
 	condition := Condition("[STATUS] == 200")
@@ -102,31 +144,6 @@ func TestService_ValidateAndSetDefaultsWithDNS(t *testing.T) {
 	}
 }
 
-func TestService_GetAlertsTriggered(t *testing.T) {
-	condition := Condition("[STATUS] == 200")
-	enabled := true
-	service := Service{
-		Name:       "twinnation-health",
-		URL:        "https://twinnation.org/health",
-		Conditions: []*Condition{&condition},
-		Alerts:     []*alert.Alert{{Type: alert.TypePagerDuty, Enabled: &enabled}},
-	}
-	service.ValidateAndSetDefaults()
-	if service.NumberOfFailuresInARow != 0 {
-		t.Error("Service.NumberOfFailuresInARow should start with 0")
-	}
-	if service.NumberOfSuccessesInARow != 0 {
-		t.Error("Service.NumberOfSuccessesInARow should start with 0")
-	}
-	if len(service.GetAlertsTriggered()) > 0 {
-		t.Error("No alerts should've been triggered, because service.NumberOfFailuresInARow is 0, which is below the failure threshold")
-	}
-	service.NumberOfFailuresInARow = service.Alerts[0].FailureThreshold
-	if len(service.GetAlertsTriggered()) != 1 {
-		t.Error("Alert should've been triggered")
-	}
-}
-
 func TestService_buildHTTPRequest(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	service := Service{
@@ -230,6 +247,7 @@ func TestIntegrationEvaluateHealth(t *testing.T) {
 		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition, &bodyCondition},
 	}
+	service.ValidateAndSetDefaults()
 	result := service.EvaluateHealth()
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a success", condition)
@@ -249,6 +267,7 @@ func TestIntegrationEvaluateHealthWithFailure(t *testing.T) {
 		URL:        "https://twinnation.org/health",
 		Conditions: []*Condition{&condition},
 	}
+	service.ValidateAndSetDefaults()
 	result := service.EvaluateHealth()
 	if result.ConditionResults[0].Success {
 		t.Errorf("Condition '%s' should have been a failure", condition)
@@ -273,6 +292,7 @@ func TestIntegrationEvaluateHealthForDNS(t *testing.T) {
 		},
 		Conditions: []*Condition{&conditionSuccess, &conditionBody},
 	}
+	service.ValidateAndSetDefaults()
 	result := service.EvaluateHealth()
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Conditions '%s' and %s should have been a success", conditionSuccess, conditionBody)
@@ -292,6 +312,7 @@ func TestIntegrationEvaluateHealthForICMP(t *testing.T) {
 		URL:        "icmp://127.0.0.1",
 		Conditions: []*Condition{&conditionSuccess},
 	}
+	service.ValidateAndSetDefaults()
 	result := service.EvaluateHealth()
 	if !result.ConditionResults[0].Success {
 		t.Errorf("Conditions '%s' should have been a success", conditionSuccess)

core/uptime.go

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

example/docker-compose/docker-compose.yml

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

examples/docker-compose-sqlite-storage/config.yaml

@@ -0,0 +1,42 @@
+storage:
+  type: sqlite
+  file: /data/data.db
+
+services:
+  - name: back-end
+    group: core
+    url: "https://example.org/"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+      - "[CERTIFICATE_EXPIRATION] > 48h"
+
+  - name: monitoring
+    group: internal
+    url: "https://example.org/"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+
+  - name: nas
+    group: internal
+    url: "https://example.org/"
+    interval: 5m
+    conditions:
+      - "[STATUS] == 200"
+
+  - name: example-dns-query
+    url: "8.8.8.8" # Address of the DNS server to use
+    interval: 5m
+    dns:
+      query-name: "example.com"
+      query-type: "A"
+    conditions:
+      - "[BODY] == 93.184.216.34"
+      - "[DNS_RCODE] == NOERROR"
+
+  - name: icmp-ping
+    url: "icmp://example.org"
+    interval: 1m
+    conditions:
+      - "[CONNECTED] == true"

examples/docker-compose-sqlite-storage/docker-compose.yml

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

examples/docker-compose/docker-compose.yml

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

go.mod

@@ -4,7 +4,7 @@ go 1.16
 
 require (
 	cloud.google.com/go v0.74.0 // indirect
-	github.com/TwinProduction/gocache v1.2.1
+	github.com/TwinProduction/gocache v1.2.3
 	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
@@ -14,13 +14,13 @@ require (
 	github.com/prometheus/client_golang v1.9.0
 	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad // indirect
 	golang.org/x/net v0.0.0-20201224014010-6772e930b67b // indirect
-	golang.org/x/sys v0.0.0-20201223074533-0d417f636930 // indirect
 	golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf // indirect
 	golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 // indirect
 	gopkg.in/yaml.v2 v2.4.0
 	k8s.io/api v0.18.14
 	k8s.io/apimachinery v0.18.14
 	k8s.io/client-go v0.18.14
+	modernc.org/sqlite v1.11.2
 )
 
 replace k8s.io/client-go => k8s.io/client-go v0.18.14

go.sum

@@ -49,8 +49,8 @@ github.com/PuerkitoBio/purell v1.0.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbt
 github.com/PuerkitoBio/urlesc v0.0.0-20160726150825-5bd2802263f2/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
 github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
 github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
-github.com/TwinProduction/gocache v1.2.1 h1:NAdMwO9SQEZFmX69YWx6fzhwb6fHakkLri0451c+V1w=
-github.com/TwinProduction/gocache v1.2.1/go.mod h1:6zkBoLjrFLkIISwkZTgLy67qliCGSon1xpORM4Ri5HM=
+github.com/TwinProduction/gocache v1.2.3 h1:4wFNih4CemUX+A99Gk/EsaU0SXSNZV42Ve77v7/7ToY=
+github.com/TwinProduction/gocache v1.2.3/go.mod h1:Yj2daITit8TTBgiOpc26XCDSbg9xcFskUilHj9u3Mh8=
 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=
@@ -99,6 +99,8 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZgvJUkLughtfhJv5dyTYa91l1fOUCrgjqmcifM=
 github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
 github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
@@ -183,6 +185,7 @@ github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 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.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.4 h1:L8R9j+yAqZuZjsqh/z+F1NCffTKKLShY6zXTItVIZ8M=
 github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
@@ -264,6 +267,8 @@ github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/X
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
+github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
+github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
@@ -282,7 +287,11 @@ github.com/mailru/easyjson v0.0.0-20160728113105-d5b7844b561a/go.mod h1:C1wdFJiN
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/mattn/go-sqlite3 v1.14.6 h1:dNPt6NO46WmLVt2DLNpwczCmdV5boIZ6g/tlDrlRUbg=
+github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
@@ -379,6 +388,8 @@ github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4O
 github.com/prometheus/procfs v0.2.0 h1:wH4vA7pcjKuZzjF7lM8awk4fnuJO6idemZXoKnULUx4=
 github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 h1:OdAsTTz6OkFY5QxjkYwrChwuRruF69c169dPK26NUlk=
+github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
@@ -480,6 +491,7 @@ golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzB
 golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.0 h1:8pl+sMODzuvGJkmj2W4kZihvVb5mKm8pB/X44PIQHv8=
 golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20170114055629-f2499483f923/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -576,6 +588,7 @@ golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -594,10 +607,11 @@ golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201126233918-771906719818/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201214210602-f9fddec55a1e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201223074533-0d417f636930 h1:vRgIt+nup/B/BwIS0g2oC0haq0iqbV3ZA+u6+0TlNCo=
-golang.org/x/sys v0.0.0-20201223074533-0d417f636930/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c h1:VwygUrnw9jn88c4u8GD3rZQbqrP/tgas88tPUbBxQrk=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf h1:MZ2shdL+ZM/XzY3ZGOnh4Nlpnxz5GSOhOmtHo3iPU6M=
@@ -667,7 +681,9 @@ golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc
 golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
 golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
 golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20201124115921-2c860bdd6e78/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20201208233053-a543418bbed2 h1:vEtypaVub6UvKkiXZ2xx9QIvp9TL7sI7xp7vdi2kezA=
 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=
@@ -812,6 +828,36 @@ k8s.io/klog v1.0.0/go.mod h1:4Bi6QPql/J/LkTDqv7R/cd3hPo4k2DG6Ptcz060Ez5I=
 k8s.io/kube-openapi v0.0.0-20200410145947-61e04a5be9a6/go.mod h1:GRQhZsXIAJ1xR0C9bd8UpWHZ5plfAS9fzPjJuQ6JL3E=
 k8s.io/utils v0.0.0-20200324210504-a9aa75ae1b89 h1:d4vVOjXm687F1iLSP2q3lyPPuyvTUt3aVoBpi2DqRsU=
 k8s.io/utils v0.0.0-20200324210504-a9aa75ae1b89/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew=
+lukechampine.com/uint128 v1.1.1 h1:pnxCASz787iMf+02ssImqk6OLt+Z5QHMoZyUXR4z6JU=
+lukechampine.com/uint128 v1.1.1/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk=
+modernc.org/cc/v3 v3.33.6 h1:r63dgSzVzRxUpAJFPQWHy1QeZeY1ydNENUDaBx1GqYc=
+modernc.org/cc/v3 v3.33.6/go.mod h1:iPJg1pkwXqAV16SNgFBVYmggfMg6xhs+2oiO0vclK3g=
+modernc.org/ccgo/v3 v3.9.5 h1:dEuUSf8WN51rDkprFuAqjfchKEzN0WttP/Py3enBwjk=
+modernc.org/ccgo/v3 v3.9.5/go.mod h1:umuo2EP2oDSBnD3ckjaVUXMrmeAw8C8OSICVa0iFf60=
+modernc.org/httpfs v1.0.6 h1:AAgIpFZRXuYnkjftxTAZwMIiwEqAfk8aVB2/oA6nAeM=
+modernc.org/httpfs v1.0.6/go.mod h1:7dosgurJGp0sPaRanU53W4xZYKh14wfzX420oZADeHM=
+modernc.org/libc v1.7.13-0.20210308123627-12f642a52bb8/go.mod h1:U1eq8YWr/Kc1RWCMFUWEdkTg8OTcfLw2kY8EDwl039w=
+modernc.org/libc v1.9.8/go.mod h1:U1eq8YWr/Kc1RWCMFUWEdkTg8OTcfLw2kY8EDwl039w=
+modernc.org/libc v1.9.11 h1:QUxZMs48Ahg2F7SN41aERvMfGLY2HU/ADnB9DC4Yts8=
+modernc.org/libc v1.9.11/go.mod h1:NyF3tsA5ArIjJ83XB0JlqhjTabTCHm9aX4XMPHyQn0Q=
+modernc.org/mathutil v1.1.1/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
+modernc.org/mathutil v1.2.2/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
+modernc.org/mathutil v1.4.0 h1:GCjoRaBew8ECCKINQA2nYjzvufFW9YiEuuB+rQ9bn2E=
+modernc.org/mathutil v1.4.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
+modernc.org/memory v1.0.4 h1:utMBrFcpnQDdNsmM6asmyH/FM9TqLPS7XF7otpJmrwM=
+modernc.org/memory v1.0.4/go.mod h1:nV2OApxradM3/OVbs2/0OsP6nPfakXpi50C7dcoHXlc=
+modernc.org/opt v0.1.1 h1:/0RX92k9vwVeDXj+Xn23DKp2VJubL7k8qNffND6qn3A=
+modernc.org/opt v0.1.1/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0=
+modernc.org/sqlite v1.11.2 h1:ShWQpeD3ag/bmx6TqidBlIWonWmQaSQKls3aenCbt+w=
+modernc.org/sqlite v1.11.2/go.mod h1:+mhs/P1ONd+6G7hcAs6irwDi/bjTQ7nLW6LHRBsEa3A=
+modernc.org/strutil v1.1.1 h1:xv+J1BXY3Opl2ALrBwyfEikFAj8pmqcpnfmuwUwcozs=
+modernc.org/strutil v1.1.1/go.mod h1:DE+MQQ/hjKBZS2zNInV5hhcipt5rLPWkmpbGeW5mmdw=
+modernc.org/tcl v1.5.5 h1:N03RwthgTR/l/eQvz3UjfYnvVVj1G2sZqzFGfoD4HE4=
+modernc.org/tcl v1.5.5/go.mod h1:ADkaTUuwukkrlhqwERyq0SM8OvyXo7+TjFz7yAF56EI=
+modernc.org/token v1.0.0 h1:a0jaWiNMDhDUtqOj09wvjWWAqd3q7WpBulmL9H2egsk=
+modernc.org/token v1.0.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
+modernc.org/z v1.0.1 h1:WyIDpEpAIx4Hel6q/Pcgj/VhaQV5XPJ2I6ryIYbjnpc=
+modernc.org/z v1.0.1/go.mod h1:8/SRk5C/HgiQWCgXdfpb+1RvhORdkz5sw72d3jjtyqA=
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
 rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
 rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=

jsonpath/jsonpath.go

@@ -25,6 +25,9 @@ func walk(path string, object interface{}) (string, int, error) {
 	case map[string]interface{}:
 		return walk(strings.Replace(path, fmt.Sprintf("%s.", currentKey), "", 1), value)
 	case string:
+		if len(keys) > 1 {
+			return "", 0, fmt.Errorf("couldn't walk through '%s', because '%s' was a string instead of an object", keys[1], currentKey)
+		}
 		return value, len(value), nil
 	case []interface{}:
 		return fmt.Sprintf("%v", value), len(value), nil

jsonpath/jsonpath_test.go

@@ -1,180 +1,148 @@
 package jsonpath
 
-import "testing"
+import (
+	"testing"
+)
 
 func TestEval(t *testing.T) {
-	path := "simple"
-	data := `{"simple": "value"}`
-
-	expectedOutput := "value"
-
-	output, outputLength, err := Eval(path, []byte(data))
-	if err != nil {
-		t.Error("Didn't expect any error, but got", err)
+	type Scenario struct {
+		Name                 string
+		Path                 string
+		Data                 string
+		ExpectedOutput       string
+		ExpectedOutputLength int
+		ExpectedError        bool
 	}
-	if outputLength != len(expectedOutput) {
-		t.Errorf("Expected output length to be %v, but was %v", len(expectedOutput), outputLength)
+	scenarios := []Scenario{
+		{
+			Name:                 "simple",
+			Path:                 "key",
+			Data:                 `{"key": "value"}`,
+			ExpectedOutput:       "value",
+			ExpectedOutputLength: 5,
+			ExpectedError:        false,
+		},
+		{
+			Name:                 "simple-with-invalid-data",
+			Path:                 "key",
+			Data:                 "invalid data",
+			ExpectedOutput:       "",
+			ExpectedOutputLength: 0,
+			ExpectedError:        true,
+		},
+		{
+			Name:                 "invalid-path",
+			Path:                 "key",
+			Data:                 `{}`,
+			ExpectedOutput:       "",
+			ExpectedOutputLength: 0,
+			ExpectedError:        true,
+		},
+		{
+			Name:                 "long-simple-walk",
+			Path:                 "long.simple.walk",
+			Data:                 `{"long": {"simple": {"walk": "value"}}}`,
+			ExpectedOutput:       "value",
+			ExpectedOutputLength: 5,
+			ExpectedError:        false,
+		},
+		{
+			Name:                 "array-of-maps",
+			Path:                 "ids[1].id",
+			Data:                 `{"ids": [{"id": 1}, {"id": 2}]}`,
+			ExpectedOutput:       "2",
+			ExpectedOutputLength: 1,
+			ExpectedError:        false,
+		},
+		{
+			Name:                 "array-of-values",
+			Path:                 "ids[0]",
+			Data:                 `{"ids": [1, 2]}`,
+			ExpectedOutput:       "1",
+			ExpectedOutputLength: 1,
+			ExpectedError:        false,
+		},
+		{
+			Name:                 "array-of-values-and-invalid-index",
+			Path:                 "ids[wat]",
+			Data:                 `{"ids": [1, 2]}`,
+			ExpectedOutput:       "",
+			ExpectedOutputLength: 0,
+			ExpectedError:        true,
+		},
+		{
+			Name:                 "array-of-values-at-root",
+			Path:                 "[1]",
+			Data:                 `[1, 2]`,
+			ExpectedOutput:       "2",
+			ExpectedOutputLength: 1,
+			ExpectedError:        false,
+		},
+		{
+			Name:                 "array-of-maps-at-root",
+			Path:                 "[0].id",
+			Data:                 `[{"id": 1}, {"id": 2}]`,
+			ExpectedOutput:       "1",
+			ExpectedOutputLength: 1,
+			ExpectedError:        false,
+		},
+		{
+			Name:                 "array-of-maps-at-root-and-invalid-index",
+			Path:                 "[5].id",
+			Data:                 `[{"id": 1}, {"id": 2}]`,
+			ExpectedOutput:       "",
+			ExpectedOutputLength: 0,
+			ExpectedError:        true,
+		},
+		{
+			Name:                 "long-walk-and-array",
+			Path:                 "data.ids[0].id",
+			Data:                 `{"data": {"ids": [{"id": 1}, {"id": 2}, {"id": 3}]}}`,
+			ExpectedOutput:       "1",
+			ExpectedOutputLength: 1,
+			ExpectedError:        false,
+		},
+		{
+			Name:                 "nested-array",
+			Path:                 "[3][2]",
+			Data:                 `[[1, 2], [3, 4], [], [5, 6, 7]]`,
+			ExpectedOutput:       "7",
+			ExpectedOutputLength: 1,
+			ExpectedError:        false,
+		},
+		{
+			Name:                 "map-of-nested-arrays",
+			Path:                 "data[1][1]",
+			Data:                 `{"data": [["a", "b", "c"], ["d", "eeeee", "f"]]}`,
+			ExpectedOutput:       "eeeee",
+			ExpectedOutputLength: 5,
+			ExpectedError:        false,
+		},
+		{
+			Name:                 "partially-invalid-path-issue122",
+			Path:                 "data.name.invalid",
+			Data:                 `{"data": {"name": "john"}}`,
+			ExpectedOutput:       "",
+			ExpectedOutputLength: 0,
+			ExpectedError:        true,
+		},
 	}
-	if output != expectedOutput {
-		t.Errorf("Expected output to be %v, but was %v", expectedOutput, output)
-	}
-}
-
-func TestEvalWithInvalidData(t *testing.T) {
-	path := "simple"
-	data := `invalid data`
-	_, _, err := Eval(path, []byte(data))
-	if err == nil {
-		t.Error("expected an error")
-	}
-}
-
-func TestEvalWithInvalidPath(t *testing.T) {
-	path := "errors"
-	data := `{}`
-	_, _, 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"}}}`
-
-	expectedOutput := "value"
-
-	output, _, err := Eval(path, []byte(data))
-	if err != nil {
-		t.Error("Didn't expect any error, but got", err)
-	}
-	if output != expectedOutput {
-		t.Errorf("Expected output to be %v, but was %v", expectedOutput, output)
-	}
-}
-
-func TestEvalWithArrayOfMaps(t *testing.T) {
-	path := "ids[1].id"
-	data := `{"ids": [{"id": 1}, {"id": 2}]}`
-
-	expectedOutput := "2"
-
-	output, _, err := Eval(path, []byte(data))
-	if err != nil {
-		t.Error("Didn't expect any error, but got", err)
-	}
-
-	if output != expectedOutput {
-		t.Errorf("Expected output to be %v, but was %v", expectedOutput, output)
-	}
-}
-
-func TestEvalWithArrayOfValues(t *testing.T) {
-	path := "ids[0]"
-	data := `{"ids": [1, 2]}`
-
-	expectedOutput := "1"
-
-	output, _, err := Eval(path, []byte(data))
-	if err != nil {
-		t.Error("Didn't expect any error, but got", err)
-	}
-	if output != expectedOutput {
-		t.Errorf("Expected output to be %v, but was %v", expectedOutput, output)
-	}
-}
-
-func TestEvalWithArrayOfValuesAndInvalidIndex(t *testing.T) {
-	path := "ids[wat]"
-	data := `{"ids": [1, 2]}`
-
-	_, _, err := Eval(path, []byte(data))
-	if err == nil {
-		t.Error("Expected an error")
-	}
-}
-
-func TestEvalWithRootArrayOfValues(t *testing.T) {
-	path := "[1]"
-	data := `[1, 2]`
-
-	expectedOutput := "2"
-
-	output, _, err := Eval(path, []byte(data))
-	if err != nil {
-		t.Error("Didn't expect any error, but got", err)
-	}
-	if output != expectedOutput {
-		t.Errorf("Expected output to be %v, but was %v", expectedOutput, output)
-	}
-}
-
-func TestEvalWithRootArrayOfMaps(t *testing.T) {
-	path := "[0].id"
-	data := `[{"id": 1}, {"id": 2}]`
-
-	expectedOutput := "1"
-
-	output, _, err := Eval(path, []byte(data))
-	if err != nil {
-		t.Error("Didn't expect any error, but got", err)
-	}
-	if output != expectedOutput {
-		t.Errorf("Expected output to be %v, but was %v", expectedOutput, output)
-	}
-}
-
-func TestEvalWithRootArrayOfMapsUsingInvalidArrayIndex(t *testing.T) {
-	path := "[5].id"
-	data := `[{"id": 1}, {"id": 2}]`
-
-	_, _, err := Eval(path, []byte(data))
-	if err == nil {
-		t.Error("Should've returned an error, but didn't")
-	}
-}
-
-func TestEvalWithLongWalkAndArray(t *testing.T) {
-	path := "data.ids[0].id"
-	data := `{"data": {"ids": [{"id": 1}, {"id": 2}, {"id": 3}]}}`
-
-	expectedOutput := "1"
-
-	output, _, err := Eval(path, []byte(data))
-	if err != nil {
-		t.Error("Didn't expect any error, but got", err)
-	}
-	if output != expectedOutput {
-		t.Errorf("Expected output to be %v, but was %v", expectedOutput, output)
-	}
-}
-
-func TestEvalWithNestedArray(t *testing.T) {
-	path := "[3][2]"
-	data := `[[1, 2], [3, 4], [], [5, 6, 7]]`
-
-	expectedOutput := "7"
-
-	output, _, err := Eval(path, []byte(data))
-	if err != nil {
-		t.Error("Didn't expect any error, but got", err)
-	}
-	if output != expectedOutput {
-		t.Errorf("Expected output to be %v, but was %v", expectedOutput, output)
-	}
-}
-
-func TestEvalWithMapOfNestedArray(t *testing.T) {
-	path := "data[1][1]"
-	data := `{"data": [["a", "b", "c"], ["d", "e", "f"]]}`
-
-	expectedOutput := "e"
-
-	output, _, err := Eval(path, []byte(data))
-	if err != nil {
-		t.Error("Didn't expect any error, but got", err)
-	}
-	if output != expectedOutput {
-		t.Errorf("Expected output to be %v, but was %v", expectedOutput, output)
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			output, outputLength, err := Eval(scenario.Path, []byte(scenario.Data))
+			if (err != nil) != scenario.ExpectedError {
+				if scenario.ExpectedError {
+					t.Errorf("Expected error, got '%v'", err)
+				} else {
+					t.Errorf("Expected no error, got '%v'", err)
+				}
+			}
+			if outputLength != scenario.ExpectedOutputLength {
+				t.Errorf("Expected output length to be %v, but was %v", scenario.ExpectedOutputLength, outputLength)
+			}
+			if output != scenario.ExpectedOutput {
+				t.Errorf("Expected output to be %v, but was %v", scenario.ExpectedOutput, output)
+			}
+		})
 	}
 }

main.go

@@ -34,6 +34,12 @@ func main() {
 	log.Println("Shutting down")
 }
 
+func start(cfg *config.Config) {
+	go controller.Handle(cfg.Security, cfg.Web, cfg.Metrics)
+	watchdog.Monitor(cfg)
+	go listenToConfigurationFileChanges(cfg)
+}
+
 func stop() {
 	watchdog.Shutdown()
 	controller.Shutdown()
@@ -46,12 +52,6 @@ func save() {
 	}
 }
 
-func start(cfg *config.Config) {
-	go controller.Handle(cfg.Security, cfg.Web, cfg.Metrics)
-	watchdog.Monitor(cfg)
-	go listenToConfigurationFileChanges(cfg)
-}
-
 func loadConfiguration() (cfg *config.Config, err error) {
 	customConfigFile := os.Getenv("GATUS_CONFIG_FILE")
 	if len(customConfigFile) > 0 {

storage/config.go

@@ -1,8 +1,12 @@
 package storage
 
-// Config is the configuration for alerting providers
+// Config is the configuration for storage
 type Config struct {
 	// File is the path of the file to use for persistence
-	// If blank, persistence is disabled.
+	// If blank, persistence is disabled
 	File string `yaml:"file"`
+
+	// Type of store
+	// If blank, uses the default in-memory store
+	Type Type `yaml:"type"`
 }

storage/storage.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/TwinProduction/gatus/storage/store"
 	"github.com/TwinProduction/gatus/storage/store/memory"
+	"github.com/TwinProduction/gatus/storage/store/sqlite"
 )
 
 var (
@@ -38,36 +39,52 @@ func Initialize(cfg *Config) error {
 	initialized = true
 	var err error
 	if cancelFunc != nil {
-		// Stop the active autoSave task
+		// Stop the active autoSaveStore task, if there's already one
 		cancelFunc()
 	}
-	if cfg == nil || len(cfg.File) == 0 {
-		log.Println("[storage][Initialize] Creating storage provider")
-		provider, _ = memory.NewStore("")
+	if cfg == nil {
+		cfg = &Config{}
+	}
+	if len(cfg.File) == 0 {
+		log.Printf("[storage][Initialize] Creating storage provider with type=%s", cfg.Type)
 	} else {
-		ctx, cancelFunc = context.WithCancel(context.Background())
-		log.Printf("[storage][Initialize] Creating storage provider with file=%s", cfg.File)
-		provider, err = memory.NewStore(cfg.File)
+		log.Printf("[storage][Initialize] Creating storage provider with type=%s and file=%s", cfg.Type, cfg.File)
+	}
+	ctx, cancelFunc = context.WithCancel(context.Background())
+	switch cfg.Type {
+	case TypeSQLite:
+		provider, err = sqlite.NewStore(string(cfg.Type), cfg.File)
 		if err != nil {
 			return err
 		}
-		go autoSave(7*time.Minute, ctx)
+	case TypeInMemory:
+		fallthrough
+	default:
+		if len(cfg.File) > 0 {
+			provider, err = memory.NewStore(cfg.File)
+			if err != nil {
+				return err
+			}
+			go autoSaveStore(ctx, provider, 7*time.Minute)
+		} else {
+			provider, _ = memory.NewStore("")
+		}
 	}
 	return nil
 }
 
-// autoSave automatically calls the SaveFunc function of the provider at every interval
-func autoSave(interval time.Duration, ctx context.Context) {
+// autoSaveStore automatically calls the Save function of the provider at every interval
+func autoSaveStore(ctx context.Context, provider store.Store, interval time.Duration) {
 	for {
 		select {
 		case <-ctx.Done():
-			log.Printf("[storage][autoSave] Stopping active job")
+			log.Printf("[storage][autoSaveStore] Stopping active job")
 			return
 		case <-time.After(interval):
-			log.Printf("[storage][autoSave] Saving")
+			log.Printf("[storage][autoSaveStore] Saving")
 			err := provider.Save()
 			if err != nil {
-				log.Println("[storage][autoSave] Save failed:", err.Error())
+				log.Println("[storage][autoSaveStore] Save failed:", err.Error())
 			}
 		}
 	}

storage/storage_test.go

@@ -3,35 +3,92 @@ package storage
 import (
 	"testing"
 	"time"
+
+	"github.com/TwinProduction/gatus/storage/store/sqlite"
 )
 
+func TestGet(t *testing.T) {
+	store := Get()
+	if store == nil {
+		t.Error("store should've been automatically initialized")
+	}
+}
+
 func TestInitialize(t *testing.T) {
-	file := t.TempDir() + "/test.db"
-	err := Initialize(&Config{File: file})
-	if err != nil {
-		t.Fatal("shouldn't have returned an error")
+	type Scenario struct {
+		Name        string
+		Cfg         *Config
+		ExpectedErr error
 	}
-	if cancelFunc == nil {
-		t.Error("cancelFunc shouldn't have been nil")
+	scenarios := []Scenario{
+		{
+			Name:        "nil",
+			Cfg:         nil,
+			ExpectedErr: nil,
+		},
+		{
+			Name:        "blank",
+			Cfg:         &Config{},
+			ExpectedErr: nil,
+		},
+		{
+			Name:        "inmemory-no-file",
+			Cfg:         &Config{Type: TypeInMemory},
+			ExpectedErr: nil,
+		},
+		{
+			Name:        "inmemory-with-file",
+			Cfg:         &Config{Type: TypeInMemory, File: t.TempDir() + "/TestInitialize_inmemory-with-file.db"},
+			ExpectedErr: nil,
+		},
+		{
+			Name:        "sqlite-no-file",
+			Cfg:         &Config{Type: TypeSQLite},
+			ExpectedErr: sqlite.ErrFilePathNotSpecified,
+		},
+		{
+			Name:        "sqlite-with-file",
+			Cfg:         &Config{Type: TypeSQLite, File: t.TempDir() + "/TestInitialize_sqlite-with-file.db"},
+			ExpectedErr: nil,
+		},
 	}
-	if ctx == nil {
-		t.Error("ctx shouldn't have been nil")
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			err := Initialize(scenario.Cfg)
+			if err != scenario.ExpectedErr {
+				t.Errorf("expected %v, got %v", scenario.ExpectedErr, err)
+			}
+			if err != nil {
+				return
+			}
+			if cancelFunc == nil {
+				t.Error("cancelFunc shouldn't have been nil")
+			}
+			if ctx == nil {
+				t.Error("ctx shouldn't have been nil")
+			}
+			if provider == nil {
+				t.Fatal("provider shouldn't have been nit")
+			}
+			provider.Close()
+			// Try to initialize it again
+			err = Initialize(scenario.Cfg)
+			if err != scenario.ExpectedErr {
+				t.Errorf("expected %v, got %v", scenario.ExpectedErr, err)
+				return
+			}
+			provider.Close()
+		})
 	}
-	// Try to initialize it again
-	err = Initialize(&Config{File: file})
-	if err != nil {
-		t.Fatal("shouldn't have returned an error")
-	}
-	cancelFunc()
 }
 
 func TestAutoSave(t *testing.T) {
-	file := t.TempDir() + "/test.db"
+	file := t.TempDir() + "/TestAutoSave.db"
 	if err := Initialize(&Config{File: file}); err != nil {
 		t.Fatal("shouldn't have returned an error")
 	}
-	go autoSave(3*time.Millisecond, ctx)
+	go autoSaveStore(ctx, provider, 3*time.Millisecond)
 	time.Sleep(15 * time.Millisecond)
 	cancelFunc()
-	time.Sleep(5 * time.Millisecond)
+	time.Sleep(50 * time.Millisecond)
 }

storage/store/memory/memory.go

@@ -2,8 +2,11 @@ package memory
 
 import (
 	"encoding/gob"
+	"sync"
+	"time"
 
 	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage/store/paging"
 	"github.com/TwinProduction/gatus/util"
 	"github.com/TwinProduction/gocache"
 )
@@ -17,11 +20,15 @@ func init() {
 
 // Store that leverages gocache
 type Store struct {
+	sync.RWMutex
 	file  string
 	cache *gocache.Cache
 }
 
-// NewStore creates a new store
+// NewStore creates a new store using gocache.Cache
+//
+// This store holds everything in memory, and if the file parameter is not blank,
+// supports eventual persistence.
 func NewStore(file string) (*Store, error) {
 	store := &Store{
 		file:  file,
@@ -36,40 +43,46 @@ func NewStore(file string) (*Store, error) {
 	return store, nil
 }
 
-// GetAllServiceStatusesWithResultPagination returns all monitored core.ServiceStatus
+// GetAllServiceStatuses 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 {
+func (s *Store) GetAllServiceStatuses(params *paging.ServiceStatusParams) 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)
+		pagedServiceStatuses[k] = ShallowCopyServiceStatus(v.(*core.ServiceStatus), params)
 	}
 	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))
+func (s *Store) GetServiceStatus(groupName, serviceName string, params *paging.ServiceStatusParams) *core.ServiceStatus {
+	return s.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(groupName, serviceName), params)
 }
 
 // GetServiceStatusByKey returns the service status for a given key
-func (s *Store) GetServiceStatusByKey(key string) *core.ServiceStatus {
+func (s *Store) GetServiceStatusByKey(key string, params *paging.ServiceStatusParams) *core.ServiceStatus {
 	serviceStatus := s.cache.GetValue(key)
 	if serviceStatus == nil {
 		return nil
 	}
-	return serviceStatus.(*core.ServiceStatus)
+	return ShallowCopyServiceStatus(serviceStatus.(*core.ServiceStatus), params)
 }
 
 // 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)
+	key := service.Key()
+	s.Lock()
 	serviceStatus, exists := s.cache.Get(key)
 	if !exists {
-		serviceStatus = core.NewServiceStatus(service)
+		serviceStatus = core.NewServiceStatus(key, service.Group, service.Name)
+		serviceStatus.(*core.ServiceStatus).Events = append(serviceStatus.(*core.ServiceStatus).Events, &core.Event{
+			Type:      core.EventStart,
+			Timestamp: time.Now(),
+		})
 	}
-	serviceStatus.(*core.ServiceStatus).AddResult(result)
+	AddResult(serviceStatus.(*core.ServiceStatus), result)
 	s.cache.Set(key, serviceStatus)
+	s.Unlock()
 }
 
 // DeleteAllServiceStatusesNotInKeys removes all ServiceStatus that are not within the keys provided
@@ -102,3 +115,8 @@ func (s *Store) Save() error {
 	}
 	return nil
 }
+
+// Close does nothing, because there's nothing to close
+func (s *Store) Close() {
+	return
+}

storage/store/memory/memory_test.go

@@ -1,12 +1,11 @@
 package memory
 
 import (
-	"fmt"
 	"testing"
 	"time"
 
 	"github.com/TwinProduction/gatus/core"
-	"github.com/TwinProduction/gatus/util"
+	"github.com/TwinProduction/gatus/storage/store/paging"
 )
 
 var (
@@ -81,174 +80,31 @@ var (
 	}
 )
 
-func TestStore_Insert(t *testing.T) {
+// Note that are much more extensive tests in /storage/store/store_test.go.
+// This test is simply an extra sanity check
+func TestStore_SanityCheck(t *testing.T) {
 	store, _ := NewStore("")
 	store.Insert(&testService, &testSuccessfulResult)
+	if numberOfServiceStatuses := len(store.GetAllServiceStatuses(paging.NewServiceStatusParams())); numberOfServiceStatuses != 1 {
+		t.Fatalf("expected 1 ServiceStatus, got %d", numberOfServiceStatuses)
+	}
 	store.Insert(&testService, &testUnsuccessfulResult)
-
-	if store.cache.Count() != 1 {
-		t.Fatalf("expected 1 ServiceStatus, got %d", store.cache.Count())
+	// Both results inserted are for the same service, therefore, the count shouldn't have increased
+	if numberOfServiceStatuses := len(store.GetAllServiceStatuses(paging.NewServiceStatusParams())); numberOfServiceStatuses != 1 {
+		t.Fatalf("expected 1 ServiceStatus, got %d", numberOfServiceStatuses)
 	}
-	key := fmt.Sprintf("%s_%s", testService.Group, testService.Name)
-	serviceStatus := store.GetServiceStatusByKey(key)
-	if serviceStatus == nil {
-		t.Fatalf("Store should've had key '%s', but didn't", key)
+	ss := store.GetServiceStatus(testService.Group, testService.Name, paging.NewServiceStatusParams().WithResults(1, 20).WithEvents(1, 20))
+	if ss == nil {
+		t.Fatalf("Store should've had key '%s', but didn't", testService.Key())
 	}
-	if len(serviceStatus.Results) != 2 {
-		t.Fatalf("Service '%s' should've had 2 results, but actually returned %d", serviceStatus.Name, len(serviceStatus.Results))
+	if len(ss.Events) != 3 {
+		t.Errorf("Service '%s' should've had 3 events, got %d", ss.Name, len(ss.Events))
 	}
-	for i, r := range serviceStatus.Results {
-		expectedResult := store.GetServiceStatus(testService.Group, testService.Name).Results[i]
-		if r.HTTPStatus != expectedResult.HTTPStatus {
-			t.Errorf("Result at index %d should've had a HTTPStatus of %d, but was actually %d", i, expectedResult.HTTPStatus, r.HTTPStatus)
-		}
-		if r.DNSRCode != expectedResult.DNSRCode {
-			t.Errorf("Result at index %d should've had a DNSRCode of %s, but was actually %s", i, expectedResult.DNSRCode, r.DNSRCode)
-		}
-		if r.Hostname != expectedResult.Hostname {
-			t.Errorf("Result at index %d should've had a Hostname of %s, but was actually %s", i, expectedResult.Hostname, r.Hostname)
-		}
-		if r.IP != expectedResult.IP {
-			t.Errorf("Result at index %d should've had a IP of %s, but was actually %s", i, expectedResult.IP, r.IP)
-		}
-		if r.Connected != expectedResult.Connected {
-			t.Errorf("Result at index %d should've had a Connected value of %t, but was actually %t", i, expectedResult.Connected, r.Connected)
-		}
-		if r.Duration != expectedResult.Duration {
-			t.Errorf("Result at index %d should've had a Duration of %s, but was actually %s", i, expectedResult.Duration.String(), r.Duration.String())
-		}
-		if len(r.Errors) != len(expectedResult.Errors) {
-			t.Errorf("Result at index %d should've had %d errors, but actually had %d errors", i, len(expectedResult.Errors), len(r.Errors))
-		}
-		if len(r.ConditionResults) != len(expectedResult.ConditionResults) {
-			t.Errorf("Result at index %d should've had %d ConditionResults, but actually had %d ConditionResults", i, len(expectedResult.ConditionResults), len(r.ConditionResults))
-		}
-		if r.Success != expectedResult.Success {
-			t.Errorf("Result at index %d should've had a Success of %t, but was actually %t", i, expectedResult.Success, r.Success)
-		}
-		if r.Timestamp != expectedResult.Timestamp {
-			t.Errorf("Result at index %d should've had a Timestamp of %s, but was actually %s", i, expectedResult.Timestamp.String(), r.Timestamp.String())
-		}
-		if r.CertificateExpiration != expectedResult.CertificateExpiration {
-			t.Errorf("Result at index %d should've had a CertificateExpiration of %s, but was actually %s", i, expectedResult.CertificateExpiration.String(), r.CertificateExpiration.String())
-		}
+	if len(ss.Results) != 2 {
+		t.Errorf("Service '%s' should've had 2 results, got %d", ss.Name, len(ss.Results))
 	}
-}
-
-func TestStore_GetServiceStatus(t *testing.T) {
-	store, _ := NewStore("")
-	store.Insert(&testService, &testSuccessfulResult)
-	store.Insert(&testService, &testUnsuccessfulResult)
-
-	serviceStatus := store.GetServiceStatus(testService.Group, testService.Name)
-	if serviceStatus == nil {
-		t.Fatalf("serviceStatus shouldn't have been nil")
-	}
-	if serviceStatus.Uptime == nil {
-		t.Fatalf("serviceStatus.Uptime shouldn't have been nil")
-	}
-	if serviceStatus.Uptime.LastHour != 0.5 {
-		t.Errorf("serviceStatus.Uptime.LastHour should've been 0.5")
-	}
-	if serviceStatus.Uptime.LastTwentyFourHours != 0.5 {
-		t.Errorf("serviceStatus.Uptime.LastTwentyFourHours should've been 0.5")
-	}
-	if serviceStatus.Uptime.LastSevenDays != 0.5 {
-		t.Errorf("serviceStatus.Uptime.LastSevenDays should've been 0.5")
-	}
-}
-
-func TestStore_GetServiceStatusForMissingStatusReturnsNil(t *testing.T) {
-	store, _ := NewStore("")
-	store.Insert(&testService, &testSuccessfulResult)
-
-	serviceStatus := store.GetServiceStatus("nonexistantgroup", "nonexistantname")
-	if serviceStatus != nil {
-		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", testService.Group, testService.Name)
-	}
-	serviceStatus = store.GetServiceStatus(testService.Group, "nonexistantname")
-	if serviceStatus != nil {
-		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", testService.Group, "nonexistantname")
-	}
-	serviceStatus = store.GetServiceStatus("nonexistantgroup", testService.Name)
-	if serviceStatus != nil {
-		t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", "nonexistantgroup", testService.Name)
-	}
-}
-
-func TestStore_GetServiceStatusByKey(t *testing.T) {
-	store, _ := NewStore("")
-	store.Insert(&testService, &testSuccessfulResult)
-	store.Insert(&testService, &testUnsuccessfulResult)
-
-	serviceStatus := store.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(testService.Group, testService.Name))
-	if serviceStatus == nil {
-		t.Fatalf("serviceStatus shouldn't have been nil")
-	}
-	if serviceStatus.Uptime == nil {
-		t.Fatalf("serviceStatus.Uptime shouldn't have been nil")
-	}
-	if serviceStatus.Uptime.LastHour != 0.5 {
-		t.Errorf("serviceStatus.Uptime.LastHour should've been 0.5")
-	}
-	if serviceStatus.Uptime.LastTwentyFourHours != 0.5 {
-		t.Errorf("serviceStatus.Uptime.LastTwentyFourHours should've been 0.5")
-	}
-	if serviceStatus.Uptime.LastSevenDays != 0.5 {
-		t.Errorf("serviceStatus.Uptime.LastSevenDays should've been 0.5")
-	}
-}
-
-func TestStore_GetAllServiceStatusesWithResultPagination(t *testing.T) {
-	store, _ := NewStore("")
-	firstResult := &testSuccessfulResult
-	secondResult := &testUnsuccessfulResult
-	store.Insert(&testService, firstResult)
-	store.Insert(&testService, secondResult)
-	// Can't be bothered dealing with timezone issues on the worker that runs the automated tests
-	firstResult.Timestamp = time.Time{}
-	secondResult.Timestamp = time.Time{}
-	serviceStatuses := store.GetAllServiceStatusesWithResultPagination(1, 20)
-	if len(serviceStatuses) != 1 {
-		t.Fatal("expected 1 service status")
-	}
-	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")
+	if deleted := store.DeleteAllServiceStatusesNotInKeys([]string{}); deleted != 1 {
+		t.Errorf("%d entries should've been deleted, got %d", 1, deleted)
 	}
 }
 

storage/store/memory/uptime.go

@@ -0,0 +1,119 @@
+package memory
+
+import (
+	"log"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+)
+
+const (
+	numberOfHoursInTenDays = 10 * 24
+	sevenDays              = 7 * 24 * time.Hour
+)
+
+// processUptimeAfterResult processes the result by extracting the relevant from the result and recalculating the uptime
+// if necessary
+func processUptimeAfterResult(uptime *core.Uptime, result *core.Result) {
+	// XXX: Remove this on v3.0.0
+	if len(uptime.SuccessfulExecutionsPerHour) != 0 || len(uptime.TotalExecutionsPerHour) != 0 {
+		migrateUptimeToHourlyStatistics(uptime)
+	}
+	if uptime.HourlyStatistics == nil {
+		uptime.HourlyStatistics = make(map[int64]*core.HourlyUptimeStatistics)
+	}
+	unixTimestampFlooredAtHour := result.Timestamp.Truncate(time.Hour).Unix()
+	hourlyStats, _ := uptime.HourlyStatistics[unixTimestampFlooredAtHour]
+	if hourlyStats == nil {
+		hourlyStats = &core.HourlyUptimeStatistics{}
+		uptime.HourlyStatistics[unixTimestampFlooredAtHour] = hourlyStats
+	}
+	if result.Success {
+		hourlyStats.SuccessfulExecutions++
+	}
+	hourlyStats.TotalExecutions++
+	hourlyStats.TotalExecutionsResponseTime += uint64(result.Duration.Milliseconds())
+	// Clean up only when we're starting to have too many useless keys
+	// Note that this is only triggered when there are more entries than there should be after
+	// 10 days, despite the fact that we are deleting everything that's older than 7 days.
+	// This is to prevent re-iterating on every `processUptimeAfterResult` as soon as the uptime has been logged for 7 days.
+	if len(uptime.HourlyStatistics) > numberOfHoursInTenDays {
+		sevenDaysAgo := time.Now().Add(-(sevenDays + time.Hour)).Unix()
+		for hourlyUnixTimestamp := range uptime.HourlyStatistics {
+			if sevenDaysAgo > hourlyUnixTimestamp {
+				delete(uptime.HourlyStatistics, hourlyUnixTimestamp)
+			}
+		}
+	}
+	if result.Success {
+		// Recalculate uptime if at least one of the 1h, 24h or 7d uptime are not 100%
+		// If they're all 100%, then recalculating the uptime would be useless unless
+		// the result added was a failure (!result.Success)
+		if uptime.LastSevenDays != 1 || uptime.LastTwentyFourHours != 1 || uptime.LastHour != 1 {
+			recalculateUptime(uptime)
+		}
+	} else {
+		// Recalculate uptime if at least one of the 1h, 24h or 7d uptime are not 0%
+		// If they're all 0%, then recalculating the uptime would be useless unless
+		// the result added was a success (result.Success)
+		if uptime.LastSevenDays != 0 || uptime.LastTwentyFourHours != 0 || uptime.LastHour != 0 {
+			recalculateUptime(uptime)
+		}
+	}
+}
+
+func recalculateUptime(uptime *core.Uptime) {
+	uptimeBrackets := make(map[string]uint64)
+	now := time.Now()
+	// The oldest uptime bracket starts 7 days ago, so we'll start from there
+	timestamp := now.Add(-sevenDays)
+	for now.Sub(timestamp) >= 0 {
+		hourlyUnixTimestamp := timestamp.Truncate(time.Hour).Unix()
+		hourlyStats := uptime.HourlyStatistics[hourlyUnixTimestamp]
+		if hourlyStats == nil || hourlyStats.TotalExecutions == 0 {
+			timestamp = timestamp.Add(time.Hour)
+			continue
+		}
+		uptimeBrackets["7d_success"] += hourlyStats.SuccessfulExecutions
+		uptimeBrackets["7d_total"] += hourlyStats.TotalExecutions
+		if now.Sub(timestamp) <= 24*time.Hour {
+			uptimeBrackets["24h_success"] += hourlyStats.SuccessfulExecutions
+			uptimeBrackets["24h_total"] += hourlyStats.TotalExecutions
+		}
+		if now.Sub(timestamp) <= time.Hour {
+			uptimeBrackets["1h_success"] += hourlyStats.SuccessfulExecutions
+			uptimeBrackets["1h_total"] += hourlyStats.TotalExecutions
+		}
+		timestamp = timestamp.Add(time.Hour)
+	}
+	if uptimeBrackets["7d_total"] > 0 {
+		uptime.LastSevenDays = float64(uptimeBrackets["7d_success"]) / float64(uptimeBrackets["7d_total"])
+	}
+	if uptimeBrackets["24h_total"] > 0 {
+		uptime.LastTwentyFourHours = float64(uptimeBrackets["24h_success"]) / float64(uptimeBrackets["24h_total"])
+	}
+	if uptimeBrackets["1h_total"] > 0 {
+		uptime.LastHour = float64(uptimeBrackets["1h_success"]) / float64(uptimeBrackets["1h_total"])
+	}
+}
+
+// XXX: Remove this on v3.0.0
+// Deprecated
+func migrateUptimeToHourlyStatistics(uptime *core.Uptime) {
+	log.Println("[migrateUptimeToHourlyStatistics] Got", len(uptime.SuccessfulExecutionsPerHour), "entries for successful executions and", len(uptime.TotalExecutionsPerHour), "entries for total executions")
+	uptime.HourlyStatistics = make(map[int64]*core.HourlyUptimeStatistics)
+	for hourlyUnixTimestamp, totalExecutions := range uptime.TotalExecutionsPerHour {
+		if totalExecutions == 0 {
+			log.Println("[migrateUptimeToHourlyStatistics] Skipping entry at", hourlyUnixTimestamp, "because total number of executions is 0")
+			continue
+		}
+		uptime.HourlyStatistics[hourlyUnixTimestamp] = &core.HourlyUptimeStatistics{
+			TotalExecutions:             totalExecutions,
+			SuccessfulExecutions:        uptime.SuccessfulExecutionsPerHour[hourlyUnixTimestamp],
+			TotalExecutionsResponseTime: 0,
+		}
+	}
+	log.Println("[migrateUptimeToHourlyStatistics] Migrated", len(uptime.HourlyStatistics), "entries")
+	uptime.SuccessfulExecutionsPerHour = nil
+	uptime.TotalExecutionsPerHour = nil
+}

storage/store/memory/uptime_bench_test.go

@@ -1,18 +1,20 @@
-package core
+package memory
 
 import (
 	"testing"
 	"time"
+
+	"github.com/TwinProduction/gatus/core"
 )
 
-func BenchmarkUptime_ProcessResult(b *testing.B) {
-	uptime := NewUptime()
+func BenchmarkProcessUptimeAfterResult(b *testing.B) {
+	uptime := core.NewUptime()
 	now := time.Now()
 	now = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), 0, 0, 0, now.Location())
 	// Start 12000 days ago
 	timestamp := now.Add(-12000 * 24 * time.Hour)
 	for n := 0; n < b.N; n++ {
-		uptime.ProcessResult(&Result{
+		processUptimeAfterResult(uptime, &core.Result{
 			Duration:  18 * time.Millisecond,
 			Success:   n%15 == 0,
 			Timestamp: timestamp,

storage/store/memory/uptime_test.go

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

storage/store/memory/util.go

@@ -0,0 +1,85 @@
+package memory
+
+import (
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage/store/paging"
+)
+
+// ShallowCopyServiceStatus returns a shallow copy of a ServiceStatus with only the results
+// within the range defined by the page and pageSize parameters
+func ShallowCopyServiceStatus(ss *core.ServiceStatus, params *paging.ServiceStatusParams) *core.ServiceStatus {
+	shallowCopy := &core.ServiceStatus{
+		Name:   ss.Name,
+		Group:  ss.Group,
+		Key:    ss.Key,
+		Uptime: core.NewUptime(),
+	}
+	numberOfResults := len(ss.Results)
+	resultsStart, resultsEnd := getStartAndEndIndex(numberOfResults, params.ResultsPage, params.ResultsPageSize)
+	if resultsStart < 0 || resultsEnd < 0 {
+		shallowCopy.Results = []*core.Result{}
+	} else {
+		shallowCopy.Results = ss.Results[resultsStart:resultsEnd]
+	}
+	numberOfEvents := len(ss.Events)
+	eventsStart, eventsEnd := getStartAndEndIndex(numberOfEvents, params.EventsPage, params.EventsPageSize)
+	if eventsStart < 0 || eventsEnd < 0 {
+		shallowCopy.Events = []*core.Event{}
+	} else {
+		shallowCopy.Events = ss.Events[eventsStart:eventsEnd]
+	}
+	if params.IncludeUptime {
+		shallowCopy.Uptime.LastHour = ss.Uptime.LastHour
+		shallowCopy.Uptime.LastTwentyFourHours = ss.Uptime.LastTwentyFourHours
+		shallowCopy.Uptime.LastSevenDays = ss.Uptime.LastSevenDays
+	}
+	return shallowCopy
+}
+
+func getStartAndEndIndex(numberOfResults int, page, pageSize int) (int, int) {
+	if page < 1 || pageSize < 0 {
+		return -1, -1
+	}
+	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
+	}
+	return start, end
+}
+
+// AddResult adds a Result to ServiceStatus.Results and makes sure that there are
+// no more than MaximumNumberOfResults results in the Results slice
+func AddResult(ss *core.ServiceStatus, result *core.Result) {
+	if ss == nil {
+		return
+	}
+	if len(ss.Results) > 0 {
+		// Check if there's any change since the last result
+		if ss.Results[len(ss.Results)-1].Success != result.Success {
+			ss.Events = append(ss.Events, core.NewEventFromResult(result))
+			if len(ss.Events) > core.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)-core.MaximumNumberOfEvents:]
+			}
+		}
+	} else {
+		// This is the first result, so we need to add the first healthy/unhealthy event
+		ss.Events = append(ss.Events, core.NewEventFromResult(result))
+	}
+	ss.Results = append(ss.Results, result)
+	if len(ss.Results) > core.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)-core.MaximumNumberOfResults:]
+	}
+	processUptimeAfterResult(ss.Uptime, result)
+}

storage/store/memory/util_bench_test.go

@@ -0,0 +1,20 @@
+package memory
+
+import (
+	"testing"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage/store/paging"
+)
+
+func BenchmarkShallowCopyServiceStatus(b *testing.B) {
+	service := &testService
+	serviceStatus := core.NewServiceStatus(service.Key(), service.Group, service.Name)
+	for i := 0; i < core.MaximumNumberOfResults; i++ {
+		AddResult(serviceStatus, &testSuccessfulResult)
+	}
+	for n := 0; n < b.N; n++ {
+		ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithResults(1, 20))
+	}
+	b.ReportAllocs()
+}

storage/store/memory/util_test.go

@@ -0,0 +1,79 @@
+package memory
+
+import (
+	"testing"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage/store/paging"
+)
+
+func TestAddResult(t *testing.T) {
+	service := &core.Service{Name: "name", Group: "group"}
+	serviceStatus := core.NewServiceStatus(service.Key(), service.Group, service.Name)
+	for i := 0; i < (core.MaximumNumberOfResults+core.MaximumNumberOfEvents)*2; i++ {
+		AddResult(serviceStatus, &core.Result{Success: i%2 == 0, Timestamp: time.Now()})
+	}
+	if len(serviceStatus.Results) != core.MaximumNumberOfResults {
+		t.Errorf("expected serviceStatus.Results to not exceed a length of %d", core.MaximumNumberOfResults)
+	}
+	if len(serviceStatus.Events) != core.MaximumNumberOfEvents {
+		t.Errorf("expected serviceStatus.Events to not exceed a length of %d", core.MaximumNumberOfEvents)
+	}
+	// Try to add nil serviceStatus
+	AddResult(nil, &core.Result{Timestamp: time.Now()})
+}
+
+func TestShallowCopyServiceStatus(t *testing.T) {
+	service := &core.Service{Name: "name", Group: "group"}
+	serviceStatus := core.NewServiceStatus(service.Key(), service.Group, service.Name)
+	ts := time.Now().Add(-25 * time.Hour)
+	for i := 0; i < 25; i++ {
+		AddResult(serviceStatus, &core.Result{Success: i%2 == 0, Timestamp: ts})
+		ts = ts.Add(time.Hour)
+	}
+	if len(ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithResults(-1, -1)).Results) != 0 {
+		t.Error("expected to have 0 result")
+	}
+	if len(ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithResults(1, 1)).Results) != 1 {
+		t.Error("expected to have 1 result")
+	}
+	if len(ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithResults(5, 0)).Results) != 0 {
+		t.Error("expected to have 0 results")
+	}
+	if len(ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithResults(-1, 20)).Results) != 0 {
+		t.Error("expected to have 0 result, because the page was invalid")
+	}
+	if len(ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithResults(1, -1)).Results) != 0 {
+		t.Error("expected to have 0 result, because the page size was invalid")
+	}
+	if len(ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithResults(1, 10)).Results) != 10 {
+		t.Error("expected to have 10 results, because given a page size of 10, page 1 should have 10 elements")
+	}
+	if len(ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithResults(2, 10)).Results) != 10 {
+		t.Error("expected to have 10 results, because given a page size of 10, page 2 should have 10 elements")
+	}
+	if len(ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithResults(3, 10)).Results) != 5 {
+		t.Error("expected to have 5 results, because given a page size of 10, page 3 should have 5 elements")
+	}
+	if len(ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithResults(4, 10)).Results) != 0 {
+		t.Error("expected to have 0 results, because given a page size of 10, page 4 should have 0 elements")
+	}
+	if len(ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithResults(1, 50)).Results) != 25 {
+		t.Error("expected to have 25 results, because there's only 25 results")
+	}
+	uptime := ShallowCopyServiceStatus(serviceStatus, paging.NewServiceStatusParams().WithUptime()).Uptime
+	if uptime == nil {
+		t.Error("expected uptime to not be nil")
+	} else {
+		if uptime.LastHour != 1 {
+			t.Error("expected uptime.LastHour to not be 1, got", uptime.LastHour)
+		}
+		if uptime.LastTwentyFourHours != 0.5 {
+			t.Error("expected uptime.LastTwentyFourHours to not be 0.5, got", uptime.LastTwentyFourHours)
+		}
+		if uptime.LastSevenDays != 0.52 {
+			t.Error("expected uptime.LastSevenDays to not be 0.52, got", uptime.LastSevenDays)
+		}
+	}
+}

storage/store/paging/paging.go

@@ -0,0 +1,35 @@
+package paging
+
+// ServiceStatusParams represents all parameters that can be used for paging purposes
+type ServiceStatusParams struct {
+	EventsPage      int  // Number of the event page
+	EventsPageSize  int  // Size of the event page
+	ResultsPage     int  // Number of the result page
+	ResultsPageSize int  // Size of the result page
+	IncludeUptime   bool // Whether to include uptime data
+}
+
+// NewServiceStatusParams creates a new ServiceStatusParams
+func NewServiceStatusParams() *ServiceStatusParams {
+	return &ServiceStatusParams{}
+}
+
+// WithEvents sets the values for EventsPage and EventsPageSize
+func (params *ServiceStatusParams) WithEvents(page, pageSize int) *ServiceStatusParams {
+	params.EventsPage = page
+	params.EventsPageSize = pageSize
+	return params
+}
+
+// WithResults sets the values for ResultsPage and ResultsPageSize
+func (params *ServiceStatusParams) WithResults(page, pageSize int) *ServiceStatusParams {
+	params.ResultsPage = page
+	params.ResultsPageSize = pageSize
+	return params
+}
+
+// WithUptime sets the value IncludeUptime to true
+func (params *ServiceStatusParams) WithUptime() *ServiceStatusParams {
+	params.IncludeUptime = true
+	return params
+}

storage/store/paging/paging_test.go

@@ -0,0 +1,81 @@
+package paging
+
+import "testing"
+
+func TestNewServiceStatusParams(t *testing.T) {
+	type Scenario struct {
+		Name                    string
+		Params                  *ServiceStatusParams
+		ExpectedEventsPage      int
+		ExpectedEventsPageSize  int
+		ExpectedResultsPage     int
+		ExpectedResultsPageSize int
+		ExpectedIncludeUptime   bool
+	}
+	scenarios := []Scenario{
+		{
+			Name:                    "empty-params",
+			Params:                  NewServiceStatusParams(),
+			ExpectedEventsPage:      0,
+			ExpectedEventsPageSize:  0,
+			ExpectedResultsPage:     0,
+			ExpectedResultsPageSize: 0,
+			ExpectedIncludeUptime:   false,
+		},
+		{
+			Name:                    "with-events-page-2-size-7",
+			Params:                  NewServiceStatusParams().WithEvents(2, 7),
+			ExpectedEventsPage:      2,
+			ExpectedEventsPageSize:  7,
+			ExpectedResultsPage:     0,
+			ExpectedResultsPageSize: 0,
+			ExpectedIncludeUptime:   false,
+		},
+		{
+			Name:                    "with-events-page-4-size-3-uptime",
+			Params:                  NewServiceStatusParams().WithEvents(4, 3).WithUptime(),
+			ExpectedEventsPage:      4,
+			ExpectedEventsPageSize:  3,
+			ExpectedResultsPage:     0,
+			ExpectedResultsPageSize: 0,
+			ExpectedIncludeUptime:   true,
+		},
+		{
+			Name:                    "with-results-page-1-size-20-uptime",
+			Params:                  NewServiceStatusParams().WithResults(1, 20).WithUptime(),
+			ExpectedEventsPage:      0,
+			ExpectedEventsPageSize:  0,
+			ExpectedResultsPage:     1,
+			ExpectedResultsPageSize: 20,
+			ExpectedIncludeUptime:   true,
+		},
+		{
+			Name:                    "with-results-page-2-size-10-events-page-3-size-50",
+			Params:                  NewServiceStatusParams().WithResults(2, 10).WithEvents(3, 50),
+			ExpectedEventsPage:      3,
+			ExpectedEventsPageSize:  50,
+			ExpectedResultsPage:     2,
+			ExpectedResultsPageSize: 10,
+			ExpectedIncludeUptime:   false,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			if scenario.Params.EventsPage != scenario.ExpectedEventsPage {
+				t.Errorf("expected ExpectedEventsPage to be %d, was %d", scenario.ExpectedEventsPageSize, scenario.Params.EventsPage)
+			}
+			if scenario.Params.EventsPageSize != scenario.ExpectedEventsPageSize {
+				t.Errorf("expected EventsPageSize to be %d, was %d", scenario.ExpectedEventsPageSize, scenario.Params.EventsPageSize)
+			}
+			if scenario.Params.ResultsPage != scenario.ExpectedResultsPage {
+				t.Errorf("expected ResultsPage to be %d, was %d", scenario.ExpectedResultsPage, scenario.Params.ResultsPage)
+			}
+			if scenario.Params.ResultsPageSize != scenario.ExpectedResultsPageSize {
+				t.Errorf("expected ResultsPageSize to be %d, was %d", scenario.ExpectedResultsPageSize, scenario.Params.ResultsPageSize)
+			}
+			if scenario.Params.IncludeUptime != scenario.ExpectedIncludeUptime {
+				t.Errorf("expected IncludeUptime to be %v, was %v", scenario.ExpectedIncludeUptime, scenario.Params.IncludeUptime)
+			}
+		})
+	}
+}

storage/store/sqlite/sqlite.go

@@ -0,0 +1,778 @@
+package sqlite
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"log"
+	"strings"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage/store/paging"
+	"github.com/TwinProduction/gatus/util"
+	_ "modernc.org/sqlite"
+)
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// Note that only exported functions in this file may create, commit, or rollback a transaction //
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+const (
+	arraySeparator = "|~|"
+
+	uptimeCleanUpThreshold  = 10 * 24 * time.Hour              // Maximum uptime age before triggering a clean up
+	eventsCleanUpThreshold  = core.MaximumNumberOfEvents + 10  // Maximum number of events before triggering a clean up
+	resultsCleanUpThreshold = core.MaximumNumberOfResults + 10 // Maximum number of results before triggering a clean up
+
+	uptimeRetention = 7 * 24 * time.Hour
+)
+
+var (
+	// ErrFilePathNotSpecified is the error returned when path parameter passed in NewStore is blank
+	ErrFilePathNotSpecified = errors.New("file path cannot be empty")
+
+	// ErrDatabaseDriverNotSpecified is the error returned when the driver parameter passed in NewStore is blank
+	ErrDatabaseDriverNotSpecified = errors.New("database driver cannot be empty")
+
+	errServiceNotFoundInDatabase = errors.New("service does not exist in database")
+	errNoRowsReturned            = errors.New("expected a row to be returned, but none was")
+)
+
+// Store that leverages a database
+type Store struct {
+	driver, file string
+
+	db *sql.DB
+}
+
+// NewStore initializes the database and creates the schema if it doesn't already exist in the file specified
+func NewStore(driver, path string) (*Store, error) {
+	if len(driver) == 0 {
+		return nil, ErrDatabaseDriverNotSpecified
+	}
+	if len(path) == 0 {
+		return nil, ErrFilePathNotSpecified
+	}
+	store := &Store{driver: driver, file: path}
+	var err error
+	if store.db, err = sql.Open(driver, path); err != nil {
+		return nil, err
+	}
+	if driver == "sqlite" {
+		_, _ = store.db.Exec("PRAGMA foreign_keys=ON")
+		_, _ = store.db.Exec("PRAGMA journal_mode=WAL")
+		_, _ = store.db.Exec("PRAGMA synchronous=NORMAL")
+		// Prevents driver from running into "database is locked" errors
+		// This is because we're using WAL to improve performance
+		store.db.SetMaxOpenConns(1)
+	}
+	if err = store.createSchema(); err != nil {
+		_ = store.db.Close()
+		return nil, err
+	}
+	return store, nil
+}
+
+// createSchema creates the schema required to perform all database operations.
+func (s *Store) createSchema() error {
+	_, err := s.db.Exec(`
+		CREATE TABLE IF NOT EXISTS service (
+			service_id    INTEGER PRIMARY KEY,
+			service_key   TEXT UNIQUE,
+			service_name  TEXT,
+			service_group TEXT,
+			UNIQUE(service_name, service_group)
+		)
+	`)
+	if err != nil {
+		return err
+	}
+	_, err = s.db.Exec(`
+		CREATE TABLE IF NOT EXISTS service_event (
+			service_event_id   INTEGER PRIMARY KEY,
+			service_id         INTEGER REFERENCES service(service_id) ON DELETE CASCADE,
+			event_type         TEXT,
+			event_timestamp    TIMESTAMP
+		)
+	`)
+	if err != nil {
+		return err
+	}
+	_, err = s.db.Exec(`
+		CREATE TABLE IF NOT EXISTS service_result (
+			service_result_id      INTEGER PRIMARY KEY,
+			service_id             INTEGER REFERENCES service(service_id) ON DELETE CASCADE,
+			success                INTEGER,
+			errors                 TEXT,
+			connected              INTEGER,
+			status                 INTEGER,
+			dns_rcode              TEXT,
+			certificate_expiration INTEGER,
+			hostname               TEXT,
+			ip                     TEXT,
+			duration               INTEGER,
+			timestamp              TIMESTAMP
+		)
+	`)
+	if err != nil {
+		return err
+	}
+	_, err = s.db.Exec(`
+		CREATE TABLE IF NOT EXISTS service_result_condition (
+			service_result_condition_id  INTEGER PRIMARY KEY,
+			service_result_id            INTEGER REFERENCES service_result(service_result_id) ON DELETE CASCADE,
+			condition                    TEXT,
+			success                      INTEGER
+		)
+	`)
+	if err != nil {
+		return err
+	}
+	_, err = s.db.Exec(`
+		CREATE TABLE IF NOT EXISTS service_uptime (
+			service_uptime_id     INTEGER PRIMARY KEY,
+			service_id            INTEGER REFERENCES service(service_id) ON DELETE CASCADE,
+			hour_unix_timestamp   INTEGER,
+			total_executions      INTEGER,
+			successful_executions INTEGER,
+			total_response_time   INTEGER,
+			UNIQUE(service_id, hour_unix_timestamp)
+		)
+	`)
+	return err
+}
+
+// GetAllServiceStatuses returns all monitored core.ServiceStatus
+// with a subset of core.Result defined by the page and pageSize parameters
+func (s *Store) GetAllServiceStatuses(params *paging.ServiceStatusParams) map[string]*core.ServiceStatus {
+	tx, err := s.db.Begin()
+	if err != nil {
+		return nil
+	}
+	keys, err := s.getAllServiceKeys(tx)
+	if err != nil {
+		_ = tx.Rollback()
+		return nil
+	}
+	serviceStatuses := make(map[string]*core.ServiceStatus, len(keys))
+	for _, key := range keys {
+		serviceStatus, err := s.getServiceStatusByKey(tx, key, params)
+		if err != nil {
+			continue
+		}
+		serviceStatuses[key] = serviceStatus
+	}
+	if err = tx.Commit(); err != nil {
+		_ = tx.Rollback()
+	}
+	return serviceStatuses
+}
+
+// GetServiceStatus returns the service status for a given service name in the given group
+func (s *Store) GetServiceStatus(groupName, serviceName string, params *paging.ServiceStatusParams) *core.ServiceStatus {
+	return s.GetServiceStatusByKey(util.ConvertGroupAndServiceToKey(groupName, serviceName), params)
+}
+
+// GetServiceStatusByKey returns the service status for a given key
+func (s *Store) GetServiceStatusByKey(key string, params *paging.ServiceStatusParams) *core.ServiceStatus {
+	tx, err := s.db.Begin()
+	if err != nil {
+		return nil
+	}
+	serviceStatus, err := s.getServiceStatusByKey(tx, key, params)
+	if err != nil {
+		_ = tx.Rollback()
+		return nil
+	}
+	if err = tx.Commit(); err != nil {
+		_ = tx.Rollback()
+	}
+	return serviceStatus
+}
+
+// Insert adds the observed result for the specified service into the store
+func (s *Store) Insert(service *core.Service, result *core.Result) {
+	tx, err := s.db.Begin()
+	if err != nil {
+		return
+	}
+	//start := time.Now()
+	serviceID, err := s.getServiceID(tx, service)
+	if err != nil {
+		if err == errServiceNotFoundInDatabase {
+			// Service doesn't exist in the database, insert it
+			if serviceID, err = s.insertService(tx, service); err != nil {
+				_ = tx.Rollback()
+				return // failed to insert service
+			}
+		} else {
+			_ = tx.Rollback()
+			return
+		}
+	}
+	// First, we need to check if we need to insert a new event.
+	//
+	// A new event must be added if either of the following cases happen:
+	// 1. There is only 1 event. The total number of events for a service can only be 1 if the only existing event is
+	//    of type EventStart, in which case we will have to create a new event of type EventHealthy or EventUnhealthy
+	//    based on result.Success.
+	// 2. The lastResult.Success != result.Success. This implies that the service went from healthy to unhealthy or
+	//    vice-versa, in which case we will have to create a new event of type EventHealthy or EventUnhealthy
+	//	  based on result.Success.
+	numberOfEvents, err := s.getNumberOfEventsByServiceID(tx, serviceID)
+	if err != nil {
+		log.Printf("[sqlite][Insert] Failed to retrieve total number of events for group=%s; service=%s: %s", service.Group, service.Name, err.Error())
+	}
+	if numberOfEvents == 0 {
+		// There's no events yet, which means we need to add the EventStart and the first healthy/unhealthy event
+		err = s.insertEvent(tx, serviceID, &core.Event{
+			Type:      core.EventStart,
+			Timestamp: result.Timestamp.Add(-50 * time.Millisecond),
+		})
+		if err != nil {
+			// Silently fail
+			log.Printf("[sqlite][Insert] Failed to insert event=%s for group=%s; service=%s: %s", core.EventStart, service.Group, service.Name, err.Error())
+		}
+		event := core.NewEventFromResult(result)
+		if err = s.insertEvent(tx, serviceID, event); err != nil {
+			// Silently fail
+			log.Printf("[sqlite][Insert] Failed to insert event=%s for group=%s; service=%s: %s", event.Type, service.Group, service.Name, err.Error())
+		}
+	} else {
+		// Get the success value of the previous result
+		var lastResultSuccess bool
+		if lastResultSuccess, err = s.getLastServiceResultSuccessValue(tx, serviceID); err != nil {
+			log.Printf("[sqlite][Insert] Failed to retrieve outcome of previous result for group=%s; service=%s: %s", service.Group, service.Name, err.Error())
+		} else {
+			// If we managed to retrieve the outcome of the previous result, we'll compare it with the new result.
+			// If the final outcome (success or failure) of the previous and the new result aren't the same, it means
+			// that the service either went from Healthy to Unhealthy or Unhealthy -> Healthy, therefore, we'll add
+			// an event to mark the change in state
+			if lastResultSuccess != result.Success {
+				event := core.NewEventFromResult(result)
+				if err = s.insertEvent(tx, serviceID, event); err != nil {
+					// Silently fail
+					log.Printf("[sqlite][Insert] Failed to insert event=%s for group=%s; service=%s: %s", event.Type, service.Group, service.Name, err.Error())
+				}
+			}
+		}
+		// Clean up old events if there's more than twice the maximum number of events
+		// This lets us both keep the table clean without impacting performance too much
+		// (since we're only deleting MaximumNumberOfEvents at a time instead of 1)
+		if numberOfEvents > eventsCleanUpThreshold {
+			if err = s.deleteOldServiceEvents(tx, serviceID); err != nil {
+				log.Printf("[sqlite][Insert] Failed to delete old events for group=%s; service=%s: %s", service.Group, service.Name, err.Error())
+			}
+		}
+	}
+	// Second, we need to insert the result.
+	if err = s.insertResult(tx, serviceID, result); err != nil {
+		log.Printf("[sqlite][Insert] Failed to insert result for group=%s; service=%s: %s", service.Group, service.Name, err.Error())
+		_ = tx.Rollback() // If we can't insert the result, we'll rollback now since there's no point continuing
+		return
+	}
+	// Clean up old results
+	numberOfResults, err := s.getNumberOfResultsByServiceID(tx, serviceID)
+	if err != nil {
+		log.Printf("[sqlite][Insert] Failed to retrieve total number of results for group=%s; service=%s: %s", service.Group, service.Name, err.Error())
+	} else {
+		if numberOfResults > resultsCleanUpThreshold {
+			if err = s.deleteOldServiceResults(tx, serviceID); err != nil {
+				log.Printf("[sqlite][Insert] Failed to delete old results for group=%s; service=%s: %s", service.Group, service.Name, err.Error())
+			}
+		}
+	}
+	// Finally, we need to insert the uptime data.
+	// Because the uptime data significantly outlives the results, we can't rely on the results for determining the uptime
+	if err = s.updateServiceUptime(tx, serviceID, result); err != nil {
+		log.Printf("[sqlite][Insert] Failed to update uptime for group=%s; service=%s: %s", service.Group, service.Name, err.Error())
+	}
+	// Clean up old uptime entries
+	ageOfOldestUptimeEntry, err := s.getAgeOfOldestServiceUptimeEntry(tx, serviceID)
+	if err != nil {
+		log.Printf("[sqlite][Insert] Failed to retrieve oldest service uptime entry for group=%s; service=%s: %s", service.Group, service.Name, err.Error())
+	} else {
+		if ageOfOldestUptimeEntry > uptimeCleanUpThreshold {
+			if err = s.deleteOldUptimeEntries(tx, serviceID, time.Now().Add(-(uptimeRetention + time.Hour))); err != nil {
+				log.Printf("[sqlite][Insert] Failed to delete old uptime entries for group=%s; service=%s: %s", service.Group, service.Name, err.Error())
+			}
+		}
+	}
+	//log.Printf("[sqlite][Insert] Successfully inserted result in duration=%dms", time.Since(start).Milliseconds())
+	if err = tx.Commit(); err != nil {
+		_ = tx.Rollback()
+	}
+	return
+}
+
+// DeleteAllServiceStatusesNotInKeys removes all rows owned by a service whose key is not within the keys provided
+func (s *Store) DeleteAllServiceStatusesNotInKeys(keys []string) int {
+	var err error
+	var result sql.Result
+	if len(keys) == 0 {
+		// Delete everything
+		result, err = s.db.Exec("DELETE FROM service")
+	} else {
+		args := make([]interface{}, 0, len(keys))
+		for i := range keys {
+			args = append(args, keys[i])
+		}
+		result, err = s.db.Exec(fmt.Sprintf("DELETE FROM service WHERE service_key NOT IN (%s)", strings.Trim(strings.Repeat("?,", len(keys)), ",")), args...)
+	}
+	if err != nil {
+		log.Printf("[sqlite][DeleteAllServiceStatusesNotInKeys] Failed to delete rows that do not belong to any of keys=%v: %s", keys, err.Error())
+		return 0
+	}
+	rowsAffects, _ := result.RowsAffected()
+	return int(rowsAffects)
+}
+
+// Clear deletes everything from the store
+func (s *Store) Clear() {
+	_, _ = s.db.Exec("DELETE FROM service")
+}
+
+// Save does nothing, because this store is immediately persistent.
+func (s *Store) Save() error {
+	return nil
+}
+
+// Close the database handle
+func (s *Store) Close() {
+	_ = s.db.Close()
+}
+
+// insertService inserts a service in the store and returns the generated id of said service
+func (s *Store) insertService(tx *sql.Tx, service *core.Service) (int64, error) {
+	//log.Printf("[sqlite][insertService] Inserting service with group=%s and name=%s", service.Group, service.Name)
+	result, err := tx.Exec(
+		"INSERT INTO service (service_key, service_name, service_group) VALUES ($1, $2, $3)",
+		service.Key(),
+		service.Name,
+		service.Group,
+	)
+	if err != nil {
+		return 0, err
+	}
+	return result.LastInsertId()
+}
+
+// insertEvent inserts a service event in the store
+func (s *Store) insertEvent(tx *sql.Tx, serviceID int64, event *core.Event) error {
+	_, err := tx.Exec(
+		"INSERT INTO service_event (service_id, event_type, event_timestamp) VALUES ($1, $2, $3)",
+		serviceID,
+		event.Type,
+		event.Timestamp,
+	)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// insertResult inserts a result in the store
+func (s *Store) insertResult(tx *sql.Tx, serviceID int64, result *core.Result) error {
+	res, err := tx.Exec(
+		`
+			INSERT INTO service_result (service_id, success, errors, connected, status, dns_rcode, certificate_expiration, hostname, ip, duration, timestamp)
+			VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+		`,
+		serviceID,
+		result.Success,
+		strings.Join(result.Errors, arraySeparator),
+		result.Connected,
+		result.HTTPStatus,
+		result.DNSRCode,
+		result.CertificateExpiration,
+		result.Hostname,
+		result.IP,
+		result.Duration,
+		result.Timestamp,
+	)
+	if err != nil {
+		return err
+	}
+	serviceResultID, err := res.LastInsertId()
+	if err != nil {
+		return err
+	}
+	return s.insertConditionResults(tx, serviceResultID, result.ConditionResults)
+}
+
+func (s *Store) insertConditionResults(tx *sql.Tx, serviceResultID int64, conditionResults []*core.ConditionResult) error {
+	var err error
+	for _, cr := range conditionResults {
+		_, err = tx.Exec("INSERT INTO service_result_condition (service_result_id, condition, success) VALUES ($1, $2, $3)",
+			serviceResultID,
+			cr.Condition,
+			cr.Success,
+		)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *Store) updateServiceUptime(tx *sql.Tx, serviceID int64, result *core.Result) error {
+	unixTimestampFlooredAtHour := result.Timestamp.Truncate(time.Hour).Unix()
+	var successfulExecutions int
+	if result.Success {
+		successfulExecutions = 1
+	}
+	_, err := tx.Exec(
+		`
+			INSERT INTO service_uptime (service_id, hour_unix_timestamp, total_executions, successful_executions, total_response_time) 
+			VALUES ($1, $2, $3, $4, $5)
+			ON CONFLICT(service_id, hour_unix_timestamp) DO UPDATE SET
+				total_executions = excluded.total_executions + total_executions,
+				successful_executions = excluded.successful_executions + successful_executions,
+				total_response_time = excluded.total_response_time + total_response_time
+		`,
+		serviceID,
+		unixTimestampFlooredAtHour,
+		1,
+		successfulExecutions,
+		result.Duration.Milliseconds(),
+	)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *Store) getAllServiceKeys(tx *sql.Tx) (keys []string, err error) {
+	rows, err := tx.Query("SELECT service_key FROM service")
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		var key string
+		_ = rows.Scan(&key)
+		keys = append(keys, key)
+	}
+	_ = rows.Close()
+	return
+}
+
+func (s *Store) getServiceStatusByKey(tx *sql.Tx, key string, parameters *paging.ServiceStatusParams) (*core.ServiceStatus, error) {
+	serviceID, serviceGroup, serviceName, err := s.getServiceIDGroupAndNameByKey(tx, key)
+	if err != nil {
+		return nil, err
+	}
+	serviceStatus := core.NewServiceStatus(key, serviceGroup, serviceName)
+	if parameters.EventsPageSize > 0 {
+		if serviceStatus.Events, err = s.getEventsByServiceID(tx, serviceID, parameters.EventsPage, parameters.EventsPageSize); err != nil {
+			log.Printf("[sqlite][getServiceStatusByKey] Failed to retrieve events for key=%s: %s", key, err.Error())
+		}
+	}
+	if parameters.ResultsPageSize > 0 {
+		if serviceStatus.Results, err = s.getResultsByServiceID(tx, serviceID, parameters.ResultsPage, parameters.ResultsPageSize); err != nil {
+			log.Printf("[sqlite][getServiceStatusByKey] Failed to retrieve results for key=%s: %s", key, err.Error())
+		}
+	}
+	if parameters.IncludeUptime {
+		now := time.Now()
+		serviceStatus.Uptime.LastHour, _, err = s.getServiceUptime(tx, serviceID, now.Add(-time.Hour), now)
+		serviceStatus.Uptime.LastTwentyFourHours, _, err = s.getServiceUptime(tx, serviceID, now.Add(-24*time.Hour), now)
+		serviceStatus.Uptime.LastSevenDays, _, err = s.getServiceUptime(tx, serviceID, now.Add(-7*24*time.Hour), now)
+	}
+	return serviceStatus, nil
+}
+
+func (s *Store) getServiceIDGroupAndNameByKey(tx *sql.Tx, key string) (id int64, group, name string, err error) {
+	rows, err := tx.Query(
+		`
+			SELECT service_id, service_group, service_name
+			FROM service
+			WHERE service_key = $1
+			LIMIT 1
+		`,
+		key,
+	)
+	if err != nil {
+		return 0, "", "", err
+	}
+	for rows.Next() {
+		_ = rows.Scan(&id, &group, &name)
+	}
+	_ = rows.Close()
+	if id == 0 {
+		return 0, "", "", errServiceNotFoundInDatabase
+	}
+	return
+}
+
+func (s *Store) getEventsByServiceID(tx *sql.Tx, serviceID int64, page, pageSize int) (events []*core.Event, err error) {
+	rows, err := tx.Query(
+		`
+			SELECT event_type, event_timestamp
+			FROM service_event
+			WHERE service_id = $1
+			ORDER BY service_event_id ASC
+			LIMIT $2 OFFSET $3
+		`,
+		serviceID,
+		pageSize,
+		(page-1)*pageSize,
+	)
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		event := &core.Event{}
+		_ = rows.Scan(&event.Type, &event.Timestamp)
+		events = append(events, event)
+	}
+	_ = rows.Close()
+	return
+}
+
+func (s *Store) getResultsByServiceID(tx *sql.Tx, serviceID int64, page, pageSize int) (results []*core.Result, err error) {
+	rows, err := tx.Query(
+		`
+			SELECT service_result_id, success, errors, connected, status, dns_rcode, certificate_expiration, hostname, ip, duration, timestamp
+			FROM service_result
+			WHERE service_id = $1
+			ORDER BY service_result_id DESC -- Normally, we'd sort by timestamp, but sorting by service_result_id is faster
+			LIMIT $2 OFFSET $3
+		`,
+		//`
+		//	SELECT * FROM (
+		//	    SELECT service_result_id, success, errors, connected, status, dns_rcode, certificate_expiration, hostname, ip, duration, timestamp
+		//		FROM service_result
+		//		WHERE service_id = $1
+		//		ORDER BY service_result_id DESC -- Normally, we'd sort by timestamp, but sorting by service_result_id is faster
+		//		LIMIT $2 OFFSET $3
+		//	)
+		//	ORDER BY service_result_id ASC -- Normally, we'd sort by timestamp, but sorting by service_result_id is faster
+		//`,
+		serviceID,
+		pageSize,
+		(page-1)*pageSize,
+	)
+	if err != nil {
+		return nil, err
+	}
+	idResultMap := make(map[int64]*core.Result)
+	for rows.Next() {
+		result := &core.Result{}
+		var id int64
+		var joinedErrors string
+		_ = rows.Scan(&id, &result.Success, &joinedErrors, &result.Connected, &result.HTTPStatus, &result.DNSRCode, &result.CertificateExpiration, &result.Hostname, &result.IP, &result.Duration, &result.Timestamp)
+		if len(joinedErrors) != 0 {
+			result.Errors = strings.Split(joinedErrors, arraySeparator)
+		}
+		//results = append(results, result)
+		// This is faster than using a subselect
+		results = append([]*core.Result{result}, results...)
+		idResultMap[id] = result
+	}
+	_ = rows.Close()
+	// Get the conditionResults
+	for serviceResultID, result := range idResultMap {
+		rows, err = tx.Query(
+			`
+				SELECT condition, success
+				FROM service_result_condition
+				WHERE service_result_id = $1
+			`,
+			serviceResultID,
+		)
+		if err != nil {
+			return
+		}
+		for rows.Next() {
+			conditionResult := &core.ConditionResult{}
+			if err = rows.Scan(&conditionResult.Condition, &conditionResult.Success); err != nil {
+				return
+			}
+			result.ConditionResults = append(result.ConditionResults, conditionResult)
+		}
+		_ = rows.Close()
+	}
+	return
+}
+
+func (s *Store) getServiceUptime(tx *sql.Tx, serviceID int64, from, to time.Time) (uptime float64, avgResponseTime time.Duration, err error) {
+	rows, err := tx.Query(
+		`
+			SELECT SUM(total_executions), SUM(successful_executions), SUM(total_response_time)
+			FROM service_uptime
+			WHERE service_id = $1
+				AND hour_unix_timestamp >= $2
+				AND hour_unix_timestamp <= $3
+		`,
+		serviceID,
+		from.Unix(),
+		to.Unix(),
+	)
+	if err != nil {
+		return 0, 0, err
+	}
+	var totalExecutions, totalSuccessfulExecutions, totalResponseTime int
+	for rows.Next() {
+		_ = rows.Scan(&totalExecutions, &totalSuccessfulExecutions, &totalResponseTime)
+		break
+	}
+	_ = rows.Close()
+	if totalExecutions > 0 {
+		uptime = float64(totalSuccessfulExecutions) / float64(totalExecutions)
+		avgResponseTime = time.Duration(float64(totalResponseTime)/float64(totalExecutions)) * time.Millisecond
+	}
+	return
+}
+
+func (s *Store) getServiceID(tx *sql.Tx, service *core.Service) (int64, error) {
+	rows, err := tx.Query("SELECT service_id FROM service WHERE service_key = $1", service.Key())
+	if err != nil {
+		return 0, err
+	}
+	var id int64
+	var found bool
+	for rows.Next() {
+		_ = rows.Scan(&id)
+		found = true
+		break
+	}
+	_ = rows.Close()
+	if !found {
+		return 0, errServiceNotFoundInDatabase
+	}
+	return id, nil
+}
+
+func (s *Store) getNumberOfEventsByServiceID(tx *sql.Tx, serviceID int64) (int64, error) {
+	rows, err := tx.Query("SELECT COUNT(1) FROM service_event WHERE service_id = $1", serviceID)
+	if err != nil {
+		return 0, err
+	}
+	var numberOfEvents int64
+	for rows.Next() {
+		_ = rows.Scan(&numberOfEvents)
+	}
+	_ = rows.Close()
+	return numberOfEvents, nil
+}
+
+func (s *Store) getNumberOfResultsByServiceID(tx *sql.Tx, serviceID int64) (int64, error) {
+	rows, err := tx.Query("SELECT COUNT(1) FROM service_result WHERE service_id = $1", serviceID)
+	if err != nil {
+		return 0, err
+	}
+	var numberOfResults int64
+	for rows.Next() {
+		_ = rows.Scan(&numberOfResults)
+	}
+	_ = rows.Close()
+	return numberOfResults, nil
+}
+
+func (s *Store) getAgeOfOldestServiceUptimeEntry(tx *sql.Tx, serviceID int64) (time.Duration, error) {
+	rows, err := tx.Query(
+		`
+			SELECT hour_unix_timestamp 
+			FROM service_uptime 
+			WHERE service_id = $1 
+			ORDER BY hour_unix_timestamp
+			LIMIT 1
+		`,
+		serviceID,
+	)
+	if err != nil {
+		return 0, err
+	}
+	var oldestServiceUptimeUnixTimestamp int64
+	var found bool
+	for rows.Next() {
+		_ = rows.Scan(&oldestServiceUptimeUnixTimestamp)
+		found = true
+		break
+	}
+	_ = rows.Close()
+	if !found {
+		return 0, errNoRowsReturned
+	}
+	return time.Since(time.Unix(oldestServiceUptimeUnixTimestamp, 0)), nil
+}
+
+func (s *Store) getLastServiceResultSuccessValue(tx *sql.Tx, serviceID int64) (bool, error) {
+	rows, err := tx.Query("SELECT success FROM service_result WHERE service_id = $1 ORDER BY service_result_id DESC LIMIT 1", serviceID)
+	if err != nil {
+		return false, err
+	}
+	var success bool
+	var found bool
+	for rows.Next() {
+		_ = rows.Scan(&success)
+		found = true
+		break
+	}
+	_ = rows.Close()
+	if !found {
+		return false, errNoRowsReturned
+	}
+	return success, nil
+}
+
+// deleteOldServiceEvents deletes old service events that are no longer needed
+func (s *Store) deleteOldServiceEvents(tx *sql.Tx, serviceID int64) error {
+	_, err := tx.Exec(
+		`
+			DELETE FROM service_event 
+			WHERE service_id = $1
+				AND service_event_id NOT IN (
+					SELECT service_event_id 
+					FROM service_event
+					WHERE service_id = $1
+					ORDER BY service_event_id DESC
+					LIMIT $2
+				)
+		`,
+		serviceID,
+		core.MaximumNumberOfEvents,
+	)
+	if err != nil {
+		return err
+	}
+	//rowsAffected, _ := result.RowsAffected()
+	//log.Printf("deleted %d rows from service_event", rowsAffected)
+	return nil
+}
+
+// deleteOldServiceResults deletes old service results that are no longer needed
+func (s *Store) deleteOldServiceResults(tx *sql.Tx, serviceID int64) error {
+	_, err := tx.Exec(
+		`
+			DELETE FROM service_result 
+			WHERE service_id = $1 
+				AND service_result_id NOT IN (
+					SELECT service_result_id
+					FROM service_result
+					WHERE service_id = $1
+					ORDER BY service_result_id DESC
+					LIMIT $2
+				)
+		`,
+		serviceID,
+		core.MaximumNumberOfResults,
+	)
+	if err != nil {
+		return err
+	}
+	//rowsAffected, _ := result.RowsAffected()
+	//log.Printf("deleted %d rows from service_result", rowsAffected)
+	return nil
+}
+
+func (s *Store) deleteOldUptimeEntries(tx *sql.Tx, serviceID int64, maxAge time.Time) error {
+	_, err := tx.Exec("DELETE FROM service_uptime WHERE service_id = $1 AND hour_unix_timestamp < $2", serviceID, maxAge.Unix())
+	//if err != nil {
+	//	return err
+	//}
+	//rowsAffected, _ := result.RowsAffected()
+	//log.Printf("deleted %d rows from service_uptime", rowsAffected)
+	return err
+}

storage/store/sqlite/sqlite_test.go

@@ -0,0 +1,352 @@
+package sqlite
+
+import (
+	"testing"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage/store/paging"
+)
+
+var (
+	firstCondition  = core.Condition("[STATUS] == 200")
+	secondCondition = core.Condition("[RESPONSE_TIME] < 500")
+	thirdCondition  = core.Condition("[CERTIFICATE_EXPIRATION] < 72h")
+
+	now = 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:             now,
+		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:             now,
+		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 TestNewStore(t *testing.T) {
+	if _, err := NewStore("", "TestNewStore.db"); err != ErrDatabaseDriverNotSpecified {
+		t.Error("expected error due to blank driver parameter")
+	}
+	if _, err := NewStore("sqlite", ""); err != ErrFilePathNotSpecified {
+		t.Error("expected error due to blank path parameter")
+	}
+	if store, err := NewStore("sqlite", t.TempDir()+"/TestNewStore.db"); err != nil {
+		t.Error("shouldn't have returned any error, got", err.Error())
+	} else {
+		_ = store.db.Close()
+	}
+}
+
+func TestStore_InsertCleansUpOldUptimeEntriesProperly(t *testing.T) {
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_InsertCleansUpOldUptimeEntriesProperly.db")
+	defer store.Close()
+	now := time.Now().Round(time.Minute)
+	now = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), 0, 0, 0, now.Location())
+
+	store.Insert(&testService, &core.Result{Timestamp: now.Add(-5 * time.Hour), Success: true})
+
+	tx, _ := store.db.Begin()
+	oldest, _ := store.getAgeOfOldestServiceUptimeEntry(tx, 1)
+	_ = tx.Commit()
+	if oldest.Truncate(time.Hour) != 5*time.Hour {
+		t.Errorf("oldest service uptime entry should've been ~5 hours old, was %s", oldest)
+	}
+
+	// The oldest cache entry should remain at ~5 hours old, because this entry is more recent
+	store.Insert(&testService, &core.Result{Timestamp: now.Add(-3 * time.Hour), Success: true})
+
+	tx, _ = store.db.Begin()
+	oldest, _ = store.getAgeOfOldestServiceUptimeEntry(tx, 1)
+	_ = tx.Commit()
+	if oldest.Truncate(time.Hour) != 5*time.Hour {
+		t.Errorf("oldest service uptime entry should've been ~5 hours old, was %s", oldest)
+	}
+
+	// The oldest cache entry should now become at ~8 hours old, because this entry is older
+	store.Insert(&testService, &core.Result{Timestamp: now.Add(-8 * time.Hour), Success: true})
+
+	tx, _ = store.db.Begin()
+	oldest, _ = store.getAgeOfOldestServiceUptimeEntry(tx, 1)
+	_ = tx.Commit()
+	if oldest.Truncate(time.Hour) != 8*time.Hour {
+		t.Errorf("oldest service uptime entry should've been ~8 hours old, was %s", oldest)
+	}
+
+	// Since this is one hour before reaching the clean up threshold, the oldest entry should now be this one
+	store.Insert(&testService, &core.Result{Timestamp: now.Add(-(uptimeCleanUpThreshold - time.Hour)), Success: true})
+
+	tx, _ = store.db.Begin()
+	oldest, _ = store.getAgeOfOldestServiceUptimeEntry(tx, 1)
+	_ = tx.Commit()
+	if oldest.Truncate(time.Hour) != uptimeCleanUpThreshold-time.Hour {
+		t.Errorf("oldest service uptime entry should've been ~%s hours old, was %s", uptimeCleanUpThreshold-time.Hour, oldest)
+	}
+
+	// Since this entry is after the uptimeCleanUpThreshold, both this entry as well as the previous
+	// one should be deleted since they both surpass uptimeRetention
+	store.Insert(&testService, &core.Result{Timestamp: now.Add(-(uptimeCleanUpThreshold + time.Hour)), Success: true})
+
+	tx, _ = store.db.Begin()
+	oldest, _ = store.getAgeOfOldestServiceUptimeEntry(tx, 1)
+	_ = tx.Commit()
+	if oldest.Truncate(time.Hour) != 8*time.Hour {
+		t.Errorf("oldest service uptime entry should've been ~8 hours old, was %s", oldest)
+	}
+}
+
+func TestStore_InsertCleansUpEventsAndResultsProperly(t *testing.T) {
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_InsertCleansUpEventsAndResultsProperly.db")
+	defer store.Close()
+	for i := 0; i < resultsCleanUpThreshold+eventsCleanUpThreshold; i++ {
+		store.Insert(&testService, &testSuccessfulResult)
+		store.Insert(&testService, &testUnsuccessfulResult)
+		ss := store.GetServiceStatusByKey(testService.Key(), paging.NewServiceStatusParams().WithResults(1, core.MaximumNumberOfResults*5).WithEvents(1, core.MaximumNumberOfEvents*5))
+		if len(ss.Results) > resultsCleanUpThreshold+1 {
+			t.Errorf("number of results shouldn't have exceeded %d, reached %d", resultsCleanUpThreshold, len(ss.Results))
+		}
+		if len(ss.Events) > eventsCleanUpThreshold+1 {
+			t.Errorf("number of events shouldn't have exceeded %d, reached %d", eventsCleanUpThreshold, len(ss.Events))
+		}
+	}
+	store.Clear()
+}
+
+func TestStore_Persistence(t *testing.T) {
+	file := t.TempDir() + "/TestStore_Persistence.db"
+	store, _ := NewStore("sqlite", file)
+	store.Insert(&testService, &testSuccessfulResult)
+	store.Insert(&testService, &testUnsuccessfulResult)
+	ssFromOldStore := store.GetServiceStatus(testService.Group, testService.Name, paging.NewServiceStatusParams().WithResults(1, core.MaximumNumberOfResults).WithEvents(1, core.MaximumNumberOfEvents).WithUptime())
+	if ssFromOldStore == nil || ssFromOldStore.Group != "group" || ssFromOldStore.Name != "name" || len(ssFromOldStore.Events) != 3 || len(ssFromOldStore.Results) != 2 || ssFromOldStore.Uptime.LastHour != 0.5 || ssFromOldStore.Uptime.LastTwentyFourHours != 0.5 || ssFromOldStore.Uptime.LastSevenDays != 0.5 {
+		store.Close()
+		t.Fatal("sanity check failed")
+	}
+	store.Close()
+	store, _ = NewStore("sqlite", file)
+	defer store.Close()
+	ssFromNewStore := store.GetServiceStatus(testService.Group, testService.Name, paging.NewServiceStatusParams().WithResults(1, core.MaximumNumberOfResults).WithEvents(1, core.MaximumNumberOfEvents).WithUptime())
+	if ssFromNewStore == nil || ssFromNewStore.Group != "group" || ssFromNewStore.Name != "name" || len(ssFromNewStore.Events) != 3 || len(ssFromNewStore.Results) != 2 || ssFromNewStore.Uptime.LastHour != 0.5 || ssFromNewStore.Uptime.LastTwentyFourHours != 0.5 || ssFromNewStore.Uptime.LastSevenDays != 0.5 {
+		t.Fatal("failed sanity check")
+	}
+	if ssFromNewStore == ssFromOldStore {
+		t.Fatal("ss from the old and new store should have a different memory address")
+	}
+	for i := range ssFromNewStore.Events {
+		if ssFromNewStore.Events[i].Timestamp != ssFromOldStore.Events[i].Timestamp {
+			t.Error("new and old should've been the same")
+		}
+		if ssFromNewStore.Events[i].Type != ssFromOldStore.Events[i].Type {
+			t.Error("new and old should've been the same")
+		}
+	}
+	for i := range ssFromOldStore.Results {
+		if ssFromNewStore.Results[i].Timestamp != ssFromOldStore.Results[i].Timestamp {
+			t.Error("new and old should've been the same")
+		}
+		if ssFromNewStore.Results[i].Success != ssFromOldStore.Results[i].Success {
+			t.Error("new and old should've been the same")
+		}
+		if ssFromNewStore.Results[i].Connected != ssFromOldStore.Results[i].Connected {
+			t.Error("new and old should've been the same")
+		}
+		if ssFromNewStore.Results[i].IP != ssFromOldStore.Results[i].IP {
+			t.Error("new and old should've been the same")
+		}
+		if ssFromNewStore.Results[i].Hostname != ssFromOldStore.Results[i].Hostname {
+			t.Error("new and old should've been the same")
+		}
+		if ssFromNewStore.Results[i].HTTPStatus != ssFromOldStore.Results[i].HTTPStatus {
+			t.Error("new and old should've been the same")
+		}
+		if ssFromNewStore.Results[i].DNSRCode != ssFromOldStore.Results[i].DNSRCode {
+			t.Error("new and old should've been the same")
+		}
+		if len(ssFromNewStore.Results[i].Errors) != len(ssFromOldStore.Results[i].Errors) {
+			t.Error("new and old should've been the same")
+		} else {
+			for j := range ssFromOldStore.Results[i].Errors {
+				if ssFromNewStore.Results[i].Errors[j] != ssFromOldStore.Results[i].Errors[j] {
+					t.Error("new and old should've been the same")
+				}
+			}
+		}
+		if len(ssFromNewStore.Results[i].ConditionResults) != len(ssFromOldStore.Results[i].ConditionResults) {
+			t.Error("new and old should've been the same")
+		} else {
+			for j := range ssFromOldStore.Results[i].ConditionResults {
+				if ssFromNewStore.Results[i].ConditionResults[j].Condition != ssFromOldStore.Results[i].ConditionResults[j].Condition {
+					t.Error("new and old should've been the same")
+				}
+				if ssFromNewStore.Results[i].ConditionResults[j].Success != ssFromOldStore.Results[i].ConditionResults[j].Success {
+					t.Error("new and old should've been the same")
+				}
+			}
+		}
+	}
+}
+
+func TestStore_Save(t *testing.T) {
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_Save.db")
+	defer store.Close()
+	if store.Save() != nil {
+		t.Error("Save shouldn't do anything for this store")
+	}
+}
+
+// Note that are much more extensive tests in /storage/store/store_test.go.
+// This test is simply an extra sanity check
+func TestStore_SanityCheck(t *testing.T) {
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_SanityCheck.db")
+	defer store.Close()
+	store.Insert(&testService, &testSuccessfulResult)
+	if numberOfServiceStatuses := len(store.GetAllServiceStatuses(paging.NewServiceStatusParams())); numberOfServiceStatuses != 1 {
+		t.Fatalf("expected 1 ServiceStatus, got %d", numberOfServiceStatuses)
+	}
+	store.Insert(&testService, &testUnsuccessfulResult)
+	// Both results inserted are for the same service, therefore, the count shouldn't have increased
+	if numberOfServiceStatuses := len(store.GetAllServiceStatuses(paging.NewServiceStatusParams())); numberOfServiceStatuses != 1 {
+		t.Fatalf("expected 1 ServiceStatus, got %d", numberOfServiceStatuses)
+	}
+	ss := store.GetServiceStatus(testService.Group, testService.Name, paging.NewServiceStatusParams().WithResults(1, 20).WithEvents(1, 20))
+	if ss == nil {
+		t.Fatalf("Store should've had key '%s', but didn't", testService.Key())
+	}
+	if len(ss.Events) != 3 {
+		t.Errorf("Service '%s' should've had 3 events, got %d", ss.Name, len(ss.Events))
+	}
+	if len(ss.Results) != 2 {
+		t.Errorf("Service '%s' should've had 2 results, got %d", ss.Name, len(ss.Results))
+	}
+	if deleted := store.DeleteAllServiceStatusesNotInKeys([]string{}); deleted != 1 {
+		t.Errorf("%d entries should've been deleted, got %d", 1, deleted)
+	}
+}
+
+// TestStore_InvalidTransaction tests what happens if an invalid transaction is passed as parameter
+func TestStore_InvalidTransaction(t *testing.T) {
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_InvalidTransaction.db")
+	defer store.Close()
+	tx, _ := store.db.Begin()
+	tx.Commit()
+	if _, err := store.insertService(tx, &testService); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if err := store.insertEvent(tx, 1, core.NewEventFromResult(&testSuccessfulResult)); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if err := store.insertResult(tx, 1, &testSuccessfulResult); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if err := store.insertConditionResults(tx, 1, testSuccessfulResult.ConditionResults); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if err := store.updateServiceUptime(tx, 1, &testSuccessfulResult); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if _, err := store.getAllServiceKeys(tx); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if _, err := store.getServiceStatusByKey(tx, testService.Key(), paging.NewServiceStatusParams().WithResults(1, 20)); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if _, err := store.getEventsByServiceID(tx, 1, 1, 50); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if _, err := store.getResultsByServiceID(tx, 1, 1, 50); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if err := store.deleteOldServiceEvents(tx, 1); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if err := store.deleteOldServiceResults(tx, 1); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if _, _, err := store.getServiceUptime(tx, 1, time.Now(), time.Now()); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if _, err := store.getServiceID(tx, &testService); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if _, err := store.getNumberOfEventsByServiceID(tx, 1); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if _, err := store.getNumberOfResultsByServiceID(tx, 1); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if _, err := store.getAgeOfOldestServiceUptimeEntry(tx, 1); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+	if _, err := store.getLastServiceResultSuccessValue(tx, 1); err == nil {
+		t.Error("should've returned an error, because the transaction was already committed")
+	}
+}
+
+func TestStore_NoRows(t *testing.T) {
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_NoRows.db")
+	defer store.Close()
+	tx, _ := store.db.Begin()
+	defer tx.Rollback()
+	if _, err := store.getLastServiceResultSuccessValue(tx, 1); err != errNoRowsReturned {
+		t.Errorf("should've %v, got %v", errNoRowsReturned, err)
+	}
+	if _, err := store.getAgeOfOldestServiceUptimeEntry(tx, 1); err != errNoRowsReturned {
+		t.Errorf("should've %v, got %v", errNoRowsReturned, err)
+	}
+}

storage/store/store.go

@@ -3,19 +3,21 @@ package store
 import (
 	"github.com/TwinProduction/gatus/core"
 	"github.com/TwinProduction/gatus/storage/store/memory"
+	"github.com/TwinProduction/gatus/storage/store/paging"
+	"github.com/TwinProduction/gatus/storage/store/sqlite"
 )
 
 // Store is the interface that each stores should implement
 type Store interface {
-	// GetAllServiceStatusesWithResultPagination returns the JSON encoding of all monitored core.ServiceStatus
+	// GetAllServiceStatuses 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
+	GetAllServiceStatuses(params *paging.ServiceStatusParams) map[string]*core.ServiceStatus
 
 	// GetServiceStatus returns the service status for a given service name in the given group
-	GetServiceStatus(groupName, serviceName string) *core.ServiceStatus
+	GetServiceStatus(groupName, serviceName string, params *paging.ServiceStatusParams) *core.ServiceStatus
 
 	// GetServiceStatusByKey returns the service status for a given key
-	GetServiceStatusByKey(key string) *core.ServiceStatus
+	GetServiceStatusByKey(key string, params *paging.ServiceStatusParams) *core.ServiceStatus
 
 	// Insert adds the observed result for the specified service into the store
 	Insert(service *core.Service, result *core.Result)
@@ -30,9 +32,16 @@ type Store interface {
 
 	// Save persists the data if and where it needs to be persisted
 	Save() error
+
+	// Close terminates every connections and closes the store, if applicable.
+	// Should only be used before stopping the application.
+	Close()
 }
 
+// TODO: add method to check state of store (by keeping track of silent errors)
+
 var (
 	// Validate interface implementation on compile
 	_ Store = (*memory.Store)(nil)
+	_ Store = (*sqlite.Store)(nil)
 )

storage/store/store_bench_test.go

@@ -6,104 +6,65 @@ import (
 
 	"github.com/TwinProduction/gatus/core"
 	"github.com/TwinProduction/gatus/storage/store/memory"
+	"github.com/TwinProduction/gatus/storage/store/paging"
+	"github.com/TwinProduction/gatus/storage/store/sqlite"
 )
 
-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) {
+func BenchmarkStore_GetAllServiceStatuses(b *testing.B) {
 	memoryStore, err := memory.NewStore("")
 	if err != nil {
 		b.Fatal("failed to create store:", err.Error())
 	}
+	sqliteStore, err := sqlite.NewStore("sqlite", b.TempDir()+"/BenchmarkStore_GetAllServiceStatuses.db")
+	if err != nil {
+		b.Fatal("failed to create store:", err.Error())
+	}
+	defer sqliteStore.Close()
 	type Scenario struct {
-		Name  string
-		Store Store
+		Name     string
+		Store    Store
+		Parallel bool
 	}
 	scenarios := []Scenario{
 		{
-			Name:  "memory",
-			Store: memoryStore,
+			Name:     "memory",
+			Store:    memoryStore,
+			Parallel: false,
+		},
+		{
+			Name:     "memory-parallel",
+			Store:    memoryStore,
+			Parallel: true,
+		},
+		{
+			Name:     "sqlite",
+			Store:    sqliteStore,
+			Parallel: false,
+		},
+		{
+			Name:     "sqlite-parallel",
+			Store:    sqliteStore,
+			Parallel: true,
 		},
 	}
 	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)
+			if scenario.Parallel {
+				b.RunParallel(func(pb *testing.PB) {
+					for pb.Next() {
+						scenario.Store.GetAllServiceStatuses(paging.NewServiceStatusParams().WithResults(1, 20))
+					}
+				})
+			} else {
+				for n := 0; n < b.N; n++ {
+					scenario.Store.GetAllServiceStatuses(paging.NewServiceStatusParams().WithResults(1, 20))
+				}
 			}
 			b.ReportAllocs()
 		})
+		scenario.Store.Clear()
 	}
 }
 
@@ -112,26 +73,129 @@ func BenchmarkStore_Insert(b *testing.B) {
 	if err != nil {
 		b.Fatal("failed to create store:", err.Error())
 	}
+	sqliteStore, err := sqlite.NewStore("sqlite", b.TempDir()+"/BenchmarkStore_Insert.db")
+	if err != nil {
+		b.Fatal("failed to create store:", err.Error())
+	}
+	defer sqliteStore.Close()
 	type Scenario struct {
-		Name  string
-		Store Store
+		Name     string
+		Store    Store
+		Parallel bool
 	}
 	scenarios := []Scenario{
 		{
-			Name:  "memory",
-			Store: memoryStore,
+			Name:     "memory",
+			Store:    memoryStore,
+			Parallel: false,
+		},
+		{
+			Name:     "memory-parallel",
+			Store:    memoryStore,
+			Parallel: true,
+		},
+		{
+			Name:     "sqlite",
+			Store:    sqliteStore,
+			Parallel: false,
+		},
+		{
+			Name:     "sqlite-parallel",
+			Store:    sqliteStore,
+			Parallel: false,
 		},
 	}
 	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)
+			if scenario.Parallel {
+				b.RunParallel(func(pb *testing.PB) {
+					n := 0
+					for pb.Next() {
+						var result core.Result
+						if n%10 == 0 {
+							result = testUnsuccessfulResult
+						} else {
+							result = testSuccessfulResult
+						}
+						result.Timestamp = time.Now()
+						scenario.Store.Insert(&testService, &result)
+						n++
+					}
+				})
+			} else {
+				for n := 0; n < b.N; n++ {
+					var result core.Result
+					if n%10 == 0 {
+						result = testUnsuccessfulResult
+					} else {
+						result = testSuccessfulResult
+					}
+					result.Timestamp = time.Now()
+					scenario.Store.Insert(&testService, &result)
+				}
+			}
+			b.ReportAllocs()
+			scenario.Store.Clear()
+		})
+	}
+}
+
+func BenchmarkStore_GetServiceStatusByKey(b *testing.B) {
+	memoryStore, err := memory.NewStore("")
+	if err != nil {
+		b.Fatal("failed to create store:", err.Error())
+	}
+	sqliteStore, err := sqlite.NewStore("sqlite", b.TempDir()+"/BenchmarkStore_GetServiceStatusByKey.db")
+	if err != nil {
+		b.Fatal("failed to create store:", err.Error())
+	}
+	defer sqliteStore.Close()
+	type Scenario struct {
+		Name     string
+		Store    Store
+		Parallel bool
+	}
+	scenarios := []Scenario{
+		{
+			Name:     "memory",
+			Store:    memoryStore,
+			Parallel: false,
+		},
+		{
+			Name:     "memory-parallel",
+			Store:    memoryStore,
+			Parallel: true,
+		},
+		{
+			Name:     "sqlite",
+			Store:    sqliteStore,
+			Parallel: false,
+		},
+		{
+			Name:     "sqlite-parallel",
+			Store:    sqliteStore,
+			Parallel: true,
+		},
+	}
+	for _, scenario := range scenarios {
+		for i := 0; i < 50; i++ {
+			scenario.Store.Insert(&testService, &testSuccessfulResult)
+			scenario.Store.Insert(&testService, &testUnsuccessfulResult)
+		}
+		b.Run(scenario.Name, func(b *testing.B) {
+			if scenario.Parallel {
+				b.RunParallel(func(pb *testing.PB) {
+					for pb.Next() {
+						scenario.Store.GetServiceStatusByKey(testService.Key(), paging.NewServiceStatusParams().WithResults(1, 20))
+					}
+				})
+			} else {
+				for n := 0; n < b.N; n++ {
+					scenario.Store.GetServiceStatusByKey(testService.Key(), paging.NewServiceStatusParams().WithResults(1, 20))
 				}
 			}
 			b.ReportAllocs()
 		})
+		scenario.Store.Clear()
 	}
 }

storage/store/store_test.go

@@ -0,0 +1,382 @@
+package store
+
+import (
+	"testing"
+	"time"
+
+	"github.com/TwinProduction/gatus/core"
+	"github.com/TwinProduction/gatus/storage/store/memory"
+	"github.com/TwinProduction/gatus/storage/store/paging"
+	"github.com/TwinProduction/gatus/storage/store/sqlite"
+)
+
+var (
+	firstCondition  = core.Condition("[STATUS] == 200")
+	secondCondition = core.Condition("[RESPONSE_TIME] < 500")
+	thirdCondition  = core.Condition("[CERTIFICATE_EXPIRATION] < 72h")
+
+	now = time.Now().Truncate(time.Minute)
+
+	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{
+		Timestamp:             now,
+		Success:               true,
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Errors:                nil,
+		Connected:             true,
+		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{
+		Timestamp:             now,
+		Success:               false,
+		Hostname:              "example.org",
+		IP:                    "127.0.0.1",
+		HTTPStatus:            200,
+		Errors:                []string{"error-1", "error-2"},
+		Connected:             true,
+		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,
+			},
+		},
+	}
+)
+
+type Scenario struct {
+	Name  string
+	Store Store
+}
+
+func initStoresAndBaseScenarios(t *testing.T, testName string) []*Scenario {
+	memoryStore, err := memory.NewStore("")
+	if err != nil {
+		t.Fatal("failed to create store:", err.Error())
+	}
+	sqliteStore, err := sqlite.NewStore("sqlite", t.TempDir()+"/"+testName+".db")
+	if err != nil {
+		t.Fatal("failed to create store:", err.Error())
+	}
+	return []*Scenario{
+		{
+			Name:  "memory",
+			Store: memoryStore,
+		},
+		{
+			Name:  "sqlite",
+			Store: sqliteStore,
+		},
+	}
+}
+
+func cleanUp(scenarios []*Scenario) {
+	for _, scenario := range scenarios {
+		scenario.Store.Close()
+	}
+}
+
+func TestStore_GetServiceStatusByKey(t *testing.T) {
+	scenarios := initStoresAndBaseScenarios(t, "TestStore_GetServiceStatusByKey")
+	defer cleanUp(scenarios)
+	firstResult := testSuccessfulResult
+	firstResult.Timestamp = now.Add(-time.Minute)
+	secondResult := testUnsuccessfulResult
+	secondResult.Timestamp = now
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			scenario.Store.Insert(&testService, &firstResult)
+			scenario.Store.Insert(&testService, &secondResult)
+
+			serviceStatus := scenario.Store.GetServiceStatusByKey(testService.Key(), paging.NewServiceStatusParams().WithEvents(1, core.MaximumNumberOfEvents).WithResults(1, core.MaximumNumberOfResults).WithUptime())
+			if serviceStatus == nil {
+				t.Fatalf("serviceStatus shouldn't have been nil")
+			}
+			if serviceStatus.Name != testService.Name {
+				t.Fatalf("serviceStatus.Name should've been %s, got %s", testService.Name, serviceStatus.Name)
+			}
+			if serviceStatus.Group != testService.Group {
+				t.Fatalf("serviceStatus.Group should've been %s, got %s", testService.Group, serviceStatus.Group)
+			}
+			if len(serviceStatus.Results) != 2 {
+				t.Fatalf("serviceStatus.Results should've had 2 entries")
+			}
+			if serviceStatus.Results[0].Timestamp.After(serviceStatus.Results[1].Timestamp) {
+				t.Error("The result at index 0 should've been older than the result at index 1")
+			}
+			if serviceStatus.Uptime == nil {
+				t.Fatalf("serviceStatus.Uptime shouldn't have been nil")
+			}
+			if serviceStatus.Uptime.LastHour != 0.5 {
+				t.Errorf("serviceStatus.Uptime.LastHour should've been 0.5, got %f", serviceStatus.Uptime.LastHour)
+			}
+			if serviceStatus.Uptime.LastTwentyFourHours != 0.5 {
+				t.Errorf("serviceStatus.Uptime.LastTwentyFourHours should've been 0.5, got %f", serviceStatus.Uptime.LastTwentyFourHours)
+			}
+			if serviceStatus.Uptime.LastSevenDays != 0.5 {
+				t.Errorf("serviceStatus.Uptime.LastSevenDays should've been 0.5, got %f", serviceStatus.Uptime.LastSevenDays)
+			}
+			scenario.Store.Clear()
+		})
+	}
+}
+
+func TestStore_GetServiceStatusForMissingStatusReturnsNil(t *testing.T) {
+	scenarios := initStoresAndBaseScenarios(t, "TestStore_GetServiceStatusForMissingStatusReturnsNil")
+	defer cleanUp(scenarios)
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			scenario.Store.Insert(&testService, &testSuccessfulResult)
+			serviceStatus := scenario.Store.GetServiceStatus("nonexistantgroup", "nonexistantname", paging.NewServiceStatusParams().WithEvents(1, core.MaximumNumberOfEvents).WithResults(1, core.MaximumNumberOfResults).WithUptime())
+			if serviceStatus != nil {
+				t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", testService.Group, testService.Name)
+			}
+			serviceStatus = scenario.Store.GetServiceStatus(testService.Group, "nonexistantname", paging.NewServiceStatusParams().WithEvents(1, core.MaximumNumberOfEvents).WithResults(1, core.MaximumNumberOfResults).WithUptime())
+			if serviceStatus != nil {
+				t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", testService.Group, "nonexistantname")
+			}
+			serviceStatus = scenario.Store.GetServiceStatus("nonexistantgroup", testService.Name, paging.NewServiceStatusParams().WithEvents(1, core.MaximumNumberOfEvents).WithResults(1, core.MaximumNumberOfResults).WithUptime())
+			if serviceStatus != nil {
+				t.Errorf("Returned service status for group '%s' and name '%s' not nil after inserting the service into the store", "nonexistantgroup", testService.Name)
+			}
+		})
+	}
+}
+
+func TestStore_GetAllServiceStatuses(t *testing.T) {
+	scenarios := initStoresAndBaseScenarios(t, "TestStore_GetAllServiceStatuses")
+	defer cleanUp(scenarios)
+	firstResult := testSuccessfulResult
+	secondResult := testUnsuccessfulResult
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			scenario.Store.Insert(&testService, &firstResult)
+			scenario.Store.Insert(&testService, &secondResult)
+			// Can't be bothered dealing with timezone issues on the worker that runs the automated tests
+			serviceStatuses := scenario.Store.GetAllServiceStatuses(paging.NewServiceStatusParams().WithResults(1, 20))
+			if len(serviceStatuses) != 1 {
+				t.Fatal("expected 1 service status")
+			}
+			actual, exists := serviceStatuses[testService.Key()]
+			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) != 0 {
+				t.Error("expected 0 events, got", len(actual.Events))
+			}
+			scenario.Store.Clear()
+		})
+	}
+}
+
+func TestStore_GetAllServiceStatusesWithResultsAndEvents(t *testing.T) {
+	scenarios := initStoresAndBaseScenarios(t, "TestStore_GetAllServiceStatusesWithResultsAndEvents")
+	defer cleanUp(scenarios)
+	firstResult := testSuccessfulResult
+	secondResult := testUnsuccessfulResult
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			scenario.Store.Insert(&testService, &firstResult)
+			scenario.Store.Insert(&testService, &secondResult)
+			// Can't be bothered dealing with timezone issues on the worker that runs the automated tests
+			serviceStatuses := scenario.Store.GetAllServiceStatuses(paging.NewServiceStatusParams().WithResults(1, 20).WithEvents(1, 50))
+			if len(serviceStatuses) != 1 {
+				t.Fatal("expected 1 service status")
+			}
+			actual, exists := serviceStatuses[testService.Key()]
+			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) != 3 {
+				t.Error("expected 3 events, got", len(actual.Events))
+			}
+			scenario.Store.Clear()
+		})
+	}
+}
+
+func TestStore_GetServiceStatusPage1IsHasMoreRecentResultsThanPage2(t *testing.T) {
+	scenarios := initStoresAndBaseScenarios(t, "TestStore_GetServiceStatusPage1IsHasMoreRecentResultsThanPage2")
+	defer cleanUp(scenarios)
+	firstResult := testSuccessfulResult
+	firstResult.Timestamp = now.Add(-time.Minute)
+	secondResult := testUnsuccessfulResult
+	secondResult.Timestamp = now
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			scenario.Store.Insert(&testService, &firstResult)
+			scenario.Store.Insert(&testService, &secondResult)
+			serviceStatusPage1 := scenario.Store.GetServiceStatusByKey(testService.Key(), paging.NewServiceStatusParams().WithResults(1, 1))
+			if serviceStatusPage1 == nil {
+				t.Fatalf("serviceStatusPage1 shouldn't have been nil")
+			}
+			if len(serviceStatusPage1.Results) != 1 {
+				t.Fatalf("serviceStatusPage1 should've had 1 result")
+			}
+			serviceStatusPage2 := scenario.Store.GetServiceStatusByKey(testService.Key(), paging.NewServiceStatusParams().WithResults(2, 1))
+			if serviceStatusPage2 == nil {
+				t.Fatalf("serviceStatusPage2 shouldn't have been nil")
+			}
+			if len(serviceStatusPage2.Results) != 1 {
+				t.Fatalf("serviceStatusPage2 should've had 1 result")
+			}
+			// Compare the timestamp of both pages
+			if !serviceStatusPage1.Results[0].Timestamp.After(serviceStatusPage2.Results[0].Timestamp) {
+				t.Errorf("The result from the first page should've been more recent than the results from the second page")
+			}
+			scenario.Store.Clear()
+		})
+	}
+}
+
+func TestStore_Insert(t *testing.T) {
+	scenarios := initStoresAndBaseScenarios(t, "TestStore_Insert")
+	defer cleanUp(scenarios)
+	firstResult := testSuccessfulResult
+	firstResult.Timestamp = now.Add(-time.Minute)
+	secondResult := testUnsuccessfulResult
+	secondResult.Timestamp = now
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			scenario.Store.Insert(&testService, &testSuccessfulResult)
+			scenario.Store.Insert(&testService, &testUnsuccessfulResult)
+
+			ss := scenario.Store.GetServiceStatusByKey(testService.Key(), paging.NewServiceStatusParams().WithEvents(1, core.MaximumNumberOfEvents).WithResults(1, core.MaximumNumberOfResults).WithUptime())
+			if ss == nil {
+				t.Fatalf("Store should've had key '%s', but didn't", testService.Key())
+			}
+			if len(ss.Events) != 3 {
+				t.Fatalf("Service '%s' should've had 3 events, got %d", ss.Name, len(ss.Events))
+			}
+			if len(ss.Results) != 2 {
+				t.Fatalf("Service '%s' should've had 2 results, got %d", ss.Name, len(ss.Results))
+			}
+			for i, expectedResult := range []core.Result{testSuccessfulResult, testUnsuccessfulResult} {
+				if expectedResult.HTTPStatus != ss.Results[i].HTTPStatus {
+					t.Errorf("Result at index %d should've had a HTTPStatus of %d, got %d", i, ss.Results[i].HTTPStatus, expectedResult.HTTPStatus)
+				}
+				if expectedResult.DNSRCode != ss.Results[i].DNSRCode {
+					t.Errorf("Result at index %d should've had a DNSRCode of %s, got %s", i, ss.Results[i].DNSRCode, expectedResult.DNSRCode)
+				}
+				if expectedResult.Hostname != ss.Results[i].Hostname {
+					t.Errorf("Result at index %d should've had a Hostname of %s, got %s", i, ss.Results[i].Hostname, expectedResult.Hostname)
+				}
+				if expectedResult.IP != ss.Results[i].IP {
+					t.Errorf("Result at index %d should've had a IP of %s, got %s", i, ss.Results[i].IP, expectedResult.IP)
+				}
+				if expectedResult.Connected != ss.Results[i].Connected {
+					t.Errorf("Result at index %d should've had a Connected value of %t, got %t", i, ss.Results[i].Connected, expectedResult.Connected)
+				}
+				if expectedResult.Duration != ss.Results[i].Duration {
+					t.Errorf("Result at index %d should've had a Duration of %s, got %s", i, ss.Results[i].Duration.String(), expectedResult.Duration.String())
+				}
+				if len(expectedResult.Errors) != len(ss.Results[i].Errors) {
+					t.Errorf("Result at index %d should've had %d errors, but actually had %d errors", i, len(ss.Results[i].Errors), len(expectedResult.Errors))
+				} else {
+					for j := range expectedResult.Errors {
+						if ss.Results[i].Errors[j] != expectedResult.Errors[j] {
+							t.Error("should've been the same")
+						}
+					}
+				}
+				if len(expectedResult.ConditionResults) != len(ss.Results[i].ConditionResults) {
+					t.Errorf("Result at index %d should've had %d ConditionResults, but actually had %d ConditionResults", i, len(ss.Results[i].ConditionResults), len(expectedResult.ConditionResults))
+				} else {
+					for j := range expectedResult.ConditionResults {
+						if ss.Results[i].ConditionResults[j].Condition != expectedResult.ConditionResults[j].Condition {
+							t.Error("should've been the same")
+						}
+						if ss.Results[i].ConditionResults[j].Success != expectedResult.ConditionResults[j].Success {
+							t.Error("should've been the same")
+						}
+					}
+				}
+				if expectedResult.Success != ss.Results[i].Success {
+					t.Errorf("Result at index %d should've had a Success of %t, got %t", i, ss.Results[i].Success, expectedResult.Success)
+				}
+				if expectedResult.Timestamp.Unix() != ss.Results[i].Timestamp.Unix() {
+					t.Errorf("Result at index %d should've had a Timestamp of %d, got %d", i, ss.Results[i].Timestamp.Unix(), expectedResult.Timestamp.Unix())
+				}
+				if expectedResult.CertificateExpiration != ss.Results[i].CertificateExpiration {
+					t.Errorf("Result at index %d should've had a CertificateExpiration of %s, got %s", i, ss.Results[i].CertificateExpiration.String(), expectedResult.CertificateExpiration.String())
+				}
+			}
+		})
+	}
+}
+
+func TestStore_DeleteAllServiceStatusesNotInKeys(t *testing.T) {
+	scenarios := initStoresAndBaseScenarios(t, "TestStore_DeleteAllServiceStatusesNotInKeys")
+	defer cleanUp(scenarios)
+	firstService := core.Service{Name: "service-1", Group: "group"}
+	secondService := core.Service{Name: "service-2", Group: "group"}
+	result := &testSuccessfulResult
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			scenario.Store.Insert(&firstService, result)
+			scenario.Store.Insert(&secondService, result)
+			if scenario.Store.GetServiceStatusByKey(firstService.Key(), paging.NewServiceStatusParams()) == nil {
+				t.Fatal("firstService should exist")
+			}
+			if scenario.Store.GetServiceStatusByKey(secondService.Key(), paging.NewServiceStatusParams()) == nil {
+				t.Fatal("secondService should exist")
+			}
+			scenario.Store.DeleteAllServiceStatusesNotInKeys([]string{firstService.Key()})
+			if scenario.Store.GetServiceStatusByKey(firstService.Key(), paging.NewServiceStatusParams()) == nil {
+				t.Error("secondService should've been deleted")
+			}
+			if scenario.Store.GetServiceStatusByKey(secondService.Key(), paging.NewServiceStatusParams()) != nil {
+				t.Error("firstService should still exist")
+			}
+			// Delete everything
+			scenario.Store.DeleteAllServiceStatusesNotInKeys([]string{})
+			if len(scenario.Store.GetAllServiceStatuses(paging.NewServiceStatusParams())) != 0 {
+				t.Errorf("everything should've been deleted")
+			}
+		})
+	}
+}

storage/type.go

@@ -0,0 +1,9 @@
+package storage
+
+// Type of the store.
+type Type string
+
+const (
+	TypeInMemory Type = "inmemory" // In-memory store
+	TypeSQLite   Type = "sqlite"   // SQLite store
+)

util/key_bench_test.go

@@ -0,0 +1,11 @@
+package util
+
+import (
+	"testing"
+)
+
+func BenchmarkConvertGroupAndServiceToKey(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		ConvertGroupAndServiceToKey("group", "service")
+	}
+}

vendor/github.com/TwinProduction/gocache/Dockerfile

@@ -2,7 +2,7 @@
 FROM golang:alpine as builder
 WORKDIR /app
 ADD . ./
-RUN CGO_ENABLED=0 GOOS=linux go build -mod vendor -a -installsuffix cgo -o bin/gocache-server ./gocacheserver/main
+RUN CGO_ENABLED=0 GOOS=linux go build -mod vendor -a -installsuffix cgo -o bin/gocache-server cmd/server/main.go
 RUN apk --update add --no-cache ca-certificates
 
 FROM scratch

vendor/github.com/TwinProduction/gocache/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:
 

vendor/github.com/TwinProduction/gocache/Makefile

@@ -12,7 +12,7 @@ docker-run-max-memory-usage:
 	docker run -p 6666:6379 -e AUTOSAVE=true -e MAX_CACHE_SIZE=0 -e MAX_MEMORY_USAGE=524288000 --name gocache-server -d gocache-server
 
 run:
-	PORT=6666 go run gocacheserver/main/server.go
+	PORT=6666 go run cmd/server/main.go
 
 start-redis:
 	docker run -p 6379:6379 --name redis -d redis

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

@@ -5,6 +5,7 @@
 [![codecov](https://codecov.io/gh/TwinProduction/gocache/branch/master/graph/badge.svg)](https://codecov.io/gh/TwinProduction/gocache)
 [![Go version](https://img.shields.io/github/go-mod/go-version/TwinProduction/gocache.svg)](https://github.com/TwinProduction/gocache)
 [![Go Reference](https://pkg.go.dev/badge/github.com/TwinProduction/gocache.svg)](https://pkg.go.dev/github.com/TwinProduction/gocache)
+[![Follow TwinProduction](https://img.shields.io/github/followers/TwinProduction?label=Follow&style=social)](https://github.com/TwinProduction)
 
 gocache is an easy-to-use, high-performance, lightweight and thread-safe (goroutine-safe) in-memory key-value cache 
 with support for LRU and FIFO eviction policies as well as expiration, bulk operations and even persistence to file.
@@ -33,6 +34,8 @@ with support for LRU and FIFO eviction policies as well as expiration, bulk oper
   - [Summary](#summary)
   - [Results](#results)
 - [FAQ](#faq)
+  - [How can I persist the data on application termination?](#how-can-i-persist-the-data-on-application-termination)
+  - [How can I automatically save the cache to a file every 5 minutes?](#how-can-i-automatically-save-the-cache-to-a-file-every-5-minutes)
   - [Why does the memory usage not go down?](#why-does-the-memory-usage-not-go-down)
 
 
@@ -58,6 +61,9 @@ It may also serve as a good reference to use in order to implement gocache in yo
 go get -u github.com/TwinProduction/gocache
 ```
 
+If you're interested in using gocache as a server rather than an embedded library, see [Server](#server)
+
+
 ### Initializing the cache
 ```go
 cache := gocache.NewCache().WithMaxSize(1000).WithEvictionPolicy(gocache.LeastRecentlyUsed)
@@ -125,52 +131,52 @@ You can also delete multiple entries by using `cache.DeleteAll([]string{"key1",
 package main
 
 import (
-	"fmt"
-	"time"
+    "fmt"
+    "time"
 
     "github.com/TwinProduction/gocache"
 )
 
 func main() {
-	cache := gocache.NewCache().WithEvictionPolicy(gocache.LeastRecentlyUsed).WithMaxSize(10000)
-	cache.StartJanitor() // Passively manages expired entries
+    cache := gocache.NewCache().WithEvictionPolicy(gocache.LeastRecentlyUsed).WithMaxSize(10000)
+    cache.StartJanitor() // Passively manages expired entries
 
-	cache.Set("key", "value")
-	cache.SetWithTTL("key-with-ttl", "value", 60*time.Minute)
-	cache.SetAll(map[string]interface{}{"k1": "v1", "k2": "v2", "k3": "v3"})
+    cache.Set("key", "value")
+    cache.SetWithTTL("key-with-ttl", "value", 60*time.Minute)
+    cache.SetAll(map[string]interface{}{"k1": "v1", "k2": "v2", "k3": "v3"})
 
-	value, exists := cache.Get("key")
-	fmt.Printf("[Get] key=key; value=%s; exists=%v\n", value, exists)
-	for key, value := range cache.GetByKeys([]string{"k1", "k2", "k3"}) {
-		fmt.Printf("[GetByKeys] key=%s; value=%s\n", key, value)
-	}
-	for _, key := range cache.GetKeysByPattern("key*", 0) {
-		fmt.Printf("[GetKeysByPattern] key=%s\n", key)
-	}
+    value, exists := cache.Get("key")
+    fmt.Printf("[Get] key=key; value=%s; exists=%v\n", value, exists)
+    for key, value := range cache.GetByKeys([]string{"k1", "k2", "k3"}) {
+        fmt.Printf("[GetByKeys] key=%s; value=%s\n", key, value)
+    }
+    for _, key := range cache.GetKeysByPattern("key*", 0) {
+        fmt.Printf("[GetKeysByPattern] key=%s\n", key)
+    }
 
-	fmt.Println("Cache size before persisting cache to file:", cache.Count())
-	err := cache.SaveToFile("cache.bak")
-	if err != nil {
-		panic(fmt.Sprintf("failed to persist cache to file: %s", err.Error()))
-	}
+    fmt.Println("Cache size before persisting cache to file:", cache.Count())
+    err := cache.SaveToFile("cache.bak")
+    if err != nil {
+        panic(fmt.Sprintf("failed to persist cache to file: %s", err.Error()))
+    }
 
-	cache.Expire("key", time.Hour)
-	time.Sleep(500*time.Millisecond)
-	timeUntilExpiration, _ := cache.TTL("key")
-	fmt.Println("Number of minutes before 'key' expires:", int(timeUntilExpiration.Seconds()))
+    cache.Expire("key", time.Hour)
+    time.Sleep(500*time.Millisecond)
+    timeUntilExpiration, _ := cache.TTL("key")
+    fmt.Println("Number of minutes before 'key' expires:", int(timeUntilExpiration.Seconds()))
 
-	cache.Delete("key")
-	cache.DeleteAll([]string{"k1", "k2", "k3"})
+    cache.Delete("key")
+    cache.DeleteAll([]string{"k1", "k2", "k3"})
 
-	fmt.Println("Cache size before restoring cache from file:", cache.Count())
-	_, err = cache.ReadFromFile("cache.bak")
-	if err != nil {
-		panic(fmt.Sprintf("failed to restore cache from file: %s", err.Error()))
-	}
+    fmt.Println("Cache size before restoring cache from file:", cache.Count())
+    _, err = cache.ReadFromFile("cache.bak")
+    if err != nil {
+        panic(fmt.Sprintf("failed to restore cache from file: %s", err.Error()))
+    }
 
-	fmt.Println("Cache size after restoring cache from file:", cache.Count())
-	cache.Clear()
-	fmt.Println("Cache size after clearing the cache:", cache.Count())
+    fmt.Println("Cache size after restoring cache from file:", cache.Count())
+    cache.Clear()
+    fmt.Println("Cache size after clearing the cache:", cache.Count())
 }
 ```
 
@@ -215,8 +221,8 @@ While you can cache structs in memory out of the box, persisting structs to a fi
 
 ```go
 type YourCustomStruct struct {
-	A string
-	B int
+    A string
+    B int
 }
 
 // ...
@@ -251,6 +257,13 @@ every key that cannot be parsed are not populated into the cache by `ReadFromFil
 In other words, if you're falling back to a database or something similar when the cache doesn't have the key requested,
 you'll be fine.
 
+Note that if you need to modify the type of a variable in a struct, you should change the name of that variable as well.
+For instance, if the struct has a `CreatedAt` variable with the type `time.Time` and that variable type is later
+modified to `uint64`, decoding the struct would fail, however, if you rename the variable to `CreatedAtUnixTimeInMs`,
+there won't be any decoding issues other than the loss of data for that field. You could also obviously handle the 
+migration gracefully by keeping both variables, populating the `CreatedAtUnixTimeInMs` variable with the `CreatedAt`
+value and then removing the `CreatedAt` field.
+
 
 ## Eviction
 
@@ -303,31 +316,37 @@ If you do not start the janitor, there will be no passive deletion of expired ke
 
 
 ## Server
-For the sake of convenience, a ready-to-go cache server is available 
-through the `gocacheserver` package. 
-
-The reason why the server is in a different package is because `gocache` 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. 
+For the sake of convenience, a ready-to-go cache server is available through the `server` package.
 
+#### As an application
 ```go
 package main
 
 import (
-	"github.com/TwinProduction/gocache"
-	"github.com/TwinProduction/gocache/gocacheserver"
+    "github.com/TwinProduction/gocache"
+    gocacheserver "github.com/TwinProduction/gocache/server"
 )
 
 func main() {
-	cache := gocache.NewCache().WithEvictionPolicy(gocache.LeastRecentlyUsed).WithMaxSize(100000)
-	server := gocacheserver.NewServer(cache).WithPort(6379)
-	server.Start()
+    cache := gocache.NewCache().WithEvictionPolicy(gocache.LeastRecentlyUsed).WithMaxSize(100000)
+    server := gocacheserver.NewServer(cache).WithPort(6379)
+    // This is a blocking function, therefore, you are expected to run this on a goroutine
+    server.Start()
 }
 ```
 
+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 `server` package.
+
+If you'd like to run it through the CLI:
+```
+go run cmd/server/main.go
+```
+
 Any Redis client should be able to interact with the server, though only the following instructions are supported:
 - [X] GET
 - [X] SET
@@ -350,14 +369,12 @@ Any Redis client should be able to interact with the server, though only the fol
 ## Running the server with Docker
 [![Docker pulls](https://img.shields.io/docker/pulls/twinproduction/gocache-server.svg)](https://cloud.docker.com/repository/docker/twinproduction/gocache-server)
 
-To build it locally, refer to the Makefile's `docker-build` and `docker-run` steps.
-
-Note that the server version of gocache is still under development.
-
 ```
 docker run --name gocache-server -p 6379:6379 twinproduction/gocache-server
 ```
 
+To build it locally, refer to the Makefile's `docker-build` and `docker-run` steps.
+
 
 ## Performance
 
@@ -448,9 +465,96 @@ WithForceNilInterfaceOnNilPointerWithConcurrency/false-8
 
 ## FAQ
 
+### How can I persist the data on application termination?
+
+Because this library doesn't persist immediately after every write operations, persistence is instead expected to be
+done on a schedule, like for instance, every 10 minutes.
+
+While this prevents you from losing all of your data, you may still lose some data if the application stopped 9 minutes
+after the previous "auto save".
+
+To increase your odds of not losing any data, you can use Go's `signal` package, more specifically its `Notify` function
+which allows listening for termination signals like SIGTERM and SIGINT. Once a termination signal is caught, you can
+add the necessary logic for a graceful shutdown.
+
+In the following example, the code that would usually be present in the `main` function is moved to a different function
+named `Start` which is launched on a different goroutine so that listening for a termination signals is what blocks the
+main goroutine instead:
+
+```go
+package main
+
+import (
+    "log"
+    "os"
+    "os/signal"
+    "syscall"
+
+    "github.com/TwinProduction/gocache"
+)
+
+const CacheFile = "gocache.data"
+
+var cache = gocache.NewCache()
+
+func main() {
+    // Load persisted data from file
+    cache.ReadFromFile(CacheFile)
+    // Start everything else on another goroutine to prevent blocking the main goroutine
+    go Start()
+    // 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")
+        err := cache.SaveToFile(CacheFile)
+        if err != nil {
+            log.Println("Failed to save storage provider:", err.Error())
+        }
+        done <- true
+    }()
+    <-done
+    log.Println("Shutting down")
+}
+```
+
+Note that this won't protect you from a SIGKILL, as this signal cannot be caught.
+
+
+### How can I automatically save the cache to a file every 5 minutes?
+
+Beside using the suggestion above, automatically persisting the cache on an interval will protect your application from
+sudden terminations triggered by signals that cannot be caught, such as the force kill signal received by an application
+being OOMKilled.
+
+The simplest implementation could be something like this:
+```go
+const CacheFile = "gocache.data"
+
+func main() {
+    cache := gocache.NewCache()
+    cache.ReadFromFile(CacheFile)
+    go autoSave(10*time.Minute)
+    // ...
+}
+
+func autoSave(interval time.Duration) {
+    for {
+        err := cache.SaveToFile(CacheFile)
+        if err != nil {
+            log.Println("Failed to persist cache to file:", err.Error())
+        }
+        time.Sleep(interval)
+    }
+}
+```
+
+
 ### Why does the memory usage not go down?
 
-> **NOTE**: As of Go 1.16, this will no longer apply. See [golang/go#42330](https://github.com/golang/go/issues/42330)
+> **NOTE**: As of Go 1.16, this no longer applies. See [golang/go#42330](https://github.com/golang/go/issues/42330)
 
 By default, Go uses `MADV_FREE` if the kernel supports it to release memory, which is significantly more efficient 
 than using `MADV_DONTNEED`. Unfortunately, this means that RSS doesn't go down unless the OS actually needs the 
@@ -463,7 +567,7 @@ notice the memory usage lowering.
 [reference](https://github.com/golang/go/issues/33376#issuecomment-666455792)
 
 You can reproduce this by following the steps below:
-- Start gocacheserver
+- Start the server
 - Note the memory usage
 - Create 500k keys
 - Note the memory usage

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

@@ -1,6 +1,6 @@
 module github.com/TwinProduction/gocache
 
-go 1.15
+go 1.16
 
 require (
 	github.com/go-redis/redis v6.15.9+incompatible

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

@@ -9,11 +9,9 @@ github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:x
 github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
 github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
 github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
@@ -55,9 +53,7 @@ google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
 google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
 google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-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/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=