feat: Set minimum interval for endpoints with [DOMAIN_EXPIRATION] to 5m

chore: Fix typo in deprecation message
docs(security): Link "Securing Gatus with OIDC using Auth0" article
2026-08-22 07:06:04 +00:00 · 2022-09-15 21:23:14 -04:00 · 2022-09-15 17:41:24 -04:00 · 2022-09-09 22:59:13 -04:00 · 2022-09-09 22:58:45 -04:00 · 2022-09-07 19:02:30 -04:00
68 changed files with 4861 additions and 3050 deletions
@@ -0,0 +1,28 @@
+name: publish-experimental
+on: [workflow_dispatch]
+jobs:
+  publish-experimental:
+    name: publish-experimental
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v3
+      - name: Get image repository
+        run: echo IMAGE_REPOSITORY=$(echo ${{ secrets.DOCKER_USERNAME }}/${{ github.event.repository.name }} | 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@v2
+        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 }}:experimental
@@ -9,7 +9,7 @@ jobs:
    name: publish-latest
    runs-on: ubuntu-latest
    if: ${{ github.event.workflow_run.conclusion == 'success' }}
-    timeout-minutes: 45
+    timeout-minutes: 60
    steps:
      - uses: actions/checkout@v3
      - name: Get image repository
@@ -19,7 +19,7 @@ jobs:
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1
      - name: Login to Docker Registry
-        uses: docker/login-action@v1
+        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
@@ -6,7 +6,7 @@ jobs:
  publish-release:
    name: publish-release
    runs-on: ubuntu-latest
-    timeout-minutes: 45
+    timeout-minutes: 60
    steps:
      - uses: actions/checkout@v3
      - name: Get image repository
@@ -18,7 +18,7 @@ jobs:
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1
      - name: Login to Docker Registry
-        uses: docker/login-action@v1
+        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
@@ -186,7 +186,7 @@
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

-   Copyright 2021 TwiN
+   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -26,7 +26,7 @@ For more details, see [Usage](#usage)

 ![Gatus dashboard conditions](.github/assets/dashboard-conditions.png)

-Have any feedback or want to share your good/bad experience with Gatus? Feel free to email me at [feedback@gatus.io](mailto:feedback@gatus.io)
+Have any feedback or questions? [Create a discussion](https://github.com/TwiN/gatus/discussions/new).

 ## Table of Contents
 - [Why Gatus?](#why-gatus)
@@ -42,6 +42,7 @@ Have any feedback or want to share your good/bad experience with Gatus? Feel fre
    - [Configuring Discord alerts](#configuring-discord-alerts)
    - [Configuring Email alerts](#configuring-email-alerts)
    - [Configuring Google Chat alerts](#configuring-google-chat-alerts)
+    - [Configuring Matrix alerts](#configuring-matrix-alerts)
    - [Configuring Mattermost alerts](#configuring-mattermost-alerts)
    - [Configuring Messagebird alerts](#configuring-messagebird-alerts)
    - [Configuring Opsgenie alerts](#configuring-opsgenie-alerts)
@@ -55,8 +56,9 @@ Have any feedback or want to share your good/bad experience with Gatus? Feel fre
  - [Maintenance](#maintenance)
  - [Security](#security)
    - [Basic](#basic)
-    - [OIDC (ALPHA)](#oidc-alpha)
+    - [OIDC](#oidc)
  - [Metrics](#metrics)
+  - [Remote instances (EXPERIMENTAL)](#remote-instances-experimental)
 - [Deployment](#deployment)
  - [Docker](#docker)
  - [Helm Chart](#helm-chart)
@@ -72,6 +74,7 @@ Have any feedback or want to share your good/bad experience with Gatus? Feel fre
  - [Monitoring an endpoint using DNS queries](#monitoring-an-endpoint-using-dns-queries)
  - [Monitoring an endpoint using STARTTLS](#monitoring-an-endpoint-using-starttls)
  - [Monitoring an endpoint using TLS](#monitoring-an-endpoint-using-tls)
+  - [Monitoring domain expiration](#monitoring-domain-expiration)
  - [disable-monitoring-lock](#disable-monitoring-lock)
  - [Reloading configuration on the fly](#reloading-configuration-on-the-fly)
  - [Endpoint groups](#endpoint-groups)
@@ -177,6 +180,7 @@ If you want to test it locally, see [Docker](#docker).
 | `endpoints[].ui.hide-hostname`                  | Whether to hide the hostname in the result.                                                                                                        | `false`                    |
 | `endpoints[].ui.hide-url`                       | Whether to ensure the URL is not displayed in the results. Useful if the URL contains a token.                                                     | `false`                    |
 | `endpoints[].ui.dont-resolve-failed-conditions` | Whether to resolve failed conditions for the UI.                                                                                                   | `false`                    |
+| `endpoints[].ui.badge.reponse-time`             | List of response time thresholds. Each time a threshold is reached, the badge has a different color.                                               | `[50, 200, 300, 500, 750]` |
 | `alerting`                                      | [Alerting configuration](#alerting).                                                                                                               | `{}`                       |
 | `security`                                      | [Security configuration](#security).                                                                                                               | `{}`                       |
 | `disable-monitoring-lock`                       | Whether to [disable the monitoring lock](#disable-monitoring-lock).                                                                                | `false`                    |
@@ -219,18 +223,20 @@ Here are some examples of conditions you can use:
 | `[BODY].name == pat(john*)`      | String at JSONPath `$.name` matches pattern `john*` | `{"name":"john.doe"}`      | `{"name":"bob"}` |
 | `[BODY].id == any(1, 2)`         | Value at JSONPath `$.id` is equal to `1` or `2`     | 1, 2                       | 3, 4, 5          |
 | `[CERTIFICATE_EXPIRATION] > 48h` | Certificate expiration is more than 48h away        | 49h, 50h, 123h             | 1h, 24h, ...     |
+| `[DOMAIN_EXPIRATION] > 720h`     | The domain must expire in more than 720h            | 4000h                      | 1h, 24h, ...     |


 #### Placeholders
 | Placeholder                | Description                                                                               | Example of resolved value                    |
 |:---------------------------|:------------------------------------------------------------------------------------------|:---------------------------------------------|
-| `[STATUS]`                 | Resolves into the HTTP status of the request                                              | 404                                          |
-| `[RESPONSE_TIME]`          | Resolves into the response time the request took, in ms                                   | 10                                           |
-| `[IP]`                     | Resolves into the IP of the target host                                                   | 192.168.0.232                                |
+| `[STATUS]`                 | Resolves into the HTTP status of the request                                              | `404`                                        |
+| `[RESPONSE_TIME]`          | Resolves into the response time the request took, in ms                                   | `10`                                         |
+| `[IP]`                     | Resolves into the IP of the target host                                                   | `192.168.0.232`                              |
 | `[BODY]`                   | Resolves into the response body. Supports JSONPath.                                       | `{"name":"john.doe"}`                        |
 | `[CONNECTED]`              | Resolves into whether a connection could be established                                   | `true`                                       |
 | `[CERTIFICATE_EXPIRATION]` | Resolves into the duration before certificate expiration (valid units are "s", "m", "h".) | `24h`, `48h`, 0 (if not protocol with certs) |
-| `[DNS_RCODE]`              | Resolves into the DNS status of the response                                              | NOERROR                                      |
+| `[DOMAIN_EXPIRATION]`      | Resolves into the duration before the domain expires (valid units are "s", "m", "h".)     | `24h`, `48h`, `1234h56m78s`                  |
+| `[DNS_RCODE]`              | Resolves into the DNS status of the response                                              | `NOERROR`                                    |


 #### Functions
@@ -245,11 +251,12 @@ Here are some examples of conditions you can use:


 ### Storage
-| Parameter      | Description                                                                    | Default    |
-|:---------------|:-------------------------------------------------------------------------------|:-----------|
-| `storage`      | Storage configuration                                                          | `{}`       |
-| `storage.path` | Path to persist the data in. Only supported for types `sqlite` and `postgres`. | `""`       |
-| `storage.type` | Type of storage. Valid types: `memory`, `sqlite`, `postgres`.                  | `"memory"` |
+| Parameter         | Description                                                                                                                                        | Default    |
+|:------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------|:-----------|
+| `storage`         | Storage configuration                                                                                                                              | `{}`       |
+| `storage.path`    | Path to persist the data in. Only supported for types `sqlite` and `postgres`.                                                                     | `""`       |
+| `storage.type`    | Type of storage. Valid types: `memory`, `sqlite`, `postgres`.                                                                                      | `"memory"` |
+| `storage.caching` | Whether to use write-through caching. Improves loading time for large dashboards. <br />Only supported if `storage.type` is `sqlite` or `postgres` | `false`    |

 - If `storage.type` is `memory` (default):
 ```yaml
@@ -276,7 +283,7 @@ See [examples/docker-compose-postgres-storage](.examples/docker-compose-postgres


 ### Client configuration
-In order to support a wide range of environments, each monitored endpoint has a unique configuration for 
+In order to support a wide range of environments, each monitored endpoint has a unique configuration for
 the client used to send the request.

 | Parameter                     | Description                                                                | Default         |
@@ -377,7 +384,7 @@ ignored.

 ```yaml
 alerting:
-  discord: 
+  discord:
    webhook-url: "https://discord.com/api/webhooks/**********/**********"

 endpoints:
@@ -420,7 +427,7 @@ alerting:
    host: "mail.example.com"
    port: 587
    to: "recipient1@example.com,recipient2@example.com"
-    # You can also add group-specific to keys, which will 
+    # You can also add group-specific to keys, which will
    # override the to key above for the specified groups
    overrides:
      - group: "core"
@@ -470,7 +477,7 @@ endpoints:

 ```yaml
 alerting:
-  googlechat: 
+  googlechat:
    webhook-url: "https://chat.googleapis.com/v1/spaces/*******/messages?key=**********&token=********"

 endpoints:
@@ -488,6 +495,37 @@ endpoints:
        send-on-resolved: true
 ```

+#### Configuring Matrix alerts
+| Parameter                          | Description                                                                                      | Default                            |
+|:-----------------------------------|:-------------------------------------------------------------------------------------------------|:-----------------------------------|
+| `alerting.matrix`                  | Settings for alerts of type `matrix`                                                             | `{}`                               |
+| `alerting.matrix.server-url`       | Homeserver URL                                                                                   | `https://matrix-client.matrix.org` |
+| `alerting.matrix.access-token`     | Bot user access token (see https://webapps.stackexchange.com/q/131056)                           | Required `""`                      |
+| `alerting.matrix.internal-room-id` | Internal room ID of room to send alerts to (can be found in Element in Room Settings > Advanced) | Required `""`                      |
+| `alerting.matrix.default-alert`    | Default alert configuration. <br />See [Setting a default alert](#setting-a-default-alert)       | N/A                                |
+
+```yaml
+alerting:
+  matrix:
+    server-url: "..."
+    access-token: "..."
+    internal-room-id: "..."
+
+endpoints:
+  - name: website
+    interval: 30s
+    url: "https://twin.sh/health"
+    conditions:
+      - "[STATUS] == 200"
+      - "[BODY].status == UP"
+      - "[RESPONSE_TIME] < 300"
+    alerts:
+      - type: matrix
+        enabled: true
+        send-on-resolved: true
+        description: "healthcheck failed"
+```
+
 #### Configuring Mattermost alerts
 | Parameter                                     | Description                                                                                 | Default       |
 |:----------------------------------------------|:--------------------------------------------------------------------------------------------|:--------------|
@@ -501,7 +539,7 @@ endpoints:

 ```yaml
 alerting:
-  mattermost: 
+  mattermost:
    webhook-url: "http://**********/hooks/**********"
    client:
      insecure: true
@@ -601,9 +639,9 @@ Behavior:

 ```yaml
 alerting:
-  pagerduty: 
+  pagerduty:
    integration-key: "********************************"
-    # You can also add group-specific integration keys, which will 
+    # You can also add group-specific integration keys, which will
    # override the integration key above for the specified groups
    overrides:
      - group: "core"
@@ -653,7 +691,7 @@ endpoints:
 | `alerting.slack.overrides[].webhook-url`  | Slack Webhook URL                                                                          | `""`          |
 ```yaml
 alerting:
-  slack: 
+  slack:
    webhook-url: "https://hooks.slack.com/services/**********/**********/**********"

 endpoints:
@@ -696,7 +734,7 @@ Here's an example of what the notifications look like:
 alerting:
  teams:
    webhook-url: "https://********.webhook.office.com/webhookb2/************"
-    # You can also add group-specific to keys, which will 
+    # You can also add group-specific to keys, which will
    # override the to key above for the specified groups
    overrides:
      - group: "core"
@@ -741,11 +779,12 @@ Here's an example of what the notifications look like:
 | `alerting.telegram.token`         | Telegram Bot Token                                                                         | Required `""`              |
 | `alerting.telegram.id`            | Telegram User ID                                                                           | Required `""`              |
 | `alerting.telegram.api-url`       | Telegram API URL                                                                           | `https://api.telegram.org` |
+| `alerting.telegram.client`        | Client configuration. <br />See [Client configuration](#client-configuration).             | `{}`                       |
 | `alerting.telegram.default-alert` | Default alert configuration. <br />See [Setting a default alert](#setting-a-default-alert) | N/A                        |

 ```yaml
 alerting:
-  telegram: 
+  telegram:
    token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"
    id: "0123456789"

@@ -801,7 +840,6 @@ endpoints:
        description: "healthcheck failed"
 ```

-
 #### Configuring custom alerts
 | Parameter                       | Description                                                                                | Default       |
 |:--------------------------------|:-------------------------------------------------------------------------------------------|:--------------|
@@ -813,9 +851,9 @@ endpoints:
 | `alerting.custom.client`        | Client configuration. <br />See [Client configuration](#client-configuration).             | `{}`          |
 | `alerting.custom.default-alert` | Default alert configuration. <br />See [Setting a default alert](#setting-a-default-alert) | N/A           |

-While they're called alerts, you can use this feature to call anything. 
+While they're called alerts, you can use this feature to call anything.

-For instance, you could automate rollbacks by having an application that keeps tracks of new deployments, and by 
+For instance, you could automate rollbacks by having an application that keeps tracks of new deployments, and by
 leveraging Gatus, you could have Gatus call that application endpoint when an endpoint starts failing. Your application
 would then check if the endpoint that started failing was part of the recently deployed application, and if it was,
 then automatically roll it back.
@@ -827,7 +865,7 @@ Furthermore, you may use the following placeholders in the body (`alerting.custo
 - `[ENDPOINT_URL]` (resolved from `endpoints[].url`)

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

@@ -867,7 +905,7 @@ alerting:
        TRIGGERED: "partial_outage"
        RESOLVED: "operational"
 ```
-As a result, the `[ALERT_TRIGGERED_OR_RESOLVED]` in the body of first example of this section would be replaced by 
+As a result, the `[ALERT_TRIGGERED_OR_RESOLVED]` in the body of first example of this section would be replaced by
 `partial_outage` when an alert is triggered and `operational` when an alert is resolved.


@@ -886,7 +924,7 @@ long configuration file.
 To avoid such problem, you can use the `default-alert` parameter present in each provider configuration:
 ```yaml
 alerting:
-  slack: 
+  slack:
    webhook-url: "https://hooks.slack.com/services/**********/**********/**********"
    default-alert:
      enabled: true
@@ -963,7 +1001,7 @@ endpoints:
 ```

 ### Maintenance
-If you have maintenance windows, you may not want to be annoyed by alerts. 
+If you have maintenance windows, you may not want to be annoyed by alerts.
 To do that, you'll have to use the maintenance configuration:

 | Parameter              | Description                                                                                                                            | Default       |
@@ -1018,7 +1056,7 @@ security:
 **WARNING:** Make sure to carefully select to cost of the bcrypt hash. The higher the cost, the longer it takes to compute the hash,
 and basic auth verifies the password against the hash on every request. As of 2022-01-08, I suggest a cost of 8.

-#### OIDC (ALPHA)
+#### OIDC
 | Parameter                        | Description                                                    | Default       |
 |:---------------------------------|:---------------------------------------------------------------|:--------------|
 | `security.oidc`                  | OpenID Connect configuration                                   | `{}`          |
@@ -1041,7 +1079,7 @@ security:
    #allowed-subjects: ["johndoe@example.com"]
 ```

-**NOTE:** The OIDC feature is currently in Alpha. Breaking changes may occur. Use this feature at your own risk.
+Confused? Read [Securing Gatus with OIDC using Auth0](https://twin.sh/articles/56/securing-gatus-with-oidc-using-auth0).


 ### Metrics
@@ -1059,6 +1097,32 @@ endpoint on the same port your application is configured to run on (`web.port`).
 See [examples/docker-compose-grafana-prometheus](.examples/docker-compose-grafana-prometheus) for further documentation as well as an example.


+### Remote instances (EXPERIMENTAL)
+This feature allows you to retrieve endpoint statuses from a remote Gatus instance.
+
+There are two main use cases for this:
+- You have multiple Gatus instances running on different machines, and you wish to visually expose the statuses through a single dashboard
+- You have one or more Gatus instances that are not publicly accessible (e.g. behind a firewall), and you wish to retrieve 
+
+This is an experimental feature. It may be removed or updated in a breaking manner at any time. Furthermore,
+there are known issues with this feature. If you'd like to provide some feedback, please write a comment in [#64](https://github.com/TwiN/gatus/issues/64).
+Use at your own risk.
+
+| Parameter                          | Description                                  | Default        |
+|:-----------------------------------|:---------------------------------------------|:---------------|
+| `remote`                           | Remote configuration                         | `{}`           |
+| `remote.instances`                 | List of remote instances                     | Required `[]`  |
+| `remote.instances.endpoint-prefix` | String to prefix all endpoint names with     | `""`           |
+| `remote.instances.url`             | URL from which to retrieve endpoint statuses | Required `""`  |
+
+```yaml
+remote:
+  instances:
+    - endpoint-prefix: "status.example.org-"
+      url: "https://status.example.org/api/v1/endpoints/statuses"
+```
+
+
 ## Deployment
 Many examples can be found in the [.examples](.examples) folder, but this section will focus on the most popular ways of deploying Gatus.

@@ -1069,8 +1133,8 @@ 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](.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 
+Other than using one of the examples provided in the [.examples](.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
 command:
 ```console
 docker run -p 8080:8080 --mount type=bind,source="$(pwd)"/config.yaml,target=/config/config.yaml --name gatus twinproduction/gatus
@@ -1154,26 +1218,26 @@ will send a `POST` request to `http://localhost:8080/playground` with the follow
 To ensure that Gatus provides reliable and accurate results (i.e. response time), Gatus only evaluates one endpoint at a time
 In other words, even if you have multiple endpoints with the same interval, they will not execute at the same time.

-You can test this yourself by running Gatus with several endpoints configured with a very short, unrealistic interval, 
+You can test this yourself by running Gatus with several endpoints configured with a very short, unrealistic interval,
 such as 1ms. You'll notice that the response time does not fluctuate - that is because while endpoints are evaluated on
 different goroutines, there's a global lock that prevents multiple endpoints from running at the same time.

-Unfortunately, there is a drawback. If you have a lot of endpoints, including some that are very slow or prone to timing out 
+Unfortunately, there is a drawback. If you have a lot of endpoints, including some that are very slow or prone to timing out
 (the default timeout is 10s), then it means that for the entire duration of the request, no other endpoint can be evaluated.

-The interval does not include the duration of the request itself, which means that if an endpoint has an interval of 30s 
-and the request takes 2s to complete, the timestamp between two evaluations will be 32s, not 30s. 
+The interval does not include the duration of the request itself, which means that if an endpoint has an interval of 30s
+and the request takes 2s to complete, the timestamp between two evaluations will be 32s, not 30s.

-While this does not prevent Gatus' from performing health checks on all other endpoints, it may cause Gatus to be unable 
+While this does not prevent Gatus' from performing health checks on all other endpoints, it may cause Gatus to be unable
 to respect the configured interval, for instance:
- Endpoint A has an interval of 5s, and times out after 10s to complete 
+- Endpoint A has an interval of 5s, and times out after 10s to complete
 - Endpoint B has an interval of 5s, and takes 1ms to complete
 - Endpoint B will be unable to run every 5s, because endpoint A's health evaluation takes longer than its interval

-To sum it up, while Gatus can handle any interval you throw at it, you're better off having slow requests with 
+To sum it up, while Gatus can handle any interval you throw at it, you're better off having slow requests with
 higher interval.

-As a rule of thumb, I personally set the interval for more complex health checks to `5m` (5 minutes) and 
+As a rule of thumb, I personally set the interval for more complex health checks to `5m` (5 minutes) and
 simple health checks used for alerting (PagerDuty/Twilio) to `30s`.


@@ -1199,18 +1263,18 @@ endpoints:
      - "[CONNECTED] == true"
 ```

-Placeholders `[STATUS]` and `[BODY]` as well as the fields `endpoints[].body`, `endpoints[].headers`, 
+Placeholders `[STATUS]` and `[BODY]` as well as the fields `endpoints[].body`, `endpoints[].headers`,
 `endpoints[].method` and `endpoints[].graphql` are not supported for TCP endpoints.

 This works for applications such as databases (Postgres, MySQL, etc.) and caches (Redis, Memcached, etc.).

-**NOTE**: `[CONNECTED] == true` does not guarantee that the endpoint itself is healthy - it only guarantees that there's 
-something at the given address listening to the given port, and that a connection to that address was successfully 
+**NOTE**: `[CONNECTED] == true` does not guarantee that the endpoint itself is healthy - it only guarantees that there's
+something at the given address listening to the given port, and that a connection to that address was successfully
 established.


 ### Monitoring an endpoint using ICMP
-By prefixing `endpoints[].url` with `icmp:\\`, you can monitor endpoints at a very basic level using ICMP, or more 
+By prefixing `endpoints[].url` with `icmp:\\`, you can monitor endpoints at a very basic level using ICMP, or more
 commonly known as "ping" or "echo":

 ```yaml
@@ -1242,12 +1306,12 @@ endpoints:

 There are two placeholders that can be used in the conditions for endpoints of type DNS:
 - The placeholder `[BODY]` resolves to the output of the query. For instance, a query of type `A` would return an IPv4.
- The placeholder `[DNS_RCODE]` resolves to the name associated to the response code returned by the query, such as 
+- The placeholder `[DNS_RCODE]` resolves to the name associated to the response code returned by the query, such as
 `NOERROR`, `FORMERR`, `SERVFAIL`, `NXDOMAIN`, etc.


 ### Monitoring an endpoint using STARTTLS
-If you have an email server that you want to ensure there are no problems with, monitoring it through 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
 endpoints:
@@ -1277,14 +1341,33 @@ endpoints:
 ```


+### Monitoring domain expiration
+You can monitor the expiration of a domain with all endpoint types except for DNS by using the `[DOMAIN_EXPIRATION]`
+placeholder:
+```yaml
+endpoints:
+  - name: check-domain-and-certificate-expiration
+    url: "https://example.org"
+    interval: 1h
+    conditions:
+      - "[DOMAIN_EXPIRATION] > 720h"
+      - "[CERTIFICATE_EXPIRATION] > 240h"
+```
+
+**NOTE**: The usage of the `[DOMAIN_EXPIRATION]` placeholder requires Gatus to send a request to the official IANA WHOIS service [through a library](https://github.com/TwiN/whois)
+and in some cases, a secondary request to a TLD-specific WHOIS server (e.g. `whois.nic.sh`). 
+To prevent the WHOIS service from throttling your IP address if you send too many requests, Gatus will prevent you from
+using the `[DOMAIN_EXPIRATION]` placeholder on an endpoint with an interval of less than `5m`.
+
+
 ### disable-monitoring-lock
 Setting `disable-monitoring-lock` to `true` means that multiple endpoints could be monitored at the same time.

-While this behavior wouldn't generally be harmful, conditions using the `[RESPONSE_TIME]` placeholder could be impacted 
+While this behavior wouldn't generally be harmful, conditions using the `[RESPONSE_TIME]` placeholder could be impacted
 by the evaluation of multiple endpoints at the same time, therefore, the default value for this parameter is `false`.

 There are three main reasons why you might want to disable the monitoring lock:
- You're using Gatus for load testing (each endpoint are periodically evaluated on a different goroutine, so 
+- You're using Gatus for load testing (each endpoint are periodically evaluated on a different goroutine, so
 technically, if you create 100 endpoints with a 1 seconds interval, Gatus will send 100 requests per second)
 - You have a _lot_ of endpoints to monitor
 - You want to test multiple endpoints at very short intervals (< 5s)
@@ -1348,7 +1431,7 @@ endpoints:
    conditions:
      - "[STATUS] == 200"

-  - name: random endpoint that isn't part of a group
+  - name: random endpoint that is not part of a group
    url: "https://example.org/"
    interval: 5m
    conditions:
@@ -1374,6 +1457,7 @@ web:
  port: ${PORT}
 ```

+
 ### Badges
 #### Uptime
 ![Uptime 1h](https://status.twin.sh/api/v1/endpoints/core_blog-external/uptimes/1h/badge.svg)
@@ -1381,7 +1465,7 @@ web:
 ![Uptime 7d](https://status.twin.sh/api/v1/endpoints/core_blog-external/uptimes/7d/badge.svg)

 Gatus can automatically generate an SVG badge for one of your monitored endpoints.
-This allows you to put badges in your individual applications' README or even create your own status page if you 
+This allows you to put badges in your individual applications' README or even create your own status page if you
 desire.

 The path to generate a badge is the following:
@@ -1392,7 +1476,7 @@ Where:
 - `{duration}` is `7d`, `24h` or `1h`
 - `{key}` has the pattern `<GROUP_NAME>_<ENDPOINT_NAME>` in which both variables have ` `, `/`, `_`, `,` and `.` replaced by `-`.

-For instance, if you want the uptime during the last 24 hours from the endpoint `frontend` in the group `core`, 
+For instance, if you want the uptime during the last 24 hours from the endpoint `frontend` in the group `core`,
 the URL would look like this:
 ```
 https://example.com/api/v1/endpoints/core_frontend/uptimes/7d/badge.svg
@@ -1418,7 +1502,7 @@ The path to generate a badge is the following:
 Where:
 - `{key}` has the pattern `<GROUP_NAME>_<ENDPOINT_NAME>` in which both variables have ` `, `/`, `_`, `,` and `.` replaced by `-`.

-For instance, if you want the current status of the endpoint `frontend` in the group `core`, 
+For instance, if you want the current status of the endpoint `frontend` in the group `core`,
 the URL would look like this:
 ```
 https://example.com/api/v1/endpoints/core_frontend/health/badge.svg
@@ -1438,6 +1522,25 @@ Where:
 - `{duration}` is `7d`, `24h` or `1h`
 - `{key}` has the pattern `<GROUP_NAME>_<ENDPOINT_NAME>` in which both variables have ` `, `/`, `_`, `,` and `.` replaced by `-`.

+##### How to change the color thresholds of the response time badge  
+To change the response time badges' threshold, a corresponding configuration can be added to an endpoint.   
+The values in the array correspond to the levels [Awesome, Great, Good, Passable, Bad]  
+All five values must be given in milliseconds (ms).  
+
+```
+endpoints:
+- name: nas
+  group: internal
+  url: "https://example.org/"
+  interval: 5m
+  conditions:
+    - "[STATUS] == 200"
+  ui:
+    badge:
+      response-time:
+        thresholds: [550, 850, 1350, 1650, 1750]
+```
+

 ### API
 Gatus provides a simple read-only API that can be queried in order to programmatically determine endpoint status and history.
@@ -1456,7 +1559,7 @@ Example: https://status.twin.sh/api/v1/endpoints/core_blog-home/statuses

 Gzip compression will be used if the `Accept-Encoding` HTTP header contains `gzip`.

-The API will return a JSON payload with the `Content-Type` response header set to `application/json`. 
+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.


@@ -17,6 +17,9 @@ const (
 	// TypeGoogleChat is the Type for the googlechat alerting provider
 	TypeGoogleChat Type = "googlechat"

+	// TypeMatrix is the Type for the matrix alerting provider
+	TypeMatrix Type = "matrix"
+
 	// TypeMattermost is the Type for the mattermost alerting provider
 	TypeMattermost Type = "mattermost"

@@ -7,6 +7,7 @@ import (
 	"github.com/TwiN/gatus/v4/alerting/provider/discord"
 	"github.com/TwiN/gatus/v4/alerting/provider/email"
 	"github.com/TwiN/gatus/v4/alerting/provider/googlechat"
+	"github.com/TwiN/gatus/v4/alerting/provider/matrix"
 	"github.com/TwiN/gatus/v4/alerting/provider/mattermost"
 	"github.com/TwiN/gatus/v4/alerting/provider/messagebird"
 	"github.com/TwiN/gatus/v4/alerting/provider/opsgenie"
@@ -31,6 +32,9 @@ type Config struct {
 	// Email is the configuration for the email alerting provider
 	Email *email.AlertProvider `yaml:"email,omitempty"`

+	// Matrix is the configuration for the matrix alerting provider
+	Matrix *matrix.AlertProvider `yaml:"matrix,omitempty"`
+
 	// Mattermost is the configuration for the mattermost alerting provider
 	Mattermost *mattermost.AlertProvider `yaml:"mattermost,omitempty"`

@@ -83,6 +87,12 @@ func (config Config) GetAlertingProviderByAlertType(alertType alert.Type) provid
 			return nil
 		}
 		return config.GoogleChat
+	case alert.TypeMatrix:
+		if config.Matrix == nil {
+			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
+			return nil
+		}
+		return config.Matrix
 	case alert.TypeMattermost:
 		if config.Mattermost == nil {
 			// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
@@ -13,14 +13,24 @@ import (
 )

 func TestAlertProvider_IsValid(t *testing.T) {
-	invalidProvider := AlertProvider{URL: ""}
-	if invalidProvider.IsValid() {
-		t.Error("provider shouldn't have been valid")
-	}
-	validProvider := AlertProvider{URL: "https://example.com"}
-	if !validProvider.IsValid() {
-		t.Error("provider should've been valid")
-	}
+	t.Run("invalid-provider", func(t *testing.T) {
+		invalidProvider := AlertProvider{URL: ""}
+		if invalidProvider.IsValid() {
+			t.Error("provider shouldn't have been valid")
+		}
+	})
+	t.Run("valid-provider", func(t *testing.T) {
+		validProvider := AlertProvider{URL: "https://example.com"}
+		if validProvider.ClientConfig != nil {
+			t.Error("provider client config should have been nil prior to IsValid() being executed")
+		}
+		if !validProvider.IsValid() {
+			t.Error("provider should've been valid")
+		}
+		if validProvider.ClientConfig == nil {
+			t.Error("provider client config should have been set after IsValid() was executed")
+		}
+	})
 }

 func TestAlertProvider_Send(t *testing.T) {
@@ -0,0 +1,193 @@
+package matrix
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"math/rand"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+)
+
+// AlertProvider is the configuration necessary for sending an alert using Matrix
+type AlertProvider struct {
+	MatrixProviderConfig `yaml:",inline"`
+
+	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
+	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
+
+	// Overrides is a list of Override that may be prioritized over the default configuration
+	Overrides []Override `yaml:"overrides,omitempty"`
+}
+
+// Override is a case under which the default integration is overridden
+type Override struct {
+	Group string `yaml:"group"`
+
+	MatrixProviderConfig `yaml:",inline"`
+}
+
+const defaultHomeserverURL = "https://matrix-client.matrix.org"
+
+type MatrixProviderConfig struct {
+	// ServerURL is the custom homeserver to use (optional)
+	ServerURL string `yaml:"server-url"`
+
+	// AccessToken is the bot user's access token to send messages
+	AccessToken string `yaml:"access-token"`
+
+	// InternalRoomID is the room that the bot user has permissions to send messages to
+	InternalRoomID string `yaml:"internal-room-id"`
+}
+
+// IsValid returns whether the provider's configuration is valid
+func (provider *AlertProvider) IsValid() bool {
+	registeredGroups := make(map[string]bool)
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" || len(override.AccessToken) == 0 || len(override.InternalRoomID) == 0 {
+				return false
+			}
+			registeredGroups[override.Group] = true
+		}
+	}
+	return len(provider.AccessToken) > 0 && len(provider.InternalRoomID) > 0
+}
+
+// Send an alert using the provider
+func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) error {
+	buffer := bytes.NewBuffer([]byte(provider.buildRequestBody(endpoint, alert, result, resolved)))
+	config := provider.getConfigForGroup(endpoint.Group)
+	if config.ServerURL == "" {
+		config.ServerURL = defaultHomeserverURL
+	}
+	// The Matrix endpoint requires a unique transaction ID for each event sent
+	txnId := randStringBytes(24)
+	request, err := http.NewRequest(
+		http.MethodPut,
+		fmt.Sprintf("%s/_matrix/client/v3/rooms/%s/send/m.room.message/%s?access_token=%s",
+			config.ServerURL,
+			url.PathEscape(config.InternalRoomID),
+			txnId,
+			url.QueryEscape(config.AccessToken),
+		),
+		buffer,
+	)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := client.GetHTTPClient(nil).Do(request)
+	if err != nil {
+		return err
+	}
+	if response.StatusCode > 399 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(body))
+	}
+	return err
+}
+
+// buildRequestBody builds the request body for the provider
+func (provider *AlertProvider) buildRequestBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
+	return fmt.Sprintf(`{
+	"msgtype": "m.text",
+	"format": "org.matrix.custom.html",
+	"body": "%s",
+	"formatted_body": "%s"
+}`,
+		buildPlaintextMessageBody(endpoint, alert, result, resolved),
+		buildHTMLMessageBody(endpoint, alert, result, resolved),
+	)
+}
+
+// buildPlaintextMessageBody builds the message body in plaintext to include in request
+func buildPlaintextMessageBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
+	var message, results string
+	if resolved {
+		message = fmt.Sprintf("An alert for `%s` has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
+	} else {
+		message = fmt.Sprintf("An alert for `%s` has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
+	}
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = "✓"
+		} else {
+			prefix = "✕"
+		}
+		results += fmt.Sprintf("\\n%s - %s", prefix, conditionResult.Condition)
+	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = "\\n" + alertDescription
+	}
+	return fmt.Sprintf("%s%s\\n%s", message, description, results)
+}
+
+// buildHTMLMessageBody builds the message body in HTML to include in request
+func buildHTMLMessageBody(endpoint *core.Endpoint, alert *alert.Alert, result *core.Result, resolved bool) string {
+	var message, results string
+	if resolved {
+		message = fmt.Sprintf("An alert for <code>%s</code> has been resolved after passing successfully %d time(s) in a row", endpoint.DisplayName(), alert.SuccessThreshold)
+	} else {
+		message = fmt.Sprintf("An alert for <code>%s</code> has been triggered due to having failed %d time(s) in a row", endpoint.DisplayName(), alert.FailureThreshold)
+	}
+	for _, conditionResult := range result.ConditionResults {
+		var prefix string
+		if conditionResult.Success {
+			prefix = "✅"
+		} else {
+			prefix = "❌"
+		}
+		results += fmt.Sprintf("<li>%s - <code>%s</code></li>", prefix, conditionResult.Condition)
+	}
+	var description string
+	if alertDescription := alert.GetDescription(); len(alertDescription) > 0 {
+		description = fmt.Sprintf("\\n<blockquote>%s</blockquote>", alertDescription)
+	}
+	return fmt.Sprintf("<h3>%s</h3>%s\\n<h5>Condition results</h5><ul>%s</ul>", message, description, results)
+}
+
+// getConfigForGroup returns the appropriate configuration for a given group
+func (provider *AlertProvider) getConfigForGroup(group string) MatrixProviderConfig {
+	if provider.Overrides != nil {
+		for _, override := range provider.Overrides {
+			if group == override.Group {
+				return MatrixProviderConfig{
+					ServerURL:      override.ServerURL,
+					AccessToken:    override.AccessToken,
+					InternalRoomID: override.InternalRoomID,
+				}
+			}
+		}
+	}
+	return MatrixProviderConfig{
+		ServerURL:      provider.ServerURL,
+		AccessToken:    provider.AccessToken,
+		InternalRoomID: provider.InternalRoomID,
+	}
+}
+
+func randStringBytes(n int) string {
+	// All the compatible characters to use in a transaction ID
+	const availableCharacterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+
+	b := make([]byte, n)
+	rand.Seed(time.Now().UnixNano())
+	for i := range b {
+		b[i] = availableCharacterBytes[rand.Intn(len(availableCharacterBytes))]
+	}
+
+	return string(b)
+}
+
+// GetDefaultAlert returns the provider's default alert configuration
+func (provider AlertProvider) GetDefaultAlert() *alert.Alert {
+	return provider.DefaultAlert
+}
@@ -0,0 +1,331 @@
+package matrix
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/TwiN/gatus/v4/alerting/alert"
+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/test"
+)
+
+func TestAlertProvider_IsValid(t *testing.T) {
+	invalidProvider := AlertProvider{
+		MatrixProviderConfig: MatrixProviderConfig{
+			AccessToken:    "",
+			InternalRoomID: "",
+		},
+	}
+	if invalidProvider.IsValid() {
+		t.Error("provider shouldn't have been valid")
+	}
+	validProvider := AlertProvider{
+		MatrixProviderConfig: MatrixProviderConfig{
+			AccessToken:    "1",
+			InternalRoomID: "!a:example.com",
+		},
+	}
+	if !validProvider.IsValid() {
+		t.Error("provider should've been valid")
+	}
+	validProviderWithHomeserver := AlertProvider{
+		MatrixProviderConfig: MatrixProviderConfig{
+			ServerURL:      "https://example.com",
+			AccessToken:    "1",
+			InternalRoomID: "!a:example.com",
+		},
+	}
+	if !validProviderWithHomeserver.IsValid() {
+		t.Error("provider with homeserver should've been valid")
+	}
+}
+
+func TestAlertProvider_IsValidWithOverride(t *testing.T) {
+	providerWithInvalidOverrideGroup := AlertProvider{
+		Overrides: []Override{
+			{
+				Group: "",
+				MatrixProviderConfig: MatrixProviderConfig{
+					AccessToken:    "",
+					InternalRoomID: "",
+				},
+			},
+		},
+	}
+	if providerWithInvalidOverrideGroup.IsValid() {
+		t.Error("provider Group shouldn't have been valid")
+	}
+	providerWithInvalidOverrideTo := AlertProvider{
+		Overrides: []Override{
+			{
+				Group: "group",
+				MatrixProviderConfig: MatrixProviderConfig{
+					AccessToken:    "",
+					InternalRoomID: "",
+				},
+			},
+		},
+	}
+	if providerWithInvalidOverrideTo.IsValid() {
+		t.Error("provider integration key shouldn't have been valid")
+	}
+	providerWithValidOverride := AlertProvider{
+		MatrixProviderConfig: MatrixProviderConfig{
+			AccessToken:    "1",
+			InternalRoomID: "!a:example.com",
+		},
+		Overrides: []Override{
+			{
+				Group: "group",
+				MatrixProviderConfig: MatrixProviderConfig{
+					ServerURL:      "https://example.com",
+					AccessToken:    "1",
+					InternalRoomID: "!a:example.com",
+				},
+			},
+		},
+	}
+	if !providerWithValidOverride.IsValid() {
+		t.Error("provider should've been valid")
+	}
+}
+
+func TestAlertProvider_Send(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name             string
+		Provider         AlertProvider
+		Alert            alert.Alert
+		Resolved         bool
+		MockRoundTripper test.MockRoundTripper
+		ExpectedError    bool
+	}{
+		{
+			Name:     "triggered",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "triggered-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: false,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+		{
+			Name:     "resolved",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+			ExpectedError: false,
+		},
+		{
+			Name:     "resolved-error",
+			Provider: AlertProvider{},
+			Alert:    alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved: true,
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody}
+			}),
+			ExpectedError: true,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper})
+			err := scenario.Provider.Send(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if scenario.ExpectedError && err == nil {
+				t.Error("expected error, got none")
+			}
+			if !scenario.ExpectedError && err != nil {
+				t.Error("expected no error, got", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_buildRequestBody(t *testing.T) {
+	firstDescription := "description-1"
+	secondDescription := "description-2"
+	scenarios := []struct {
+		Name         string
+		Provider     AlertProvider
+		Alert        alert.Alert
+		Resolved     bool
+		ExpectedBody string
+	}{
+		{
+			Name:         "triggered",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     false,
+			ExpectedBody: "{\n\t\"msgtype\": \"m.text\",\n\t\"format\": \"org.matrix.custom.html\",\n\t\"body\": \"An alert for `endpoint-name` has been triggered due to having failed 3 time(s) in a row\\ndescription-1\\n\\n✕ - [CONNECTED] == true\\n✕ - [STATUS] == 200\",\n\t\"formatted_body\": \"<h3>An alert for <code>endpoint-name</code> has been triggered due to having failed 3 time(s) in a row</h3>\\n<blockquote>description-1</blockquote>\\n<h5>Condition results</h5><ul><li>❌ - <code>[CONNECTED] == true</code></li><li>❌ - <code>[STATUS] == 200</code></li></ul>\"\n}",
+		},
+		{
+			Name:         "resolved",
+			Provider:     AlertProvider{},
+			Alert:        alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3},
+			Resolved:     true,
+			ExpectedBody: "{\n\t\"msgtype\": \"m.text\",\n\t\"format\": \"org.matrix.custom.html\",\n\t\"body\": \"An alert for `endpoint-name` has been resolved after passing successfully 5 time(s) in a row\\ndescription-2\\n\\n✓ - [CONNECTED] == true\\n✓ - [STATUS] == 200\",\n\t\"formatted_body\": \"<h3>An alert for <code>endpoint-name</code> has been resolved after passing successfully 5 time(s) in a row</h3>\\n<blockquote>description-2</blockquote>\\n<h5>Condition results</h5><ul><li>✅ - <code>[CONNECTED] == true</code></li><li>✅ - <code>[STATUS] == 200</code></li></ul>\"\n}",
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			body := scenario.Provider.buildRequestBody(
+				&core.Endpoint{Name: "endpoint-name"},
+				&scenario.Alert,
+				&core.Result{
+					ConditionResults: []*core.ConditionResult{
+						{Condition: "[CONNECTED] == true", Success: scenario.Resolved},
+						{Condition: "[STATUS] == 200", Success: scenario.Resolved},
+					},
+				},
+				scenario.Resolved,
+			)
+			if body != scenario.ExpectedBody {
+				t.Errorf("expected %s, got %s", scenario.ExpectedBody, body)
+			}
+			out := make(map[string]interface{})
+			if err := json.Unmarshal([]byte(body), &out); err != nil {
+				t.Error("expected body to be valid JSON, got error:", err.Error())
+			}
+		})
+	}
+}
+
+func TestAlertProvider_GetDefaultAlert(t *testing.T) {
+	if (AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil {
+		t.Error("expected default alert to be not nil")
+	}
+	if (AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil {
+		t.Error("expected default alert to be nil")
+	}
+}
+
+func TestAlertProvider_getConfigForGroup(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Provider       AlertProvider
+		InputGroup     string
+		ExpectedOutput MatrixProviderConfig
+	}{
+		{
+			Name: "provider-no-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				MatrixProviderConfig: MatrixProviderConfig{
+					ServerURL:      "https://example.com",
+					AccessToken:    "1",
+					InternalRoomID: "!a:example.com",
+				},
+				Overrides: nil,
+			},
+			InputGroup: "",
+			ExpectedOutput: MatrixProviderConfig{
+				ServerURL:      "https://example.com",
+				AccessToken:    "1",
+				InternalRoomID: "!a:example.com",
+			},
+		},
+		{
+			Name: "provider-no-override-specify-group-should-default",
+			Provider: AlertProvider{
+				MatrixProviderConfig: MatrixProviderConfig{
+					ServerURL:      "https://example.com",
+					AccessToken:    "1",
+					InternalRoomID: "!a:example.com",
+				},
+				Overrides: nil,
+			},
+			InputGroup: "group",
+			ExpectedOutput: MatrixProviderConfig{
+				ServerURL:      "https://example.com",
+				AccessToken:    "1",
+				InternalRoomID: "!a:example.com",
+			},
+		},
+		{
+			Name: "provider-with-override-specify-no-group-should-default",
+			Provider: AlertProvider{
+				MatrixProviderConfig: MatrixProviderConfig{
+					ServerURL:      "https://example.com",
+					AccessToken:    "1",
+					InternalRoomID: "!a:example.com",
+				},
+				Overrides: []Override{
+					{
+						Group: "group",
+						MatrixProviderConfig: MatrixProviderConfig{
+							ServerURL:      "https://example01.com",
+							AccessToken:    "12",
+							InternalRoomID: "!a:example01.com",
+						},
+					},
+				},
+			},
+			InputGroup: "",
+			ExpectedOutput: MatrixProviderConfig{
+				ServerURL:      "https://example.com",
+				AccessToken:    "1",
+				InternalRoomID: "!a:example.com",
+			},
+		},
+		{
+			Name: "provider-with-override-specify-group-should-override",
+			Provider: AlertProvider{
+				MatrixProviderConfig: MatrixProviderConfig{
+					ServerURL:      "https://example.com",
+					AccessToken:    "1",
+					InternalRoomID: "!a:example.com",
+				},
+				Overrides: []Override{
+					{
+						Group: "group",
+						MatrixProviderConfig: MatrixProviderConfig{
+							ServerURL:      "https://example01.com",
+							AccessToken:    "12",
+							InternalRoomID: "!a:example01.com",
+						},
+					},
+				},
+			},
+			InputGroup: "group",
+			ExpectedOutput: MatrixProviderConfig{
+				ServerURL:      "https://example01.com",
+				AccessToken:    "12",
+				InternalRoomID: "!a:example01.com",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if got := tt.Provider.getConfigForGroup(tt.InputGroup); got != tt.ExpectedOutput {
+				t.Errorf("AlertProvider.getConfigForGroup() = %v, want %v", got, tt.ExpectedOutput)
+			}
+		})
+	}
+}
@@ -6,6 +6,7 @@ import (
 	"github.com/TwiN/gatus/v4/alerting/provider/discord"
 	"github.com/TwiN/gatus/v4/alerting/provider/email"
 	"github.com/TwiN/gatus/v4/alerting/provider/googlechat"
+	"github.com/TwiN/gatus/v4/alerting/provider/matrix"
 	"github.com/TwiN/gatus/v4/alerting/provider/mattermost"
 	"github.com/TwiN/gatus/v4/alerting/provider/messagebird"
 	"github.com/TwiN/gatus/v4/alerting/provider/opsgenie"
@@ -57,6 +58,7 @@ var (
 	_ AlertProvider = (*discord.AlertProvider)(nil)
 	_ AlertProvider = (*email.AlertProvider)(nil)
 	_ AlertProvider = (*googlechat.AlertProvider)(nil)
+	_ AlertProvider = (*matrix.AlertProvider)(nil)
 	_ AlertProvider = (*mattermost.AlertProvider)(nil)
 	_ AlertProvider = (*messagebird.AlertProvider)(nil)
 	_ AlertProvider = (*opsgenie.AlertProvider)(nil)
@@ -19,12 +19,18 @@ type AlertProvider struct {
 	ID     string `yaml:"id"`
 	APIURL string `yaml:"api-url"`

+	// ClientConfig is the configuration of the client used to communicate with the provider's target
+	ClientConfig *client.Config `yaml:"client,omitempty"`
+
 	// DefaultAlert is the default alert configuration to use for endpoints with an alert of the appropriate type
 	DefaultAlert *alert.Alert `yaml:"default-alert,omitempty"`
 }

 // IsValid returns whether the provider's configuration is valid
 func (provider *AlertProvider) IsValid() bool {
+	if provider.ClientConfig == nil {
+		provider.ClientConfig = client.GetDefaultConfig()
+	}
 	return len(provider.Token) > 0 && len(provider.ID) > 0
 }

@@ -40,7 +46,7 @@ func (provider *AlertProvider) Send(endpoint *core.Endpoint, alert *alert.Alert,
 		return err
 	}
 	request.Header.Set("Content-Type", "application/json")
-	response, err := client.GetHTTPClient(nil).Do(request)
+	response, err := client.GetHTTPClient(provider.ClientConfig).Do(request)
 	if err != nil {
 		return err
 	}
@@ -12,14 +12,24 @@ import (
 )

 func TestAlertProvider_IsValid(t *testing.T) {
-	invalidProvider := AlertProvider{Token: "", ID: ""}
-	if invalidProvider.IsValid() {
-		t.Error("provider shouldn't have been valid")
-	}
-	validProvider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}
-	if !validProvider.IsValid() {
-		t.Error("provider should've been valid")
-	}
+	t.Run("invalid-provider", func(t *testing.T) {
+		invalidProvider := AlertProvider{Token: "", ID: ""}
+		if invalidProvider.IsValid() {
+			t.Error("provider shouldn't have been valid")
+		}
+	})
+	t.Run("valid-provider", func(t *testing.T) {
+		validProvider := AlertProvider{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}
+		if validProvider.ClientConfig != nil {
+			t.Error("provider client config should have been nil prior to IsValid() being executed")
+		}
+		if !validProvider.IsValid() {
+			t.Error("provider should've been valid")
+		}
+		if validProvider.ClientConfig == nil {
+			t.Error("provider client config should have been set after IsValid() was executed")
+		}
+	})
 }

 func TestAlertProvider_Send(t *testing.T) {
@@ -17,7 +17,7 @@ import (
 // injectedHTTPClient is used for testing purposes
 var injectedHTTPClient *http.Client

-// GetHTTPClient returns the shared HTTP client
+// GetHTTPClient returns the shared HTTP client, or the client from the configuration passed
 func GetHTTPClient(config *Config) *http.Client {
 	if injectedHTTPClient != nil {
 		return injectedHTTPClient
@@ -45,3 +45,9 @@ endpoints:
    interval: 1m
    conditions:
      - "[CONNECTED] == true"
+
+  - name: check-domain-expiration
+    url: "https://example.org/"
+    interval: 1h
+    conditions:
+      - "[DOMAIN_EXPIRATION] > 720h"
@@ -2,6 +2,7 @@ package config

 import (
 	"errors"
+	"fmt"
 	"log"
 	"os"
 	"time"
@@ -10,11 +11,13 @@ import (
 	"github.com/TwiN/gatus/v4/alerting/alert"
 	"github.com/TwiN/gatus/v4/alerting/provider"
 	"github.com/TwiN/gatus/v4/config/maintenance"
+	"github.com/TwiN/gatus/v4/config/remote"
 	"github.com/TwiN/gatus/v4/config/ui"
 	"github.com/TwiN/gatus/v4/config/web"
 	"github.com/TwiN/gatus/v4/core"
 	"github.com/TwiN/gatus/v4/security"
 	"github.com/TwiN/gatus/v4/storage"
+	"github.com/TwiN/gatus/v4/util"
 	"gopkg.in/yaml.v2"
 )

@@ -85,10 +88,24 @@ type Config struct {
 	// Maintenance is the configuration for creating a maintenance window in which no alerts are sent
 	Maintenance *maintenance.Config `yaml:"maintenance,omitempty"`

+	// Remote is the configuration for remote Gatus instances
+	// WARNING: This is in ALPHA and may change or be completely removed in the future
+	Remote *remote.Config `yaml:"remote,omitempty"`
+
 	filePath        string    // path to the file from which config was loaded from
 	lastFileModTime time.Time // last modification time
 }

+func (config *Config) GetEndpointByKey(key string) *core.Endpoint {
+	for i := 0; i < len(config.Endpoints); i++ {
+		ep := config.Endpoints[i]
+		if util.ConvertGroupAndEndpointNameToKey(ep.Group, ep.Name) == key {
+			return ep
+		}
+	}
+	return nil
+}
+
 // HasLoadedConfigurationFileBeenModified returns whether the file that the
 // configuration has been loaded from has been modified since it was last read
 func (config Config) HasLoadedConfigurationFileBeenModified() bool {
@@ -185,10 +202,22 @@ func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
 		if err := validateStorageConfig(config); err != nil {
 			return nil, err
 		}
+		if err := validateRemoteConfig(config); err != nil {
+			return nil, err
+		}
 	}
 	return
 }

+func validateRemoteConfig(config *Config) error {
+	if config.Remote != nil {
+		if err := config.Remote.ValidateAndSetDefaults(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func validateStorageConfig(config *Config) error {
 	if config.Storage == nil {
 		config.Storage = &storage.Config{
@@ -239,7 +268,7 @@ func validateEndpointsConfig(config *Config) error {
 			log.Printf("[config][validateEndpointsConfig] Validating endpoint '%s'", endpoint.Name)
 		}
 		if err := endpoint.ValidateAndSetDefaults(); err != nil {
-			return err
+			return fmt.Errorf("invalid endpoint %s: %s", endpoint.DisplayName(), err)
 		}
 	}
 	log.Printf("[config][validateEndpointsConfig] Validated %d endpoints", len(config.Endpoints))
@@ -274,6 +303,7 @@ func validateAlertingConfig(alertingConfig *alerting.Config, endpoints []*core.E
 		alert.TypeCustom,
 		alert.TypeDiscord,
 		alert.TypeEmail,
+		alert.TypeMatrix,
 		alert.TypeMattermost,
 		alert.TypeMessagebird,
 		alert.TypeOpsgenie,
@@ -1125,7 +1125,7 @@ endpoints:
    conditions:
      - "[STATUS] == 200"
 `))
-	if err != core.ErrEndpointWithNoName {
+	if err == nil {
 		t.Error("should've returned an error")
 	}
 }
@@ -0,0 +1,39 @@
+package remote
+
+import (
+	"log"
+
+	"github.com/TwiN/gatus/v4/client"
+)
+
+// NOTICE: This is an experimental alpha feature and may be updated/removed in future versions.
+// For more information, see https://github.com/TwiN/gatus/issues/64
+
+type Config struct {
+	// Instances is a list of remote instances to retrieve endpoint statuses from.
+	Instances []Instance `yaml:"instances,omitempty"`
+
+	// ClientConfig is the configuration of the client used to communicate with the provider's target
+	ClientConfig *client.Config `yaml:"client,omitempty"`
+}
+
+type Instance struct {
+	EndpointPrefix string `yaml:"endpoint-prefix"`
+	URL            string `yaml:"url"`
+}
+
+func (c *Config) ValidateAndSetDefaults() error {
+	if c.ClientConfig == nil {
+		c.ClientConfig = client.GetDefaultConfig()
+	} else {
+		if err := c.ClientConfig.ValidateAndSetDefaults(); err != nil {
+			return err
+		}
+	}
+	if len(c.Instances) > 0 {
+		log.Println("WARNING: Your configuration is using 'remote', which is in alpha and may be updated/removed in future versions.")
+		log.Println("WARNING: See https://github.com/TwiN/gatus/issues/64 for more information")
+		log.Println("WARNING: This feature is a candidate for removal in future versions. Please comment on the issue above if you need this feature.")
+	}
+	return nil
+}
@@ -8,10 +8,9 @@ import (
 	"os"
 	"time"

+	"github.com/TwiN/gatus/v4/config"
 	"github.com/TwiN/gatus/v4/config/ui"
-	"github.com/TwiN/gatus/v4/config/web"
 	"github.com/TwiN/gatus/v4/controller/handler"
-	"github.com/TwiN/gatus/v4/security"
 )

 var (
@@ -21,19 +20,19 @@ var (
 )

 // Handle creates the router and starts the server
-func Handle(securityConfig *security.Config, webConfig *web.Config, uiConfig *ui.Config, enableMetrics bool) {
-	var router http.Handler = handler.CreateRouter(ui.StaticFolder, securityConfig, uiConfig, enableMetrics)
+func Handle(cfg *config.Config) {
+	var router http.Handler = handler.CreateRouter(ui.StaticFolder, cfg)
 	if os.Getenv("ENVIRONMENT") == "dev" {
 		router = handler.DevelopmentCORS(router)
 	}
 	server = &http.Server{
-		Addr:         fmt.Sprintf("%s:%d", webConfig.Address, webConfig.Port),
+		Addr:         fmt.Sprintf("%s:%d", cfg.Web.Address, cfg.Web.Port),
 		Handler:      router,
 		ReadTimeout:  15 * time.Second,
 		WriteTimeout: 15 * time.Second,
 		IdleTimeout:  15 * time.Second,
 	}
-	log.Println("[controller][Handle] Listening on " + webConfig.SocketAddress())
+	log.Println("[controller][Handle] Listening on " + cfg.Web.SocketAddress())
 	if os.Getenv("ROUTER_TEST") == "true" {
 		return
 	}
@@ -32,7 +32,7 @@ func TestHandle(t *testing.T) {
 	_ = os.Setenv("ROUTER_TEST", "true")
 	_ = os.Setenv("ENVIRONMENT", "dev")
 	defer os.Clearenv()
-	Handle(cfg.Security, cfg.Web, cfg.UI, cfg.Metrics)
+	Handle(cfg)
 	defer Shutdown()
 	request, _ := http.NewRequest("GET", "/health", http.NoBody)
 	responseRecorder := httptest.NewRecorder()
@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"

+	"github.com/TwiN/gatus/v4/config"
 	"github.com/TwiN/gatus/v4/storage/store"
 	"github.com/TwiN/gatus/v4/storage/store/common"
 	"github.com/TwiN/gatus/v4/storage/store/common/paging"
@@ -28,6 +29,10 @@ const (
 	HealthStatusUnknown = "?"
 )

+var (
+	badgeColors = []string{badgeColorHexAwesome, badgeColorHexGreat, badgeColorHexGood, badgeColorHexPassable, badgeColorHexBad}
+)
+
 // UptimeBadge handles the automatic generation of badge based on the group name and endpoint name passed.
 //
 // Valid values for {duration}: 7d, 24h, 1h
@@ -68,38 +73,40 @@ func UptimeBadge(writer http.ResponseWriter, request *http.Request) {
 // ResponseTimeBadge handles the automatic generation of badge based on the group name and endpoint name passed.
 //
 // Valid values for {duration}: 7d, 24h, 1h
-func ResponseTimeBadge(writer http.ResponseWriter, request *http.Request) {
-	variables := mux.Vars(request)
-	duration := variables["duration"]
-	var from time.Time
-	switch duration {
-	case "7d":
-		from = time.Now().Add(-7 * 24 * time.Hour)
-	case "24h":
-		from = time.Now().Add(-24 * time.Hour)
-	case "1h":
-		from = time.Now().Add(-2 * time.Hour) // Because response time metrics are stored by hour, we have to cheat a little
-	default:
-		http.Error(writer, "Durations supported: 7d, 24h, 1h", http.StatusBadRequest)
-		return
-	}
-	key := variables["key"]
-	averageResponseTime, err := store.Get().GetAverageResponseTimeByKey(key, from, time.Now())
-	if err != nil {
-		if err == common.ErrEndpointNotFound {
-			http.Error(writer, err.Error(), http.StatusNotFound)
-		} else if err == common.ErrInvalidTimeRange {
-			http.Error(writer, err.Error(), http.StatusBadRequest)
-		} else {
-			http.Error(writer, err.Error(), http.StatusInternalServerError)
+func ResponseTimeBadge(config *config.Config) http.HandlerFunc {
+	return func(writer http.ResponseWriter, request *http.Request) {
+		variables := mux.Vars(request)
+		duration := variables["duration"]
+		var from time.Time
+		switch duration {
+		case "7d":
+			from = time.Now().Add(-7 * 24 * time.Hour)
+		case "24h":
+			from = time.Now().Add(-24 * time.Hour)
+		case "1h":
+			from = time.Now().Add(-2 * time.Hour) // Because response time metrics are stored by hour, we have to cheat a little
+		default:
+			http.Error(writer, "Durations supported: 7d, 24h, 1h", http.StatusBadRequest)
+			return
 		}
-		return
+		key := variables["key"]
+		averageResponseTime, err := store.Get().GetAverageResponseTimeByKey(key, from, time.Now())
+		if err != nil {
+			if err == common.ErrEndpointNotFound {
+				http.Error(writer, err.Error(), http.StatusNotFound)
+			} else if err == common.ErrInvalidTimeRange {
+				http.Error(writer, err.Error(), http.StatusBadRequest)
+			} else {
+				http.Error(writer, err.Error(), http.StatusInternalServerError)
+			}
+			return
+		}
+		writer.Header().Set("Content-Type", "image/svg+xml")
+		writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+		writer.Header().Set("Expires", "0")
+		writer.WriteHeader(http.StatusOK)
+		_, _ = writer.Write(generateResponseTimeBadgeSVG(duration, averageResponseTime, key, config))
 	}
-	writer.Header().Set("Content-Type", "image/svg+xml")
-	writer.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
-	writer.Header().Set("Expires", "0")
-	writer.WriteHeader(http.StatusOK)
-	_, _ = writer.Write(generateResponseTimeBadgeSVG(duration, averageResponseTime))
 }

 // HealthBadge handles the automatic generation of badge based on the group name and endpoint name passed.
@@ -199,7 +206,7 @@ func getBadgeColorFromUptime(uptime float64) string {
 	return badgeColorHexVeryBad
 }

-func generateResponseTimeBadgeSVG(duration string, averageResponseTime int) []byte {
+func generateResponseTimeBadgeSVG(duration string, averageResponseTime int, key string, cfg *config.Config) []byte {
 	var labelWidth, valueWidth int
 	switch duration {
 	case "7d":
@@ -210,7 +217,7 @@ func generateResponseTimeBadgeSVG(duration string, averageResponseTime int) []by
 		labelWidth = 105
 	default:
 	}
-	color := getBadgeColorFromResponseTime(averageResponseTime)
+	color := getBadgeColorFromResponseTime(averageResponseTime, key, cfg)
 	sanitizedValue := strconv.Itoa(averageResponseTime) + "ms"
 	valueWidth = len(sanitizedValue) * 11
 	width := labelWidth + valueWidth
@@ -247,17 +254,13 @@ func generateResponseTimeBadgeSVG(duration string, averageResponseTime int) []by
 	return svg
 }

-func getBadgeColorFromResponseTime(responseTime int) string {
-	if responseTime <= 50 {
-		return badgeColorHexAwesome
-	} else if responseTime <= 200 {
-		return badgeColorHexGreat
-	} else if responseTime <= 300 {
-		return badgeColorHexGood
-	} else if responseTime <= 500 {
-		return badgeColorHexPassable
-	} else if responseTime <= 750 {
-		return badgeColorHexBad
+func getBadgeColorFromResponseTime(responseTime int, key string, cfg *config.Config) string {
+	endpoint := cfg.GetEndpointByKey(key)
+	// the threshold config requires 5 values, so we can be sure it's set here
+	for i := 0; i < 5; i++ {
+		if responseTime <= endpoint.UIConfig.Badge.ResponseTime.Thresholds[i] {
+			return badgeColors[i]
+		}
 	}
 	return badgeColorHexVeryBad
 }
@@ -9,6 +9,7 @@ import (

 	"github.com/TwiN/gatus/v4/config"
 	"github.com/TwiN/gatus/v4/core"
+	"github.com/TwiN/gatus/v4/core/ui"
 	"github.com/TwiN/gatus/v4/storage/store"
 	"github.com/TwiN/gatus/v4/watchdog"
 )
@@ -29,9 +30,39 @@ func TestBadge(t *testing.T) {
 			},
 		},
 	}
+
+	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,
+			},
+		},
+	}
+
+	cfg.Endpoints[0].UIConfig = ui.GetDefaultConfig()
+	cfg.Endpoints[1].UIConfig = ui.GetDefaultConfig()
+
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Connected: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Connected: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+	router := CreateRouter("../../web/static", cfg)
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -109,6 +140,16 @@ func TestBadge(t *testing.T) {
 			Path:         "/api/v1/endpoints/core_backend/response-times/24h/chart.svg",
 			ExpectedCode: http.StatusOK,
 		},
+		{
+			Name:         "chart-response-time-7d",
+			Path:         "/api/v1/endpoints/core_frontend/response-times/7d/chart.svg",
+			ExpectedCode: http.StatusOK,
+		},
+		{
+			Name:         "chart-response-time-with-invalid-duration",
+			Path:         "/api/v1/endpoints/core_backend/response-times/3d/chart.svg",
+			ExpectedCode: http.StatusBadRequest,
+		},
 	}
 	for _, scenario := range scenarios {
 		t.Run(scenario.Name, func(t *testing.T) {
@@ -181,55 +222,128 @@ func TestGetBadgeColorFromUptime(t *testing.T) {
 }

 func TestGetBadgeColorFromResponseTime(t *testing.T) {
+	defer store.Get().Clear()
+	defer cache.Clear()
+
+	var (
+		firstCondition  = core.Condition("[STATUS] == 200")
+		secondCondition = core.Condition("[RESPONSE_TIME] < 500")
+		thirdCondition  = core.Condition("[CERTIFICATE_EXPIRATION] < 72h")
+	)
+
+	firstTestEndpoint := core.Endpoint{
+		Name:                    "a",
+		URL:                     "https://example.org/what/ever",
+		Method:                  "GET",
+		Body:                    "body",
+		Interval:                30 * time.Second,
+		Conditions:              []core.Condition{firstCondition, secondCondition, thirdCondition},
+		Alerts:                  nil,
+		NumberOfFailuresInARow:  0,
+		NumberOfSuccessesInARow: 0,
+		UIConfig:                ui.GetDefaultConfig(),
+	}
+	secondTestEndpoint := core.Endpoint{
+		Name:                    "b",
+		URL:                     "https://example.org/what/ever",
+		Method:                  "GET",
+		Body:                    "body",
+		Interval:                30 * time.Second,
+		Conditions:              []core.Condition{firstCondition, secondCondition, thirdCondition},
+		Alerts:                  nil,
+		NumberOfFailuresInARow:  0,
+		NumberOfSuccessesInARow: 0,
+		UIConfig: &ui.Config{
+			Badge: &ui.Badge{
+				ResponseTime: &ui.ResponseTime{
+					Thresholds: []int{100, 500, 1000, 2000, 3000},
+				},
+			},
+		},
+	}
+	cfg := &config.Config{
+		Metrics:   true,
+		Endpoints: []*core.Endpoint{&firstTestEndpoint, &secondTestEndpoint},
+	}
+
+	store.Get().Insert(&firstTestEndpoint, &testSuccessfulResult)
+	store.Get().Insert(&secondTestEndpoint, &testSuccessfulResult)
+
 	scenarios := []struct {
+		Key           string
 		ResponseTime  int
 		ExpectedColor string
 	}{
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  10,
 			ExpectedColor: badgeColorHexAwesome,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  50,
 			ExpectedColor: badgeColorHexAwesome,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  75,
 			ExpectedColor: badgeColorHexGreat,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  150,
 			ExpectedColor: badgeColorHexGreat,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  201,
 			ExpectedColor: badgeColorHexGood,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  300,
 			ExpectedColor: badgeColorHexGood,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  301,
 			ExpectedColor: badgeColorHexPassable,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  450,
 			ExpectedColor: badgeColorHexPassable,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  700,
 			ExpectedColor: badgeColorHexBad,
 		},
 		{
+			Key:           firstTestEndpoint.Key(),
 			ResponseTime:  1500,
 			ExpectedColor: badgeColorHexVeryBad,
 		},
+		{
+			Key:           secondTestEndpoint.Key(),
+			ResponseTime:  50,
+			ExpectedColor: badgeColorHexAwesome,
+		},
+		{
+			Key:           secondTestEndpoint.Key(),
+			ResponseTime:  1500,
+			ExpectedColor: badgeColorHexPassable,
+		},
+		{
+			Key:           secondTestEndpoint.Key(),
+			ResponseTime:  2222,
+			ExpectedColor: badgeColorHexBad,
+		},
 	}
 	for _, scenario := range scenarios {
-		t.Run("response-time-"+strconv.Itoa(scenario.ResponseTime), func(t *testing.T) {
-			if getBadgeColorFromResponseTime(scenario.ResponseTime) != scenario.ExpectedColor {
-				t.Errorf("expected %s from %d, got %v", scenario.ExpectedColor, scenario.ResponseTime, getBadgeColorFromResponseTime(scenario.ResponseTime))
+		t.Run(scenario.Key+"-response-time-"+strconv.Itoa(scenario.ResponseTime), func(t *testing.T) {
+			if getBadgeColorFromResponseTime(scenario.ResponseTime, scenario.Key, cfg) != scenario.ExpectedColor {
+				t.Errorf("expected %s from %d, got %v", scenario.ExpectedColor, scenario.ResponseTime, getBadgeColorFromResponseTime(scenario.ResponseTime, scenario.Key, cfg))
 			}
 		})
 	}
@@ -30,7 +30,7 @@ func TestResponseTimeChart(t *testing.T) {
 	}
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+	router := CreateRouter("../../web/static", cfg)
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -5,11 +5,16 @@ import (
 	"compress/gzip"
 	"encoding/json"
 	"fmt"
+	"io"
 	"log"
 	"net/http"
 	"strings"
 	"time"

+	"github.com/TwiN/gatus/v4/client"
+	"github.com/TwiN/gatus/v4/config"
+	"github.com/TwiN/gatus/v4/config/remote"
+	"github.com/TwiN/gatus/v4/core"
 	"github.com/TwiN/gatus/v4/storage/store"
 	"github.com/TwiN/gatus/v4/storage/store/common"
 	"github.com/TwiN/gatus/v4/storage/store/common/paging"
@@ -28,48 +33,89 @@ var (
 // EndpointStatuses handles requests to retrieve all EndpointStatus
 // Due to the size of the response, this function leverages a cache.
 // Must not be wrapped by GzipHandler
-func EndpointStatuses(writer http.ResponseWriter, r *http.Request) {
-	page, pageSize := extractPageAndPageSizeFromRequest(r)
-	gzipped := strings.Contains(r.Header.Get("Accept-Encoding"), "gzip")
-	var exists bool
-	var value interface{}
-	if gzipped {
-		writer.Header().Set("Content-Encoding", "gzip")
-		value, exists = cache.Get(fmt.Sprintf("endpoint-status-%d-%d-gzipped", page, pageSize))
-	} else {
-		value, exists = cache.Get(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize))
-	}
-	var data []byte
-	if !exists {
-		var err error
-		buffer := &bytes.Buffer{}
-		gzipWriter := gzip.NewWriter(buffer)
-		endpointStatuses, err := store.Get().GetAllEndpointStatuses(paging.NewEndpointStatusParams().WithResults(page, pageSize))
-		if err != nil {
-			log.Printf("[handler][EndpointStatuses] Failed to retrieve endpoint statuses: %s", err.Error())
-			http.Error(writer, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		data, err = json.Marshal(endpointStatuses)
-		if err != nil {
-			log.Printf("[handler][EndpointStatuses] Unable to marshal object to JSON: %s", err.Error())
-			http.Error(writer, "unable to marshal object to JSON", http.StatusInternalServerError)
-			return
-		}
-		_, _ = gzipWriter.Write(data)
-		_ = gzipWriter.Close()
-		gzippedData := buffer.Bytes()
-		cache.SetWithTTL(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize), data, cacheTTL)
-		cache.SetWithTTL(fmt.Sprintf("endpoint-status-%d-%d-gzipped", page, pageSize), gzippedData, cacheTTL)
+func EndpointStatuses(cfg *config.Config) http.HandlerFunc {
+	return func(writer http.ResponseWriter, r *http.Request) {
+		page, pageSize := extractPageAndPageSizeFromRequest(r)
+		gzipped := strings.Contains(r.Header.Get("Accept-Encoding"), "gzip")
+		var exists bool
+		var value interface{}
 		if gzipped {
-			data = gzippedData
+			writer.Header().Set("Content-Encoding", "gzip")
+			value, exists = cache.Get(fmt.Sprintf("endpoint-status-%d-%d-gzipped", page, pageSize))
+		} else {
+			value, exists = cache.Get(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize))
 		}
-	} else {
-		data = value.([]byte)
+		var data []byte
+		if !exists {
+			var err error
+			buffer := &bytes.Buffer{}
+			gzipWriter := gzip.NewWriter(buffer)
+			endpointStatuses, err := store.Get().GetAllEndpointStatuses(paging.NewEndpointStatusParams().WithResults(page, pageSize))
+			if err != nil {
+				log.Printf("[handler][EndpointStatuses] Failed to retrieve endpoint statuses: %s", err.Error())
+				http.Error(writer, err.Error(), http.StatusInternalServerError)
+				return
+			}
+			// ALPHA: Retrieve endpoint statuses from remote instances
+			if endpointStatusesFromRemote, err := getEndpointStatusesFromRemoteInstances(cfg.Remote); err != nil {
+				log.Printf("[handler][EndpointStatuses] Silently failed to retrieve endpoint statuses from remote: %s", err.Error())
+			} else if endpointStatusesFromRemote != nil {
+				endpointStatuses = append(endpointStatuses, endpointStatusesFromRemote...)
+			}
+			// Marshal endpoint statuses to JSON
+			data, err = json.Marshal(endpointStatuses)
+			if err != nil {
+				log.Printf("[handler][EndpointStatuses] Unable to marshal object to JSON: %s", err.Error())
+				http.Error(writer, "unable to marshal object to JSON", http.StatusInternalServerError)
+				return
+			}
+			_, _ = gzipWriter.Write(data)
+			_ = gzipWriter.Close()
+			gzippedData := buffer.Bytes()
+			cache.SetWithTTL(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize), data, cacheTTL)
+			cache.SetWithTTL(fmt.Sprintf("endpoint-status-%d-%d-gzipped", page, pageSize), gzippedData, cacheTTL)
+			if gzipped {
+				data = gzippedData
+			}
+		} else {
+			data = value.([]byte)
+		}
+		writer.Header().Add("Content-Type", "application/json")
+		writer.WriteHeader(http.StatusOK)
+		_, _ = writer.Write(data)
 	}
-	writer.Header().Add("Content-Type", "application/json")
-	writer.WriteHeader(http.StatusOK)
-	_, _ = writer.Write(data)
+}
+
+func getEndpointStatusesFromRemoteInstances(remoteConfig *remote.Config) ([]*core.EndpointStatus, error) {
+	if remoteConfig == nil || len(remoteConfig.Instances) == 0 {
+		return nil, nil
+	}
+	var endpointStatusesFromAllRemotes []*core.EndpointStatus
+	httpClient := client.GetHTTPClient(remoteConfig.ClientConfig)
+	for _, instance := range remoteConfig.Instances {
+		response, err := httpClient.Get(instance.URL)
+		if err != nil {
+			return nil, err
+		}
+		body, err := io.ReadAll(response.Body)
+		if err != nil {
+			_ = response.Body.Close()
+			log.Printf("[handler][getEndpointStatusesFromRemoteInstances] Silently failed to retrieve endpoint statuses from %s: %s", instance.URL, err.Error())
+			continue
+		}
+		var endpointStatuses []*core.EndpointStatus
+		if err = json.Unmarshal(body, &endpointStatuses); err != nil {
+			_ = response.Body.Close()
+			log.Printf("[handler][getEndpointStatusesFromRemoteInstances] Silently failed to retrieve endpoint statuses from %s: %s", instance.URL, err.Error())
+			continue
+		}
+		_ = response.Body.Close()
+		for _, endpointStatus := range endpointStatuses {
+			endpointStatus.Name = instance.EndpointPrefix + endpointStatus.Name
+		}
+		endpointStatusesFromAllRemotes = append(endpointStatusesFromAllRemotes, endpointStatuses...)
+	}
+	return endpointStatusesFromAllRemotes, nil
 }

 // EndpointStatus retrieves a single core.EndpointStatus by group and endpoint name
@@ -97,7 +97,7 @@ func TestEndpointStatus(t *testing.T) {
 	}
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+	router := CreateRouter("../../web/static", cfg)

 	type Scenario struct {
 		Name         string
@@ -153,7 +153,7 @@ func TestEndpointStatuses(t *testing.T) {
 	// Can't be bothered dealing with timezone issues on the worker that runs the automated tests
 	firstResult.Timestamp = time.Time{}
 	secondResult.Timestamp = time.Time{}
-	router := CreateRouter("../../web/static", nil, nil, false)
+	router := CreateRouter("../../web/static", &config.Config{Metrics: true})

 	type Scenario struct {
 		Name         string
@@ -4,10 +4,12 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"testing"
+
+	"github.com/TwiN/gatus/v4/config"
 )

 func TestFavIcon(t *testing.T) {
-	router := CreateRouter("../../web/static", nil, nil, false)
+	router := CreateRouter("../../web/static", &config.Config{})
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -3,43 +3,42 @@ package handler
 import (
 	"net/http"

-	"github.com/TwiN/gatus/v4/config/ui"
-	"github.com/TwiN/gatus/v4/security"
+	"github.com/TwiN/gatus/v4/config"
 	"github.com/TwiN/health"
 	"github.com/gorilla/mux"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 )

-func CreateRouter(staticFolder string, securityConfig *security.Config, uiConfig *ui.Config, enabledMetrics bool) *mux.Router {
+func CreateRouter(staticFolder string, cfg *config.Config) *mux.Router {
 	router := mux.NewRouter()
-	if enabledMetrics {
+	if cfg.Metrics {
 		router.Handle("/metrics", promhttp.Handler()).Methods("GET")
 	}
 	api := router.PathPrefix("/api").Subrouter()
 	protected := api.PathPrefix("/").Subrouter()
 	unprotected := api.PathPrefix("/").Subrouter()
-	if securityConfig != nil {
-		if err := securityConfig.RegisterHandlers(router); err != nil {
+	if cfg.Security != nil {
+		if err := cfg.Security.RegisterHandlers(router); err != nil {
 			panic(err)
 		}
-		if err := securityConfig.ApplySecurityMiddleware(protected); err != nil {
+		if err := cfg.Security.ApplySecurityMiddleware(protected); err != nil {
 			panic(err)
 		}
 	}
 	// Endpoints
-	unprotected.Handle("/v1/config", ConfigHandler{securityConfig: securityConfig}).Methods("GET")
-	protected.HandleFunc("/v1/endpoints/statuses", EndpointStatuses).Methods("GET") // No GzipHandler for this one, because we cache the content as Gzipped already
+	unprotected.Handle("/v1/config", ConfigHandler{securityConfig: cfg.Security}).Methods("GET")
+	protected.HandleFunc("/v1/endpoints/statuses", EndpointStatuses(cfg)).Methods("GET") // No GzipHandler for this one, because we cache the content as Gzipped already
 	protected.HandleFunc("/v1/endpoints/{key}/statuses", GzipHandlerFunc(EndpointStatus)).Methods("GET")
 	unprotected.HandleFunc("/v1/endpoints/{key}/health/badge.svg", HealthBadge).Methods("GET")
 	unprotected.HandleFunc("/v1/endpoints/{key}/uptimes/{duration}/badge.svg", UptimeBadge).Methods("GET")
-	unprotected.HandleFunc("/v1/endpoints/{key}/response-times/{duration}/badge.svg", ResponseTimeBadge).Methods("GET")
+	unprotected.HandleFunc("/v1/endpoints/{key}/response-times/{duration}/badge.svg", ResponseTimeBadge(cfg)).Methods("GET")
 	unprotected.HandleFunc("/v1/endpoints/{key}/response-times/{duration}/chart.svg", ResponseTimeChart).Methods("GET")
 	// Misc
 	router.Handle("/health", health.Handler().WithJSON(true)).Methods("GET")
 	router.HandleFunc("/favicon.ico", FavIcon(staticFolder)).Methods("GET")
 	// SPA
-	router.HandleFunc("/endpoints/{name}", SinglePageApplication(staticFolder, uiConfig)).Methods("GET")
-	router.HandleFunc("/", SinglePageApplication(staticFolder, uiConfig)).Methods("GET")
+	router.HandleFunc("/endpoints/{name}", SinglePageApplication(staticFolder, cfg.UI)).Methods("GET")
+	router.HandleFunc("/", SinglePageApplication(staticFolder, cfg.UI)).Methods("GET")
 	// Everything else falls back on static content
 	router.PathPrefix("/").Handler(GzipHandler(http.FileServer(http.Dir(staticFolder))))
 	return router
@@ -4,10 +4,12 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"testing"
+
+	"github.com/TwiN/gatus/v4/config"
 )

 func TestCreateRouter(t *testing.T) {
-	router := CreateRouter("../../web/static", nil, nil, true)
+	router := CreateRouter("../../web/static", &config.Config{Metrics: true})
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -30,7 +30,7 @@ func TestSinglePageApplication(t *testing.T) {
 	}
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[0], &core.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()})
 	watchdog.UpdateEndpointStatuses(cfg.Endpoints[1], &core.Result{Success: false, Duration: time.Second, Timestamp: time.Now()})
-	router := CreateRouter("../../web/static", cfg.Security, nil, cfg.Metrics)
+	router := CreateRouter("../../web/static", cfg)
 	type Scenario struct {
 		Name         string
 		Path         string
@@ -46,6 +46,9 @@ const (
 	// Values that could replace the placeholder: 4461677039 (~52 days)
 	CertificateExpirationPlaceholder = "[CERTIFICATE_EXPIRATION]"

+	// DomainExpirationPlaceholder is a placeholder for the duration before the domain expires, in milliseconds.
+	DomainExpirationPlaceholder = "[DOMAIN_EXPIRATION]"
+
 	// LengthFunctionPrefix is the prefix for the length function
 	//
 	// Usage: len([BODY].articles) == 10, len([BODY].name) > 5
@@ -142,9 +145,21 @@ func (c Condition) hasBodyPlaceholder() bool {
 	return strings.Contains(string(c), BodyPlaceholder)
 }

+// hasDomainExpirationPlaceholder checks whether the condition has a DomainExpirationPlaceholder
+// Used for determining whether a whois operation is necessary
+func (c Condition) hasDomainExpirationPlaceholder() bool {
+	return strings.Contains(string(c), DomainExpirationPlaceholder)
+}
+
+// hasIPPlaceholder checks whether the condition has an IPPlaceholder
+// Used for determining whether an IP lookup is necessary
+func (c Condition) hasIPPlaceholder() bool {
+	return strings.Contains(string(c), IPPlaceholder)
+}
+
 // isEqual compares two strings.
 //
-// Supports the pattern and the any functions.
+// Supports the "pat" and the "any" functions.
 // i.e. if one of the parameters starts with PatternFunctionPrefix and ends with FunctionSuffix, it will be treated like
 // a pattern.
 func isEqual(first, second string) bool {
@@ -219,6 +234,8 @@ func sanitizeAndResolve(elements []string, result *Result) ([]string, []string)
 			element = strconv.FormatBool(result.Connected)
 		case CertificateExpirationPlaceholder:
 			element = strconv.FormatInt(result.CertificateExpiration.Milliseconds(), 10)
+		case DomainExpirationPlaceholder:
+			element = strconv.FormatInt(result.DomainExpiration.Milliseconds(), 10)
 		default:
 			// if contains the BodyPlaceholder, then evaluate json path
 			if strings.Contains(element, BodyPlaceholder) {
@@ -16,6 +16,7 @@ import (
 	"github.com/TwiN/gatus/v4/client"
 	"github.com/TwiN/gatus/v4/core/ui"
 	"github.com/TwiN/gatus/v4/util"
+	"github.com/TwiN/whois"
 )

 type EndpointType string
@@ -33,13 +34,13 @@ const (
 	// GatusUserAgent is the default user agent that Gatus uses to send requests.
 	GatusUserAgent = "Gatus/1.0"

-	// EndpointType enum for the endpoint type.
 	EndpointTypeDNS      EndpointType = "DNS"
 	EndpointTypeTCP      EndpointType = "TCP"
 	EndpointTypeICMP     EndpointType = "ICMP"
 	EndpointTypeSTARTTLS EndpointType = "STARTTLS"
 	EndpointTypeTLS      EndpointType = "TLS"
 	EndpointTypeHTTP     EndpointType = "HTTP"
+	EndpointTypeUNKNOWN  EndpointType = "UNKNOWN"
 )

 var (
@@ -54,6 +55,15 @@ var (

 	// ErrEndpointWithInvalidNameOrGroup is the error with which Gatus will panic if an endpoint has an invalid character where it shouldn't
 	ErrEndpointWithInvalidNameOrGroup = errors.New("endpoint name and group must not have \" or \\")
+
+	// ErrUnknownEndpointType is the error with which Gatus will panic if an endpoint has an unknown type
+	ErrUnknownEndpointType = errors.New("unknown endpoint type")
+
+	// ErrInvalidEndpointIntervalForDomainExpirationPlaceholder is the error with which Gatus will panic if an endpoint
+	// has both an interval smaller than 5 minutes and a condition with DomainExpirationPlaceholder.
+	// This is because the free whois service we are using should not be abused, especially considering the fact that
+	// the data takes a while to be updated.
+	ErrInvalidEndpointIntervalForDomainExpirationPlaceholder = errors.New("the minimum interval for an endpoint with a condition using the " + DomainExpirationPlaceholder + " placeholder is 300s (5m)")
 )

 // Endpoint is the configuration of a monitored
@@ -128,12 +138,14 @@ func (endpoint Endpoint) Type() EndpointType {
 		return EndpointTypeSTARTTLS
 	case strings.HasPrefix(endpoint.URL, "tls://"):
 		return EndpointTypeTLS
-	default:
+	case strings.HasPrefix(endpoint.URL, "http://") || strings.HasPrefix(endpoint.URL, "https://"):
 		return EndpointTypeHTTP
+	default:
+		return EndpointTypeUNKNOWN
 	}
 }

-// ValidateAndSetDefaults validates the endpoint's configuration and sets the default value of fields that have one
+// ValidateAndSetDefaults validates the endpoint's configuration and sets the default value of args that have one
 func (endpoint *Endpoint) ValidateAndSetDefaults() error {
 	// Set default values
 	if endpoint.ClientConfig == nil {
@@ -145,6 +157,10 @@ func (endpoint *Endpoint) ValidateAndSetDefaults() error {
 	}
 	if endpoint.UIConfig == nil {
 		endpoint.UIConfig = ui.GetDefaultConfig()
+	} else {
+		if err := endpoint.UIConfig.ValidateAndSetDefaults(); err != nil {
+			return err
+		}
 	}
 	if endpoint.Interval == 0 {
 		endpoint.Interval = 1 * time.Minute
@@ -181,9 +197,19 @@ func (endpoint *Endpoint) ValidateAndSetDefaults() error {
 	if len(endpoint.Conditions) == 0 {
 		return ErrEndpointWithNoCondition
 	}
+	if endpoint.Interval < 5*time.Minute {
+		for _, condition := range endpoint.Conditions {
+			if condition.hasDomainExpirationPlaceholder() {
+				return ErrInvalidEndpointIntervalForDomainExpirationPlaceholder
+			}
+		}
+	}
 	if endpoint.DNS != nil {
 		return endpoint.DNS.validateAndSetDefault()
 	}
+	if endpoint.Type() == EndpointTypeUNKNOWN {
+		return ErrUnknownEndpointType
+	}
 	// Make sure that the request can be created
 	_, err := http.NewRequest(endpoint.Method, endpoint.URL, bytes.NewBuffer([]byte(endpoint.Body)))
 	if err != nil {
@@ -208,7 +234,26 @@ func (endpoint Endpoint) Key() string {
 // EvaluateHealth sends a request to the endpoint's URL and evaluates the conditions of the endpoint.
 func (endpoint *Endpoint) EvaluateHealth() *Result {
 	result := &Result{Success: true, Errors: []string{}}
-	endpoint.getIP(result)
+	// Parse or extract hostname from URL
+	if endpoint.DNS != nil {
+		result.Hostname = strings.TrimSuffix(endpoint.URL, ":53")
+	} else {
+		urlObject, err := url.Parse(endpoint.URL)
+		if err != nil {
+			result.AddError(err.Error())
+		} else {
+			result.Hostname = urlObject.Hostname()
+		}
+	}
+	// Retrieve IP if necessary
+	if endpoint.needsToRetrieveIP() {
+		endpoint.getIP(result)
+	}
+	// Retrieve domain expiration if necessary
+	if endpoint.needsToRetrieveDomainExpiration() && len(result.Hostname) > 0 {
+		endpoint.getDomainExpiration(result)
+	}
+	//
 	if len(result.Errors) == 0 {
 		endpoint.call(result)
 	} else {
@@ -239,16 +284,6 @@ func (endpoint *Endpoint) EvaluateHealth() *Result {
 }

 func (endpoint *Endpoint) getIP(result *Result) {
-	if endpoint.DNS != nil {
-		result.Hostname = strings.TrimSuffix(endpoint.URL, ":53")
-	} else {
-		urlObject, err := url.Parse(endpoint.URL)
-		if err != nil {
-			result.AddError(err.Error())
-			return
-		}
-		result.Hostname = urlObject.Hostname()
-	}
 	ips, err := net.LookupIP(result.Hostname)
 	if err != nil {
 		result.AddError(err.Error())
@@ -257,6 +292,15 @@ func (endpoint *Endpoint) getIP(result *Result) {
 	result.IP = ips[0].String()
 }

+func (endpoint *Endpoint) getDomainExpiration(result *Result) {
+	whoisClient := whois.NewClient()
+	if whoisResponse, err := whoisClient.QueryAndParse(result.Hostname); err != nil {
+		result.AddError("error querying and parsing hostname using whois client: " + err.Error())
+	} else {
+		result.DomainExpiration = time.Until(whoisResponse.ExpirationDate)
+	}
+}
+
 func (endpoint *Endpoint) call(result *Result) {
 	var request *http.Request
 	var response *http.Response
@@ -305,7 +349,7 @@ func (endpoint *Endpoint) call(result *Result) {
 		if endpoint.needsToReadBody() {
 			result.body, err = io.ReadAll(response.Body)
 			if err != nil {
-				result.AddError(err.Error())
+				result.AddError("error reading response body:" + err.Error())
 			}
 		}
 	}
@@ -332,7 +376,7 @@ func (endpoint *Endpoint) buildHTTPRequest() *http.Request {
 	return request
 }

-// needsToReadBody checks if there's any conditions that requires the response body to be read
+// needsToReadBody checks if there's any condition that requires the response body to be read
 func (endpoint *Endpoint) needsToReadBody() bool {
 	for _, condition := range endpoint.Conditions {
 		if condition.hasBodyPlaceholder() {
@@ -341,3 +385,23 @@ func (endpoint *Endpoint) needsToReadBody() bool {
 	}
 	return false
 }
+
+// needsToRetrieveDomainExpiration checks if there's any condition that requires a whois query to be performed
+func (endpoint *Endpoint) needsToRetrieveDomainExpiration() bool {
+	for _, condition := range endpoint.Conditions {
+		if condition.hasDomainExpirationPlaceholder() {
+			return true
+		}
+	}
+	return false
+}
+
+// needsToRetrieveIP checks if there's any condition that requires an IP lookup
+func (endpoint *Endpoint) needsToRetrieveIP() bool {
+	for _, condition := range endpoint.Conditions {
+		if condition.hasIPPlaceholder() {
+			return true
+		}
+	}
+	return false
+}
@@ -1,7 +1,11 @@
 package core

 import (
+	"bytes"
+	"crypto/tls"
+	"crypto/x509"
 	"io"
+	"net/http"
 	"strings"
 	"testing"
 	"time"
@@ -9,8 +13,233 @@ import (
 	"github.com/TwiN/gatus/v4/alerting/alert"
 	"github.com/TwiN/gatus/v4/client"
 	"github.com/TwiN/gatus/v4/core/ui"
+	"github.com/TwiN/gatus/v4/test"
 )

+func TestEndpoint(t *testing.T) {
+	defer client.InjectHTTPClient(nil)
+	scenarios := []struct {
+		Name             string
+		Endpoint         Endpoint
+		ExpectedResult   *Result
+		MockRoundTripper test.MockRoundTripper
+	}{
+		{
+			Name: "success",
+			Endpoint: Endpoint{
+				Name:       "website-health",
+				URL:        "https://twin.sh/health",
+				Conditions: []Condition{"[STATUS] == 200", "[BODY].status == UP", "[CERTIFICATE_EXPIRATION] > 24h"},
+			},
+			ExpectedResult: &Result{
+				Success:   true,
+				Connected: true,
+				Hostname:  "twin.sh",
+				ConditionResults: []*ConditionResult{
+					{Condition: "[STATUS] == 200", Success: true},
+					{Condition: "[BODY].status == UP", Success: true},
+					{Condition: "[CERTIFICATE_EXPIRATION] > 24h", Success: true},
+				},
+				DomainExpiration: 0, // Because there's no [DOMAIN_EXPIRATION] condition, this is not resolved, so it should be 0.
+			},
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(bytes.NewBufferString(`{"status": "UP"}`)),
+					TLS:        &tls.ConnectionState{PeerCertificates: []*x509.Certificate{{NotAfter: time.Now().Add(9999 * time.Hour)}}},
+				}
+			}),
+		},
+		{
+			Name: "failed-body-condition",
+			Endpoint: Endpoint{
+				Name:       "website-health",
+				URL:        "https://twin.sh/health",
+				Conditions: []Condition{"[STATUS] == 200", "[BODY].status == UP"},
+			},
+			ExpectedResult: &Result{
+				Success:   false,
+				Connected: true,
+				Hostname:  "twin.sh",
+				ConditionResults: []*ConditionResult{
+					{Condition: "[STATUS] == 200", Success: true},
+					{Condition: "[BODY].status (DOWN) == UP", Success: false},
+				},
+				DomainExpiration: 0, // Because there's no [DOMAIN_EXPIRATION] condition, this is not resolved, so it should be 0.
+			},
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(bytes.NewBufferString(`{"status": "DOWN"}`))}
+			}),
+		},
+		{
+			Name: "failed-status-condition",
+			Endpoint: Endpoint{
+				Name:       "website-health",
+				URL:        "https://twin.sh/health",
+				Conditions: []Condition{"[STATUS] == 200"},
+			},
+			ExpectedResult: &Result{
+				Success:   false,
+				Connected: true,
+				Hostname:  "twin.sh",
+				ConditionResults: []*ConditionResult{
+					{Condition: "[STATUS] (502) == 200", Success: false},
+				},
+				DomainExpiration: 0, // Because there's no [DOMAIN_EXPIRATION] condition, this is not resolved, so it should be 0.
+			},
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusBadGateway, Body: http.NoBody}
+			}),
+		},
+		{
+			Name: "condition-with-failed-certificate-expiration",
+			Endpoint: Endpoint{
+				Name:       "website-health",
+				URL:        "https://twin.sh/health",
+				Conditions: []Condition{"[CERTIFICATE_EXPIRATION] > 100h"},
+				UIConfig:   &ui.Config{DontResolveFailedConditions: true},
+			},
+			ExpectedResult: &Result{
+				Success:   false,
+				Connected: true,
+				Hostname:  "twin.sh",
+				ConditionResults: []*ConditionResult{
+					// Because UIConfig.DontResolveFailedConditions is true, the values in the condition should not be resolved
+					{Condition: "[CERTIFICATE_EXPIRATION] > 100h", Success: false},
+				},
+				DomainExpiration: 0, // Because there's no [DOMAIN_EXPIRATION] condition, this is not resolved, so it should be 0.
+			},
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       http.NoBody,
+					TLS:        &tls.ConnectionState{PeerCertificates: []*x509.Certificate{{NotAfter: time.Now().Add(5 * time.Hour)}}},
+				}
+			}),
+		},
+		{
+			Name: "domain-expiration",
+			Endpoint: Endpoint{
+				Name:       "website-health",
+				URL:        "https://twin.sh/health",
+				Conditions: []Condition{"[DOMAIN_EXPIRATION] > 100h"},
+			},
+			ExpectedResult: &Result{
+				Success:   true,
+				Connected: true,
+				Hostname:  "twin.sh",
+				ConditionResults: []*ConditionResult{
+					{Condition: "[DOMAIN_EXPIRATION] > 100h", Success: true},
+				},
+				DomainExpiration: 999999 * time.Hour, // Note that this test only checks if it's non-zero.
+			},
+			MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response {
+				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}
+			}),
+		},
+		{
+			Name: "endpoint-that-will-time-out-and-hidden-hostname",
+			Endpoint: Endpoint{
+				Name:         "endpoint-that-will-time-out",
+				URL:          "https://twin.sh/health",
+				Conditions:   []Condition{"[CONNECTED] == true"},
+				UIConfig:     &ui.Config{HideHostname: true},
+				ClientConfig: &client.Config{Timeout: time.Millisecond},
+			},
+			ExpectedResult: &Result{
+				Success:   false,
+				Connected: false,
+				Hostname:  "", // Because Endpoint.UIConfig.HideHostname is true, this should be empty.
+				ConditionResults: []*ConditionResult{
+					{Condition: "[CONNECTED] (false) == true", Success: false},
+				},
+				// Because there's no [DOMAIN_EXPIRATION] condition, this is not resolved, so it should be 0.
+				DomainExpiration: 0,
+				// Because Endpoint.UIConfig.HideHostname is true, the hostname should be replaced by <redacted>.
+				Errors: []string{`Get "https://<redacted>/health": context deadline exceeded (Client.Timeout exceeded while awaiting headers)`},
+			},
+			MockRoundTripper: nil,
+		},
+		{
+			Name: "endpoint-that-will-time-out-and-hidden-url",
+			Endpoint: Endpoint{
+				Name:         "endpoint-that-will-time-out",
+				URL:          "https://twin.sh/health",
+				Conditions:   []Condition{"[CONNECTED] == true"},
+				UIConfig:     &ui.Config{HideURL: true},
+				ClientConfig: &client.Config{Timeout: time.Millisecond},
+			},
+			ExpectedResult: &Result{
+				Success:   false,
+				Connected: false,
+				Hostname:  "twin.sh",
+				ConditionResults: []*ConditionResult{
+					{Condition: "[CONNECTED] (false) == true", Success: false},
+				},
+				// Because there's no [DOMAIN_EXPIRATION] condition, this is not resolved, so it should be 0.
+				DomainExpiration: 0,
+				// Because Endpoint.UIConfig.HideURL is true, the URL should be replaced by <redacted>.
+				Errors: []string{`Get "<redacted>": context deadline exceeded (Client.Timeout exceeded while awaiting headers)`},
+			},
+			MockRoundTripper: nil,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.Name, func(t *testing.T) {
+			if scenario.MockRoundTripper != nil {
+				mockClient := &http.Client{Transport: scenario.MockRoundTripper}
+				if scenario.Endpoint.ClientConfig != nil && scenario.Endpoint.ClientConfig.Timeout > 0 {
+					mockClient.Timeout = scenario.Endpoint.ClientConfig.Timeout
+				}
+				client.InjectHTTPClient(mockClient)
+			} else {
+				client.InjectHTTPClient(nil)
+			}
+			scenario.Endpoint.ValidateAndSetDefaults()
+			result := scenario.Endpoint.EvaluateHealth()
+			if result.Success != scenario.ExpectedResult.Success {
+				t.Errorf("Expected success to be %v, got %v", scenario.ExpectedResult.Success, result.Success)
+			}
+			if result.Connected != scenario.ExpectedResult.Connected {
+				t.Errorf("Expected connected to be %v, got %v", scenario.ExpectedResult.Connected, result.Connected)
+			}
+			if result.Hostname != scenario.ExpectedResult.Hostname {
+				t.Errorf("Expected hostname to be %v, got %v", scenario.ExpectedResult.Hostname, result.Hostname)
+			}
+			if len(result.ConditionResults) != len(scenario.ExpectedResult.ConditionResults) {
+				t.Errorf("Expected %v condition results, got %v", len(scenario.ExpectedResult.ConditionResults), len(result.ConditionResults))
+			} else {
+				for i, conditionResult := range result.ConditionResults {
+					if conditionResult.Condition != scenario.ExpectedResult.ConditionResults[i].Condition {
+						t.Errorf("Expected condition to be %v, got %v", scenario.ExpectedResult.ConditionResults[i].Condition, conditionResult.Condition)
+					}
+					if conditionResult.Success != scenario.ExpectedResult.ConditionResults[i].Success {
+						t.Errorf("Expected success of condition '%s' to be %v, got %v", conditionResult.Condition, scenario.ExpectedResult.ConditionResults[i].Success, conditionResult.Success)
+					}
+				}
+			}
+			if len(result.Errors) != len(scenario.ExpectedResult.Errors) {
+				t.Errorf("Expected %v errors, got %v", len(scenario.ExpectedResult.Errors), len(result.Errors))
+			} else {
+				for i, err := range result.Errors {
+					if err != scenario.ExpectedResult.Errors[i] {
+						t.Errorf("Expected error to be %v, got %v", scenario.ExpectedResult.Errors[i], err)
+					}
+				}
+			}
+			if result.DomainExpiration != scenario.ExpectedResult.DomainExpiration {
+				// Note that DomainExpiration is only resolved if there's a condition with the DomainExpirationPlaceholder in it.
+				// In other words, if there's no condition with [DOMAIN_EXPIRATION] in it, the DomainExpiration field will be 0.
+				// Because this is a live call, mocking it would be too much of a pain, so we're just going to check if
+				// the actual value is non-zero when the expected result is non-zero.
+				if scenario.ExpectedResult.DomainExpiration.Hours() > 0 && !(result.DomainExpiration.Hours() > 0) {
+					t.Errorf("Expected domain expiration to be non-zero, got %v", result.DomainExpiration)
+				}
+			}
+		})
+	}
+}
+
 func TestEndpoint_IsEnabled(t *testing.T) {
 	if !(Endpoint{Enabled: nil}).IsEnabled() {
 		t.Error("endpoint.IsEnabled() should've returned true, because Enabled was set to nil")
@@ -24,53 +253,72 @@ func TestEndpoint_IsEnabled(t *testing.T) {
 }

 func TestEndpoint_Type(t *testing.T) {
-	type fields struct {
+	type args struct {
 		URL string
 		DNS *DNS
 	}
 	tests := []struct {
-		fields fields
-		want   EndpointType
-	}{{
-		fields: fields{
-			URL: "1.1.1.1",
-			DNS: &DNS{
-				QueryType: "A",
-				QueryName: "example.com",
+		args args
+		want EndpointType
+	}{
+		{
+			args: args{
+				URL: "1.1.1.1",
+				DNS: &DNS{
+					QueryType: "A",
+					QueryName: "example.com",
+				},
 			},
+			want: EndpointTypeDNS,
 		},
-		want: EndpointTypeDNS,
-	}, {
-		fields: fields{
-			URL: "tcp://127.0.0.1:6379",
+		{
+			args: args{
+				URL: "tcp://127.0.0.1:6379",
+			},
+			want: EndpointTypeTCP,
 		},
-		want: EndpointTypeTCP,
-	}, {
-		fields: fields{
-			URL: "icmp://example.com",
+		{
+			args: args{
+				URL: "icmp://example.com",
+			},
+			want: EndpointTypeICMP,
 		},
-		want: EndpointTypeICMP,
-	}, {
-		fields: fields{
-			URL: "starttls://smtp.gmail.com:587",
+		{
+			args: args{
+				URL: "starttls://smtp.gmail.com:587",
+			},
+			want: EndpointTypeSTARTTLS,
 		},
-		want: EndpointTypeSTARTTLS,
-	}, {
-		fields: fields{
-			URL: "tls://example.com:443",
+		{
+			args: args{
+				URL: "tls://example.com:443",
+			},
+			want: EndpointTypeTLS,
 		},
-		want: EndpointTypeTLS,
-	}, {
-		fields: fields{
-			URL: "https://twin.sh/health",
+		{
+			args: args{
+				URL: "https://twin.sh/health",
+			},
+			want: EndpointTypeHTTP,
 		},
-		want: EndpointTypeHTTP,
-	}}
+		{
+			args: args{
+				URL: "invalid://example.org",
+			},
+			want: EndpointTypeUNKNOWN,
+		},
+		{
+			args: args{
+				URL: "no-scheme",
+			},
+			want: EndpointTypeUNKNOWN,
+		},
+	}
 	for _, tt := range tests {
 		t.Run(string(tt.want), func(t *testing.T) {
 			endpoint := Endpoint{
-				URL: tt.fields.URL,
-				DNS: tt.fields.DNS,
+				URL: tt.args.URL,
+				DNS: tt.args.DNS,
 			}
 			if got := endpoint.Type(); got != tt.want {
 				t.Errorf("Endpoint.Type() = %v, want %v", got, tt.want)
@@ -124,11 +372,10 @@ func TestEndpoint_ValidateAndSetDefaults(t *testing.T) {
 }

 func TestEndpoint_ValidateAndSetDefaultsWithClientConfig(t *testing.T) {
-	condition := Condition("[STATUS] == 200")
 	endpoint := Endpoint{
 		Name:       "website-health",
 		URL:        "https://twin.sh/health",
-		Conditions: []Condition{condition},
+		Conditions: []Condition{Condition("[STATUS] == 200")},
 		ClientConfig: &client.Config{
 			Insecure:       true,
 			IgnoreRedirect: true,
@@ -151,51 +398,10 @@ func TestEndpoint_ValidateAndSetDefaultsWithClientConfig(t *testing.T) {
 	}
 }

-func TestEndpoint_ValidateAndSetDefaultsWithNoName(t *testing.T) {
-	defer func() { recover() }()
-	condition := Condition("[STATUS] == 200")
-	endpoint := &Endpoint{
-		Name:       "",
-		URL:        "http://example.com",
-		Conditions: []Condition{condition},
-	}
-	err := endpoint.ValidateAndSetDefaults()
-	if err == nil {
-		t.Fatal("Should've returned an error because endpoint didn't have a name, which is a mandatory field")
-	}
-}
-
-func TestEndpoint_ValidateAndSetDefaultsWithNoUrl(t *testing.T) {
-	defer func() { recover() }()
-	condition := Condition("[STATUS] == 200")
-	endpoint := &Endpoint{
-		Name:       "example",
-		URL:        "",
-		Conditions: []Condition{condition},
-	}
-	err := endpoint.ValidateAndSetDefaults()
-	if err == nil {
-		t.Fatal("Should've returned an error because endpoint didn't have an url, which is a mandatory field")
-	}
-}
-
-func TestEndpoint_ValidateAndSetDefaultsWithNoConditions(t *testing.T) {
-	defer func() { recover() }()
-	endpoint := &Endpoint{
-		Name:       "example",
-		URL:        "http://example.com",
-		Conditions: nil,
-	}
-	err := endpoint.ValidateAndSetDefaults()
-	if err == nil {
-		t.Fatal("Should've returned an error because endpoint didn't have at least 1 condition")
-	}
-}
-
 func TestEndpoint_ValidateAndSetDefaultsWithDNS(t *testing.T) {
 	endpoint := &Endpoint{
 		Name: "dns-test",
-		URL:  "http://example.com",
+		URL:  "https://example.com",
 		DNS: &DNS{
 			QueryType: "A",
 			QueryName: "example.com",
@@ -204,13 +410,70 @@ func TestEndpoint_ValidateAndSetDefaultsWithDNS(t *testing.T) {
 	}
 	err := endpoint.ValidateAndSetDefaults()
 	if err != nil {
-
+		t.Error("did not expect an error, got", err)
 	}
 	if endpoint.DNS.QueryName != "example.com." {
 		t.Error("Endpoint.dns.query-name should be formatted with . suffix")
 	}
 }

+func TestEndpoint_ValidateAndSetDefaultsWithSimpleErrors(t *testing.T) {
+	scenarios := []struct {
+		endpoint    *Endpoint
+		expectedErr error
+	}{
+		{
+			endpoint: &Endpoint{
+				Name:       "",
+				URL:        "https://example.com",
+				Conditions: []Condition{Condition("[STATUS] == 200")},
+			},
+			expectedErr: ErrEndpointWithNoName,
+		},
+		{
+			endpoint: &Endpoint{
+				Name:       "endpoint-with-no-url",
+				URL:        "",
+				Conditions: []Condition{Condition("[STATUS] == 200")},
+			},
+			expectedErr: ErrEndpointWithNoURL,
+		},
+		{
+			endpoint: &Endpoint{
+				Name:       "endpoint-with-no-conditions",
+				URL:        "https://example.com",
+				Conditions: nil,
+			},
+			expectedErr: ErrEndpointWithNoCondition,
+		},
+		{
+			endpoint: &Endpoint{
+				Name:       "domain-expiration-with-bad-interval",
+				URL:        "https://example.com",
+				Interval:   time.Minute,
+				Conditions: []Condition{Condition("[DOMAIN_EXPIRATION] > 720h")},
+			},
+			expectedErr: ErrInvalidEndpointIntervalForDomainExpirationPlaceholder,
+		},
+		{
+			endpoint: &Endpoint{
+				Name:       "domain-expiration-with-good-interval",
+				URL:        "https://example.com",
+				Interval:   5 * time.Minute,
+				Conditions: []Condition{Condition("[DOMAIN_EXPIRATION] > 720h")},
+			},
+			expectedErr: nil,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.endpoint.Name, func(t *testing.T) {
+			if err := scenario.endpoint.ValidateAndSetDefaults(); err != scenario.expectedErr {
+				t.Errorf("Expected error %v, got %v", scenario.expectedErr, err)
+			}
+		})
+	}
+}
+
 func TestEndpoint_buildHTTPRequest(t *testing.T) {
 	condition := Condition("[STATUS] == 200")
 	endpoint := Endpoint{
@@ -330,26 +593,6 @@ func TestIntegrationEvaluateHealth(t *testing.T) {
 	}
 }

-func TestIntegrationEvaluateHealthWithFailure(t *testing.T) {
-	condition := Condition("[STATUS] == 500")
-	endpoint := Endpoint{
-		Name:       "website-health",
-		URL:        "https://twin.sh/health",
-		Conditions: []Condition{condition},
-	}
-	endpoint.ValidateAndSetDefaults()
-	result := endpoint.EvaluateHealth()
-	if result.ConditionResults[0].Success {
-		t.Errorf("Condition '%s' should have been a failure", condition)
-	}
-	if !result.Connected {
-		t.Error("Because the connection has been established, result.Connected should've been true")
-	}
-	if result.Success {
-		t.Error("Because one of the conditions failed, result.Success should have been false")
-	}
-}
-
 func TestIntegrationEvaluateHealthWithInvalidCondition(t *testing.T) {
 	condition := Condition("[STATUS] invalid 200")
 	endpoint := Endpoint{
@@ -370,32 +613,6 @@ func TestIntegrationEvaluateHealthWithInvalidCondition(t *testing.T) {
 	}
 }

-func TestIntegrationEvaluateHealthWithError(t *testing.T) {
-	condition := Condition("[STATUS] == 200")
-	endpoint := Endpoint{
-		Name:       "invalid-host",
-		URL:        "http://invalid/health",
-		Conditions: []Condition{condition},
-		UIConfig: &ui.Config{
-			HideHostname: true,
-		},
-	}
-	endpoint.ValidateAndSetDefaults()
-	result := endpoint.EvaluateHealth()
-	if result.Success {
-		t.Error("Because one of the conditions was invalid, result.Success should have been false")
-	}
-	if len(result.Errors) == 0 {
-		t.Error("There should've been an error")
-	}
-	if !strings.Contains(result.Errors[0], "<redacted>") {
-		t.Error("result.Errors[0] should've had the hostname redacted because ui.hide-hostname is set to true")
-	}
-	if result.Hostname != "" {
-		t.Error("result.Hostname should've been empty because ui.hide-hostname is set to true")
-	}
-}
-
 func TestIntegrationEvaluateHealthWithErrorAndHideURL(t *testing.T) {
 	endpoint := Endpoint{
 		Name:       "invalid-url",
@@ -436,7 +653,7 @@ func TestIntegrationEvaluateHealthForDNS(t *testing.T) {
 	endpoint.ValidateAndSetDefaults()
 	result := endpoint.EvaluateHealth()
 	if !result.ConditionResults[0].Success {
-		t.Errorf("Conditions '%s' and %s should have been a success", conditionSuccess, conditionBody)
+		t.Errorf("Conditions '%s' and '%s' should have been a success", conditionSuccess, conditionBody)
 	}
 	if !result.Connected {
 		t.Error("Because the connection has been established, result.Connected should've been true")
@@ -447,16 +664,15 @@ func TestIntegrationEvaluateHealthForDNS(t *testing.T) {
 }

 func TestIntegrationEvaluateHealthForICMP(t *testing.T) {
-	conditionSuccess := Condition("[CONNECTED] == true")
 	endpoint := Endpoint{
 		Name:       "icmp-test",
 		URL:        "icmp://127.0.0.1",
-		Conditions: []Condition{conditionSuccess},
+		Conditions: []Condition{"[CONNECTED] == true"},
 	}
 	endpoint.ValidateAndSetDefaults()
 	result := endpoint.EvaluateHealth()
 	if !result.ConditionResults[0].Success {
-		t.Errorf("Conditions '%s' should have been a success", conditionSuccess)
+		t.Errorf("Conditions '%s' should have been a success", endpoint.Conditions[0])
 	}
 	if !result.Connected {
 		t.Error("Because the connection has been established, result.Connected should've been true")
@@ -467,11 +683,10 @@ func TestIntegrationEvaluateHealthForICMP(t *testing.T) {
 }

 func TestEndpoint_getIP(t *testing.T) {
-	conditionSuccess := Condition("[CONNECTED] == true")
 	endpoint := Endpoint{
 		Name:       "invalid-url-test",
 		URL:        "",
-		Conditions: []Condition{conditionSuccess},
+		Conditions: []Condition{"[CONNECTED] == true"},
 	}
 	result := &Result{}
 	endpoint.getIP(result)
@@ -480,7 +695,7 @@ func TestEndpoint_getIP(t *testing.T) {
 	}
 }

-func TestEndpoint_NeedsToReadBody(t *testing.T) {
+func TestEndpoint_needsToReadBody(t *testing.T) {
 	statusCondition := Condition("[STATUS] == 200")
 	bodyCondition := Condition("[BODY].status == UP")
 	bodyConditionWithLength := Condition("len([BODY].tags) > 0")
@@ -503,3 +718,21 @@ func TestEndpoint_NeedsToReadBody(t *testing.T) {
 		t.Error("expected true, got false")
 	}
 }
+
+func TestEndpoint_needsToRetrieveDomainExpiration(t *testing.T) {
+	if (&Endpoint{Conditions: []Condition{"[STATUS] == 200"}}).needsToRetrieveDomainExpiration() {
+		t.Error("expected false, got true")
+	}
+	if !(&Endpoint{Conditions: []Condition{"[STATUS] == 200", "[DOMAIN_EXPIRATION] < 720h"}}).needsToRetrieveDomainExpiration() {
+		t.Error("expected true, got false")
+	}
+}
+
+func TestEndpoint_needsToRetrieveIP(t *testing.T) {
+	if (&Endpoint{Conditions: []Condition{"[STATUS] == 200"}}).needsToRetrieveIP() {
+		t.Error("expected false, got true")
+	}
+	if !(&Endpoint{Conditions: []Condition{"[STATUS] == 200", "[IP] == 127.0.0.1"}}).needsToRetrieveIP() {
+		t.Error("expected true, got false")
+	}
+}
@@ -1,11 +0,0 @@
-package core
-
-// HealthStatus is the status of Gatus
-type HealthStatus struct {
-	// Status is the state of Gatus (UP/DOWN)
-	Status string `json:"status"`
-
-	// Message is an accompanying description of why the status is as reported.
-	// If the Status is UP, no message will be provided
-	Message string `json:"message,omitempty"`
-}
@@ -41,6 +41,9 @@ type Result struct {
 	// CertificateExpiration is the duration before the certificate expires
 	CertificateExpiration time.Duration `json:"-"`

+	// DomainExpiration is the duration before the domain expires
+	DomainExpiration time.Duration `json:"-"`
+
 	// body is the response body
 	//
 	// Note that this variable is only used during the evaluation of an Endpoint's health.
@@ -1,13 +1,48 @@
 package ui

+import "errors"
+
 // Config is the UI configuration for core.Endpoint
 type Config struct {
 	// HideHostname whether to hide the hostname in the Result
 	HideHostname bool `yaml:"hide-hostname"`
+
 	// HideURL whether to ensure the URL is not displayed in the results. Useful if the URL contains a token.
 	HideURL bool `yaml:"hide-url"`
+
 	// DontResolveFailedConditions whether to resolve failed conditions in the Result for display in the UI
 	DontResolveFailedConditions bool `yaml:"dont-resolve-failed-conditions"`
+
+	// Badge is the configuration for the badges generated
+	Badge *Badge `yaml:"badge"`
+}
+
+type Badge struct {
+	ResponseTime *ResponseTime `yaml:"response-time"`
+}
+
+type ResponseTime struct {
+	Thresholds []int `yaml:"thresholds"`
+}
+
+var (
+	ErrInvalidBadgeResponseTimeConfig = errors.New("invalid response time badge configuration: expected parameter 'response-time' to have 5 ascending numerical values")
+)
+
+func (config *Config) ValidateAndSetDefaults() error {
+	if config.Badge != nil {
+		if len(config.Badge.ResponseTime.Thresholds) != 5 {
+			return ErrInvalidBadgeResponseTimeConfig
+		}
+		for i := 4; i > 0; i-- {
+			if config.Badge.ResponseTime.Thresholds[i] < config.Badge.ResponseTime.Thresholds[i-1] {
+				return ErrInvalidBadgeResponseTimeConfig
+			}
+		}
+	} else {
+		config.Badge = GetDefaultConfig().Badge
+	}
+	return nil
 }

 // GetDefaultConfig retrieves the default UI configuration
@@ -16,5 +51,10 @@ func GetDefaultConfig() *Config {
 		HideHostname:                false,
 		HideURL:                     false,
 		DontResolveFailedConditions: false,
+		Badge: &Badge{
+			ResponseTime: &ResponseTime{
+				Thresholds: []int{50, 200, 300, 500, 750},
+			},
+		},
 	}
 }
@@ -4,8 +4,9 @@ go 1.18

 require (
 	github.com/TwiN/g8 v1.3.0
-	github.com/TwiN/gocache/v2 v2.0.0
+	github.com/TwiN/gocache/v2 v2.1.0
 	github.com/TwiN/health v1.4.0
+	github.com/TwiN/whois v1.0.0
 	github.com/coreos/go-oidc/v3 v3.1.0
 	github.com/go-ping/ping v0.0.0-20210911151512-381826476871
 	github.com/google/uuid v1.3.0
@@ -35,10 +35,12 @@ github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/TwiN/g8 v1.3.0 h1:mNv3R35GhDn1gEV0BKMl1oupZ1tDtOWPTHUKu+W/k3U=
 github.com/TwiN/g8 v1.3.0/go.mod h1:SiIdItS0agSUloFqdQQt/RObB2jGSq+nnE9WfFv3RIo=
-github.com/TwiN/gocache/v2 v2.0.0 h1:CPbDNKdSJpmBkh7aWcO7D3KK1yWaMlwX+3dsBPE8/so=
-github.com/TwiN/gocache/v2 v2.0.0/go.mod h1:j4MABVaia2Tp53ERWc/3l4YxkswtPjB2hQzmL/kD/VQ=
+github.com/TwiN/gocache/v2 v2.1.0 h1:AJnSX7Sgz22fsO7rdXYQzMQ4zWpMjBKqk70ADeqtLDU=
+github.com/TwiN/gocache/v2 v2.1.0/go.mod h1:AKHAFZSwLLmoLm1a2siDOWmZ2RjIKqentRGfOFWkllY=
 github.com/TwiN/health v1.4.0 h1:Ts7lb4ihYDpVEbFSGAhSEZTSwuDOADnwJLFngFl4xzw=
 github.com/TwiN/health v1.4.0/go.mod h1:CSUh+ryfD2POS2vKtc/yO4IxgR58lKvQ0/8qnoPqPqs=
+github.com/TwiN/whois v1.0.0 h1:I+aQzXLPmhWovkFUzlPV2DdfLZUWDLrkMDlM6QwCv+Q=
+github.com/TwiN/whois v1.0.0/go.mod h1:9WbCzYlR+r5eq9vbgJVh7A4H2uR2ct4wKEB0/QITJ/c=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
@@ -36,7 +36,7 @@ func main() {
 }

 func start(cfg *config.Config) {
-	go controller.Handle(cfg.Security, cfg.Web, cfg.UI, cfg.Metrics)
+	go controller.Handle(cfg)
 	watchdog.Monitor(cfg)
 	go listenToConfigurationFileChanges(cfg)
 }
@@ -19,6 +19,12 @@ type Config struct {
 	// Type of store
 	// If blank, uses the default in-memory store
 	Type Type `yaml:"type"`
+
+	// Caching is whether to enable caching.
+	// This is used to drastically decrease read latency by pre-emptively caching writes
+	// as they happen, also known as the write-through caching strategy.
+	// Does not apply if Config.Type is not TypePostgres or TypeSQLite.
+	Caching bool `yaml:"caching,omitempty"`
 }

 // ValidateAndSetDefaults validates the configuration and sets the default values (if applicable)
@@ -1,7 +1,6 @@
 package memory

 import (
-	"encoding/gob"
 	"sort"
 	"sync"
 	"time"
@@ -13,14 +12,6 @@ import (
 	"github.com/TwiN/gocache/v2"
 )

-func init() {
-	gob.Register(&core.EndpointStatus{})
-	gob.Register(&core.HourlyUptimeStatistics{})
-	gob.Register(&core.Uptime{})
-	gob.Register(&core.Result{})
-	gob.Register(&core.Event{})
-}
-
 // Store that leverages gocache
 type Store struct {
 	sync.RWMutex
@@ -32,7 +23,7 @@ type Store struct {
 //
 // This store holds everything in memory, and if the file parameter is not blank,
 // supports eventual persistence.
-func NewStore(file string) (*Store, error) {
+func NewStore() (*Store, error) {
 	store := &Store{
 		cache: gocache.NewCache().WithMaxSize(gocache.NoMaxSize),
 	}
@@ -82,7 +82,7 @@ var (
 // 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, _ := NewStore()
 	defer store.Close()
 	store.Insert(&testEndpoint, &testSuccessfulResult)
 	endpointStatuses, _ := store.GetAllEndpointStatuses(paging.NewEndpointStatusParams())
@@ -122,22 +122,14 @@ func TestStore_SanityCheck(t *testing.T) {
 }

 func TestStore_Save(t *testing.T) {
-	files := []string{
-		"",
-		t.TempDir() + "/test.db",
+	store, err := NewStore()
+	if err != nil {
+		t.Fatal("expected no error, got", err.Error())
 	}
-	for _, file := range files {
-		t.Run(file, func(t *testing.T) {
-			store, err := NewStore(file)
-			if err != nil {
-				t.Fatal("expected no error, got", err.Error())
-			}
-			err = store.Save()
-			if err != nil {
-				t.Fatal("expected no error, got", err.Error())
-			}
-			store.Clear()
-			store.Close()
-		})
+	err = store.Save()
+	if err != nil {
+		t.Fatal("expected no error, got", err.Error())
 	}
+	store.Clear()
+	store.Close()
 }
@@ -5,8 +5,8 @@ func (s *Store) createPostgresSchema() error {
 		CREATE TABLE IF NOT EXISTS endpoints (
 			endpoint_id    BIGSERIAL PRIMARY KEY,
 			endpoint_key   TEXT UNIQUE,
-			endpoint_name  TEXT,
-			endpoint_group TEXT,
+			endpoint_name  TEXT NOT NULL,
+			endpoint_group TEXT NOT NULL,
 			UNIQUE(endpoint_name, endpoint_group)
 		)
 	`)
@@ -16,9 +16,9 @@ func (s *Store) createPostgresSchema() error {
 	_, err = s.db.Exec(`
 		CREATE TABLE IF NOT EXISTS endpoint_events (
 			endpoint_event_id  BIGSERIAL PRIMARY KEY,
-			endpoint_id        INTEGER REFERENCES endpoints(endpoint_id) ON DELETE CASCADE,
-			event_type         TEXT,
-			event_timestamp    TIMESTAMP
+			endpoint_id        INTEGER   NOT NULL REFERENCES endpoints(endpoint_id) ON DELETE CASCADE,
+			event_type         TEXT      NOT NULL,
+			event_timestamp    TIMESTAMP NOT NULL
 		)
 	`)
 	if err != nil {
@@ -27,17 +27,18 @@ func (s *Store) createPostgresSchema() error {
 	_, err = s.db.Exec(`
 		CREATE TABLE IF NOT EXISTS endpoint_results (
 			endpoint_result_id     BIGSERIAL PRIMARY KEY,
-			endpoint_id            BIGINT REFERENCES endpoints(endpoint_id) ON DELETE CASCADE,
-			success                BOOLEAN,
-			errors                 TEXT,
-			connected              BOOLEAN,
-			status                 BIGINT,
-			dns_rcode              TEXT,
-			certificate_expiration BIGINT,
-			hostname               TEXT,
-			ip                     TEXT,
-			duration               BIGINT,
-			timestamp              TIMESTAMP
+			endpoint_id            BIGINT    NOT NULL REFERENCES endpoints(endpoint_id) ON DELETE CASCADE,
+			success                BOOLEAN   NOT NULL,
+			errors                 TEXT      NOT NULL,
+			connected              BOOLEAN   NOT NULL,
+			status                 BIGINT    NOT NULL,
+			dns_rcode              TEXT      NOT NULL,
+			certificate_expiration BIGINT    NOT NULL,
+			domain_expiration      BIGINT    NOT NULL,
+			hostname               TEXT      NOT NULL,
+			ip                     TEXT      NOT NULL,
+			duration               BIGINT    NOT NULL,
+			timestamp              TIMESTAMP NOT NULL
 		)
 	`)
 	if err != nil {
@@ -46,9 +47,9 @@ func (s *Store) createPostgresSchema() error {
 	_, err = s.db.Exec(`
 		CREATE TABLE IF NOT EXISTS endpoint_result_conditions (
 			endpoint_result_condition_id  BIGSERIAL PRIMARY KEY,
-			endpoint_result_id            BIGINT REFERENCES endpoint_results(endpoint_result_id) ON DELETE CASCADE,
-			condition                     TEXT,
-			success                       BOOLEAN
+			endpoint_result_id            BIGINT  NOT NULL REFERENCES endpoint_results(endpoint_result_id) ON DELETE CASCADE,
+			condition                     TEXT    NOT NULL,
+			success                       BOOLEAN NOT NULL
 		)
 	`)
 	if err != nil {
@@ -57,13 +58,15 @@ func (s *Store) createPostgresSchema() error {
 	_, err = s.db.Exec(`
 		CREATE TABLE IF NOT EXISTS endpoint_uptimes (
 			endpoint_uptime_id     BIGSERIAL PRIMARY KEY,
-			endpoint_id            BIGINT REFERENCES endpoints(endpoint_id) ON DELETE CASCADE,
-			hour_unix_timestamp    BIGINT,
-			total_executions       BIGINT,
-			successful_executions  BIGINT,
-			total_response_time    BIGINT,
+			endpoint_id            BIGINT NOT NULL REFERENCES endpoints(endpoint_id) ON DELETE CASCADE,
+			hour_unix_timestamp    BIGINT NOT NULL,
+			total_executions       BIGINT NOT NULL,
+			successful_executions  BIGINT NOT NULL,
+			total_response_time    BIGINT NOT NULL,
 			UNIQUE(endpoint_id, hour_unix_timestamp)
 		)
 	`)
+	// Silent table modifications
+	_, _ = s.db.Exec(`ALTER TABLE endpoint_results ADD IF NOT EXISTS domain_expiration BIGINT NOT NULL DEFAULT 0`)
 	return err
 }
@@ -5,8 +5,8 @@ func (s *Store) createSQLiteSchema() error {
 		CREATE TABLE IF NOT EXISTS endpoints (
 			endpoint_id    INTEGER PRIMARY KEY,
 			endpoint_key   TEXT UNIQUE,
-			endpoint_name  TEXT,
-			endpoint_group TEXT,
+			endpoint_name  TEXT NOT NULL,
+			endpoint_group TEXT NOT NULL,
 			UNIQUE(endpoint_name, endpoint_group)
 		)
 	`)
@@ -16,9 +16,9 @@ func (s *Store) createSQLiteSchema() error {
 	_, err = s.db.Exec(`
 		CREATE TABLE IF NOT EXISTS endpoint_events (
 			endpoint_event_id  INTEGER PRIMARY KEY,
-			endpoint_id        INTEGER REFERENCES endpoints(endpoint_id) ON DELETE CASCADE,
-			event_type         TEXT,
-			event_timestamp    TIMESTAMP
+			endpoint_id        INTEGER   NOT NULL REFERENCES endpoints(endpoint_id) ON DELETE CASCADE,
+			event_type         TEXT      NOT NULL,
+			event_timestamp    TIMESTAMP NOT NULL
 		)
 	`)
 	if err != nil {
@@ -27,17 +27,18 @@ func (s *Store) createSQLiteSchema() error {
 	_, err = s.db.Exec(`
 		CREATE TABLE IF NOT EXISTS endpoint_results (
 			endpoint_result_id     INTEGER PRIMARY KEY,
-			endpoint_id            INTEGER REFERENCES endpoints(endpoint_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
+			endpoint_id            INTEGER   NOT NULL REFERENCES endpoints(endpoint_id) ON DELETE CASCADE,
+			success                INTEGER   NOT NULL,
+			errors                 TEXT      NOT NULL,
+			connected              INTEGER   NOT NULL,
+			status                 INTEGER   NOT NULL,
+			dns_rcode              TEXT      NOT NULL,
+			certificate_expiration INTEGER   NOT NULL,
+		    domain_expiration      INTEGER   NOT NULL,
+			hostname               TEXT      NOT NULL,
+			ip                     TEXT      NOT NULL,
+			duration               INTEGER   NOT NULL,
+			timestamp              TIMESTAMP NOT NULL
 		)
 	`)
 	if err != nil {
@@ -46,9 +47,9 @@ func (s *Store) createSQLiteSchema() error {
 	_, err = s.db.Exec(`
 		CREATE TABLE IF NOT EXISTS endpoint_result_conditions (
 			endpoint_result_condition_id  INTEGER PRIMARY KEY,
-			endpoint_result_id            INTEGER REFERENCES endpoint_results(endpoint_result_id) ON DELETE CASCADE,
-			condition                     TEXT,
-			success                       INTEGER
+			endpoint_result_id            INTEGER NOT NULL REFERENCES endpoint_results(endpoint_result_id) ON DELETE CASCADE,
+			condition                     TEXT    NOT NULL,
+			success                       INTEGER NOT NULL
 		)
 	`)
 	if err != nil {
@@ -57,13 +58,15 @@ func (s *Store) createSQLiteSchema() error {
 	_, err = s.db.Exec(`
 		CREATE TABLE IF NOT EXISTS endpoint_uptimes (
 			endpoint_uptime_id    INTEGER PRIMARY KEY,
-			endpoint_id           INTEGER REFERENCES endpoints(endpoint_id) ON DELETE CASCADE,
-			hour_unix_timestamp   INTEGER,
-			total_executions      INTEGER,
-			successful_executions INTEGER,
-			total_response_time   INTEGER,
+			endpoint_id           INTEGER NOT NULL REFERENCES endpoints(endpoint_id) ON DELETE CASCADE,
+			hour_unix_timestamp   INTEGER NOT NULL,
+			total_executions      INTEGER NOT NULL,
+			successful_executions INTEGER NOT NULL,
+			total_response_time   INTEGER NOT NULL,
 			UNIQUE(endpoint_id, hour_unix_timestamp)
 		)
 	`)
+	// Silent table modifications TODO: Remove this
+	_, _ = s.db.Exec(`ALTER TABLE endpoint_results ADD domain_expiration INTEGER NOT NULL DEFAULT 0`)
 	return err
 }
@@ -13,6 +13,7 @@ import (
 	"github.com/TwiN/gatus/v4/storage/store/common"
 	"github.com/TwiN/gatus/v4/storage/store/common/paging"
 	"github.com/TwiN/gatus/v4/util"
+	"github.com/TwiN/gocache/v2"
 	_ "github.com/lib/pq"
 	_ "modernc.org/sqlite"
 )
@@ -32,6 +33,8 @@ const (
 	resultsCleanUpThreshold = common.MaximumNumberOfResults + 10 // Maximum number of results before triggering a clean up

 	uptimeRetention = 7 * 24 * time.Hour
+
+	cacheTTL = 10 * time.Minute
 )

 var (
@@ -49,10 +52,14 @@ type Store struct {
 	driver, path string

 	db *sql.DB
+
+	// writeThroughCache is a cache used to drastically decrease read latency by pre-emptively
+	// caching writes as they happen. If nil, writes are not cached.
+	writeThroughCache *gocache.Cache
 }

 // NewStore initializes the database and creates the schema if it doesn't already exist in the path specified
-func NewStore(driver, path string) (*Store, error) {
+func NewStore(driver, path string, caching bool) (*Store, error) {
 	if len(driver) == 0 {
 		return nil, ErrDatabaseDriverNotSpecified
 	}
@@ -79,6 +86,9 @@ func NewStore(driver, path string) (*Store, error) {
 		_ = store.db.Close()
 		return nil, err
 	}
+	if caching {
+		store.writeThroughCache = gocache.NewCache().WithMaxSize(10000)
+	}
 	return store, nil
 }

@@ -323,6 +333,19 @@ func (s *Store) Insert(endpoint *core.Endpoint, result *core.Result) error {
 			}
 		}
 	}
+	if s.writeThroughCache != nil {
+		cacheKeysToRefresh := s.writeThroughCache.GetKeysByPattern(endpoint.Key()+"*", 0)
+		for _, cacheKey := range cacheKeysToRefresh {
+			s.writeThroughCache.Delete(cacheKey)
+			endpointKey, params, err := extractKeyAndParamsFromCacheKey(cacheKey)
+			if err != nil {
+				log.Printf("[sql][Insert] Silently deleting cache key %s instead of refreshing due to error: %s", cacheKey, err.Error())
+				continue
+			}
+			// Retrieve the endpoint status by key, which will in turn refresh the cache
+			_, _ = s.getEndpointStatusByKey(tx, endpointKey, params)
+		}
+	}
 	if err = tx.Commit(); err != nil {
 		_ = tx.Rollback()
 	}
@@ -350,6 +373,11 @@ func (s *Store) DeleteAllEndpointStatusesNotInKeys(keys []string) int {
 		log.Printf("[sql][DeleteAllEndpointStatusesNotInKeys] Failed to delete rows that do not belong to any of keys=%v: %s", keys, err.Error())
 		return 0
 	}
+	if s.writeThroughCache != nil {
+		// It's easier to just wipe out the entire cache than to try to find all keys that are not in the keys list
+		_ = s.writeThroughCache.DeleteKeysByPattern("*")
+	}
+	// Return number of rows deleted
 	rowsAffects, _ := result.RowsAffected()
 	return int(rowsAffects)
 }
@@ -357,6 +385,9 @@ func (s *Store) DeleteAllEndpointStatusesNotInKeys(keys []string) int {
 // Clear deletes everything from the store
 func (s *Store) Clear() {
 	_, _ = s.db.Exec("DELETE FROM endpoints")
+	if s.writeThroughCache != nil {
+		_ = s.writeThroughCache.DeleteKeysByPattern("*")
+	}
 }

 // Save does nothing, because this store is immediately persistent.
@@ -367,6 +398,10 @@ func (s *Store) Save() error {
 // Close the database handle
 func (s *Store) Close() {
 	_ = s.db.Close()
+	if s.writeThroughCache != nil {
+		// Clear the cache too. If the store's been closed, we don't want to keep the cache around.
+		_ = s.writeThroughCache.DeleteKeysByPattern("*")
+	}
 }

 // insertEndpoint inserts an endpoint in the store and returns the generated id of said endpoint
@@ -404,8 +439,8 @@ func (s *Store) insertEndpointResult(tx *sql.Tx, endpointID int64, result *core.
 	var endpointResultID int64
 	err := tx.QueryRow(
 		`
-			INSERT INTO endpoint_results (endpoint_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)
+			INSERT INTO endpoint_results (endpoint_id, success, errors, connected, status, dns_rcode, certificate_expiration, domain_expiration, hostname, ip, duration, timestamp)
+			VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
 			RETURNING endpoint_result_id
 		`,
 		endpointID,
@@ -415,6 +450,7 @@ func (s *Store) insertEndpointResult(tx *sql.Tx, endpointID int64, result *core.
 		result.HTTPStatus,
 		result.DNSRCode,
 		result.CertificateExpiration,
+		result.DomainExpiration,
 		result.Hostname,
 		result.IP,
 		result.Duration,
@@ -479,6 +515,15 @@ func (s *Store) getAllEndpointKeys(tx *sql.Tx) (keys []string, err error) {
 }

 func (s *Store) getEndpointStatusByKey(tx *sql.Tx, key string, parameters *paging.EndpointStatusParams) (*core.EndpointStatus, error) {
+	var cacheKey string
+	if s.writeThroughCache != nil {
+		cacheKey = generateCacheKey(key, parameters)
+		if cachedEndpointStatus, exists := s.writeThroughCache.Get(cacheKey); exists {
+			if castedCachedEndpointStatus, ok := cachedEndpointStatus.(*core.EndpointStatus); ok {
+				return castedCachedEndpointStatus, nil
+			}
+		}
+	}
 	endpointID, group, endpointName, err := s.getEndpointIDGroupAndNameByKey(tx, key)
 	if err != nil {
 		return nil, err
@@ -494,6 +539,9 @@ func (s *Store) getEndpointStatusByKey(tx *sql.Tx, key string, parameters *pagin
 			log.Printf("[sql][getEndpointStatusByKey] Failed to retrieve results for key=%s: %s", key, err.Error())
 		}
 	}
+	if s.writeThroughCache != nil {
+		s.writeThroughCache.SetWithTTL(cacheKey, endpointStatus, cacheTTL)
+	}
 	return endpointStatus, nil
 }

@@ -543,7 +591,7 @@ func (s *Store) getEndpointEventsByEndpointID(tx *sql.Tx, endpointID int64, page
 func (s *Store) getEndpointResultsByEndpointID(tx *sql.Tx, endpointID int64, page, pageSize int) (results []*core.Result, err error) {
 	rows, err := tx.Query(
 		`
-			SELECT endpoint_result_id, success, errors, connected, status, dns_rcode, certificate_expiration, hostname, ip, duration, timestamp
+			SELECT endpoint_result_id, success, errors, connected, status, dns_rcode, certificate_expiration, domain_expiration, hostname, ip, duration, timestamp
 			FROM endpoint_results
 			WHERE endpoint_id = $1
 			ORDER BY endpoint_result_id DESC -- Normally, we'd sort by timestamp, but sorting by endpoint_result_id is faster
@@ -561,7 +609,11 @@ func (s *Store) getEndpointResultsByEndpointID(tx *sql.Tx, endpointID int64, pag
 		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)
+		err = rows.Scan(&id, &result.Success, &joinedErrors, &result.Connected, &result.HTTPStatus, &result.DNSRCode, &result.CertificateExpiration, &result.DomainExpiration, &result.Hostname, &result.IP, &result.Duration, &result.Timestamp)
+		if err != nil {
+			log.Printf("[sql][getEndpointResultsByEndpointID] Silently failed to retrieve endpoint result for endpointID=%d: %s", endpointID, err.Error())
+			err = nil
+		}
 		if len(joinedErrors) != 0 {
 			result.Errors = strings.Split(joinedErrors, arraySeparator)
 		}
@@ -788,3 +840,29 @@ func (s *Store) deleteOldUptimeEntries(tx *sql.Tx, endpointID int64, maxAge time
 	_, err := tx.Exec("DELETE FROM endpoint_uptimes WHERE endpoint_id = $1 AND hour_unix_timestamp < $2", endpointID, maxAge.Unix())
 	return err
 }
+
+func generateCacheKey(endpointKey string, p *paging.EndpointStatusParams) string {
+	return fmt.Sprintf("%s-%d-%d-%d-%d", endpointKey, p.EventsPage, p.EventsPageSize, p.ResultsPage, p.ResultsPageSize)
+}
+
+func extractKeyAndParamsFromCacheKey(cacheKey string) (string, *paging.EndpointStatusParams, error) {
+	parts := strings.Split(cacheKey, "-")
+	if len(parts) < 5 {
+		return "", nil, fmt.Errorf("invalid cache key: %s", cacheKey)
+	}
+	params := &paging.EndpointStatusParams{}
+	var err error
+	if params.EventsPage, err = strconv.Atoi(parts[len(parts)-4]); err != nil {
+		return "", nil, fmt.Errorf("invalid cache key: %s", err.Error())
+	}
+	if params.EventsPageSize, err = strconv.Atoi(parts[len(parts)-3]); err != nil {
+		return "", nil, fmt.Errorf("invalid cache key: %s", err.Error())
+	}
+	if params.ResultsPage, err = strconv.Atoi(parts[len(parts)-2]); err != nil {
+		return "", nil, fmt.Errorf("invalid cache key: %s", err.Error())
+	}
+	if params.ResultsPageSize, err = strconv.Atoi(parts[len(parts)-1]); err != nil {
+		return "", nil, fmt.Errorf("invalid cache key: %s", err.Error())
+	}
+	return strings.Join(parts[:len(parts)-4], "-"), params, nil
+}
@@ -81,13 +81,13 @@ var (
 )

 func TestNewStore(t *testing.T) {
-	if _, err := NewStore("", "TestNewStore.db"); err != ErrDatabaseDriverNotSpecified {
+	if _, err := NewStore("", "TestNewStore.db", false); err != ErrDatabaseDriverNotSpecified {
 		t.Error("expected error due to blank driver parameter")
 	}
-	if _, err := NewStore("sqlite", ""); err != ErrPathNotSpecified {
+	if _, err := NewStore("sqlite", "", false); err != ErrPathNotSpecified {
 		t.Error("expected error due to blank path parameter")
 	}
-	if store, err := NewStore("sqlite", t.TempDir()+"/TestNewStore.db"); err != nil {
+	if store, err := NewStore("sqlite", t.TempDir()+"/TestNewStore.db", false); err != nil {
 		t.Error("shouldn't have returned any error, got", err.Error())
 	} else {
 		_ = store.db.Close()
@@ -95,7 +95,7 @@ func TestNewStore(t *testing.T) {
 }

 func TestStore_InsertCleansUpOldUptimeEntriesProperly(t *testing.T) {
-	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_InsertCleansUpOldUptimeEntriesProperly.db")
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_InsertCleansUpOldUptimeEntriesProperly.db", false)
 	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())
@@ -152,7 +152,7 @@ func TestStore_InsertCleansUpOldUptimeEntriesProperly(t *testing.T) {
 }

 func TestStore_InsertCleansUpEventsAndResultsProperly(t *testing.T) {
-	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_InsertCleansUpEventsAndResultsProperly.db")
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_InsertCleansUpEventsAndResultsProperly.db", false)
 	defer store.Close()
 	for i := 0; i < resultsCleanUpThreshold+eventsCleanUpThreshold; i++ {
 		store.Insert(&testEndpoint, &testSuccessfulResult)
@@ -170,7 +170,7 @@ func TestStore_InsertCleansUpEventsAndResultsProperly(t *testing.T) {

 func TestStore_Persistence(t *testing.T) {
 	path := t.TempDir() + "/TestStore_Persistence.db"
-	store, _ := NewStore("sqlite", path)
+	store, _ := NewStore("sqlite", path, false)
 	store.Insert(&testEndpoint, &testSuccessfulResult)
 	store.Insert(&testEndpoint, &testUnsuccessfulResult)
 	if uptime, _ := store.GetUptimeByKey(testEndpoint.Key(), time.Now().Add(-time.Hour), time.Now()); uptime != 0.5 {
@@ -188,7 +188,7 @@ func TestStore_Persistence(t *testing.T) {
 		t.Fatal("sanity check failed")
 	}
 	store.Close()
-	store, _ = NewStore("sqlite", path)
+	store, _ = NewStore("sqlite", path, false)
 	defer store.Close()
 	ssFromNewStore, _ := store.GetEndpointStatus(testEndpoint.Group, testEndpoint.Name, paging.NewEndpointStatusParams().WithResults(1, common.MaximumNumberOfResults).WithEvents(1, common.MaximumNumberOfEvents))
 	if ssFromNewStore == nil || ssFromNewStore.Group != "group" || ssFromNewStore.Name != "name" || len(ssFromNewStore.Events) != 3 || len(ssFromNewStore.Results) != 2 {
@@ -252,7 +252,7 @@ func TestStore_Persistence(t *testing.T) {
 }

 func TestStore_Save(t *testing.T) {
-	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_Save.db")
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_Save.db", false)
 	defer store.Close()
 	if store.Save() != nil {
 		t.Error("Save shouldn't do anything for this store")
@@ -262,7 +262,7 @@ func TestStore_Save(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("sqlite", t.TempDir()+"/TestStore_SanityCheck.db")
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_SanityCheck.db", false)
 	defer store.Close()
 	store.Insert(&testEndpoint, &testSuccessfulResult)
 	endpointStatuses, _ := store.GetAllEndpointStatuses(paging.NewEndpointStatusParams())
@@ -306,7 +306,7 @@ func TestStore_SanityCheck(t *testing.T) {

 // 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")
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_InvalidTransaction.db", false)
 	defer store.Close()
 	tx, _ := store.db.Begin()
 	tx.Commit()
@@ -364,7 +364,7 @@ func TestStore_InvalidTransaction(t *testing.T) {
 }

 func TestStore_NoRows(t *testing.T) {
-	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_NoRows.db")
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_NoRows.db", false)
 	defer store.Close()
 	tx, _ := store.db.Begin()
 	defer tx.Rollback()
@@ -378,7 +378,7 @@ func TestStore_NoRows(t *testing.T) {

 // This tests very unlikely cases where a table is deleted.
 func TestStore_BrokenSchema(t *testing.T) {
-	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_BrokenSchema.db")
+	store, _ := NewStore("sqlite", t.TempDir()+"/TestStore_BrokenSchema.db", false)
 	defer store.Close()
 	if err := store.Insert(&testEndpoint, &testSuccessfulResult); err != nil {
 		t.Fatal("expected no error, got", err.Error())
@@ -391,6 +391,7 @@ func TestStore_BrokenSchema(t *testing.T) {
 	}
 	// Break
 	_, _ = store.db.Exec("DROP TABLE endpoints")
+	// And now we'll try to insert something in our broken schema
 	if err := store.Insert(&testEndpoint, &testSuccessfulResult); err == nil {
 		t.Fatal("expected an error")
 	}
@@ -477,3 +478,89 @@ func TestStore_BrokenSchema(t *testing.T) {
 		t.Fatal("expected an error")
 	}
 }
+
+func TestCacheKey(t *testing.T) {
+	scenarios := []struct {
+		endpointKey      string
+		params           paging.EndpointStatusParams
+		overrideCacheKey string
+		expectedCacheKey string
+		wantErr          bool
+	}{
+		{
+			endpointKey:      "simple",
+			params:           paging.EndpointStatusParams{EventsPage: 1, EventsPageSize: 2, ResultsPage: 3, ResultsPageSize: 4},
+			expectedCacheKey: "simple-1-2-3-4",
+			wantErr:          false,
+		},
+		{
+			endpointKey:      "with-hyphen",
+			params:           paging.EndpointStatusParams{EventsPage: 0, EventsPageSize: 0, ResultsPage: 1, ResultsPageSize: 20},
+			expectedCacheKey: "with-hyphen-0-0-1-20",
+			wantErr:          false,
+		},
+		{
+			endpointKey:      "with-multiple-hyphens",
+			params:           paging.EndpointStatusParams{EventsPage: 0, EventsPageSize: 0, ResultsPage: 2, ResultsPageSize: 20},
+			expectedCacheKey: "with-multiple-hyphens-0-0-2-20",
+			wantErr:          false,
+		},
+		{
+			overrideCacheKey: "invalid-a-2-3-4",
+			wantErr:          true,
+		},
+		{
+			overrideCacheKey: "invalid-1-a-3-4",
+			wantErr:          true,
+		},
+		{
+			overrideCacheKey: "invalid-1-2-a-4",
+			wantErr:          true,
+		},
+		{
+			overrideCacheKey: "invalid-1-2-3-a",
+			wantErr:          true,
+		},
+		{
+			overrideCacheKey: "notenoughhyphen1-2-3-4",
+			wantErr:          true,
+		},
+	}
+	for _, scenario := range scenarios {
+		t.Run(scenario.expectedCacheKey+scenario.overrideCacheKey, func(t *testing.T) {
+			var cacheKey string
+			if len(scenario.overrideCacheKey) > 0 {
+				cacheKey = scenario.overrideCacheKey
+			} else {
+				cacheKey = generateCacheKey(scenario.endpointKey, &scenario.params)
+				if cacheKey != scenario.expectedCacheKey {
+					t.Errorf("expected %s, got %s", scenario.expectedCacheKey, cacheKey)
+				}
+			}
+			extractedEndpointKey, extractedParams, err := extractKeyAndParamsFromCacheKey(cacheKey)
+			if (err != nil) != scenario.wantErr {
+				t.Errorf("expected error %v, got %v", scenario.wantErr, err)
+				return
+			}
+			if err != nil {
+				// If there's an error, we don't need to check the extracted values
+				return
+			}
+			if extractedEndpointKey != scenario.endpointKey {
+				t.Errorf("expected endpointKey %s, got %s", scenario.endpointKey, extractedEndpointKey)
+			}
+			if extractedParams.EventsPage != scenario.params.EventsPage {
+				t.Errorf("expected EventsPage %d, got %d", scenario.params.EventsPage, extractedParams.EventsPage)
+			}
+			if extractedParams.EventsPageSize != scenario.params.EventsPageSize {
+				t.Errorf("expected EventsPageSize %d, got %d", scenario.params.EventsPageSize, extractedParams.EventsPageSize)
+			}
+			if extractedParams.ResultsPage != scenario.params.ResultsPage {
+				t.Errorf("expected ResultsPage %d, got %d", scenario.params.ResultsPage, extractedParams.ResultsPage)
+			}
+			if extractedParams.ResultsPageSize != scenario.params.ResultsPageSize {
+				t.Errorf("expected ResultsPageSize %d, got %d", scenario.params.ResultsPageSize, extractedParams.ResultsPageSize)
+			}
+		})
+	}
+}
@@ -12,7 +12,7 @@ import (
 	"github.com/TwiN/gatus/v4/storage/store/sql"
 )

-// Store is the interface that each stores should implement
+// Store is the interface that each store should implement
 type Store interface {
 	// GetAllEndpointStatuses returns the JSON encoding of all monitored core.EndpointStatus
 	// with a subset of core.Result defined by the page and pageSize parameters
@@ -103,22 +103,14 @@ func Initialize(cfg *storage.Config) error {
 	ctx, cancelFunc = context.WithCancel(context.Background())
 	switch cfg.Type {
 	case storage.TypeSQLite, storage.TypePostgres:
-		store, err = sql.NewStore(string(cfg.Type), cfg.Path)
+		store, err = sql.NewStore(string(cfg.Type), cfg.Path, cfg.Caching)
 		if err != nil {
 			return err
 		}
 	case storage.TypeMemory:
 		fallthrough
 	default:
-		if len(cfg.Path) > 0 {
-			store, err = memory.NewStore(cfg.Path)
-			if err != nil {
-				return err
-			}
-			go autoSave(ctx, store, 7*time.Minute)
-		} else {
-			store, _ = memory.NewStore("")
-		}
+		store, _ = memory.NewStore()
 	}
 	return nil
 }
@@ -12,11 +12,11 @@ import (
 )

 func BenchmarkStore_GetAllEndpointStatuses(b *testing.B) {
-	memoryStore, err := memory.NewStore("")
+	memoryStore, err := memory.NewStore()
 	if err != nil {
 		b.Fatal("failed to create store:", err.Error())
 	}
-	sqliteStore, err := sql.NewStore("sqlite", b.TempDir()+"/BenchmarkStore_GetAllEndpointStatuses.db")
+	sqliteStore, err := sql.NewStore("sqlite", b.TempDir()+"/BenchmarkStore_GetAllEndpointStatuses.db", false)
 	if err != nil {
 		b.Fatal("failed to create store:", err.Error())
 	}
@@ -81,11 +81,11 @@ func BenchmarkStore_GetAllEndpointStatuses(b *testing.B) {
 }

 func BenchmarkStore_Insert(b *testing.B) {
-	memoryStore, err := memory.NewStore("")
+	memoryStore, err := memory.NewStore()
 	if err != nil {
 		b.Fatal("failed to create store:", err.Error())
 	}
-	sqliteStore, err := sql.NewStore("sqlite", b.TempDir()+"/BenchmarkStore_Insert.db")
+	sqliteStore, err := sql.NewStore("sqlite", b.TempDir()+"/BenchmarkStore_Insert.db", false)
 	if err != nil {
 		b.Fatal("failed to create store:", err.Error())
 	}
@@ -153,11 +153,11 @@ func BenchmarkStore_Insert(b *testing.B) {
 }

 func BenchmarkStore_GetEndpointStatusByKey(b *testing.B) {
-	memoryStore, err := memory.NewStore("")
+	memoryStore, err := memory.NewStore()
 	if err != nil {
 		b.Fatal("failed to create store:", err.Error())
 	}
-	sqliteStore, err := sql.NewStore("sqlite", b.TempDir()+"/BenchmarkStore_GetEndpointStatusByKey.db")
+	sqliteStore, err := sql.NewStore("sqlite", b.TempDir()+"/BenchmarkStore_GetEndpointStatusByKey.db", false)
 	if err != nil {
 		b.Fatal("failed to create store:", err.Error())
 	}
@@ -89,11 +89,15 @@ type Scenario struct {
 }

 func initStoresAndBaseScenarios(t *testing.T, testName string) []*Scenario {
-	memoryStore, err := memory.NewStore("")
+	memoryStore, err := memory.NewStore()
 	if err != nil {
 		t.Fatal("failed to create store:", err.Error())
 	}
-	sqliteStore, err := sql.NewStore("sqlite", t.TempDir()+"/"+testName+".db")
+	sqliteStore, err := sql.NewStore("sqlite", t.TempDir()+"/"+testName+".db", false)
+	if err != nil {
+		t.Fatal("failed to create store:", err.Error())
+	}
+	sqliteStoreWithCaching, err := sql.NewStore("sqlite", t.TempDir()+"/"+testName+"-with-caching.db", true)
 	if err != nil {
 		t.Fatal("failed to create store:", err.Error())
 	}
@@ -106,6 +110,10 @@ func initStoresAndBaseScenarios(t *testing.T, testName string) []*Scenario {
 			Name:  "sqlite",
 			Store: sqliteStore,
 		},
+		{
+			Name:  "sqlite-with-caching",
+			Store: sqliteStoreWithCaching,
+		},
 	}
 }

@@ -528,17 +536,17 @@ func TestStore_DeleteAllEndpointStatusesNotInKeys(t *testing.T) {
 			scenario.Store.Insert(&firstEndpoint, result)
 			scenario.Store.Insert(&secondEndpoint, result)
 			if ss, _ := scenario.Store.GetEndpointStatusByKey(firstEndpoint.Key(), paging.NewEndpointStatusParams()); ss == nil {
-				t.Fatal("firstEndpoint should exist")
+				t.Fatal("firstEndpoint should exist, got", ss)
 			}
 			if ss, _ := scenario.Store.GetEndpointStatusByKey(secondEndpoint.Key(), paging.NewEndpointStatusParams()); ss == nil {
-				t.Fatal("secondEndpoint should exist")
+				t.Fatal("secondEndpoint should exist, got", ss)
 			}
 			scenario.Store.DeleteAllEndpointStatusesNotInKeys([]string{firstEndpoint.Key()})
 			if ss, _ := scenario.Store.GetEndpointStatusByKey(firstEndpoint.Key(), paging.NewEndpointStatusParams()); ss == nil {
-				t.Error("secondEndpoint should've been deleted")
+				t.Error("secondEndpoint should still exist, got", ss)
 			}
 			if ss, _ := scenario.Store.GetEndpointStatusByKey(secondEndpoint.Key(), paging.NewEndpointStatusParams()); ss != nil {
-				t.Error("firstEndpoint should still exist")
+				t.Error("firstEndpoint should have been deleted, got", ss)
 			}
 			// Delete everything
 			scenario.Store.DeleteAllEndpointStatusesNotInKeys([]string{})
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2021 TwiN
+Copyright (c) 2022 TwiN

 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:

@@ -1,9 +1,9 @@
 # gocache
-![build](https://github.com/TwiN/gocache/workflows/build/badge.svg?branch=master) 
+![test](https://github.com/TwiN/gocache/workflows/test/badge.svg?branch=master) 
 [![Go Report Card](https://goreportcard.com/badge/github.com/TwiN/gocache)](https://goreportcard.com/report/github.com/TwiN/gocache)
 [![codecov](https://codecov.io/gh/TwiN/gocache/branch/master/graph/badge.svg)](https://codecov.io/gh/TwiN/gocache)
 [![Go version](https://img.shields.io/github/go-mod/go-version/TwiN/gocache.svg)](https://github.com/TwiN/gocache)
-[![Go Reference](https://pkg.go.dev/badge/github.com/TwiN/gocache.svg)](https://pkg.go.dev/github.com/TwiN/gocache)
+[![Go Reference](https://pkg.go.dev/badge/github.com/TwiN/gocache.svg)](https://pkg.go.dev/github.com/TwiN/gocache/v2)
 [![Follow TwiN](https://img.shields.io/github/followers/TwiN?label=Follow&style=social)](https://github.com/TwiN)

 gocache is an easy-to-use, high-performance, lightweight and thread-safe (goroutine-safe) in-memory key-value cache 
@@ -65,27 +65,28 @@ cache.StartJanitor()
 ```

 ### Functions
-| Function                          | Description |
-| --------------------------------- | ----------- |
-| WithMaxSize                       | Sets the max size of the cache. `gocache.NoMaxSize` means there is no limit. If not set, the default max size is `gocache.DefaultMaxSize`.
-| WithMaxMemoryUsage                | Sets the max memory usage of the cache. `gocache.NoMaxMemoryUsage` means there is no limit. The default behavior is to not evict based on memory usage.
-| WithEvictionPolicy                | Sets the eviction algorithm to be used when the cache reaches the max size. If not set, the default eviction policy is `gocache.FirstInFirstOut` (FIFO).
-| WithForceNilInterfaceOnNilPointer | Configures whether values with a nil pointer passed to write functions should be forcefully set to nil. Defaults to true.
-| StartJanitor                      | Starts the janitor, which is in charge of deleting expired cache entries in the background.
-| StopJanitor                       | Stops the janitor.
-| Set                               | Same as `SetWithTTL`, but with no expiration (`gocache.NoExpiration`)
-| SetAll                            | Same as `Set`, but in bulk
-| SetWithTTL                        | Creates or updates a cache entry with the given key, value and expiration time. If the max size after the aforementioned operation is above the configured max size, the tail will be evicted. Depending on the eviction policy, the tail is defined as the oldest 
-| Get                               | Gets a cache entry by its key.
-| GetByKeys                         | Gets a map of entries by their keys. The resulting map will contain all keys, even if some of the keys in the slice passed as parameter were not present in the cache.  
-| GetAll                            | Gets all cache entries.
-| GetKeysByPattern                  | Retrieves a slice of keys that matches a given pattern.
-| Delete                            | Removes a key from the cache.
-| DeleteAll                         | Removes multiple keys from the cache.
-| Count                             | Gets the size of the cache. This includes cache keys which may have already expired, but have not been removed yet.
-| Clear                             | Wipes the cache.
-| TTL                               | Gets the time until a cache key expires. 
-| Expire                            | Sets the expiration time of an existing cache key.
+| Function                          | Description                                                                                                                                                                                                                                                        |
+|-----------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| WithMaxSize                       | Sets the max size of the cache. `gocache.NoMaxSize` means there is no limit. If not set, the default max size is `gocache.DefaultMaxSize`.                                                                                                                         |
+| WithMaxMemoryUsage                | Sets the max memory usage of the cache. `gocache.NoMaxMemoryUsage` means there is no limit. The default behavior is to not evict based on memory usage.                                                                                                            |
+| WithEvictionPolicy                | Sets the eviction algorithm to be used when the cache reaches the max size. If not set, the default eviction policy is `gocache.FirstInFirstOut` (FIFO).                                                                                                           |
+| WithForceNilInterfaceOnNilPointer | Configures whether values with a nil pointer passed to write functions should be forcefully set to nil. Defaults to true.                                                                                                                                          |
+| StartJanitor                      | Starts the janitor, which is in charge of deleting expired cache entries in the background.                                                                                                                                                                        |
+| StopJanitor                       | Stops the janitor.                                                                                                                                                                                                                                                 |
+| Set                               | Same as `SetWithTTL`, but with no expiration (`gocache.NoExpiration`)                                                                                                                                                                                              |
+| SetAll                            | Same as `Set`, but in bulk                                                                                                                                                                                                                                         |
+| SetWithTTL                        | Creates or updates a cache entry with the given key, value and expiration time. If the max size after the aforementioned operation is above the configured max size, the tail will be evicted. Depending on the eviction policy, the tail is defined as the oldest |
+| Get                               | Gets a cache entry by its key.                                                                                                                                                                                                                                     |
+| GetByKeys                         | Gets a map of entries by their keys. The resulting map will contain all keys, even if some of the keys in the slice passed as parameter were not present in the cache.                                                                                             |
+| GetAll                            | Gets all cache entries.                                                                                                                                                                                                                                            |
+| GetKeysByPattern                  | Retrieves a slice of keys that matches a given pattern.                                                                                                                                                                                                            |
+| Delete                            | Removes a key from the cache.                                                                                                                                                                                                                                      |
+| DeleteAll                         | Removes multiple keys from the cache.                                                                                                                                                                                                                              |
+| DeleteKeysByPattern               | Removes all keys that that matches a given pattern.                                                                                                                                                                                                                |
+| Count                             | Gets the size of the cache. This includes cache keys which may have already expired, but have not been removed yet.                                                                                                                                                |
+| Clear                             | Wipes the cache.                                                                                                                                                                                                                                                   |
+| TTL                               | Gets the time until a cache key expires.                                                                                                                                                                                                                           |
+| Expire                            | Sets the expiration time of an existing cache key.                                                                                                                                                                                                                 |

 For further documentation, please refer to [Go Reference](https://pkg.go.dev/github.com/TwiN/gocache)

@@ -132,7 +133,7 @@ func main() {
    cache.SetWithTTL("key-with-ttl", "value", 60*time.Minute)
    cache.SetAll(map[string]interface{}{"k1": "v1", "k2": "v2", "k3": "v3"})

-	fmt.Println("[Count] Cache size:", cache.Count())
+    fmt.Println("[Count] Cache size:", cache.Count())

    value, exists := cache.Get("key")
    fmt.Printf("[Get] key=key; value=%s; exists=%v\n", value, exists)
@@ -345,8 +346,8 @@ import (
 var cache = gocache.NewCache()

 func main() {
-	data := retrieveCacheEntriesUsingWhateverMeanYouUsedToPersistIt()
-	cache.SetAll(data)
+    data := retrieveCacheEntriesUsingWhateverMeanYouUsedToPersistIt()
+    cache.SetAll(data)
    // Start everything else on another goroutine to prevent blocking the main goroutine
    go Start()
    // Wait for termination signal
@@ -311,8 +311,8 @@ func (cache *Cache) Get(key string) (interface{}, bool) {
 	cache.mutex.Lock()
 	entry, ok := cache.get(key)
 	if !ok {
-		cache.mutex.Unlock()
 		cache.stats.Misses++
+		cache.mutex.Unlock()
 		return nil, false
 	}
 	if entry.Expired() {
@@ -388,8 +388,7 @@ func (cache *Cache) GetAll() map[string]interface{} {
 //     cache.GetKeysByPattern("*some*", 0) will return all keys containing "some" in them
 //     cache.GetKeysByPattern("*some*", 5) will return 5 keys (or less) containing "some" in them
 //
-// Note that GetKeysByPattern does not trigger active evictions, nor does it count as accessing the entry, the latter
-// only applying if the cache uses the LeastRecentlyUsed eviction policy.
+// Note that GetKeysByPattern does not trigger active evictions, nor does it count as accessing the entry (if LRU).
 // The reason for that behavior is that these two (active eviction and access) only applies when you access the value
 // of the cache entry, and this function only returns the keys.
 func (cache *Cache) GetKeysByPattern(pattern string, limit int) []string {
@@ -435,6 +434,13 @@ func (cache *Cache) DeleteAll(keys []string) int {
 	return numberOfKeysDeleted
 }

+// DeleteKeysByPattern deletes all entries matching a given key pattern and returns the number of entries deleted.
+//
+// Note that DeleteKeysByPattern does not trigger active evictions, nor does it count as accessing the entry (if LRU).
+func (cache *Cache) DeleteKeysByPattern(pattern string) int {
+	return cache.DeleteAll(cache.GetKeysByPattern(pattern, 0))
+}
+
 // Count returns the total amount of entries in the cache, regardless of whether they're expired or not
 func (cache *Cache) Count() int {
 	cache.mutex.RLock()
@@ -0,0 +1,2 @@
+.idea
+bin
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 TwiN
+
+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:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -0,0 +1,4 @@
+.PHONY: build-binaries
+
+build-binaries:
+	./scripts/build.sh
@@ -0,0 +1,65 @@
+# whois
+![test](https://github.com/TwiN/whois/workflows/test/badge.svg?branch=master)
+
+Lightweight library for retrieving WHOIS information on a domain.
+
+It automatically retrieves the appropriate WHOIS server based on the domain's TLD by first querying IANA.
+
+
+## Usage
+### As an executable
+To install it:
+```console
+go install github.com/TwiN/whois/cmd/whois@latest
+```
+To run it:
+```console 
+whois example.com
+```
+
+### As a library
+```console
+go get github.com/TwiN/whois
+```
+
+#### Query
+If all you want is the text a WHOIS server would return you, you can use the `Query` method of the `whois.Client` type:
+```go
+package main
+
+import "github.com/TwiN/whois"
+
+func main() {
+    client := whois.NewClient()
+    output, err := client.Query("example.com")
+    if err != nil {
+    	panic(err)
+    }
+    println(output)
+}
+```
+
+#### QueryAndParse
+If you want specific pieces of information, you can use the `QueryAndParse` method of the `whois.Client` type:
+```go
+package main
+
+import "github.com/TwiN/whois"
+
+func main() {
+    client := whois.NewClient()
+    response, err := client.QueryAndParse("example.com")
+    if err != nil {
+    	panic(err)
+    }
+    println(response.ExpirationDate.String()) 
+}
+```
+Note that because there is no standardized format for WHOIS responses, this parsing may not be successful for every single TLD.
+
+Currently, the only fields parsed are:
+- `ExpirationDate`: The time.Time at which the domain will expire
+- `DomainStatuses`: The statuses that the domain currently has (e.g. `clientTransferProhibited`)
+- `NameServers`: The nameservers currently tied to the domain
+
+If you'd like one or more other fields to be parsed, please don't be shy and create an issue or a pull request.
@@ -0,0 +1,94 @@
+package whois
+
+import (
+	"io"
+	"net"
+	"strings"
+	"time"
+)
+
+const (
+	ianaWHOISServerAddress = "whois.iana.org:43"
+)
+
+type Client struct {
+	whoisServerAddress string
+}
+
+func NewClient() *Client {
+	return &Client{
+		whoisServerAddress: ianaWHOISServerAddress,
+	}
+}
+
+func (c Client) Query(domain string) (string, error) {
+	parts := strings.Split(domain, ".")
+	output, err := c.query(c.whoisServerAddress, parts[len(parts)-1])
+	if err != nil {
+		return "", err
+	}
+	if strings.Contains(output, "whois:") {
+		startIndex := strings.Index(output, "whois:") + 6
+		endIndex := strings.Index(output[startIndex:], "\n") + startIndex
+		whois := strings.TrimSpace(output[startIndex:endIndex])
+		if referOutput, err := c.query(whois+":43", domain); err == nil {
+			return referOutput, nil
+		}
+		return "", err
+	}
+	return output, nil
+}
+
+func (c Client) query(whoisServerAddress, domain string) (string, error) {
+	connection, err := net.DialTimeout("tcp", whoisServerAddress, 10*time.Second)
+	if err != nil {
+		return "", err
+	}
+	defer connection.Close()
+	connection.SetDeadline(time.Now().Add(5 * time.Second))
+	_, err = connection.Write([]byte(domain + "\r\n"))
+	if err != nil {
+		return "", err
+	}
+	output, err := io.ReadAll(connection)
+	if err != nil {
+		return "", err
+	}
+	return string(output), nil
+}
+
+type Response struct {
+	ExpirationDate time.Time
+	DomainStatuses []string
+	NameServers    []string
+}
+
+// QueryAndParse tries to parse the response from the WHOIS server
+// There is no standardized format for WHOIS responses, so this is an attempt at best.
+//
+// Being the selfish person that I am, I also only parse the fields that I need.
+// If you need more fields, please open an issue or pull request.
+func (c Client) QueryAndParse(domain string) (*Response, error) {
+	text, err := c.Query(domain)
+	if err != nil {
+		return nil, err
+	}
+	response := Response{}
+	for _, line := range strings.Split(text, "\n") {
+		line = strings.TrimSpace(line)
+		valueStartIndex := strings.Index(line, ":")
+		if valueStartIndex == -1 {
+			continue
+		}
+		key := strings.ToLower(strings.TrimSpace(line[:valueStartIndex]))
+		value := strings.TrimSpace(line[valueStartIndex+1:])
+		if response.ExpirationDate.Unix() != 0 && strings.Contains(key, "expir") && strings.Contains(key, "date") {
+			response.ExpirationDate, _ = time.Parse(time.RFC3339, strings.ToUpper(value))
+		} else if strings.Contains(key, "domain status") {
+			response.DomainStatuses = append(response.DomainStatuses, value)
+		} else if strings.Contains(key, "name server") {
+			response.NameServers = append(response.NameServers, value)
+		}
+	}
+	return &response, nil
+}
@@ -1,12 +1,15 @@
 # github.com/TwiN/g8 v1.3.0
 ## explicit; go 1.17
 github.com/TwiN/g8
-# github.com/TwiN/gocache/v2 v2.0.0
-## explicit; go 1.17
+# github.com/TwiN/gocache/v2 v2.1.0
+## explicit; go 1.18
 github.com/TwiN/gocache/v2
 # github.com/TwiN/health v1.4.0
 ## explicit; go 1.18
 github.com/TwiN/health
+# github.com/TwiN/whois v1.0.0
+## explicit; go 1.19
+github.com/TwiN/whois
 # github.com/beorn7/perks v1.0.1
 ## explicit; go 1.11
 github.com/beorn7/perks/quantile
@@ -9,6 +9,7 @@ import (
 	"github.com/TwiN/gatus/v4/alerting/provider/custom"
 	"github.com/TwiN/gatus/v4/alerting/provider/discord"
 	"github.com/TwiN/gatus/v4/alerting/provider/email"
+	"github.com/TwiN/gatus/v4/alerting/provider/matrix"
 	"github.com/TwiN/gatus/v4/alerting/provider/mattermost"
 	"github.com/TwiN/gatus/v4/alerting/provider/messagebird"
 	"github.com/TwiN/gatus/v4/alerting/provider/pagerduty"
@@ -312,6 +313,19 @@ func TestHandleAlertingWithProviderThatReturnsAnError(t *testing.T) {
 				},
 			},
 		},
+		{
+			Name:      "matrix",
+			AlertType: alert.TypeMatrix,
+			AlertingConfig: &alerting.Config{
+				Matrix: &matrix.AlertProvider{
+					MatrixProviderConfig: matrix.MatrixProviderConfig{
+						ServerURL:      "https://example.com",
+						AccessToken:    "1",
+						InternalRoomID: "!a:example.com",
+					},
+				},
+			},
+		},
 	}

 	for _, scenario := range scenarios {
@@ -1,6 +1,6 @@
 {
  "name": "gatus",
-  "version": "3.8.0",
+  "version": "4.0.0",
  "private": true,
  "scripts": {
    "serve": "vue-cli-service serve --mode development",
@@ -23,7 +23,7 @@
    "eslint": "7.32.0",
    "eslint-plugin-vue": "7.20.0",
    "postcss": "8.4.14",
-    "tailwindcss": "3.1.2"
+    "tailwindcss": "^3.1.8"
  },
  "eslintConfig": {
    "root": true,
@@ -29,12 +29,12 @@
    </h2>
    <div class="mt-8 py-7 px-4 rounded-sm sm:bg-gray-100 sm:border sm:border-gray-300 sm:shadow-2xl sm:px-10">
      <div class="sm:mx-auto sm:w-full">
-        <h2 class="mb-4 text-center text-xl font-bold text-gray-600 dark:text-gray-200 dark:sm:text-gray-600 ">
+        <h2 class="mb-3 text-center text-xl font-bold text-gray-600 dark:text-gray-200 dark:sm:text-gray-600 ">
          Sign in
        </h2>
      </div>
-      <div v-if="$route && $route.query.error" class="text-red-500 text-center my-2">
-        <div class="text-xl">
+      <div v-if="$route && $route.query.error" class="text-red-500 text-center mb-5">
+        <div class="text-sm">
          <span class="text-red-500" v-if="$route.query.error === 'access_denied'">You do not have access to this status page</span>
          <span class="text-red-500" v-else>{{ $route.query.error }}</span>
        </div>
@@ -65,29 +65,27 @@
    <div v-if="endpointStatus && endpointStatus.key">
      <h1 class="text-xl xl:text-3xl font-mono text-gray-400 mt-4">EVENTS</h1>
      <hr />
-      <div>
-        <slot v-for="event in events" :key="event">
-          <div class="p-3 my-4">
-            <h2 class="text-lg">
-              <img v-if="event.type === 'HEALTHY'" src="../assets/arrow-up-green.png" alt="Healthy"
-                   class="border border-green-600 rounded-full opacity-75 bg-green-100 mr-2 inline" width="26"/>
-              <img v-else-if="event.type === 'UNHEALTHY'" src="../assets/arrow-down-red.png" alt="Unhealthy"
-                   class="border border-red-500 rounded-full opacity-75 bg-red-100 mr-2 inline" width="26"/>
-              <img v-else-if="event.type === 'START'" src="../assets/arrow-right-black.png" alt="Start"
-                   class="border border-gray-500 rounded-full opacity-75 bg-gray-100 mr-2 inline" width="26"/>
-              {{ event.fancyText }}
-            </h2>
-            <div class="flex mt-1 text-sm text-gray-400">
-              <div class="flex-1 text-left pl-10">
-                {{ prettifyTimestamp(event.timestamp) }}
-              </div>
-              <div class="flex-1 text-right">
-                {{ event.fancyTimeAgo }}
-              </div>
+      <ul role="list" class="px-0 xl:px-24 divide-y divide-gray-200 dark:divide-gray-600">
+        <li v-for="event in events" :key="event" class="p-3 my-4">
+          <h2 class="text-lg">
+            <img v-if="event.type === 'HEALTHY'" src="../assets/arrow-up-green.png" alt="Healthy"
+                 class="border border-green-600 rounded-full opacity-75 bg-green-100 mr-2 inline" width="26"/>
+            <img v-else-if="event.type === 'UNHEALTHY'" src="../assets/arrow-down-red.png" alt="Unhealthy"
+                 class="border border-red-500 rounded-full opacity-75 bg-red-100 mr-2 inline" width="26"/>
+            <img v-else-if="event.type === 'START'" src="../assets/arrow-right-black.png" alt="Start"
+                 class="border border-gray-500 rounded-full opacity-75 bg-gray-100 mr-2 inline" width="26"/>
+            {{ event.fancyText }}
+          </h2>
+          <div class="flex mt-1 text-sm text-gray-400">
+            <div class="flex-1 text-left pl-10">
+              {{ prettifyTimestamp(event.timestamp) }}
+            </div>
+            <div class="flex-1 text-right">
+              {{ event.fancyTimeAgo }}
            </div>
          </div>
-        </slot>
-      </div>
+        </li>
+      </ul>
    </div>
  </div>
  <Settings @refreshData="fetchData"/>
@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><script>window.config = {logo: "{{ .Logo }}", header: "{{ .Header }}", link: "{{ .Link }}", buttons: []};{{- range .Buttons}}window.config.buttons.push({name:"{{ .Name }}",link:"{{ .Link }}"});{{end}}</script><title>{{ .Title }}</title><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width,initial-scale=1"><link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png"/><link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png"/><link rel="shortcut icon" href="/favicon.ico"/><meta property="description" content="Gatus is an advanced automated status page that lets you monitor your applications and configure alerts to notify you if there's an issue"/><script defer="defer" type="module" src="/js/chunk-vendors.js"></script><script defer="defer" type="module" src="/js/app.js"></script><link href="/css/app.css" rel="stylesheet"><script defer="defer" src="/js/chunk-vendors-legacy.js" nomodule></script><script defer="defer" src="/js/app-legacy.js" nomodule></script></head><body class="dark:bg-gray-900"><noscript><strong>Enable JavaScript to view this page.</strong></noscript><div id="app"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><script>window.config = {logo: "{{ .Logo }}", header: "{{ .Header }}", link: "{{ .Link }}", buttons: []};{{- range .Buttons}}window.config.buttons.push({name:"{{ .Name }}",link:"{{ .Link }}"});{{end}}</script><title>{{ .Title }}</title><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width,initial-scale=1"><link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png"/><link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png"/><link rel="shortcut icon" href="/favicon.ico"/><meta property="description" content="Gatus is an advanced automated status page that lets you monitor your applications and configure alerts to notify you if there's an issue"/><script defer="defer" src="/js/chunk-vendors.js"></script><script defer="defer" src="/js/app.js"></script><link href="/css/app.css" rel="stylesheet"></head><body class="dark:bg-gray-900"><noscript><strong>Enable JavaScript to view this page.</strong></noscript><div id="app"></div></body></html>
Author	SHA1	Message	Date
TwiN	38054f57e5	feat: Set minimum interval for endpoints with [DOMAIN_EXPIRATION] to 5m	2022-09-15 21:23:14 -04:00
TwiN	33ce0e99b5	chore: Fix typo in deprecation message	2022-09-15 17:41:24 -04:00
TwiN	b5e6466c1d	docs(security): Link "Securing Gatus with OIDC using Auth0" article	2022-09-09 22:59:13 -04:00
TwiN	f89ecd5c64	fix(ui): Decrease size of error message	2022-09-09 22:58:45 -04:00
TwiN	e434178a5c	test(alerting): Make sure ClientConfig is set after IsValid() call in Telegram provider	2022-09-07 19:02:30 -04:00
Lukas SchlöttererandGitHub	7a3ee1b557	feat(alerting): add client config for telegram (#324 )	2022-09-07 18:50:59 -04:00
TwiN	e51abaf5bd	chore: Add check-domain-expiration to placeholder configuration file	2022-09-07 18:19:57 -04:00
TwiN	46d6d6c733	test(alerting): Improve coverage for custom alerting provider	2022-09-07 18:19:20 -04:00
TwiN	d9f86f1155	fix(storage): Default domain_expiration to 0 for SQL when the column doesn't already exist This will prevent temporary issues with the parsing of old results that would otherwise have a value of NULL for domain_expiration Fixes an issue introduced by #325	2022-09-07 18:18:26 -04:00
TwiNandGitHub	01484832fc	feat: Add [DOMAIN_EXPIRATION] placeholder for monitoring domain expiration using WHOIS (#325 ) * feat: Add [DOMAIN_EXPIRATION] placeholder for monitoring domain expiration using WHOIS * test: Fix issue caused by possibility of millisecond elapsed during previous tests * test: Fix test with different behavior based on architecture * docs: Revert accidental change to starttls example * docs: Fix mistake in comment for Condition.hasIPPlaceholder()	2022-09-06 21:22:02 -04:00
TwiN	4857b43771	test: Improve coverage for Endpoint.Type()	2022-09-01 21:12:29 -04:00
TwiN	52d7cb6f04	ux: Improve endpoint validation by checking type on start	2022-09-01 21:12:29 -04:00
TwiN	5c6bf84106	ux: Improve error message when endpoint is invalid	2022-09-01 21:12:29 -04:00
TwiN	c84ae1cd55	refactor: Remove unused file	2022-09-01 21:12:29 -04:00
TwiN	daf8e3a16f	test(chart): Improve coverage for response time charts	2022-08-30 20:00:04 -04:00
TwiN	df719958cf	chore(remote): Log message about feature being a candidate for removal	2022-08-23 21:38:50 -04:00
TwiN	2be81b8e1a	docs(remote): Add "Remote instances (EXPERIMENTAL)" section	2022-08-22 18:26:36 -04:00
TwiN	4bed86dec9	ui(event): Add divider between each event	2022-08-18 20:24:52 -04:00
TwiN	072cf20cc6	chore(dependencies): Update tailwindcss to 3.1.8	2022-08-18 20:24:08 -04:00
TwiN	cca421e283	refactor(storage): Remove TODO comment about writeThroughCache	2022-08-18 19:29:39 -04:00
TwiN	a044f1d274	docs(storage): Add documentation for storage.caching	2022-08-18 19:29:39 -04:00
TwiN	9de6334f21	feat(storage): Add optional write-through cache to sql store	2022-08-18 19:29:39 -04:00
TwiNandGitHub	f01b66f083	refactor(storage): Remove decommissioned path for memory store (#313 )	2022-08-11 20:42:56 -04:00
TwiN	262d436533	ci: Remove paths-ignore since workflow_run doesn't support it	2022-08-11 20:33:25 -04:00
TwiN	b8ab17eee1	ci: Decrease timeout-minutes to 20	2022-08-11 20:31:36 -04:00
TwiN	7bbd7bcee3	ci: Stop publish-latest from being triggered by changes in .github folder	2022-08-11 20:29:33 -04:00
TwiN	4865d12147	chore(ci): Remove redundant input Since we now get to pick from what branch to execute the workflow, it is no longer necessary to have a branch input.	2022-08-11 20:27:48 -04:00
TwiN	0713ca1c1a	chore(ci): Remove useless "description" parameter	2022-08-11 20:25:10 -04:00
TwiN	dce202d0be	feat(ci): Add publish-experimental workflow	2022-08-11 20:24:23 -04:00
TwiN	4673d147db	chore(ci): Update docker/login-action to v2	2022-08-11 20:17:17 -04:00
TwiN	0943c45ae6	test(badge): Add test cases for custom response-time badge thresholds	2022-08-10 21:26:36 -04:00
TwiN	798c4248ff	refactor(badge): Fix formatting	2022-08-10 21:09:22 -04:00
Jesibu GitHub TwiN	1bce4e727e	feat(api): Configurable response time badge thresholds (#309 ) * recreated all changes for setting thresholds on Uptime Badges * Suggestion accepted: Update core/ui/ui.go Co-authored-by: TwiN <twin@linux.com> * Suggestion accepted: Update core/ui/ui.go Co-authored-by: TwiN <twin@linux.com> * implemented final suggestions by Twin * Update controller/handler/badge.go * Update README.md * test: added the suggestons to set the UiConfig at another line Co-authored-by: TwiN <twin@linux.com>	2022-08-10 21:05:34 -04:00
TwiN	1aa94a3365	feat(remote): Implement lazy distributed feature (#64 ) THIS IS AN EXPERIMENTAL FEATURE/IMPLEMENTATION, AND IT MAY BE REMOVED IN THE FUTURE. Note that for now, it will be an undocumented feature.	2022-07-28 20:29:29 -04:00
TwiN	319f460553	docs: Update GetHTTPClient comment	2022-07-28 20:29:29 -04:00
TwiN	7daf2b5cac	legal: Revert change to copyright appendix relevant: #203	2022-07-28 17:55:23 -04:00
TwiNandGitHub	f0fc275f67	legal: Update copyright dates	2022-07-28 09:20:42 -04:00
KalissaacandTwiN	04a682eddc	style(alerting): Alphabetically sort Matrix provider	2022-07-20 19:00:12 -04:00
KalissaacandTwiN	2fb807632c	style(alerting): Add comments and rename character bytes constant	2022-07-20 19:00:12 -04:00
KalissaacandTwiN	4b339bca37	fix(alerting): Update Matrix send endpoint to v3	2022-07-20 19:00:12 -04:00
KalissaacandTwiN	09c3a6c72b	fix(alerting): Reuse MatrixProviderConfig struct	2022-07-20 19:00:12 -04:00
KalissaacandTwiN	755c8bb43a	fix(alerting): Alphabetically sort Matrix provider	2022-07-20 19:00:12 -04:00
KalissaacandTwiN	9d4a639f31	test(alerting): Add Matrix tests	2022-07-20 19:00:12 -04:00
KalissaacandTwiN	60e6b2b039	docs(alerting): Add Matrix alerts to README	2022-07-20 19:00:12 -04:00
KalissaacandTwiN	37f3f964ea	feat(alerts): Add Matrix alert provider	2022-07-20 19:00:12 -04:00
TwiN	4a1a8ff380	ci: Increase timeout-minutes to 60	2022-07-18 20:45:42 -04:00
TwiN	6787fed062	docs: Update feedback/question contact	2022-07-14 18:13:46 -04:00