Quick start
```console docker run -p 8080:8080 --name gatus ghcr.io/twin/gatus:stable ``` You can also use Docker Hub if you prefer: ```console docker run -p 8080:8080 --name gatus twinproduction/gatus:stable ``` For more details, see [Usage](#usage)Example Domain
*)" # Body must contain the specified header ``` This example would look similar to this:  If you want to test it locally, see [Docker](#docker). ## Configuration By default, the configuration file is expected to be at `config/config.yaml`. You can specify a custom path by setting the `GATUS_CONFIG_PATH` environment variable. If `GATUS_CONFIG_PATH` points to a directory, all `*.yaml` and `*.yml` files inside said directory and its subdirectories are merged like so: - All maps/objects are deep merged (i.e. you could define `alerting.slack` in one file and `alerting.pagerduty` in another file) - All slices/arrays are appended (i.e. you can define `endpoints` in multiple files and each endpoint will be added to the final list of endpoints) - Parameters with a primitive value (e.g. `metrics`, `alerting.slack.webhook-url`, etc.) may only be defined once to forcefully avoid any ambiguity - To clarify, this also means that you could not define `alerting.slack.webhook-url` in two files with different values. All files are merged into one before they are processed. This is by design. > 💡 You can also use environment variables in the configuration file (e.g. `$DOMAIN`, `${DOMAIN}`) > > ⚠️ When your configuration parameter contains a `$` symbol, you have to escape `$` with `$$`. > > See [Use environment variables in config files](#use-environment-variables-in-config-files) or [examples/docker-compose-postgres-storage/config/config.yaml](.examples/docker-compose-postgres-storage/config/config.yaml) for examples. If you want to test it locally, see [Docker](#docker). ## Configuration | Parameter | Description | Default | |:-----------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------|:--------------| | `metrics` | Whether to expose metrics at `/metrics`. | `false` | | `storage` | [Storage configuration](#storage). | `{}` | | `alerting` | [Alerting configuration](#alerting). | `{}` | | `announcements` | [Announcements configuration](#announcements). | `[]` | | `endpoints` | [Endpoints configuration](#endpoints). | Required `[]` | | `external-endpoints` | [External Endpoints configuration](#external-endpoints). | `[]` | | `security` | [Security configuration](#security). | `{}` | | `concurrency` | Maximum number of endpoints/suites to monitor concurrently. Set to `0` for unlimited. See [Concurrency](#concurrency). | `3` | | `disable-monitoring-lock` | Whether to [disable the monitoring lock](#disable-monitoring-lock). **Deprecated**: Use `concurrency: 0` instead. | `false` | | `skip-invalid-config-update` | Whether to ignore invalid configuration update.See [Reloading configuration on the fly](#reloading-configuration-on-the-fly). | `false` | | `web` | [Web configuration](#web). | `{}` | | `ui` | [UI configuration](#ui). | `{}` | | `maintenance` | [Maintenance configuration](#maintenance). | `{}` | If you want more verbose logging, you may set the `GATUS_LOG_LEVEL` environment variable to `DEBUG`. Conversely, if you want less verbose logging, you can set the aforementioned environment variable to `WARN`, `ERROR` or `FATAL`. The default value for `GATUS_LOG_LEVEL` is `INFO`. ### Endpoints Endpoints are URLs, applications, or services that you want to monitor. Each endpoint has a list of conditions that are evaluated on an interval that you define. If any condition fails, the endpoint is considered as unhealthy. You can then configure alerts to be triggered when an endpoint is unhealthy once a certain threshold is reached. | Parameter | Description | Default | |:------------------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------| | `endpoints` | List of endpoints to monitor. | Required `[]` | | `endpoints[].enabled` | Whether to monitor the endpoint. | `true` | | `endpoints[].name` | Name of the endpoint. Can be anything. | Required `""` | | `endpoints[].group` | Group name. Used to group multiple endpoints together on the dashboard.
See [Endpoint groups](#endpoint-groups). | `""` | | `endpoints[].url` | URL to send the request to. | Required `""` | | `endpoints[].method` | Request method. | `GET` | | `endpoints[].conditions` | Conditions used to determine the health of the endpoint.
See [Conditions](#conditions). | `[]` | | `endpoints[].interval` | Duration to wait between every status check. | `60s` | | `endpoints[].graphql` | Whether to wrap the body in a query param (`{"query":"$body"}`). | `false` | | `endpoints[].body` | Request body. | `""` | | `endpoints[].headers` | Request headers. | `{}` | | `endpoints[].dns` | Configuration for an endpoint of type DNS.
See [Monitoring an endpoint using DNS queries](#monitoring-an-endpoint-using-dns-queries). | `""` | | `endpoints[].dns.query-type` | Query type (e.g. MX). | `""` | | `endpoints[].dns.query-name` | Query name (e.g. example.com). | `""` | | `endpoints[].ssh` | Configuration for an endpoint of type SSH.
See [Monitoring an endpoint using SSH](#monitoring-an-endpoint-using-ssh). | `""` | | `endpoints[].ssh.username` | SSH username (e.g. example). | Required `""` | | `endpoints[].ssh.password` | SSH password (e.g. password). | Required `""` | | `endpoints[].alerts` | List of all alerts for a given endpoint.
See [Alerting](#alerting). | `[]` | | `endpoints[].maintenance-windows` | List of all maintenance windows for a given endpoint.
See [Maintenance](#maintenance). | `[]` | | `endpoints[].client` | [Client configuration](#client-configuration). | `{}` | | `endpoints[].ui` | UI configuration at the endpoint level. | `{}` | | `endpoints[].ui.hide-conditions` | Whether to hide conditions from the results. Note that this only hides conditions from results evaluated from the moment this was enabled. | `false` | | `endpoints[].ui.hide-hostname` | Whether to hide the hostname from the results. | `false` | | `endpoints[].ui.hide-port` | Whether to hide the port from the results. | `false` | | `endpoints[].ui.hide-url` | Whether to hide the URL from the results. Useful if the URL contains a token. | `false` | | `endpoints[].ui.hide-errors` | Whether to hide errors from the results. | `false` | | `endpoints[].ui.dont-resolve-failed-conditions` | Whether to resolve failed conditions for the UI. | `false` | | `endpoints[].ui.resolve-successful-conditions` | Whether to resolve successful conditions for the UI (helpful to expose body assertions even when checks pass). | `false` | | `endpoints[].ui.badge.response-time` | List of response time thresholds. Each time a threshold is reached, the badge has a different color. | `[50, 200, 300, 500, 750]` | | `endpoints[].extra-labels` | Extra labels to add to the metrics. Useful for grouping endpoints together. | `{}` | | `endpoints[].always-run` | (SUITES ONLY) Whether to execute this endpoint even if previous endpoints in the suite failed. | `false` | | `endpoints[].store` | (SUITES ONLY) Map of values to extract from the response and store in the suite context (stored even on failure). | `{}` | You may use the following placeholders in the body (`endpoints[].body`): - `[ENDPOINT_NAME]` (resolved from `endpoints[].name`) - `[ENDPOINT_GROUP]` (resolved from `endpoints[].group`) - `[ENDPOINT_URL]` (resolved from `endpoints[].url`) - `[LOCAL_ADDRESS]` (resolves to the local IP and port like `192.0.2.1:25` or `[2001:db8::1]:80`) - `[RANDOM_STRING_N]` (resolves to a random string of numbers and letters of length N (max: 8192)) ### External Endpoints Unlike regular endpoints, external endpoints are not monitored by Gatus, but they are instead pushed programmatically. This allows you to monitor anything you want, even when what you want to check lives in an environment that would not normally be accessible by Gatus. For instance: - You can create your own agent that lives in a private network and pushes the status of your services to a publicly-exposed Gatus instance - You can monitor services that are not supported by Gatus - You can implement your own monitoring system while using Gatus as the dashboard | Parameter | Description | Default | |:------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------|:---------------| | `external-endpoints` | List of endpoints to monitor. | `[]` | | `external-endpoints[].enabled` | Whether to monitor the endpoint. | `true` | | `external-endpoints[].name` | Name of the endpoint. Can be anything. | Required `""` | | `external-endpoints[].group` | Group name. Used to group multiple endpoints together on the dashboard.
See [Endpoint groups](#endpoint-groups). | `""` | | `external-endpoints[].token` | Bearer token required to push status to. | Required `""` | | `external-endpoints[].alerts` | List of all alerts for a given endpoint.
See [Alerting](#alerting). | `[]` | | `external-endpoints[].heartbeat` | Heartbeat configuration for monitoring when the external endpoint stops sending updates. | `{}` | | `external-endpoints[].heartbeat.interval` | Expected interval between updates. If no update is received within this interval, alerts will be triggered. Must be at least 10s. | `0` (disabled) | Example: ```yaml external-endpoints: - name: ext-ep-test group: core token: "potato" heartbeat: interval: 30m # Automatically create a failure if no update is received within 30 minutes alerts: - type: discord description: "healthcheck failed" send-on-resolved: true ``` To push the status of an external endpoint, you can use [gatus-cli](https://github.com/TwiN/gatus-cli): ``` gatus-cli external-endpoint push --url https://status.example.org --key "core_ext-ep-test" --token "potato" --success ``` or send an HTTP request: ``` POST /api/v1/endpoints/{key}/external?success={success}&error={error}&duration={duration} ``` Where: - `{key}` has the pattern `
Only supported if `storage.type` is `sqlite` or `postgres` | `false` | | `storage.maximum-number-of-results` | The maximum number of results that an endpoint can have | `100` | | `storage.maximum-number-of-events` | The maximum number of events that an endpoint can have | `50` | The results for each endpoint health check as well as the data for uptime and the past events must be persisted so that they can be displayed on the dashboard. These parameters allow you to configure the storage in question. - If `storage.type` is `memory` (default): ```yaml # Note that this is the default value, and you can omit the storage configuration altogether to achieve the same result. # Because the data is stored in memory, the data will not survive a restart. storage: type: memory maximum-number-of-results: 200 maximum-number-of-events: 5 ``` - If `storage.type` is `sqlite`, `storage.path` must not be blank: ```yaml storage: type: sqlite path: data.db ``` See [examples/docker-compose-sqlite-storage](.examples/docker-compose-sqlite-storage) for an example. - If `storage.type` is `postgres`, `storage.path` must be the connection URL: ```yaml storage: type: postgres path: "postgres://user:password@127.0.0.1:5432/gatus?sslmode=disable" ``` See [examples/docker-compose-postgres-storage](.examples/docker-compose-postgres-storage) for an example. ### Client configuration 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 | |:---------------------------------------|:------------------------------------------------------------------------------|:----------------| | `client.insecure` | Whether to skip verifying the server's certificate chain and host name. | `false` | | `client.ignore-redirect` | Whether to ignore redirects (true) or follow them (false, default). | `false` | | `client.timeout` | Duration before timing out. | `10s` | | `client.dns-resolver` | Override the DNS resolver using the format `{proto}://{host}:{port}`. | `""` | | `client.oauth2` | OAuth2 client configuration. | `{}` | | `client.oauth2.token-url` | The token endpoint URL | required `""` | | `client.oauth2.client-id` | The client id which should be used for the `Client credentials flow` | required `""` | | `client.oauth2.client-secret` | The client secret which should be used for the `Client credentials flow` | required `""` | | `client.oauth2.scopes[]` | A list of `scopes` which should be used for the `Client credentials flow`. | required `[""]` | | `client.proxy-url` | The URL of the proxy to use for the client | `""` | | `client.identity-aware-proxy` | Google Identity-Aware-Proxy client configuration. | `{}` | | `client.identity-aware-proxy.audience` | The Identity-Aware-Proxy audience. (client-id of the IAP oauth2 credential) | required `""` | | `client.tls.certificate-file` | Path to a client certificate (in PEM format) for mTLS configurations. | `""` | | `client.tls.private-key-file` | Path to a client private key (in PEM format) for mTLS configurations. | `""` | | `client.tls.renegotiation` | Type of renegotiation support to provide. (`never`, `freely`, `once`). | `"never"` | | `client.network` | The network to use for ICMP endpoint client (`ip`, `ip4` or `ip6`). | `"ip"` | | `client.tunnel` | Name of the SSH tunnel to use for this endpoint. See [Tunneling](#tunneling). | `""` | > 📝 Some of these parameters are ignored based on the type of endpoint. For instance, there's no certificate involved > in ICMP requests (ping), therefore, setting `client.insecure` to `true` for an endpoint of that type will not do anything. This default configuration is as follows: ```yaml client: insecure: false ignore-redirect: false timeout: 10s ``` Note that this configuration is only available under `endpoints[]`, `alerting.mattermost` and `alerting.custom`. Here's an example with the client configuration under `endpoints[]`: ```yaml endpoints: - name: website url: "https://twin.sh/health" client: insecure: false ignore-redirect: false timeout: 10s conditions: - "[STATUS] == 200" ``` This example shows how you can specify a custom DNS resolver: ```yaml endpoints: - name: with-custom-dns-resolver url: "https://your.health.api/health" client: dns-resolver: "tcp://8.8.8.8:53" conditions: - "[STATUS] == 200" ``` This example shows how you can use the `client.oauth2` configuration to query a backend API with `Bearer token`: ```yaml endpoints: - name: with-custom-oauth2 url: "https://your.health.api/health" client: oauth2: token-url: https://your-token-server/token client-id: 00000000-0000-0000-0000-000000000000 client-secret: your-client-secret scopes: ['https://your.health.api/.default'] conditions: - "[STATUS] == 200" ``` This example shows how you can use the `client.identity-aware-proxy` configuration to query a backend API with `Bearer token` using Google Identity-Aware-Proxy: ```yaml endpoints: - name: with-custom-iap url: "https://my.iap.protected.app/health" client: identity-aware-proxy: audience: "XXXXXXXX-XXXXXXXXXXXX.apps.googleusercontent.com" conditions: - "[STATUS] == 200" ``` > 📝 Note that Gatus will use the [gcloud default credentials](https://cloud.google.com/docs/authentication/application-default-credentials) within its environment to generate the token. This example shows you how you can use the `client.tls` configuration to perform an mTLS query to a backend API: ```yaml endpoints: - name: website url: "https://your.mtls.protected.app/health" client: tls: certificate-file: /path/to/user_cert.pem private-key-file: /path/to/user_key.pem renegotiation: once conditions: - "[STATUS] == 200" ``` > 📝 Note that if running in a container, you must volume mount the certificate and key into the container. ### Tunneling Gatus supports SSH tunneling to monitor internal services through jump hosts or bastion servers. This is particularly useful for monitoring services that are not directly accessible from where Gatus is deployed. SSH tunnels are defined globally in the `tunneling` section and then referenced by name in endpoint client configurations. | Parameter | Description | Default | |:--------------------------------------|:------------------------------------------------------------|:--------------| | `tunneling` | SSH tunnel configurations | `{}` | | `tunneling.
See table below for all valid types. | Required `""` | | `alerts[].enabled` | Whether to enable the alert. | `true` | | `alerts[].failure-threshold` | Number of failures in a row needed before triggering the alert. | `3` | | `alerts[].success-threshold` | Number of successes in a row before an ongoing incident is marked as resolved. | `2` | | `alerts[].minimum-reminder-interval` | Minimum time interval between alert reminders. E.g. `"30m"`, `"1h45m30s"` or `"24h"`. If empty or `0`, reminders are disabled. Cannot be lower than `5m`. | `0` | | `alerts[].send-on-resolved` | Whether to send a notification once a triggered alert is marked as resolved. | `false` | | `alerts[].description` | Description of the alert. Will be included in the alert sent. | `""` | | `alerts[].provider-override` | Alerting provider configuration override for the given alert type | `{}` | Here's an example of what an alert configuration might look like at the endpoint level: ```yaml endpoints: - name: example url: "https://example.org" conditions: - "[STATUS] == 200" alerts: - type: slack description: "healthcheck failed" send-on-resolved: true ``` You can also override global provider configuration by using `alerts[].provider-override`, like so: ```yaml endpoints: - name: example url: "https://example.org" conditions: - "[STATUS] == 200" alerts: - type: slack provider-override: webhook-url: "https://hooks.slack.com/services/**********/**********/**********" ``` > 📝 If an alerting provider is not properly configured, all alerts configured with the provider's type will be > ignored. | Parameter | Description | Default | |:---------------------------|:----------------------------------------------------------------------------------------------------------------------------------------|:--------| | `alerting.awsses` | Configuration for alerts of type `awsses`.
See [Configuring AWS SES alerts](#configuring-aws-ses-alerts). | `{}` | | `alerting.clickup` | Configuration for alerts of type `clickup`.
See [Configuring ClickUp alerts](#configuring-clickup-alerts). | `{}` | | `alerting.custom` | Configuration for custom actions on failure or alerts.
See [Configuring Custom alerts](#configuring-custom-alerts). | `{}` | | `alerting.datadog` | Configuration for alerts of type `datadog`.
See [Configuring Datadog alerts](#configuring-datadog-alerts). | `{}` | | `alerting.discord` | Configuration for alerts of type `discord`.
See [Configuring Discord alerts](#configuring-discord-alerts). | `{}` | | `alerting.email` | Configuration for alerts of type `email`.
See [Configuring Email alerts](#configuring-email-alerts). | `{}` | | `alerting.gitea` | Configuration for alerts of type `gitea`.
See [Configuring Gitea alerts](#configuring-gitea-alerts). | `{}` | | `alerting.github` | Configuration for alerts of type `github`.
See [Configuring GitHub alerts](#configuring-github-alerts). | `{}` | | `alerting.gitlab` | Configuration for alerts of type `gitlab`.
See [Configuring GitLab alerts](#configuring-gitlab-alerts). | `{}` | | `alerting.googlechat` | Configuration for alerts of type `googlechat`.
See [Configuring Google Chat alerts](#configuring-google-chat-alerts). | `{}` | | `alerting.gotify` | Configuration for alerts of type `gotify`.
See [Configuring Gotify alerts](#configuring-gotify-alerts). | `{}` | | `alerting.homeassistant` | Configuration for alerts of type `homeassistant`.
See [Configuring HomeAssistant alerts](#configuring-homeassistant-alerts). | `{}` | | `alerting.ifttt` | Configuration for alerts of type `ifttt`.
See [Configuring IFTTT alerts](#configuring-ifttt-alerts). | `{}` | | `alerting.ilert` | Configuration for alerts of type `ilert`.
See [Configuring ilert alerts](#configuring-ilert-alerts). | `{}` | | `alerting.incident-io` | Configuration for alerts of type `incident-io`.
See [Configuring Incident.io alerts](#configuring-incidentio-alerts). | `{}` | | `alerting.line` | Configuration for alerts of type `line`.
See [Configuring Line alerts](#configuring-line-alerts). | `{}` | | `alerting.matrix` | Configuration for alerts of type `matrix`.
See [Configuring Matrix alerts](#configuring-matrix-alerts). | `{}` | | `alerting.mattermost` | Configuration for alerts of type `mattermost`.
See [Configuring Mattermost alerts](#configuring-mattermost-alerts). | `{}` | | `alerting.messagebird` | Configuration for alerts of type `messagebird`.
See [Configuring Messagebird alerts](#configuring-messagebird-alerts). | `{}` | | `alerting.n8n` | Configuration for alerts of type `n8n`.
See [Configuring n8n alerts](#configuring-n8n-alerts). | `{}` | | `alerting.newrelic` | Configuration for alerts of type `newrelic`.
See [Configuring New Relic alerts](#configuring-new-relic-alerts). | `{}` | | `alerting.ntfy` | Configuration for alerts of type `ntfy`.
See [Configuring Ntfy alerts](#configuring-ntfy-alerts). | `{}` | | `alerting.opsgenie` | Configuration for alerts of type `opsgenie`.
See [Configuring Opsgenie alerts](#configuring-opsgenie-alerts). | `{}` | | `alerting.pagerduty` | Configuration for alerts of type `pagerduty`.
See [Configuring PagerDuty alerts](#configuring-pagerduty-alerts). | `{}` | | `alerting.plivo` | Configuration for alerts of type `plivo`.
See [Configuring Plivo alerts](#configuring-plivo-alerts). | `{}` | | `alerting.pushover` | Configuration for alerts of type `pushover`.
See [Configuring Pushover alerts](#configuring-pushover-alerts). | `{}` | | `alerting.rocketchat` | Configuration for alerts of type `rocketchat`.
See [Configuring Rocket.Chat alerts](#configuring-rocketchat-alerts). | `{}` | | `alerting.sendgrid` | Configuration for alerts of type `sendgrid`.
See [Configuring SendGrid alerts](#configuring-sendgrid-alerts). | `{}` | | `alerting.signal` | Configuration for alerts of type `signal`.
See [Configuring Signal alerts](#configuring-signal-alerts). | `{}` | | `alerting.signl4` | Configuration for alerts of type `signl4`.
See [Configuring SIGNL4 alerts](#configuring-signl4-alerts). | `{}` | | `alerting.slack` | Configuration for alerts of type `slack`.
See [Configuring Slack alerts](#configuring-slack-alerts). | `{}` | | `alerting.splunk` | Configuration for alerts of type `splunk`.
See [Configuring Splunk alerts](#configuring-splunk-alerts). | `{}` | | `alerting.squadcast` | Configuration for alerts of type `squadcast`.
See [Configuring Squadcast alerts](#configuring-squadcast-alerts). | `{}` | | `alerting.teams` | Configuration for alerts of type `teams`. *(Deprecated)*
See [Configuring Teams alerts](#configuring-teams-alerts-deprecated). | `{}` | | `alerting.teams-workflows` | Configuration for alerts of type `teams-workflows`.
See [Configuring Teams Workflow alerts](#configuring-teams-workflow-alerts). | `{}` | | `alerting.telegram` | Configuration for alerts of type `telegram`.
See [Configuring Telegram alerts](#configuring-telegram-alerts). | `{}` | | `alerting.twilio` | Settings for alerts of type `twilio`.
See [Configuring Twilio alerts](#configuring-twilio-alerts). | `{}` | | `alerting.vonage` | Configuration for alerts of type `vonage`.
See [Configuring Vonage alerts](#configuring-vonage-alerts). | `{}` | | `alerting.webex` | Configuration for alerts of type `webex`.
See [Configuring Webex alerts](#configuring-webex-alerts). | `{}` | | `alerting.zapier` | Configuration for alerts of type `zapier`.
See [Configuring Zapier alerts](#configuring-zapier-alerts). | `{}` | | `alerting.zulip` | Configuration for alerts of type `zulip`.
See [Configuring Zulip alerts](#configuring-zulip-alerts). | `{}` | #### Configuring AWS SES alerts | Parameter | Description | Default | |:-------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.aws-ses` | Settings for alerts of type `aws-ses` | `{}` | | `alerting.aws-ses.access-key-id` | AWS Access Key ID | Optional `""` | | `alerting.aws-ses.secret-access-key` | AWS Secret Access Key | Optional `""` | | `alerting.aws-ses.region` | AWS Region | Required `""` | | `alerting.aws-ses.from` | The Email address to send the emails from (should be registered in SES) | Required `""` | | `alerting.aws-ses.to` | Comma separated list of email address to notify | Required `""` | | `alerting.aws-ses.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.aws-ses.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.aws-ses.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.aws-ses.overrides[].*` | See `alerting.aws-ses.*` parameters | `{}` | ```yaml alerting: aws-ses: access-key-id: "..." secret-access-key: "..." region: "us-east-1" from: "status@example.com" to: "user@example.com" endpoints: - name: website interval: 30s url: "https://twin.sh/health" conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: aws-ses failure-threshold: 5 send-on-resolved: true description: "healthcheck failed" ``` If the `access-key-id` and `secret-access-key` are not defined Gatus will fall back to IAM authentication. Make sure you have the ability to use `ses:SendEmail`. #### Configuring ClickUp alerts | Parameter | Description | Default | | :--------------------------------- | :----------------------------------------------------------------------------------------- | :------------ | | `alerting.clickup` | Configuration for alerts of type `clickup` | `{}` | | `alerting.clickup.list-id` | ClickUp List ID where tasks will be created | Required `""` | | `alerting.clickup.token` | ClickUp API token | Required `""` | | `alerting.clickup.api-url` | Custom API URL | `https://api.clickup.com/api/v2` | | `alerting.clickup.assignees` | List of user IDs to assign tasks to | `[]` | | `alerting.clickup.status` | Initial status for created tasks | `""` | | `alerting.clickup.priority` | Priority level: `urgent`, `high`, `normal`, `low`, or `none` | `normal` | | `alerting.clickup.notify-all` | Whether to notify all assignees when task is created | `true` | | `alerting.clickup.name` | Custom task name template (supports placeholders) | `Health Check: [ENDPOINT_GROUP]:[ENDPOINT_NAME]` | | `alerting.clickup.content` | Custom task content template (supports placeholders) | `Triggered: [ENDPOINT_GROUP] - [ENDPOINT_NAME] - [ALERT_DESCRIPTION] - [RESULT_ERRORS]` | | `alerting.clickup.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.clickup.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.clickup.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.clickup.overrides[].*` | See `alerting.clickup.*` parameters | `{}` | The ClickUp alerting provider creates tasks in a ClickUp list when alerts are triggered. If `send-on-resolved` is set to `true` on the endpoint alert, the task will be automatically closed when the alert is resolved. The following placeholders are supported in `name` and `content`: - `[ENDPOINT_GROUP]` - Resolved from `endpoints[].group` - `[ENDPOINT_NAME]` - Resolved from `endpoints[].name` - `[ALERT_DESCRIPTION]` - Resolved from `endpoints[].alerts[].description` - `[RESULT_ERRORS]` - Resolved from the health evaluation errors ```yaml alerting: clickup: list-id: "123456789" token: "pk_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" assignees: - "12345" - "67890" status: "in progress" priority: high name: "Health Check Alert: [ENDPOINT_GROUP] - [ENDPOINT_NAME]" content: "Alert triggered for [ENDPOINT_GROUP] - [ENDPOINT_NAME] - [ALERT_DESCRIPTION] - [RESULT_ERRORS]" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: clickup send-on-resolved: true ``` To get your ClickUp API token follow: [Generate or regenerate a Personal API Token](https://developer.clickup.com/docs/authentication#:~:text=the%20API%20docs.-,Generate%20or%20regenerate%20a%20Personal%20API%20Token,-Log%20in%20to) To find your List ID: 1. Open the ClickUp list where you want tasks to be created 2. The List ID is in the URL: `https://app.clickup.com/{workspace_id}/v/l/li/{list_id}` To find Assignee IDs: 1. Go to `https://app.clickup.com/{workspace_id}/teams-pulse/teams/people` 2. Hover over a team member 3. Click the 3 dots (overflow menu) 3. Click `Copy member ID` #### Configuring Datadog alerts > ⚠️ **WARNING**: This alerting provider has not been tested yet. If you've tested it and confirmed that it works, please remove this warning and create a pull request, or comment on [#1223](https://github.com/TwiN/gatus/discussions/1223) with whether the provider works as intended. Thank you for your cooperation. | Parameter | Description | Default | |:-------------------------------------|:-------------------------------------------------------------------------------------------|:------------------| | `alerting.datadog` | Configuration for alerts of type `datadog` | `{}` | | `alerting.datadog.api-key` | Datadog API key | Required `""` | | `alerting.datadog.site` | Datadog site (e.g., datadoghq.com, datadoghq.eu) | `"datadoghq.com"` | | `alerting.datadog.tags` | Additional tags to include | `[]` | | `alerting.datadog.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.datadog.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.datadog.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.datadog.overrides[].*` | See `alerting.datadog.*` parameters | `{}` | ```yaml alerting: datadog: api-key: "YOUR_API_KEY" site: "datadoghq.com" # or datadoghq.eu for EU region tags: - "environment:production" - "team:platform" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: datadog send-on-resolved: true ``` #### Configuring Discord alerts | Parameter | Description | Default | |:-------------------------------------|:-------------------------------------------------------------------------------------------|:------------------------------------| | `alerting.discord` | Configuration for alerts of type `discord` | `{}` | | `alerting.discord.webhook-url` | Discord Webhook URL | Required `""` | | `alerting.discord.title` | Title of the notification | `":helmet_with_white_cross: Gatus"` | | `alerting.discord.message-content` | Message content to send before the embed (useful for pinging users/roles, e.g. `<@123>`) | `""` | | `alerting.discord.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.discord.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.discord.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.discord.overrides[].*` | See `alerting.discord.*` parameters | `{}` | ```yaml alerting: discord: webhook-url: "https://discord.com/api/webhooks/**********/**********" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: discord description: "healthcheck failed" send-on-resolved: true ``` #### Configuring Email alerts | Parameter | Description | Default | |:-----------------------------------|:----------------------------------------------------------------------------------------------|:--------------| | `alerting.email` | Configuration for alerts of type `email` | `{}` | | `alerting.email.from` | Email used to send the alert | Required `""` | | `alerting.email.username` | Username of the SMTP server used to send the alert. If empty, uses `alerting.email.from`. | `""` | | `alerting.email.password` | Password of the SMTP server used to send the alert. If empty, no authentication is performed. | `""` | | `alerting.email.host` | Host of the mail server (e.g. `smtp.gmail.com`) | Required `""` | | `alerting.email.port` | Port the mail server is listening to (e.g. `587`) | Required `0` | | `alerting.email.to` | Email(s) to send the alerts to | Required `""` | | `alerting.email.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.email.client.insecure` | Whether to skip TLS verification | `false` | | `alerting.email.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.email.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.email.overrides[].*` | See `alerting.email.*` parameters | `{}` | ```yaml alerting: email: from: "from@example.com" username: "from@example.com" password: "hunter2" host: "mail.example.com" port: 587 to: "recipient1@example.com,recipient2@example.com" client: insecure: false # You can also add group-specific to keys, which will # override the to key above for the specified groups overrides: - group: "core" to: "recipient3@example.com,recipient4@example.com" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: email description: "healthcheck failed" send-on-resolved: true - name: back-end group: core url: "https://example.org/" interval: 5m conditions: - "[STATUS] == 200" - "[CERTIFICATE_EXPIRATION] > 48h" alerts: - type: email description: "healthcheck failed" send-on-resolved: true ``` > ⚠ Some mail servers are painfully slow. #### Configuring Gitea alerts | Parameter | Description | Default | |:--------------------------------|:-----------------------------------------------------------------------------------------------------------|:--------------| | `alerting.gitea` | Configuration for alerts of type `gitea` | `{}` | | `alerting.gitea.repository-url` | Gitea repository URL (e.g. `https://gitea.com/TwiN/example`) | Required `""` | | `alerting.gitea.token` | Personal access token to use for authentication.
Must have at least RW on issues and RO on metadata. | Required `""` | | `alerting.gitea.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert). | N/A | The Gitea alerting provider creates an issue prefixed with `alert(gatus):` and suffixed with the endpoint's display name for each alert. If `send-on-resolved` is set to `true` on the endpoint alert, the issue will be automatically closed when the alert is resolved. ```yaml alerting: gitea: repository-url: "https://gitea.com/TwiN/test" token: "349d63f16......" endpoints: - name: example url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 75" alerts: - type: gitea failure-threshold: 2 success-threshold: 3 send-on-resolved: true description: "Everything's burning AAAAAHHHHHHHHHHHHHHH" ```  #### Configuring GitHub alerts | Parameter | Description | Default | |:---------------------------------|:-----------------------------------------------------------------------------------------------------------|:--------------| | `alerting.github` | Configuration for alerts of type `github` | `{}` | | `alerting.github.repository-url` | GitHub repository URL (e.g. `https://github.com/TwiN/example`) | Required `""` | | `alerting.github.token` | Personal access token to use for authentication.
Must have at least RW on issues and RO on metadata. | Required `""` | | `alerting.github.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert). | N/A | The GitHub alerting provider creates an issue prefixed with `alert(gatus):` and suffixed with the endpoint's display name for each alert. If `send-on-resolved` is set to `true` on the endpoint alert, the issue will be automatically closed when the alert is resolved. ```yaml alerting: github: repository-url: "https://github.com/TwiN/test" token: "github_pat_12345..." endpoints: - name: example url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 75" alerts: - type: github failure-threshold: 2 success-threshold: 3 send-on-resolved: true description: "Everything's burning AAAAAHHHHHHHHHHHHHHH" ```  #### Configuring GitLab alerts | Parameter | Description | Default | |:------------------------------------|:--------------------------------------------------------------------------------------------------------------------|:--------------| | `alerting.gitlab` | Configuration for alerts of type `gitlab` | `{}` | | `alerting.gitlab.webhook-url` | GitLab alert webhook URL (e.g. `https://gitlab.com/yourusername/example/alerts/notify/gatus/xxxxxxxxxxxxxxxx.json`) | Required `""` | | `alerting.gitlab.authorization-key` | GitLab alert authorization key. | Required `""` | | `alerting.gitlab.severity` | Override default severity (critical), can be one of `critical, high, medium, low, info, unknown` | `""` | | `alerting.gitlab.monitoring-tool` | Override the monitoring tool name (gatus) | `"gatus"` | | `alerting.gitlab.environment-name` | Set gitlab environment's name. Required to display alerts on a dashboard. | `""` | | `alerting.gitlab.service` | Override endpoint display name | `""` | | `alerting.gitlab.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert). | N/A | The GitLab alerting provider creates an alert prefixed with `alert(gatus):` and suffixed with the endpoint's display name for each alert. If `send-on-resolved` is set to `true` on the endpoint alert, the alert will be automatically closed when the alert is resolved. See https://docs.gitlab.com/ee/operations/incident_management/integrations.html#configuration to configure the endpoint. ```yaml alerting: gitlab: webhook-url: "https://gitlab.com/hlidotbe/example/alerts/notify/gatus/xxxxxxxxxxxxxxxx.json" authorization-key: "12345" endpoints: - name: example url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 75" alerts: - type: gitlab failure-threshold: 2 success-threshold: 3 send-on-resolved: true description: "Everything's burning AAAAAHHHHHHHHHHHHHHH" ```  #### Configuring Google Chat alerts | Parameter | Description | Default | |:----------------------------------------|:--------------------------------------------------------------------------------------------|:--------------| | `alerting.googlechat` | Configuration for alerts of type `googlechat` | `{}` | | `alerting.googlechat.webhook-url` | Google Chat Webhook URL | Required `""` | | `alerting.googlechat.client` | Client configuration.
See [Client configuration](#client-configuration). | `{}` | | `alerting.googlechat.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert). | N/A | | `alerting.googlechat.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.googlechat.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.googlechat.overrides[].*` | See `alerting.googlechat.*` parameters | `{}` | ```yaml alerting: googlechat: webhook-url: "https://chat.googleapis.com/v1/spaces/*******/messages?key=**********&token=********" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: googlechat description: "healthcheck failed" send-on-resolved: true ``` #### Configuring Gotify alerts | Parameter | Description | Default | |:----------------------------------------------|:--------------------------------------------------------------------------------------------|:----------------------| | `alerting.gotify` | Configuration for alerts of type `gotify` | `{}` | | `alerting.gotify.server-url` | Gotify server URL | Required `""` | | `alerting.gotify.token` | Token that is used for authentication. | Required `""` | | `alerting.gotify.priority` | Priority of the alert according to Gotify standards. | `5` | | `alerting.gotify.title` | Title of the notification | `"Gatus:
See [Setting a default alert](#setting-a-default-alert). | N/A | ```yaml alerting: gotify: server-url: "https://gotify.example" token: "**************" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: gotify description: "healthcheck failed" send-on-resolved: true ``` Here's an example of what the notifications look like:  #### Configuring HomeAssistant alerts | Parameter | Description | Default Value | |:-------------------------------------------|:---------------------------------------------------------------------------------------|:--------------| | `alerting.homeassistant.url` | HomeAssistant instance URL | Required `""` | | `alerting.homeassistant.token` | Long-lived access token from HomeAssistant | Required `""` | | `alerting.homeassistant.default-alert` | Default alert configuration to use for endpoints with an alert of the appropriate type | `{}` | | `alerting.homeassistant.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.homeassistant.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.homeassistant.overrides[].*` | See `alerting.homeassistant.*` parameters | `{}` | ```yaml alerting: homeassistant: url: "http://homeassistant:8123" # URL of your HomeAssistant instance token: "YOUR_LONG_LIVED_ACCESS_TOKEN" # Long-lived access token from HomeAssistant endpoints: - name: my-service url: "https://my-service.com" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: homeassistant enabled: true send-on-resolved: true description: "My service health check" failure-threshold: 3 success-threshold: 2 ``` The alerts will be sent as events to HomeAssistant with the event type `gatus_alert`. The event data includes: - `status`: "triggered" or "resolved" - `endpoint`: The name of the monitored endpoint - `description`: The alert description if provided - `conditions`: List of conditions and their results - `failure_count`: Number of consecutive failures (when triggered) - `success_count`: Number of consecutive successes (when resolved) You can use these events in HomeAssistant automations to: - Send notifications - Control devices - Trigger scenes - Log to history - And more Example HomeAssistant automation: ```yaml automation: - alias: "Gatus Alert Handler" trigger: platform: event event_type: gatus_alert action: - service: notify.notify data_template: title: "Gatus Alert: {{ trigger.event.data.event_data.endpoint }}" message: > Status: {{ trigger.event.data.event_data.status }} {% if trigger.event.data.event_data.description %} Description: {{ trigger.event.data.event_data.description }} {% endif %} {% for condition in trigger.event.data.event_data.conditions %} {{ '✅' if condition.success else '❌' }} {{ condition.condition }} {% endfor %} ``` To get your HomeAssistant long-lived access token: 1. Open HomeAssistant 2. Click on your profile name (bottom left) 3. Scroll down to "Long-Lived Access Tokens" 4. Click "Create Token" 5. Give it a name (e.g., "Gatus") 6. Copy the token - you'll only see it once! #### Configuring IFTTT alerts > ⚠️ **WARNING**: This alerting provider has not been tested yet. If you've tested it and confirmed that it works, please remove this warning and create a pull request, or comment on [#1223](https://github.com/TwiN/gatus/discussions/1223) with whether the provider works as intended. Thank you for your cooperation. | Parameter | Description | Default | |:-----------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.ifttt` | Configuration for alerts of type `ifttt` | `{}` | | `alerting.ifttt.webhook-key` | IFTTT Webhook key | Required `""` | | `alerting.ifttt.event-name` | IFTTT event name | Required `""` | | `alerting.ifttt.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.ifttt.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.ifttt.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.ifttt.overrides[].*` | See `alerting.ifttt.*` parameters | `{}` | ```yaml alerting: ifttt: webhook-key: "YOUR_WEBHOOK_KEY" event-name: "gatus_alert" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: ifttt send-on-resolved: true ``` #### Configuring Ilert alerts | Parameter | Description | Default | |:-----------------------------------|:-------------------------------------------------------------------------------------------|:--------| | `alerting.ilert` | Configuration for alerts of type `ilert` | `{}` | | `alerting.ilert.integration-key` | ilert Alert Source integration key | `""` | | `alerting.ilert.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.ilert.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.ilert.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.ilert.overrides[].*` | See `alerting.ilert.*` parameters | `{}` | It is highly recommended to set `endpoints[].alerts[].send-on-resolved` to `true` for alerts of type `ilert`, because unlike other alerts, the operation resulting from setting said parameter to `true` will not create another alert but mark the alert as resolved on ilert instead. Behavior: - By default, `alerting.ilert.integration-key` is used as the integration key - If the endpoint being evaluated belongs to a group (`endpoints[].group`) matching the value of `alerting.ilert.overrides[].group`, the provider will use that override's integration key instead of `alerting.ilert.integration-key`'s ```yaml alerting: ilert: integration-key: "********************************" # You can also add group-specific integration keys, which will # override the integration key above for the specified groups overrides: - group: "core" integration-key: "********************************" endpoints: - name: website url: "https://twin.sh/health" interval: 30s conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: ilert failure-threshold: 3 success-threshold: 5 send-on-resolved: true description: "healthcheck failed" ``` #### Configuring Incident.io alerts | Parameter | Description | Default | |:-----------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.incident-io` | Configuration for alerts of type `incident-io` | `{}` | | `alerting.incident-io.url` | url to trigger an alert event. | Required `""` | | `alerting.incident-io.auth-token` | Token that is used for authentication. | Required `""` | | `alerting.incident-io.source-url` | Source URL | `""` | | `alerting.incident-io.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.incident-io.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.incident-io.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.incident-io.overrides[].*` | See `alerting.incident-io.*` parameters | `{}` | ```yaml alerting: incident-io: url: "*****************" auth-token: "********************************************" endpoints: - name: website url: "https://twin.sh/health" interval: 30s conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: incident-io description: "healthcheck failed" send-on-resolved: true ``` In order to get the required alert source config id and authentication token, you must configure an HTTP alert source. > **_NOTE:_** the source config id is of the form `https://api.incident.io/v2/alert_events/http/$ID` and the token is expected to be passed as a bearer token like so: `Authorization: Bearer $TOKEN` #### Configuring Line alerts | Parameter | Description | Default | |:-------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.line` | Configuration for alerts of type `line` | `{}` | | `alerting.line.channel-access-token` | Line Messaging API channel access token | Required `""` | | `alerting.line.user-ids` | List of Line user IDs to send messages to (this can be user ids, room ids or group ids) | Required `[]` | | `alerting.line.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.line.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.line.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.line.overrides[].*` | See `alerting.line.*` parameters | `{}` | ```yaml alerting: line: channel-access-token: "YOUR_CHANNEL_ACCESS_TOKEN" user-ids: - "U1234567890abcdef" # This can be a group id, room id or user id - "U2345678901bcdefg" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: line send-on-resolved: true ``` #### Configuring Matrix alerts | Parameter | Description | Default | |:-----------------------------------------|:-------------------------------------------------------------------------------------------|:-----------------------------------| | `alerting.matrix` | Configuration 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 Room Settings > Advanced) | Required `""` | | `alerting.matrix.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.matrix.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.matrix.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.matrix.overrides[].*` | See `alerting.matrix.*` parameters | `{}` | ```yaml alerting: matrix: server-url: "https://matrix-client.matrix.org" access-token: "123456" internal-room-id: "!example:matrix.org" endpoints: - name: website interval: 5m url: "https://twin.sh/health" conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: matrix send-on-resolved: true description: "healthcheck failed" ``` #### Configuring Mattermost alerts | Parameter | Description | Default | |:----------------------------------------------|:--------------------------------------------------------------------------------------------|:--------------| | `alerting.mattermost` | Configuration for alerts of type `mattermost` | `{}` | | `alerting.mattermost.webhook-url` | Mattermost Webhook URL | Required `""` | | `alerting.mattermost.channel` | Mattermost channel name override (optional) | `""` | | `alerting.mattermost.client` | Client configuration.
See [Client configuration](#client-configuration). | `{}` | | `alerting.mattermost.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert). | N/A | | `alerting.mattermost.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.mattermost.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.mattermost.overrides[].*` | See `alerting.mattermost.*` parameters | `{}` | ```yaml alerting: mattermost: webhook-url: "http://**********/hooks/**********" client: insecure: true endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: mattermost description: "healthcheck failed" send-on-resolved: true ``` Here's an example of what the notifications look like:  #### Configuring Messagebird alerts | Parameter | Description | Default | |:-------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.messagebird` | Configuration for alerts of type `messagebird` | `{}` | | `alerting.messagebird.access-key` | Messagebird access key | Required `""` | | `alerting.messagebird.originator` | The sender of the message | Required `""` | | `alerting.messagebird.recipients` | The recipients of the message | Required `""` | | `alerting.messagebird.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | Example of sending **SMS** text message alert using Messagebird: ```yaml alerting: messagebird: access-key: "..." originator: "31619191918" recipients: "31619191919,31619191920" endpoints: - name: website interval: 5m url: "https://twin.sh/health" conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: messagebird failure-threshold: 3 send-on-resolved: true description: "healthcheck failed" ``` #### Configuring New Relic alerts > ⚠️ **WARNING**: This alerting provider has not been tested yet. If you've tested it and confirmed that it works, please remove this warning and create a pull request, or comment on [#1223](https://github.com/TwiN/gatus/discussions/1223) with whether the provider works as intended. Thank you for your cooperation. | Parameter | Description | Default | |:--------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.newrelic` | Configuration for alerts of type `newrelic` | `{}` | | `alerting.newrelic.api-key` | New Relic API key | Required `""` | | `alerting.newrelic.account-id` | New Relic account ID | Required `""` | | `alerting.newrelic.region` | Region (US or EU) | `"US"` | | `alerting.newrelic.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.newrelic.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.newrelic.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.newrelic.overrides[].*` | See `alerting.newrelic.*` parameters | `{}` | ```yaml alerting: newrelic: api-key: "YOUR_API_KEY" account-id: "1234567" region: "US" # or "EU" for European region endpoints: - name: example url: "https://example.org" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: newrelic send-on-resolved: true ``` #### Configuring n8n alerts | Parameter | Description | Default | |:---------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.n8n` | Configuration for alerts of type `n8n` | `{}` | | `alerting.n8n.webhook-url` | n8n webhook URL | Required `""` | | `alerting.n8n.title` | Title of the alert sent to n8n | `""` | | `alerting.n8n.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.n8n.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.n8n.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.n8n.overrides[].*` | See `alerting.n8n.*` parameters | `{}` | [n8n](https://n8n.io/) is a workflow automation platform that allows you to automate tasks across different applications and services using webhooks. See [n8n-nodes-gatus-trigger](https://github.com/TwiN/n8n-nodes-gatus-trigger) for a n8n community node that can be used as trigger. Example: ```yaml alerting: n8n: webhook-url: "https://your-n8n-instance.com/webhook/your-webhook-id" title: "Gatus Monitoring" default-alert: send-on-resolved: true endpoints: - name: example url: "https://example.org" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: n8n description: "Health check alert" ``` The JSON payload sent to the n8n webhook will include: - `title`: The configured title - `endpoint_name`: Name of the endpoint - `endpoint_group`: Group of the endpoint (if any) - `endpoint_url`: URL being monitored - `alert_description`: Custom alert description - `resolved`: Boolean indicating if the alert is resolved - `message`: Human-readable alert message - `condition_results`: Array of condition results with their success status #### Configuring Ntfy alerts | Parameter | Description | Default | |:-------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------|:------------------| | `alerting.ntfy` | Configuration for alerts of type `ntfy` | `{}` | | `alerting.ntfy.topic` | Topic at which the alert will be sent | Required `""` | | `alerting.ntfy.url` | The URL of the target server | `https://ntfy.sh` | | `alerting.ntfy.token` | [Access token](https://docs.ntfy.sh/publish/#access-tokens) for restricted topics | `""` | | `alerting.ntfy.email` | E-mail address for additional e-mail notifications | `""` | | `alerting.ntfy.click` | Website opened when notification is clicked | `""` | | `alerting.ntfy.priority` | The priority of the alert | `3` | | `alerting.ntfy.disable-firebase` | Whether message push delivery via firebase should be disabled. [ntfy.sh defaults to enabled](https://docs.ntfy.sh/publish/#disable-firebase) | `false` | | `alerting.ntfy.disable-cache` | Whether server side message caching should be disabled. [ntfy.sh defaults to enabled](https://docs.ntfy.sh/publish/#message-caching) | `false` | | `alerting.ntfy.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.ntfy.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.ntfy.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.ntfy.overrides[].*` | See `alerting.ntfy.*` parameters | `{}` | [ntfy](https://github.com/binwiederhier/ntfy) is an amazing project that allows you to subscribe to desktop and mobile notifications, making it an awesome addition to Gatus. Example: ```yaml alerting: ntfy: topic: "gatus-test-topic" priority: 2 token: faketoken default-alert: failure-threshold: 3 send-on-resolved: true # You can also add group-specific to keys, which will # override the to key above for the specified groups overrides: - group: "other" topic: "gatus-other-test-topic" priority: 4 click: "https://example.com" endpoints: - name: website interval: 5m url: "https://twin.sh/health" conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: ntfy - name: other example group: other interval: 30m url: "https://example.com" conditions: - "[STATUS] == 200" - "[BODY].status == UP" alerts: - type: ntfy description: example ``` #### Configuring Opsgenie alerts | Parameter | Description | Default | |:----------------------------------|:-------------------------------------------------------------------------------------------|:---------------------| | `alerting.opsgenie` | Configuration for alerts of type `opsgenie` | `{}` | | `alerting.opsgenie.api-key` | Opsgenie API Key | Required `""` | | `alerting.opsgenie.priority` | Priority level of the alert. | `P1` | | `alerting.opsgenie.source` | Source field of the alert. | `gatus` | | `alerting.opsgenie.entity-prefix` | Entity field prefix. | `gatus-` | | `alerting.opsgenie.alias-prefix` | Alias field prefix. | `gatus-healthcheck-` | | `alerting.opsgenie.tags` | Tags of alert. | `[]` | | `alerting.opsgenie.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | Opsgenie provider will automatically open and close alerts. ```yaml alerting: opsgenie: api-key: "00000000-0000-0000-0000-000000000000" ``` #### Configuring PagerDuty alerts | Parameter | Description | Default | |:---------------------------------------|:-------------------------------------------------------------------------------------------|:--------| | `alerting.pagerduty` | Configuration for alerts of type `pagerduty` | `{}` | | `alerting.pagerduty.integration-key` | PagerDuty Events API v2 integration key | `""` | | `alerting.pagerduty.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.pagerduty.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.pagerduty.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.pagerduty.overrides[].*` | See `alerting.pagerduty.*` parameters | `{}` | It is highly recommended to set `endpoints[].alerts[].send-on-resolved` to `true` for alerts of type `pagerduty`, because unlike other alerts, the operation resulting from setting said parameter to `true` will not create another incident but mark the incident as resolved on PagerDuty instead. Behavior: - By default, `alerting.pagerduty.integration-key` is used as the integration key - If the endpoint being evaluated belongs to a group (`endpoints[].group`) matching the value of `alerting.pagerduty.overrides[].group`, the provider will use that override's integration key instead of `alerting.pagerduty.integration-key`'s ```yaml alerting: pagerduty: integration-key: "********************************" # You can also add group-specific integration keys, which will # override the integration key above for the specified groups overrides: - group: "core" integration-key: "********************************" endpoints: - name: website url: "https://twin.sh/health" interval: 30s conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: pagerduty failure-threshold: 3 success-threshold: 5 send-on-resolved: true description: "healthcheck failed" - name: back-end group: core url: "https://example.org/" interval: 5m conditions: - "[STATUS] == 200" - "[CERTIFICATE_EXPIRATION] > 48h" alerts: - type: pagerduty failure-threshold: 3 success-threshold: 5 send-on-resolved: true description: "healthcheck failed" ``` #### Configuring Plivo alerts > ⚠️ **WARNING**: This alerting provider has not been tested yet. If you've tested it and confirmed that it works, please remove this warning and create a pull request, or comment on [#1223](https://github.com/TwiN/gatus/discussions/1223) with whether the provider works as intended. Thank you for your cooperation. | Parameter | Description | Default | |:-----------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.plivo` | Configuration for alerts of type `plivo` | `{}` | | `alerting.plivo.auth-id` | Plivo Auth ID | Required `""` | | `alerting.plivo.auth-token` | Plivo Auth Token | Required `""` | | `alerting.plivo.from` | Phone number to send SMS from | Required `""` | | `alerting.plivo.to` | List of phone numbers to send SMS to | Required `[]` | | `alerting.plivo.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.plivo.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.plivo.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.plivo.overrides[].*` | See `alerting.plivo.*` parameters | `{}` | ```yaml alerting: plivo: auth-id: "MAXXXXXXXXXXXXXXXXXX" auth-token: "your-auth-token" from: "+1234567890" to: - "+0987654321" - "+1122334455" endpoints: - name: website interval: 30s url: "https://twin.sh/health" conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: plivo failure-threshold: 5 send-on-resolved: true description: "healthcheck failed" ``` #### Configuring Pushover alerts | Parameter | Description | Default | |:--------------------------------------|:-------------------------------------------------------------------------------------------------------------|:----------------------| | `alerting.pushover` | Configuration for alerts of type `pushover` | `{}` | | `alerting.pushover.application-token` | Pushover application token | `""` | | `alerting.pushover.user-key` | User or group key | `""` | | `alerting.pushover.title` | Fixed title for all messages sent via Pushover | `"Gatus:
See [sounds](https://pushover.net/api#sounds) for all valid choices. | `""` | | `alerting.pushover.ttl` | Set the Time-to-live of the message to be automatically deleted from pushover notifications | `0` | | `alerting.pushover.device` | Device to send the message to (optional)
See [devices](https://pushover.net/api#identifiers) for details | `""` (all devices) | | `alerting.pushover.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | ```yaml alerting: pushover: application-token: "******************************" user-key: "******************************" endpoints: - name: website url: "https://twin.sh/health" interval: 30s conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: pushover failure-threshold: 3 success-threshold: 5 send-on-resolved: true description: "healthcheck failed" ``` #### Configuring Rocket.Chat alerts > ⚠️ **WARNING**: This alerting provider has not been tested yet. If you've tested it and confirmed that it works, please remove this warning and create a pull request, or comment on [#1223](https://github.com/TwiN/gatus/discussions/1223) with whether the provider works as intended. Thank you for your cooperation. | Parameter | Description | Default | |:----------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.rocketchat` | Configuration for alerts of type `rocketchat` | `{}` | | `alerting.rocketchat.webhook-url` | Rocket.Chat incoming webhook URL | Required `""` | | `alerting.rocketchat.channel` | Optional channel override | `""` | | `alerting.rocketchat.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.rocketchat.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.rocketchat.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.rocketchat.overrides[].*` | See `alerting.rocketchat.*` parameters | `{}` | ```yaml alerting: rocketchat: webhook-url: "https://your-rocketchat.com/hooks/YOUR_WEBHOOK_ID/YOUR_TOKEN" channel: "#alerts" # Optional endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: rocketchat send-on-resolved: true ``` #### Configuring SendGrid alerts > ⚠️ **WARNING**: This alerting provider has not been tested yet. If you've tested it and confirmed that it works, please remove this warning and create a pull request, or comment on [#1223](https://github.com/TwiN/gatus/discussions/1223) with whether the provider works as intended. Thank you for your cooperation. | Parameter | Description | Default | |:--------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.sendgrid` | Configuration for alerts of type `sendgrid` | `{}` | | `alerting.sendgrid.api-key` | SendGrid API key | Required `""` | | `alerting.sendgrid.from` | Email address to send from | Required `""` | | `alerting.sendgrid.to` | Email address(es) to send alerts to (comma-separated for multiple recipients) | Required `""` | | `alerting.sendgrid.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.sendgrid.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.sendgrid.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.sendgrid.overrides[].*` | See `alerting.sendgrid.*` parameters | `{}` | ```yaml alerting: sendgrid: api-key: "SG.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" from: "alerts@example.com" to: "admin@example.com,ops@example.com" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: sendgrid send-on-resolved: true ``` #### Configuring Signal alerts > ⚠️ **WARNING**: This alerting provider has not been tested yet. If you've tested it and confirmed that it works, please remove this warning and create a pull request, or comment on [#1223](https://github.com/TwiN/gatus/discussions/1223) with whether the provider works as intended. Thank you for your cooperation. | Parameter | Description | Default | |:------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.signal` | Configuration for alerts of type `signal` | `{}` | | `alerting.signal.api-url` | Signal API URL (e.g., signal-cli-rest-api instance) | Required `""` | | `alerting.signal.number` | Sender phone number | Required `""` | | `alerting.signal.recipients` | List of recipient phone numbers | Required `[]` | | `alerting.signal.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.signal.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.signal.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.signal.overrides[].*` | See `alerting.signal.*` parameters | `{}` | ```yaml alerting: signal: api-url: "http://localhost:8080" number: "+1234567890" recipients: - "+0987654321" - "+1122334455" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: signal send-on-resolved: true ``` #### Configuring SIGNL4 alerts SIGNL4 is a mobile alerting and incident management service that sends critical alerts to team members via mobile push, SMS, voice calls, and email. | Parameter | Description | Default | |:------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.signl4` | Configuration for alerts of type `signl4` | `{}` | | `alerting.signl4.team-secret` | SIGNL4 team secret (part of webhook URL) | Required `""` | | `alerting.signl4.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.signl4.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.signl4.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.signl4.overrides[].*` | See `alerting.signl4.*` parameters | `{}` | ```yaml alerting: signl4: team-secret: "your-team-secret-here" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: signl4 send-on-resolved: true ``` #### Configuring Slack alerts | Parameter | Description | Default | |:-----------------------------------|:-------------------------------------------------------------------------------------------|:------------------------------------| | `alerting.slack` | Configuration for alerts of type `slack` | `{}` | | `alerting.slack.webhook-url` | Slack Webhook URL | Required `""` | | `alerting.slack.title` | Title of the notification | `":helmet_with_white_cross: Gatus"` | | `alerting.slack.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.slack.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.slack.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.slack.overrides[].*` | See `alerting.slack.*` parameters | `{}` | ```yaml alerting: slack: webhook-url: "https://hooks.slack.com/services/**********/**********/**********" endpoints: - name: website url: "https://twin.sh/health" interval: 30s conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: slack description: "healthcheck failed 3 times in a row" send-on-resolved: true - type: slack failure-threshold: 5 description: "healthcheck failed 5 times in a row" send-on-resolved: true ``` Here's an example of what the notifications look like:  #### Configuring Splunk alerts | Parameter | Description | Default | |:------------------------------------|:-------------------------------------------------------------------------------------------|:----------------| | `alerting.splunk` | Configuration for alerts of type `splunk` | `{}` | | `alerting.splunk.hec-url` | Splunk HEC (HTTP Event Collector) URL | Required `""` | | `alerting.splunk.hec-token` | Splunk HEC token | Required `""` | | `alerting.splunk.source` | Event source | `"gatus"` | | `alerting.splunk.sourcetype` | Event source type | `"gatus:alert"` | | `alerting.splunk.index` | Splunk index | `""` | | `alerting.splunk.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.splunk.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.splunk.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.splunk.overrides[].*` | See `alerting.splunk.*` parameters | `{}` | ```yaml alerting: splunk: hec-url: "https://splunk.example.com:8088" hec-token: "YOUR_HEC_TOKEN" index: "main" # Optional endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: splunk send-on-resolved: true ``` #### Configuring Squadcast alerts > ⚠️ **WARNING**: This alerting provider has not been tested yet. If you've tested it and confirmed that it works, please remove this warning and create a pull request, or comment on [#1223](https://github.com/TwiN/gatus/discussions/1223) with whether the provider works as intended. Thank you for your cooperation. | Parameter | Description | Default | |:---------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.squadcast` | Configuration for alerts of type `squadcast` | `{}` | | `alerting.squadcast.webhook-url` | Squadcast webhook URL | Required `""` | | `alerting.squadcast.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.squadcast.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.squadcast.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.squadcast.overrides[].*` | See `alerting.squadcast.*` parameters | `{}` | ```yaml alerting: squadcast: webhook-url: "https://api.squadcast.com/v3/incidents/api/YOUR_API_KEY" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: squadcast send-on-resolved: true ``` #### Configuring Teams alerts *(Deprecated)* > [!CAUTION] > **Deprecated:** Office 365 Connectors within Microsoft Teams are being retired ([Source: Microsoft DevBlog](https://devblogs.microsoft.com/microsoft365dev/retirement-of-office-365-connectors-within-microsoft-teams/)). > Existing connectors will continue to work until December 2025. The new [Teams Workflow Alerts](#configuring-teams-workflow-alerts) should be used with Microsoft Workflows instead of this legacy configuration. | Parameter | Description | Default | |:-----------------------------------|:-------------------------------------------------------------------------------------------|:--------------------| | `alerting.teams` | Configuration for alerts of type `teams` | `{}` | | `alerting.teams.webhook-url` | Teams Webhook URL | Required `""` | | `alerting.teams.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.teams.title` | Title of the notification | `"🚨 Gatus"` | | `alerting.teams.client.insecure` | Whether to skip TLS verification | `false` | | `alerting.teams.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.teams.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.teams.overrides[].*` | See `alerting.teams.*` parameters | `{}` | ```yaml alerting: teams: webhook-url: "https://********.webhook.office.com/webhookb2/************" client: insecure: false # You can also add group-specific to keys, which will # override the to key above for the specified groups overrides: - group: "core" webhook-url: "https://********.webhook.office.com/webhookb3/************" endpoints: - name: website url: "https://twin.sh/health" interval: 30s conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: teams description: "healthcheck failed" send-on-resolved: true - name: back-end group: core url: "https://example.org/" interval: 5m conditions: - "[STATUS] == 200" - "[CERTIFICATE_EXPIRATION] > 48h" alerts: - type: teams description: "healthcheck failed" send-on-resolved: true ``` Here's an example of what the notifications look like:  #### Configuring Teams Workflow alerts > [!NOTE] > This alert is compatible with Workflows for Microsoft Teams. To setup the workflow and get the webhook URL, follow the [Microsoft Documentation](https://support.microsoft.com/en-us/office/create-incoming-webhooks-with-workflows-for-microsoft-teams-8ae491c7-0394-4861-ba59-055e33f75498). | Parameter | Description | Default | |:---------------------------------------------|:-------------------------------------------------------------------------------------------|:-------------------| | `alerting.teams-workflows` | Configuration for alerts of type `teams` | `{}` | | `alerting.teams-workflows.webhook-url` | Teams Webhook URL | Required `""` | | `alerting.teams-workflows.title` | Title of the notification | `"⛑ Gatus"` | | `alerting.teams-workflows.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.teams-workflows.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.teams-workflows.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.teams-workflows.overrides[].*` | See `alerting.teams-workflows.*` parameters | `{}` | ```yaml alerting: teams-workflows: webhook-url: "https://********.webhook.office.com/webhookb2/************" # You can also add group-specific to keys, which will # override the to key above for the specified groups overrides: - group: "core" webhook-url: "https://********.webhook.office.com/webhookb3/************" endpoints: - name: website url: "https://twin.sh/health" interval: 30s conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: teams-workflows description: "healthcheck failed" send-on-resolved: true - name: back-end group: core url: "https://example.org/" interval: 5m conditions: - "[STATUS] == 200" - "[CERTIFICATE_EXPIRATION] > 48h" alerts: - type: teams-workflows description: "healthcheck failed" send-on-resolved: true ``` Here's an example of what the notifications look like:  #### Configuring Telegram alerts | Parameter | Description | Default | |:--------------------------------------|:-------------------------------------------------------------------------------------------|:---------------------------| | `alerting.telegram` | Configuration for alerts of type `telegram` | `{}` | | `alerting.telegram.token` | Telegram Bot Token | Required `""` | | `alerting.telegram.id` | Telegram Chat ID | Required `""` | | `alerting.telegram.topic-id` | Telegram Topic ID in a group corresponds to `message_thread_id` in the Telegram API | `""` | | `alerting.telegram.api-url` | Telegram API URL | `https://api.telegram.org` | | `alerting.telegram.client` | Client configuration.
See [Client configuration](#client-configuration). | `{}` | | `alerting.telegram.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.telegram.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.telegram.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.telegram.overrides[].*` | See `alerting.telegram.*` parameters | `{}` | ```yaml alerting: telegram: token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11" id: "0123456789" topic-id: "7" endpoints: - name: website url: "https://twin.sh/health" interval: 30s conditions: - "[STATUS] == 200" - "[BODY].status == UP" alerts: - type: telegram send-on-resolved: true ``` Here's an example of what the notifications look like:  #### Configuring Twilio alerts | Parameter | Description | Default | |:--------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.twilio` | Settings for alerts of type `twilio` | `{}` | | `alerting.twilio.sid` | Twilio account SID | Required `""` | | `alerting.twilio.token` | Twilio auth token | Required `""` | | `alerting.twilio.from` | Number to send Twilio alerts from | Required `""` | | `alerting.twilio.to` | Number to send twilio alerts to | Required `""` | | `alerting.twilio.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | Custom message templates are supported via the following additional parameters: | Parameter | Description | Default | |:----------------------------------------|:-------------------------------------------------------------------------------------------|:--------| | `alerting.twilio.text-twilio-triggered` | Custom message template for triggered alerts. Supports `[ENDPOINT]`, `[ALERT_DESCRIPTION]` | `""` | | `alerting.twilio.text-twilio-resolved` | Custom message template for resolved alerts. Supports `[ENDPOINT]`, `[ALERT_DESCRIPTION]` | `""` | ```yaml alerting: twilio: sid: "..." token: "..." from: "+1-234-567-8901" to: "+1-234-567-8901" # Custom message templates using placeholders (optional) # Supports both old format {endpoint}/{description} and new format [ENDPOINT]/[ALERT_DESCRIPTION] text-twilio-triggered: "🚨 ALERT: [ENDPOINT] is down! [ALERT_DESCRIPTION]" text-twilio-resolved: "✅ RESOLVED: [ENDPOINT] is back up! [ALERT_DESCRIPTION]" endpoints: - name: website interval: 30s url: "https://twin.sh/health" conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: twilio failure-threshold: 5 send-on-resolved: true description: "healthcheck failed" ``` #### Configuring Vonage alerts > ⚠️ **WARNING**: This alerting provider has not been tested yet. If you've tested it and confirmed that it works, please remove this warning and create a pull request, or comment on [#1223](https://github.com/TwiN/gatus/discussions/1223) with whether the provider works as intended. Thank you for your cooperation. | Parameter | Description | Default | |:------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.vonage` | Configuration for alerts of type `vonage` | `{}` | | `alerting.vonage.api-key` | Vonage API key | Required `""` | | `alerting.vonage.api-secret` | Vonage API secret | Required `""` | | `alerting.vonage.from` | Sender name or phone number | Required `""` | | `alerting.vonage.to` | Recipient phone number | Required `""` | | `alerting.vonage.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.vonage.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.vonage.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.vonage.overrides[].*` | See `alerting.vonage.*` parameters | `{}` | ```yaml alerting: vonage: api-key: "YOUR_API_KEY" api-secret: "YOUR_API_SECRET" from: "Gatus" to: "+1234567890" ``` Example of sending alerts to Vonage: ```yaml endpoints: - name: website url: "https://example.org" alerts: - type: vonage failure-threshold: 5 send-on-resolved: true description: "healthcheck failed" ``` #### Configuring Webex alerts > ⚠️ **WARNING**: This alerting provider has not been tested yet. If you've tested it and confirmed that it works, please remove this warning and create a pull request, or comment on [#1223](https://github.com/TwiN/gatus/discussions/1223) with whether the provider works as intended. Thank you for your cooperation. | Parameter | Description | Default | |:-----------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.webex` | Configuration for alerts of type `webex` | `{}` | | `alerting.webex.webhook-url` | Webex Teams webhook URL | Required `""` | | `alerting.webex.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.webex.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.webex.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.webex.overrides[].*` | See `alerting.webex.*` parameters | `{}` | ```yaml alerting: webex: webhook-url: "https://webexapis.com/v1/webhooks/incoming/YOUR_WEBHOOK_ID" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: webex send-on-resolved: true ``` #### Configuring Zapier alerts > ⚠️ **WARNING**: This alerting provider has not been tested yet. If you've tested it and confirmed that it works, please remove this warning and create a pull request, or comment on [#1223](https://github.com/TwiN/gatus/discussions/1223) with whether the provider works as intended. Thank you for your cooperation. | Parameter | Description | Default | |:--------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.zapier` | Configuration for alerts of type `zapier` | `{}` | | `alerting.zapier.webhook-url` | Zapier webhook URL | Required `""` | | `alerting.zapier.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.zapier.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.zapier.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.zapier.overrides[].*` | See `alerting.zapier.*` parameters | `{}` | ```yaml alerting: zapier: webhook-url: "https://hooks.zapier.com/hooks/catch/YOUR_WEBHOOK_ID/" endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" alerts: - type: zapier send-on-resolved: true ``` #### Configuring Zulip alerts | Parameter | Description | Default | |:-----------------------------------|:------------------------------------------------------------------------------------|:--------------| | `alerting.zulip` | Configuration for alerts of type `zulip` | `{}` | | `alerting.zulip.bot-email` | Bot Email | Required `""` | | `alerting.zulip.bot-api-key` | Bot API key | Required `""` | | `alerting.zulip.domain` | Full organization domain (e.g.: yourZulipDomain.zulipchat.com) | Required `""` | | `alerting.zulip.channel-id` | The channel ID where Gatus will send the alerts | Required `""` | | `alerting.zulip.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.zulip.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.zulip.overrides[].*` | See `alerting.zulip.*` parameters | `{}` | ```yaml alerting: zulip: bot-email: gatus-bot@some.zulip.org bot-api-key: "********************************" domain: some.zulip.org channel-id: 123456 endpoints: - name: website url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: zulip description: "healthcheck failed" send-on-resolved: true ``` #### Configuring custom alerts | Parameter | Description | Default | |:------------------------------------|:-------------------------------------------------------------------------------------------|:--------------| | `alerting.custom` | Configuration for custom actions on failure or alerts | `{}` | | `alerting.custom.url` | Custom alerting request url | Required `""` | | `alerting.custom.method` | Request method | `GET` | | `alerting.custom.body` | Custom alerting request body. | `""` | | `alerting.custom.headers` | Custom alerting request headers | `{}` | | `alerting.custom.client` | Client configuration.
See [Client configuration](#client-configuration). | `{}` | | `alerting.custom.default-alert` | Default alert configuration.
See [Setting a default alert](#setting-a-default-alert) | N/A | | `alerting.custom.overrides` | List of overrides that may be prioritized over the default configuration | `[]` | | `alerting.custom.overrides[].group` | Endpoint group for which the configuration will be overridden by this configuration | `""` | | `alerting.custom.overrides[].*` | See `alerting.custom.*` parameters | `{}` | 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 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. Furthermore, you may use the following placeholders in the body (`alerting.custom.body`) and in the url (`alerting.custom.url`): - `[ALERT_DESCRIPTION]` (resolved from `endpoints[].alerts[].description`) - `[ENDPOINT_NAME]` (resolved from `endpoints[].name`) - `[ENDPOINT_GROUP]` (resolved from `endpoints[].group`) - `[ENDPOINT_URL]` (resolved from `endpoints[].url`) - `[RESULT_ERRORS]` (resolved from the health evaluation of a given health check) - `[RESULT_CONDITIONS]` (condition results from the health evaluation of a given health check) - If you have an alert using the `custom` provider with `send-on-resolved` set to `true`, you can use the `[ALERT_TRIGGERED_OR_RESOLVED]` placeholder to differentiate the notifications. The aforementioned placeholder will be replaced by `TRIGGERED` or `RESOLVED` accordingly, though it can be modified (details at the end of this section). For all intents and purposes, we'll configure the custom alert with a Slack webhook, but you can call anything you want. ```yaml alerting: custom: url: "https://hooks.slack.com/services/**********/**********/**********" method: "POST" body: | { "text": "[ALERT_TRIGGERED_OR_RESOLVED]: [ENDPOINT_GROUP] - [ENDPOINT_NAME] - [ALERT_DESCRIPTION] - [RESULT_ERRORS]" } endpoints: - name: website url: "https://twin.sh/health" interval: 30s conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 300" alerts: - type: custom failure-threshold: 10 success-threshold: 3 send-on-resolved: true description: "health check failed" ``` Note that you can customize the resolved values for the `[ALERT_TRIGGERED_OR_RESOLVED]` placeholder like so: ```yaml alerting: custom: placeholders: ALERT_TRIGGERED_OR_RESOLVED: TRIGGERED: "partial_outage" RESOLVED: "operational" ``` As a result, the `[ALERT_TRIGGERED_OR_RESOLVED]` in the body of first example of this section would be replaced by `partial_outage` when an alert is triggered and `operational` when an alert is resolved. #### Setting a default alert | Parameter | Description | Default | |:---------------------------------------------|:------------------------------------------------------------------------------|:--------| | `alerting.*.default-alert.enabled` | Whether to enable the alert | N/A | | `alerting.*.default-alert.failure-threshold` | Number of failures in a row needed before triggering the alert | N/A | | `alerting.*.default-alert.success-threshold` | Number of successes in a row before an ongoing incident is marked as resolved | N/A | | `alerting.*.default-alert.send-on-resolved` | Whether to send a notification once a triggered alert is marked as resolved | N/A | | `alerting.*.default-alert.description` | Description of the alert. Will be included in the alert sent | N/A | > ⚠ You must still specify the `type` of the alert in the endpoint configuration even if you set the default alert of a provider. While you can specify the alert configuration directly in the endpoint definition, it's tedious and may lead to a very long configuration file. To avoid such problem, you can use the `default-alert` parameter present in each provider configuration: ```yaml alerting: slack: webhook-url: "https://hooks.slack.com/services/**********/**********/**********" default-alert: description: "health check failed" send-on-resolved: true failure-threshold: 5 success-threshold: 5 ``` As a result, your Gatus configuration looks a lot tidier: ```yaml endpoints: - name: example url: "https://example.org" conditions: - "[STATUS] == 200" alerts: - type: slack - name: other-example url: "https://example.com" conditions: - "[STATUS] == 200" alerts: - type: slack ``` It also allows you to do things like this: ```yaml endpoints: - name: example url: "https://example.org" conditions: - "[STATUS] == 200" alerts: - type: slack failure-threshold: 5 - type: slack failure-threshold: 10 - type: slack failure-threshold: 15 ``` Of course, you can also mix alert types: ```yaml alerting: slack: webhook-url: "https://hooks.slack.com/services/**********/**********/**********" default-alert: failure-threshold: 3 pagerduty: integration-key: "********************************" default-alert: failure-threshold: 5 endpoints: - name: endpoint-1 url: "https://example.org" conditions: - "[STATUS] == 200" alerts: - type: slack - type: pagerduty - name: endpoint-2 url: "https://example.org" conditions: - "[STATUS] == 200" alerts: - type: slack - type: pagerduty ``` ### Maintenance 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 | |:-----------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------------| | `maintenance.enabled` | Whether the maintenance period is enabled | `true` | | `maintenance.start` | Time at which the maintenance window starts in `hh:mm` format (e.g. `23:00`) | Required `""` | | `maintenance.duration` | Duration of the maintenance window (e.g. `1h`, `30m`) | Required `""` | | `maintenance.timezone` | Timezone of the maintenance window format (e.g. `Europe/Amsterdam`).
See [List of tz database time zones](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) for more info | `UTC` | | `maintenance.every` | Days on which the maintenance period applies (e.g. `[Monday, Thursday]`).
If left empty, the maintenance window applies every day | `[]` | Here's an example: ```yaml maintenance: start: 23:00 duration: 1h timezone: "Europe/Amsterdam" every: [Monday, Thursday] ``` Note that you can also specify each day on separate lines: ```yaml maintenance: start: 23:00 duration: 1h timezone: "Europe/Amsterdam" every: - Monday - Thursday ``` You can also specify maintenance windows on a per-endpoint basis: ```yaml endpoints: - name: endpoint-1 url: "https://example.org" maintenance-windows: - start: "07:30" duration: 40m timezone: "Europe/Berlin" - start: "14:30" duration: 1h timezone: "Europe/Berlin" ``` ### Security | Parameter | Description | Default | |:-----------------|:-----------------------------|:--------| | `security` | Security configuration | `{}` | | `security.basic` | HTTP Basic configuration | `{}` | | `security.oidc` | OpenID Connect configuration | `{}` | #### Basic Authentication | Parameter | Description | Default | |:----------------------------------------|:-----------------------------------------------------------------------------------|:--------------| | `security.basic` | HTTP Basic configuration | `{}` | | `security.basic.username` | Username for Basic authentication. | Required `""` | | `security.basic.password-bcrypt-base64` | Password hashed with Bcrypt and then encoded with base64 for Basic authentication. | Required `""` | The example below will require that you authenticate with the username `john.doe` and the password `hunter2`: ```yaml security: basic: username: "john.doe" password-bcrypt-base64: "JDJhJDEwJHRiMnRFakxWazZLdXBzRERQazB1TE8vckRLY05Yb1hSdnoxWU0yQ1FaYXZRSW1McmladDYu" ``` > ⚠ Make sure to carefully select the 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 2023-01-06, I suggest a cost of 9. #### OIDC | Parameter | Description | Default | |:---------------------------------|:---------------------------------------------------------------|:--------------| | `security.oidc` | OpenID Connect configuration | `{}` | | `security.oidc.issuer-url` | Issuer URL | Required `""` | | `security.oidc.redirect-url` | Redirect URL. Must end with `/authorization-code/callback` | Required `""` | | `security.oidc.client-id` | Client id | Required `""` | | `security.oidc.client-secret` | Client secret | Required `""` | | `security.oidc.scopes` | Scopes to request. The only scope you need is `openid`. | Required `[]` | | `security.oidc.allowed-subjects` | List of subjects to allow. If empty, all subjects are allowed. | `[]` | | `security.oidc.session-ttl` | Session time-to-live (e.g. `8h`, `1h30m`, `2h`). | `8h` | ```yaml security: oidc: issuer-url: "https://example.okta.com" redirect-url: "https://status.example.com/authorization-code/callback" client-id: "123456789" client-secret: "abcdefghijk" scopes: ["openid"] # You may optionally specify a list of allowed subjects. If this is not specified, all subjects will be allowed. #allowed-subjects: ["johndoe@example.com"] # You may optionally specify a session time-to-live. If this is not specified, defaults to 8 hours. #session-ttl: 8h ``` Confused? Read [Securing Gatus with OIDC using Auth0](https://twin.sh/articles/56/securing-gatus-with-oidc-using-auth0). ### TLS Encryption Gatus supports basic encryption with TLS. To enable this, certificate files in PEM format have to be provided. The example below shows an example configuration which makes gatus respond on port 4443 to HTTPS requests: ```yaml web: port: 4443 tls: certificate-file: "certificate.crt" private-key-file: "private.key" ``` ### Metrics To enable metrics, you must set `metrics` to `true`. Doing so will expose Prometheus-friendly metrics at the `/metrics` endpoint on the same port your application is configured to run on (`web.port`). | Metric name | Type | Description | Labels | Relevant endpoint types | |:---------------------------------------------|:--------|:---------------------------------------------------------------------------|:--------------------------------|:------------------------| | gatus_results_total | counter | Number of results per endpoint per success state | key, group, name, type, success | All | | gatus_results_code_total | counter | Total number of results by code | key, group, name, type, code | DNS, HTTP | | gatus_results_connected_total | counter | Total number of results in which a connection was successfully established | key, group, name, type | All | | gatus_results_duration_seconds | gauge | Duration of the request in seconds | key, group, name, type | All | | gatus_results_certificate_expiration_seconds | gauge | Number of seconds until the certificate expires | key, group, name, type | HTTP, STARTTLS | | gatus_results_domain_expiration_seconds | gauge | Number of seconds until the domains expires | key, group, name, type | HTTP, STARTTLS | | gatus_results_endpoint_success | gauge | Displays whether or not the endpoint was a success (0 failure, 1 success) | key, group, name, type | All | See [examples/docker-compose-grafana-prometheus](.examples/docker-compose-grafana-prometheus) for further documentation as well as an example. #### Custom Labels You can add custom labels to your endpoints’ Prometheus metrics by defining key–value pairs under the `extra-labels` field. For example: ```yaml endpoints: - name: front-end group: core url: "https://twin.sh/health" interval: 5m conditions: - "[STATUS] == 200" - "[BODY].status == UP" - "[RESPONSE_TIME] < 150" extra-labels: environment: staging ``` ### Connectivity | Parameter | Description | Default | |:--------------------------------|:-------------------------------------------|:--------------| | `connectivity` | Connectivity configuration | `{}` | | `connectivity.checker` | Connectivity checker configuration | Required `{}` | | `connectivity.checker.target` | Host to use for validating connectivity | Required `""` | | `connectivity.checker.interval` | Interval at which to validate connectivity | `1m` | While Gatus is used to monitor other services, it is possible for Gatus itself to lose connectivity to the internet. In order to prevent Gatus from reporting endpoints as unhealthy when Gatus itself is unhealthy, you may configure Gatus to periodically check for internet connectivity. All endpoint executions are skipped while the connectivity checker deems connectivity to be down. ```yaml connectivity: checker: target: 1.1.1.1:53 interval: 60s ``` ### 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. ### Docker To run Gatus locally with Docker: ```console docker run -p 8080:8080 --name gatus ghcr.io/twin/gatus:stable ``` 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 ghcr.io/twin/gatus:stable ``` If you're on Windows, replace `"$(pwd)"` by the absolute path to your current directory, e.g.: ```console docker run -p 8080:8080 --mount type=bind,source=C:/Users/Chris/Desktop/config.yaml,target=/config/config.yaml --name gatus ghcr.io/twin/gatus:stable ``` To build the image locally: ```console docker build . -t ghcr.io/twin/gatus:stable ``` ### Helm Chart [Helm](https://helm.sh) must be installed to use the chart. Please refer to Helm's [documentation](https://helm.sh/docs/) to get started. Once Helm is set up properly, add the repository as follows: ```console helm repo add twin https://twin.github.io/helm-charts helm repo update helm install gatus twin/gatus ``` To get more details, please check [chart's configuration](https://github.com/TwiN/helm-charts/blob/master/charts/gatus/README.md). ### Terraform #### Kubernetes Gatus can be deployed on Kubernetes using Terraform by using the following module: [terraform-kubernetes-gatus](https://github.com/TwiN/terraform-kubernetes-gatus). ## Running the tests ```console go test -v ./... ``` ## Using in Production See the [Deployment](#deployment) section. ## FAQ ### Sending a GraphQL request By setting `endpoints[].graphql` to true, the body will automatically be wrapped by the standard GraphQL `query` parameter. For instance, the following configuration: ```yaml endpoints: - name: filter-users-by-gender url: http://localhost:8080/playground method: POST graphql: true body: | { users(gender: "female") { id name gender avatar } } conditions: - "[STATUS] == 200" - "[BODY].data.users[0].gender == female" ``` will send a `POST` request to `http://localhost:8080/playground` with the following body: ```json {"query":" {\n users(gender: \"female\") {\n id\n name\n gender\n avatar\n }\n }"} ``` ### Recommended interval To ensure that Gatus provides reliable and accurate results (i.e. response time), Gatus limits the number of endpoints/suites that can be evaluated at the same time. In other words, even if you have multiple endpoints with the same interval, they are not guaranteed to run at the same time. The number of concurrent evaluations is determined by the `concurrency` configuration parameter, which defaults to `3`. 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 semaphore that controls how many endpoints/suites 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 (the default timeout is 10s), those slow evaluations may prevent other endpoints/suites from being 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. 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, assuming `concurrency` is set to `1`: - 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 higher interval. 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`. ### Default timeouts | Endpoint type | Timeout | |:--------------|:--------| | HTTP | 10s | | TCP | 10s | | ICMP | 10s | To modify the timeout, see [Client configuration](#client-configuration). ### Monitoring a TCP endpoint By prefixing `endpoints[].url` with `tcp://`, you can monitor TCP endpoints at a very basic level: ```yaml endpoints: - name: redis url: "tcp://127.0.0.1:6379" interval: 30s conditions: - "[CONNECTED] == true" ``` If `endpoints[].body` is set then it is sent and the first 1024 bytes of the response will be in `[BODY]`. Placeholder `[STATUS]` as well as the fields `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.). > 📝 `[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 a UDP endpoint By prefixing `endpoints[].url` with `udp://`, you can monitor UDP endpoints at a very basic level: ```yaml endpoints: - name: example url: "udp://example.org:80" conditions: - "[CONNECTED] == true" ``` If `endpoints[].body` is set then it is sent and the first 1024 bytes of the response will be in `[BODY]`. Placeholder `[STATUS]` as well as the fields `endpoints[].headers`, `endpoints[].method` and `endpoints[].graphql` are not supported for UDP endpoints. This works for UDP based application. ### Monitoring a SCTP endpoint By prefixing `endpoints[].url` with `sctp://`, you can monitor Stream Control Transmission Protocol (SCTP) endpoints at a very basic level: ```yaml endpoints: - name: example url: "sctp://127.0.0.1:38412" conditions: - "[CONNECTED] == true" ``` Placeholders `[STATUS]` and `[BODY]` as well as the fields `endpoints[].body`, `endpoints[].headers`, `endpoints[].method` and `endpoints[].graphql` are not supported for SCTP endpoints. This works for SCTP based application. ### Monitoring a WebSocket endpoint By prefixing `endpoints[].url` with `ws://` or `wss://`, you can monitor WebSocket endpoints: ```yaml endpoints: - name: example url: "wss://echo.websocket.org/" body: "status" conditions: - "[CONNECTED] == true" - "[BODY] == pat(*served by*)" ``` The `[BODY]` placeholder contains the output of the query, and `[CONNECTED]` shows whether the connection was successfully established. You can use Go template syntax. ### Monitoring an endpoint using gRPC You can monitor gRPC services by prefixing `endpoints[].url` with `grpc://` or `grpcs://`. Gatus executes the standard `grpc.health.v1.Health/Check` RPC against the target. ```yaml endpoints: - name: my-grpc url: grpc://localhost:50051 interval: 30s conditions: - "[CONNECTED] == true" - "[BODY].status == SERVING" # BODY is read only when referenced client: timeout: 5s ``` For TLS-enabled servers, use `grpcs://` and configure client TLS if necessary: ```yaml endpoints: - name: my-grpcs url: grpcs://example.com:443 conditions: - "[CONNECTED] == true" - "[BODY].status == SERVING" client: timeout: 5s insecure: false # set true to skip cert verification (not recommended) tls: certificate-file: /path/to/cert.pem # optional mTLS client cert private-key-file: /path/to/key.pem # optional mTLS client key ``` Notes: - The health check targets the default service (`service: ""`). Support for a custom service name can be added later if needed. - The response body is exposed as a minimal JSON object like `{"status":"SERVING"}` only when required by conditions or suite store mappings. - Timeouts, custom DNS resolvers and SSH tunnels are honored via the existing [`client` configuration](#client-configuration). ### Monitoring an endpoint using ICMP 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 endpoints: - name: ping-example url: "icmp://example.com" conditions: - "[CONNECTED] == true" ``` Only the placeholders `[CONNECTED]`, `[IP]` and `[RESPONSE_TIME]` are supported for endpoints of type ICMP. You can specify a domain prefixed by `icmp://`, or an IP address prefixed by `icmp://`. If you run Gatus on Linux, please read the Linux section on [https://github.com/prometheus-community/pro-bing#linux] if you encounter any problems. Prior to `v5.31.0`, some environment setups required adding `CAP_NET_RAW` capabilities to allow pings to work. As of `v5.31.0`, this is no longer necessary, and ICMP checks will work with unprivileged pings unless running as root. See #1346 for details. ### Monitoring an endpoint using DNS queries Defining a `dns` configuration in an endpoint will automatically mark said endpoint as an endpoint of type DNS: ```yaml endpoints: - name: example-dns-query url: "8.8.8.8" # Address of the DNS server to use dns: query-name: "example.com" query-type: "A" conditions: - "[BODY] == 93.184.215.14" - "[DNS_RCODE] == NOERROR" ``` 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 `NOERROR`, `FORMERR`, `SERVFAIL`, `NXDOMAIN`, etc. ### Monitoring an endpoint using SSH You can monitor endpoints using SSH by prefixing `endpoints[].url` with `ssh://`: ```yaml endpoints: # Password-based SSH example - name: ssh-example-password url: "ssh://example.com:22" # port is optional. Default is 22. ssh: username: "username" password: "password" body: | { "command": "echo '{\"memory\": {\"used\": 512}}'" } interval: 1m conditions: - "[CONNECTED] == true" - "[STATUS] == 0" - "[BODY].memory.used > 500" # Key-based SSH example - name: ssh-example-key url: "ssh://example.com:22" # port is optional. Default is 22. ssh: username: "username" private-key: | -----BEGIN RSA PRIVATE KEY----- TESTRSAKEY... -----END RSA PRIVATE KEY----- interval: 1m conditions: - "[CONNECTED] == true" - "[STATUS] == 0" ``` you can also use no authentication to monitor the endpoint by not specifying the username, password and private key fields. ```yaml endpoints: - name: ssh-example url: "ssh://example.com:22" # port is optional. Default is 22. ssh: username: "" password: "" private-key: "" interval: 1m conditions: - "[CONNECTED] == true" - "[STATUS] == 0" ``` The following placeholders are supported for endpoints of type SSH: - `[CONNECTED]` resolves to `true` if the SSH connection was successful, `false` otherwise - `[STATUS]` resolves the exit code of the command executed on the remote server (e.g. `0` for success) - `[BODY]` resolves to the stdout output of the command executed on the remote server - `[IP]` resolves to the IP address of the server - `[RESPONSE_TIME]` resolves to the time it took to establish the connection and execute the command ### 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 will serve as a good initial indicator: ```yaml endpoints: - name: starttls-smtp-example url: "starttls://smtp.gmail.com:587" interval: 30m client: timeout: 5s conditions: - "[CONNECTED] == true" - "[CERTIFICATE_EXPIRATION] > 48h" ``` ### Monitoring an endpoint using TLS Monitoring endpoints using SSL/TLS encryption, such as LDAP over TLS, can help detect certificate expiration: ```yaml endpoints: - name: tls-ldaps-example url: "tls://ldap.example.com:636" interval: 30m client: timeout: 5s conditions: - "[CONNECTED] == true" - "[CERTIFICATE_EXPIRATION] > 48h" ``` If `endpoints[].body` is set then it is sent and the first 1024 bytes of the response will be in `[BODY]`. Placeholder `[STATUS]` as well as the fields `endpoints[].headers`, `endpoints[].method` and `endpoints[].graphql` are not supported for TLS 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" ``` > ⚠ The usage of the `[DOMAIN_EXPIRATION]` placeholder requires Gatus to use RDAP, or as a fallback, 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`. ### Concurrency By default, Gatus allows up to 3 endpoints/suites to be monitored concurrently. This provides a balance between performance and resource usage while maintaining accurate response time measurements. You can configure the concurrency level using the `concurrency` parameter: ```yaml # Allow 10 endpoints/suites to be monitored concurrently concurrency: 10 # Allow unlimited concurrent monitoring concurrency: 0 # Use default concurrency (3) # concurrency: 3 ``` **Important considerations:** - Higher concurrency can improve monitoring performance when you have many endpoints - Conditions using the `[RESPONSE_TIME]` placeholder may be less accurate with very high concurrency due to system resource contention - Set to `0` for unlimited concurrency (equivalent to the deprecated `disable-monitoring-lock: true`) **Use cases for higher concurrency:** - You have a large number of endpoints to monitor - You want to monitor endpoints at very short intervals (< 5s) - You're using Gatus for load testing scenarios **Legacy configuration:** The `disable-monitoring-lock` parameter is deprecated but still supported for backward compatibility. It's equivalent to setting `concurrency: 0`. ### Reloading configuration on the fly For the sake of convenience, Gatus automatically reloads the configuration on the fly if the loaded configuration file is updated while Gatus is running. By default, the application will exit if the updating configuration is invalid, but you can configure Gatus to continue running if the configuration file is updated with an invalid configuration by setting `skip-invalid-config-update` to `true`. Keep in mind that it is in your best interest to ensure the validity of the configuration file after each update you apply to the configuration file while Gatus is running by looking at the log and making sure that you do not see the following message: ``` The configuration file was updated, but it is not valid. The old configuration will continue being used. ``` Failure to do so may result in Gatus being unable to start if the application is restarted for whatever reason. I recommend not setting `skip-invalid-config-update` to `true` to avoid a situation like this, but the choice is yours to make. **If you are not using a file storage**, updating the configuration while Gatus is running is effectively the same as restarting the application. > 📝 Updates may not be detected if the config file is bound instead of the config folder. See [#151](https://github.com/TwiN/gatus/issues/151). ### Endpoint groups Endpoint groups are used for grouping multiple endpoints together on the dashboard. ```yaml endpoints: - name: frontend group: core url: "https://example.org/" interval: 5m conditions: - "[STATUS] == 200" - name: backend group: core url: "https://example.org/" interval: 5m conditions: - "[STATUS] == 200" - name: monitoring group: internal url: "https://example.org/" interval: 5m conditions: - "[STATUS] == 200" - name: nas group: internal url: "https://example.org/" interval: 5m conditions: - "[STATUS] == 200" - name: random endpoint that is not part of a group url: "https://example.org/" interval: 5m conditions: - "[STATUS] == 200" ``` The configuration above will result in a dashboard that looks like this when sorting by group:  ### How do I sort by group by default? Set `ui.default-sort-by` to `group` in the configuration file: ```yaml ui: default-sort-by: group ``` Note that if a user has already sorted the dashboard by a different field, the default sort will not be applied unless the user clears their browser's localstorage. ### Exposing Gatus on a custom path Currently, you can expose the Gatus UI using a fully qualified domain name (FQDN) such as `status.example.org`. However, it does not support path-based routing, which means you cannot expose it through a URL like `example.org/status/`. For more information, see https://github.com/TwiN/gatus/issues/88. ### Exposing Gatus on a custom port By default, Gatus is exposed on port `8080`, but you may specify a different port by setting the `web.port` parameter: ```yaml web: port: 8081 ``` If you're using a PaaS like Heroku that doesn't let you set a custom port and exposes it through an environment variable instead see [Use environment variables in config files](#use-environment-variables-in-config-files). ### Use environment variables in config files You can use environment variables directly in the configuration file which will be substituted from the environment: ```yaml web: port: ${PORT} ui: title: $TITLE ``` ⚠️ When your configuration parameter contains a `$` symbol, you have to escape `$` with `$$`. ### Configuring a startup delay If, for any reason, you need Gatus to wait for a given amount of time before monitoring the endpoints on application start, you can use the `GATUS_DELAY_START_SECONDS` environment variable to make Gatus sleep on startup. ### Keeping your configuration small While not specific to Gatus, you can leverage YAML anchors to create a default configuration. If you have a large configuration file, this should help you keep things clean.
Example
```yaml default-endpoint: &defaults group: core interval: 5m client: insecure: true timeout: 30s conditions: - "[STATUS] == 200" endpoints: - name: anchor-example-1 <<: *defaults # This will merge the configuration under &defaults with this endpoint url: "https://example.org" - name: anchor-example-2 <<: *defaults group: example # This will override the group defined in &defaults url: "https://example.com" - name: anchor-example-3 <<: *defaults url: "https://twin.sh/health" conditions: # This will override the conditions defined in &defaults - "[STATUS] == 200" - "[BODY].status == UP" ```", prefix, conditionResult.Condition) } var description string if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { description = ":: " + alertDescription } payload := Body{ Cards: []Cards{ { Sections: []Sections{ { Widgets: []Widgets{ { KeyValue: &KeyValue{ TopLabel: ep.DisplayName(), Content: message, ContentMultiline: "true", BottomLabel: description, Icon: "BOOKMARK", }, }, }, }, }, }, }, } if len(formattedConditionResults) > 0 { payload.Cards[0].Sections[0].Widgets = append(payload.Cards[0].Sections[0].Widgets, Widgets{ KeyValue: &KeyValue{ TopLabel: "Condition results", Content: formattedConditionResults, ContentMultiline: "true", Icon: "DESCRIPTION", }, }) } if ep.Type() == endpoint.TypeHTTP { // We only include a button targeting the URL if the endpoint is an HTTP endpoint // If the URL isn't prefixed with https://, Google Chat will just display a blank message aynways. // See https://github.com/TwiN/gatus/issues/362 payload.Cards[0].Sections[0].Widgets = append(payload.Cards[0].Sections[0].Widgets, Widgets{ Buttons: []Buttons{ { TextButton: TextButton{ Text: "URL", OnClick: OnClick{OpenLink: OpenLink{URL: ep.URL}}, }, }, }, }) } bodyAsJSON, _ := json.Marshal(payload) return bodyAsJSON } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/googlechat/googlechat_test.go ================================================ package googlechat import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{WebhookURL: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithInvalidOverrideTo := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: ""}, Group: "group", }, }, } if err := providerWithInvalidOverrideTo.Validate(); err == nil { t.Error("provider integration key shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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( &endpoint.Endpoint{Name: "endpoint-name", Group: "endpoint-group"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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 Endpoint endpoint.Endpoint Provider AlertProvider Alert alert.Alert Resolved bool ExpectedBody string }{ { Name: "triggered", Endpoint: endpoint.Endpoint{Name: "endpoint-name", URL: "https://example.org"}, Provider: AlertProvider{}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#DD0000'\u003eAn alert has been triggered due to having failed 3 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-1","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"❌ [CONNECTED] == true\u003cbr\u003e❌ [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}},{"buttons":[{"textButton":{"text":"URL","onClick":{"openLink":{"url":"https://example.org"}}}}]}]}]}]}`, }, { Name: "resolved", Endpoint: endpoint.Endpoint{Name: "endpoint-name", URL: "https://example.org"}, Provider: AlertProvider{}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#36A64F'\u003eAn alert has been resolved after passing successfully 5 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-2","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"✅ [CONNECTED] == true\u003cbr\u003e✅ [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}},{"buttons":[{"textButton":{"text":"URL","onClick":{"openLink":{"url":"https://example.org"}}}}]}]}]}]}`, }, { Name: "icmp-should-not-include-url", // See https://github.com/TwiN/gatus/issues/362 Endpoint: endpoint.Endpoint{Name: "endpoint-name", URL: "icmp://example.org"}, Provider: AlertProvider{}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#DD0000'\u003eAn alert has been triggered due to having failed 3 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-1","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"❌ [CONNECTED] == true\u003cbr\u003e❌ [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}}]}]}]}`, }, { Name: "tcp-should-not-include-url", // See https://github.com/TwiN/gatus/issues/362 Endpoint: endpoint.Endpoint{Name: "endpoint-name", URL: "tcp://example.org"}, Provider: AlertProvider{}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: `{"cards":[{"sections":[{"widgets":[{"keyValue":{"topLabel":"endpoint-name","content":"\u003cfont color='#DD0000'\u003eAn alert has been triggered due to having failed 3 time(s) in a row\u003c/font\u003e","contentMultiline":"true","bottomLabel":":: description-1","icon":"BOOKMARK"}},{"keyValue":{"topLabel":"Condition results","content":"❌ [CONNECTED] == true\u003cbr\u003e❌ [STATUS] == 200\u003cbr\u003e","contentMultiline":"true","icon":"DESCRIPTION"}}]}]}]}`, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { body := scenario.Provider.buildRequestBody( &scenario.Endpoint, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://example01.com"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://group-example.com"}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"webhook-url": "http://alert-example.com"}}, ExpectedOutput: Config{WebhookURL: "http://alert-example.com"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.WebhookURL != scenario.ExpectedOutput.WebhookURL { t.Errorf("expected webhook URL to be %s, got %s", scenario.ExpectedOutput.WebhookURL, got.WebhookURL) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/gotify/gotify.go ================================================ package gotify import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) const DefaultPriority = 5 var ( ErrServerURLNotSet = errors.New("server URL not set") ErrTokenNotSet = errors.New("token not set") ) type Config struct { ServerURL string `yaml:"server-url"` // URL of the Gotify server Token string `yaml:"token"` // Token to use when sending a message to the Gotify server Priority int `yaml:"priority,omitempty"` // Priority of the message. Defaults to DefaultPriority. Title string `yaml:"title,omitempty"` // Title of the message that will be sent } func (cfg *Config) Validate() error { if cfg.Priority == 0 { cfg.Priority = DefaultPriority } if len(cfg.ServerURL) == 0 { return ErrServerURLNotSet } if len(cfg.Token) == 0 { return ErrTokenNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.ServerURL) > 0 { cfg.ServerURL = override.ServerURL } if len(override.Token) > 0 { cfg.Token = override.Token } if override.Priority != 0 { cfg.Priority = override.Priority } if len(override.Title) > 0 { cfg.Title = override.Title } } // AlertProvider is the configuration necessary for sending an alert using Gotify type AlertProvider struct { DefaultConfig Config `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"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(cfg, ep, alert, result, resolved)) request, err := http.NewRequest(http.MethodPost, cfg.ServerURL+"/message?token="+cfg.Token, 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 } defer response.Body.Close() if response.StatusCode > 399 { body, _ := io.ReadAll(response.Body) return fmt.Errorf("failed to send alert to Gotify: %s", string(body)) } return nil } type Body struct { Message string `json:"message"` Title string `json:"title"` Priority int `json:"priority"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var message string if resolved { message = fmt.Sprintf("An alert for `%s` has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) } else { message = fmt.Sprintf("An alert for `%s` has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) } var formattedConditionResults string for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = "✓" } else { prefix = "✕" } formattedConditionResults += fmt.Sprintf("\n%s - %s", prefix, conditionResult.Condition) } if len(alert.GetDescription()) > 0 { message += " with the following description: " + alert.GetDescription() } message += formattedConditionResults title := "Gatus: " + ep.DisplayName() if cfg.Title != "" { title = cfg.Title } bodyAsJSON, _ := json.Marshal(Body{ Message: message, Title: title, Priority: cfg.Priority, }) return bodyAsJSON } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/gotify/gotify_test.go ================================================ package gotify import ( "encoding/json" "fmt" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/config/endpoint" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected bool }{ { name: "valid", provider: AlertProvider{DefaultConfig: Config{ServerURL: "https://gotify.example.com", Token: "faketoken"}}, expected: true, }, { name: "invalid-server-url", provider: AlertProvider{DefaultConfig: Config{ServerURL: "", Token: "faketoken"}}, expected: false, }, { name: "invalid-app-token", provider: AlertProvider{DefaultConfig: Config{ServerURL: "https://gotify.example.com", Token: ""}}, expected: false, }, { name: "no-priority-should-use-default-value", provider: AlertProvider{DefaultConfig: Config{ServerURL: "https://gotify.example.com", Token: "faketoken"}}, expected: true, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { if err := scenario.provider.Validate(); (err == nil) != scenario.expected { t.Errorf("expected: %t, got: %t", scenario.expected, err == nil) } }) } } func TestAlertProvider_buildRequestBody(t *testing.T) { var ( description = "custom-description" //title = "custom-title" endpointName = "custom-endpoint" ) scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert Resolved bool ExpectedBody string }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{ServerURL: "https://gotify.example.com", Token: "faketoken"}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: fmt.Sprintf("{\"message\":\"An alert for `%s` has been triggered due to having failed 3 time(s) in a row with the following description: %s\\n✕ - [CONNECTED] == true\\n✕ - [STATUS] == 200\",\"title\":\"Gatus: custom-endpoint\",\"priority\":0}", endpointName, description), }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{ServerURL: "https://gotify.example.com", Token: "faketoken"}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: fmt.Sprintf("{\"message\":\"An alert for `%s` has been resolved after passing successfully 5 time(s) in a row with the following description: %s\\n✓ - [CONNECTED] == true\\n✓ - [STATUS] == 200\",\"title\":\"Gatus: custom-endpoint\",\"priority\":0}", endpointName, description), }, { Name: "custom-title", Provider: AlertProvider{DefaultConfig: Config{ServerURL: "https://gotify.example.com", Token: "faketoken", Title: "custom-title"}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: fmt.Sprintf("{\"message\":\"An alert for `%s` has been triggered due to having failed 3 time(s) in a row with the following description: %s\\n✕ - [CONNECTED] == true\\n✕ - [STATUS] == 200\",\"title\":\"custom-title\",\"priority\":0}", endpointName, description), }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { body := scenario.Provider.buildRequestBody( &scenario.Provider.DefaultConfig, &endpoint.Endpoint{Name: endpointName}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(body, &out); err != nil { t.Error("expected body to be valid JSON, got error:", err.Error()) } }) } } func TestAlertProvider_GetDefaultAlert(t *testing.T) { provider := AlertProvider{DefaultAlert: &alert.Alert{}} if provider.GetDefaultAlert() != provider.DefaultAlert { t.Error("expected default alert to be returned") } } func TestAlertProvider_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-should-default", Provider: AlertProvider{ DefaultConfig: Config{ServerURL: "https://gotify.example.com", Token: "12345"}, }, InputAlert: alert.Alert{}, ExpectedOutput: Config{ServerURL: "https://gotify.example.com", Token: "12345", Priority: DefaultPriority}, }, { Name: "provider-with-alert-override", Provider: AlertProvider{ DefaultConfig: Config{ServerURL: "https://gotify.example.com", Token: "12345"}, }, InputAlert: alert.Alert{ProviderOverride: map[string]any{"server-url": "https://gotify.group-example.com", "token": "54321", "title": "alert-title", "priority": 3}}, ExpectedOutput: Config{ServerURL: "https://gotify.group-example.com", Token: "54321", Title: "alert-title", Priority: 3}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig("", &scenario.InputAlert) if err != nil { t.Error("expected no error, got:", err.Error()) } if got.ServerURL != scenario.ExpectedOutput.ServerURL { t.Errorf("expected server URL to be %s, got %s", scenario.ExpectedOutput.ServerURL, got.ServerURL) } if got.Token != scenario.ExpectedOutput.Token { t.Errorf("expected token to be %s, got %s", scenario.ExpectedOutput.Token, got.Token) } if got.Title != scenario.ExpectedOutput.Title { t.Errorf("expected title to be %s, got %s", scenario.ExpectedOutput.Title, got.Title) } if got.Priority != scenario.ExpectedOutput.Priority { t.Errorf("expected priority to be %d, got %d", scenario.ExpectedOutput.Priority, got.Priority) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides("", &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/homeassistant/homeassistant.go ================================================ package homeassistant import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrURLNotSet = errors.New("url not set") ErrTokenNotSet = errors.New("token not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { URL string `yaml:"url"` Token string `yaml:"token"` } func (cfg *Config) Validate() error { if len(cfg.URL) == 0 { return ErrURLNotSet } if len(cfg.Token) == 0 { return ErrTokenNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.URL) > 0 { cfg.URL = override.URL } if len(override.Token) > 0 { cfg.Token = override.Token } } // AlertProvider is the configuration necessary for sending an alert using HomeAssistant type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(ep, alert, result, resolved)) request, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/api/events/gatus_alert", cfg.URL), buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") request.Header.Set("Authorization", "Bearer "+cfg.Token) response, err := client.GetHTTPClient(nil).Do(request) if err != nil { return err } defer response.Body.Close() 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 } type Body struct { EventType string `json:"event_type"` EventData struct { Status string `json:"status"` Endpoint string `json:"endpoint"` Description string `json:"description,omitempty"` Conditions []struct { Condition string `json:"condition"` Success bool `json:"success"` } `json:"conditions,omitempty"` FailureCount int `json:"failure_count,omitempty"` SuccessCount int `json:"success_count,omitempty"` } `json:"event_data"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { body := Body{ EventType: "gatus_alert", EventData: struct { Status string `json:"status"` Endpoint string `json:"endpoint"` Description string `json:"description,omitempty"` Conditions []struct { Condition string `json:"condition"` Success bool `json:"success"` } `json:"conditions,omitempty"` FailureCount int `json:"failure_count,omitempty"` SuccessCount int `json:"success_count,omitempty"` }{ Status: "resolved", Endpoint: ep.DisplayName(), }, } if !resolved { body.EventData.Status = "triggered" body.EventData.FailureCount = alert.FailureThreshold } else { body.EventData.SuccessCount = alert.SuccessThreshold } if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { body.EventData.Description = alertDescription } if len(result.ConditionResults) > 0 { for _, conditionResult := range result.ConditionResults { body.EventData.Conditions = append(body.EventData.Conditions, struct { Condition string `json:"condition"` Success bool `json:"success"` }{ Condition: conditionResult.Condition, Success: conditionResult.Success, }) } } bodyAsJSON, _ := json.Marshal(body) return bodyAsJSON } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/homeassistant/homeassistant_test.go ================================================ package homeassistant import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{URL: "", Token: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } invalidProviderNoToken := AlertProvider{DefaultConfig: Config{URL: "http://homeassistant:8123", Token: ""}} if err := invalidProviderNoToken.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{DefaultConfig: Config{URL: "http://homeassistant:8123", Token: "token"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ Overrides: []Override{ { Config: Config{URL: "http://homeassistant:8123", Token: "token"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{URL: "http://homeassistant:8123", Token: "token"}, Overrides: []Override{ { Config: Config{URL: "http://homeassistant:8123", Token: "token"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { 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{DefaultConfig: Config{URL: "http://homeassistant:8123", Token: "token"}}, 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{DefaultConfig: Config{URL: "http://homeassistant:8123", Token: "token"}}, 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{DefaultConfig: Config{URL: "http://homeassistant:8123", Token: "token"}}, 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, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper}) err := scenario.Provider.Send( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "SUCCESSFUL_CONDITION", Success: true}, {Condition: "FAILING_CONDITION", Success: false}, }, }, 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) { description := "test-description" provider := AlertProvider{DefaultConfig: Config{URL: "http://homeassistant:8123", Token: "token"}} body := provider.buildRequestBody( &endpoint.Endpoint{Name: "endpoint-name"}, &alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "SUCCESSFUL_CONDITION", Success: true}, {Condition: "FAILING_CONDITION", Success: false}, }, }, false, ) var decodedBody Body if err := json.Unmarshal(body, &decodedBody); err != nil { t.Error("expected body to be valid JSON, got error:", err.Error()) } if decodedBody.EventType != "gatus_alert" { t.Errorf("expected event_type to be gatus_alert, got %s", decodedBody.EventType) } if decodedBody.EventData.Status != "triggered" { t.Errorf("expected status to be triggered, got %s", decodedBody.EventData.Status) } if decodedBody.EventData.Description != description { t.Errorf("expected description to be %s, got %s", description, decodedBody.EventData.Description) } if len(decodedBody.EventData.Conditions) != 2 { t.Errorf("expected 2 conditions, got %d", len(decodedBody.EventData.Conditions)) } if !decodedBody.EventData.Conditions[0].Success { t.Error("expected first condition to be successful") } if decodedBody.EventData.Conditions[1].Success { t.Error("expected second condition to be unsuccessful") } } ================================================ FILE: alerting/provider/ifttt/ifttt.go ================================================ package ifttt import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrWebhookKeyNotSet = errors.New("webhook-key not set") ErrEventNameNotSet = errors.New("event-name not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { WebhookKey string `yaml:"webhook-key"` // IFTTT Webhook key EventName string `yaml:"event-name"` // IFTTT event name } func (cfg *Config) Validate() error { if len(cfg.WebhookKey) == 0 { return ErrWebhookKeyNotSet } if len(cfg.EventName) == 0 { return ErrEventNameNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.WebhookKey) > 0 { cfg.WebhookKey = override.WebhookKey } if len(override.EventName) > 0 { cfg.EventName = override.EventName } } // AlertProvider is the configuration necessary for sending an alert using IFTTT type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } url := fmt.Sprintf("https://maker.ifttt.com/trigger/%s/with/key/%s", cfg.EventName, cfg.WebhookKey) body, err := provider.buildRequestBody(ep, alert, result, resolved) if err != nil { return err } buffer := bytes.NewBuffer(body) request, err := http.NewRequest(http.MethodPost, url, 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 } defer response.Body.Close() if response.StatusCode >= 400 { body, _ := io.ReadAll(response.Body) return fmt.Errorf("call to ifttt alert returned status code %d: %s", response.StatusCode, string(body)) } return err } type Body struct { Value1 string `json:"value1"` // Alert status/title Value2 string `json:"value2"` // Alert message Value3 string `json:"value3"` // Additional details } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) ([]byte, error) { var value1, value2, value3 string if resolved { value1 = fmt.Sprintf("✅ RESOLVED: %s", ep.DisplayName()) value2 = fmt.Sprintf("Alert has been resolved after passing successfully %d time(s) in a row", alert.SuccessThreshold) } else { value1 = fmt.Sprintf("🚨 ALERT: %s", ep.DisplayName()) value2 = fmt.Sprintf("Endpoint has failed %d time(s) in a row", alert.FailureThreshold) } // Build additional details value3 = fmt.Sprintf("Endpoint: %s", ep.DisplayName()) if ep.Group != "" { value3 += fmt.Sprintf(" | Group: %s", ep.Group) } if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { value3 += fmt.Sprintf(" | Description: %s", alertDescription) } // Add condition results summary if len(result.ConditionResults) > 0 { successCount := 0 for _, conditionResult := range result.ConditionResults { if conditionResult.Success { successCount++ } } value3 += fmt.Sprintf(" | Conditions: %d/%d passed", successCount, len(result.ConditionResults)) } body := Body{ Value1: value1, Value2: value2, Value3: value3, } bodyAsJSON, err := json.Marshal(body) if err != nil { return nil, err } return bodyAsJSON, nil } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/ifttt/ifttt_test.go ================================================ package ifttt import ( "encoding/json" "net/http" "strings" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected error }{ { name: "valid", provider: AlertProvider{DefaultConfig: Config{WebhookKey: "ifttt-webhook-key-123", EventName: "gatus_alert"}}, expected: nil, }, { name: "invalid-webhook-key", provider: AlertProvider{DefaultConfig: Config{EventName: "gatus_alert"}}, expected: ErrWebhookKeyNotSet, }, { name: "invalid-event-name", provider: AlertProvider{DefaultConfig: Config{WebhookKey: "ifttt-webhook-key-123"}}, expected: ErrEventNameNotSet, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { err := scenario.provider.Validate() if err != scenario.expected { t.Errorf("expected %v, got %v", scenario.expected, err) } }) } } 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{DefaultConfig: Config{WebhookKey: "ifttt-webhook-key-123", EventName: "gatus_alert"}}, alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: false, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { if r.Host != "maker.ifttt.com" { t.Errorf("expected host maker.ifttt.com, got %s", r.Host) } if r.URL.Path != "/trigger/gatus_alert/with/key/ifttt-webhook-key-123" { t.Errorf("expected path /trigger/gatus_alert/with/key/ifttt-webhook-key-123, got %s", r.URL.Path) } body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) value1 := body["value1"].(string) if !strings.Contains(value1, "ALERT") { t.Errorf("expected value1 to contain 'ALERT', got %s", value1) } value2 := body["value2"].(string) if !strings.Contains(value2, "failed 3 time(s)") { t.Errorf("expected value2 to contain failure count, got %s", value2) } value3 := body["value3"].(string) if !strings.Contains(value3, "Endpoint: endpoint-name") { t.Errorf("expected value3 to contain endpoint details, got %s", value3) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "resolved", provider: AlertProvider{DefaultConfig: Config{WebhookKey: "ifttt-webhook-key-123", EventName: "gatus_resolved"}}, alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: true, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { if r.URL.Path != "/trigger/gatus_resolved/with/key/ifttt-webhook-key-123" { t.Errorf("expected path /trigger/gatus_resolved/with/key/ifttt-webhook-key-123, got %s", r.URL.Path) } body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) value1 := body["value1"].(string) if !strings.Contains(value1, "RESOLVED") { t.Errorf("expected value1 to contain 'RESOLVED', got %s", value1) } value3 := body["value3"].(string) if !strings.Contains(value3, "Endpoint: endpoint-name") { t.Errorf("expected value3 to contain endpoint details, got %s", value3) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "error-response", provider: AlertProvider{DefaultConfig: Config{WebhookKey: "ifttt-webhook-key-123", EventName: "gatus_alert"}}, 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.StatusUnauthorized, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.alert, &endpoint.Result{ ConditionResults: []*endpoint.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_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") } } ================================================ FILE: alerting/provider/ilert/ilert.go ================================================ package ilert import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) const ( restAPIUrl = "https://api.ilert.com/api/v1/events/gatus/" ) var ( ErrIntegrationKeyNotSet = errors.New("integration key is not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { IntegrationKey string `yaml:"integration-key"` } func (cfg *Config) Validate() error { if len(cfg.IntegrationKey) == 0 { return ErrIntegrationKeyNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.IntegrationKey) > 0 { cfg.IntegrationKey = override.IntegrationKey } } // AlertProvider is the configuration necessary for sending an alert using ilert type AlertProvider struct { DefaultConfig Config `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"` } type Override struct { Group string `yaml:"group"` Config `yaml:",inline"` } func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(cfg, ep, alert, result, resolved)) req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s%s", restAPIUrl, cfg.IntegrationKey), buffer) if err != nil { return err } req.Header.Set("Content-Type", "application/json") response, err := client.GetHTTPClient(nil).Do(req) if err != nil { return err } defer response.Body.Close() 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 } type Body struct { Alert alert.Alert `json:"alert"` Name string `json:"name"` Group string `json:"group"` Status string `json:"status"` Title string `json:"title"` Details string `json:"details,omitempty"` ConditionResults []*endpoint.ConditionResult `json:"condition_results"` URL string `json:"url"` } func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var details, status string if resolved { status = "resolved" } else { status = "firing" } if len(alert.GetDescription()) > 0 { details = alert.GetDescription() } else { details = "No description" } var body []byte body, _ = json.Marshal(Body{ Alert: *alert, Name: ep.Name, Group: ep.Group, Title: ep.DisplayName(), Status: status, Details: details, ConditionResults: result.ConditionResults, URL: ep.URL, }) return body } func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/ilert/ilert_test.go ================================================ package ilert import ( "bytes" "encoding/json" "io" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected bool }{ { name: "valid", provider: AlertProvider{ DefaultConfig: Config{ IntegrationKey: "some-random-key", }, }, expected: true, }, { name: "invalid-integration-key", provider: AlertProvider{ DefaultConfig: Config{ IntegrationKey: "", }, }, expected: false, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { err := scenario.provider.Validate() if scenario.expected && err != nil { t.Error("expected no error, got", err.Error()) } if !scenario.expected && err == nil { t.Error("expected error, got none") } }) } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: []Override{ { Config: Config{IntegrationKey: "00000000000000000000000000000002"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: []Override{ { Config: Config{IntegrationKey: "00000000000000000000000000000002"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { t.Error("provider should've been valid, got error:", err.Error()) } } func TestAlertProvider_Send(t *testing.T) { defer client.InjectHTTPClient(nil) firstDescription := "description-1" secondDescription := "description-2" sendOnResolved := true scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert Resolved bool MockRoundTripper test.MockRoundTripper ExpectedError bool }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{ IntegrationKey: "some-integration-key", }}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 3, FailureThreshold: 3, ResolveKey: "123", Type: "ilert", SendOnResolved: &sendOnResolved}, Resolved: false, MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { var b bytes.Buffer reader := io.NopCloser(&b) return &http.Response{StatusCode: http.StatusAccepted, Body: reader} }), ExpectedError: false, }, { Name: "triggered-error", Provider: AlertProvider{DefaultConfig: Config{ IntegrationKey: "some-integration-key", }}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 3, FailureThreshold: 3, ResolveKey: "123", Type: "ilert", SendOnResolved: &sendOnResolved}, Resolved: false, MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { return &http.Response{StatusCode: http.StatusBadRequest, Body: http.NoBody} }), ExpectedError: true, }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{ IntegrationKey: "some-integration-key", }}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 3, FailureThreshold: 3, ResolveKey: "123", Type: "ilert", SendOnResolved: &sendOnResolved}, Resolved: true, MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { var b bytes.Buffer reader := io.NopCloser(&b) return &http.Response{StatusCode: http.StatusAccepted, Body: reader} }), ExpectedError: false, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper}) err := scenario.Provider.Send( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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" sendOnResolved := true scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert Resolved bool ExpectedBody string }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{IntegrationKey: "some-integration-key"}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 3, FailureThreshold: 3, ResolveKey: "123", Type: "ilert", SendOnResolved: &sendOnResolved}, Resolved: false, ExpectedBody: `{"alert":{"Type":"ilert","Enabled":null,"FailureThreshold":3,"SuccessThreshold":3,"MinimumReminderInterval":0,"Description":"description-1","SendOnResolved":true,"ProviderOverride":null,"ResolveKey":"123","Triggered":false},"name":"endpoint-name","group":"","status":"firing","title":"endpoint-name","details":"description-1","condition_results":[{"condition":"[CONNECTED] == true","success":false},{"condition":"[STATUS] == 200","success":false}],"url":""}`, }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{IntegrationKey: "some-integration-key"}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 4, FailureThreshold: 3, ResolveKey: "123", Type: "ilert", SendOnResolved: &sendOnResolved}, Resolved: true, ExpectedBody: `{"alert":{"Type":"ilert","Enabled":null,"FailureThreshold":3,"SuccessThreshold":4,"MinimumReminderInterval":0,"Description":"description-1","SendOnResolved":true,"ProviderOverride":null,"ResolveKey":"123","Triggered":false},"name":"endpoint-name","group":"","status":"resolved","title":"endpoint-name","details":"description-1","condition_results":[{"condition":"[CONNECTED] == true","success":true},{"condition":"[STATUS] == 200","success":true}],"url":""}`, }, { Name: "group-override", Provider: AlertProvider{DefaultConfig: Config{IntegrationKey: "some-integration-key"}, Overrides: []Override{{Group: "g", Config: Config{IntegrationKey: "different-integration-key"}}}}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3, ResolveKey: "123", Type: "ilert", SendOnResolved: &sendOnResolved}, Resolved: false, ExpectedBody: `{"alert":{"Type":"ilert","Enabled":null,"FailureThreshold":3,"SuccessThreshold":5,"MinimumReminderInterval":0,"Description":"description-2","SendOnResolved":true,"ProviderOverride":null,"ResolveKey":"123","Triggered":false},"name":"endpoint-name","group":"","status":"firing","title":"endpoint-name","details":"description-2","condition_results":[{"condition":"[CONNECTED] == true","success":false},{"condition":"[STATUS] == 200","success":false}],"url":""}`, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { cfg, err := scenario.Provider.GetConfig("g", &scenario.Alert) if err != nil { t.Error("expected no error, got", err.Error()) } body := scenario.Provider.buildRequestBody( cfg, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{IntegrationKey: "00000000000000000000000000000001"}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{IntegrationKey: "00000000000000000000000000000001"}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: []Override{ { Group: "group", Config: Config{IntegrationKey: "00000000000000000000000000000002"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{IntegrationKey: "00000000000000000000000000000001"}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: []Override{ { Group: "group", Config: Config{IntegrationKey: "00000000000000000000000000000002"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{IntegrationKey: "00000000000000000000000000000002"}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: []Override{ { Group: "group", Config: Config{IntegrationKey: "00000000000000000000000000000002"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"integration-key": "00000000000000000000000000000003"}}, ExpectedOutput: Config{IntegrationKey: "00000000000000000000000000000003"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.IntegrationKey != scenario.ExpectedOutput.IntegrationKey { t.Errorf("expected %s, got %s", scenario.ExpectedOutput.IntegrationKey, got.IntegrationKey) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/incidentio/dedup.go ================================================ package incidentio import ( "crypto/sha256" "encoding/hex" "fmt" "time" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/config/endpoint" ) // generateDeduplicationKey generates a unique deduplication_key for incident.io func generateDeduplicationKey(ep *endpoint.Endpoint, alert *alert.Alert) string { data := fmt.Sprintf("%s|%s|%s|%d", ep.Key(), alert.Type, alert.GetDescription(), time.Now().UnixNano()) hash := sha256.Sum256([]byte(data)) return hex.EncodeToString(hash[:]) } ================================================ FILE: alerting/provider/incidentio/incidentio.go ================================================ package incidentio import ( "bytes" "encoding/json" "errors" "fmt" "io" "maps" "net/http" "strconv" "strings" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/logr" "gopkg.in/yaml.v3" ) const ( restAPIUrl = "https://api.incident.io/v2/alert_events/http/" ) var ( ErrURLNotSet = errors.New("url not set") ErrURLNotPrefixedWithRestAPIURL = fmt.Errorf("url must be prefixed with %s", restAPIUrl) ErrDuplicateGroupOverride = errors.New("duplicate group override") ErrAuthTokenNotSet = errors.New("auth-token not set") ) type Config struct { URL string `yaml:"url,omitempty"` AuthToken string `yaml:"auth-token,omitempty"` SourceURL string `yaml:"source-url,omitempty"` Metadata map[string]interface{} `yaml:"metadata,omitempty"` } func (cfg *Config) Validate() error { if len(cfg.URL) == 0 { return ErrURLNotSet } if !strings.HasPrefix(cfg.URL, restAPIUrl) { return ErrURLNotPrefixedWithRestAPIURL } if len(cfg.AuthToken) == 0 { return ErrAuthTokenNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.URL) > 0 { cfg.URL = override.URL } if len(override.AuthToken) > 0 { cfg.AuthToken = override.AuthToken } if len(override.SourceURL) > 0 { cfg.SourceURL = override.SourceURL } if len(override.Metadata) > 0 { cfg.Metadata = override.Metadata } } // AlertProvider is the configuration necessary for sending an alert using incident.io type AlertProvider struct { DefaultConfig Config `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"` } type Override struct { Group string `yaml:"group"` Config `yaml:",inline"` } func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(cfg, ep, alert, result, resolved)) req, err := http.NewRequest(http.MethodPost, cfg.URL, buffer) if err != nil { return err } req.Header.Set("Content-Type", "application/json") req.Header.Set("Authorization", "Bearer "+cfg.AuthToken) response, err := client.GetHTTPClient(nil).Do(req) if err != nil { return err } defer response.Body.Close() 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)) } incidentioResponse := Response{} err = json.NewDecoder(response.Body).Decode(&incidentioResponse) if err != nil { // Silently fail. We don't want to create tons of alerts just because we failed to parse the body. logr.Errorf("[incidentio.Send] Ran into error decoding pagerduty response: %s", err.Error()) } alert.ResolveKey = incidentioResponse.DeduplicationKey return err } type Body struct { AlertSourceConfigID string `json:"alert_source_config_id"` Status string `json:"status"` Title string `json:"title"` DeduplicationKey string `json:"deduplication_key,omitempty"` Description string `json:"description,omitempty"` SourceURL string `json:"source_url,omitempty"` Metadata map[string]interface{} `json:"metadata,omitempty"` } type Response struct { DeduplicationKey string `json:"deduplication_key"` } func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var message, formattedConditionResults, status string if resolved { message = "An alert has been resolved after passing successfully " + strconv.Itoa(alert.SuccessThreshold) + " time(s) in a row" status = "resolved" } else { message = "An alert has been triggered due to having failed " + strconv.Itoa(alert.FailureThreshold) + " time(s) in a row" status = "firing" } for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = "🟢" } else { prefix = "🔴" } formattedConditionResults += fmt.Sprintf(" %s %s ", prefix, conditionResult.Condition) } if len(alert.GetDescription()) > 0 { message += " with the following description: " + alert.GetDescription() } message += fmt.Sprintf(" and the following conditions: %s ", formattedConditionResults) // Generate deduplication key if empty (first firing) if alert.ResolveKey == "" { // Generate unique key (endpoint key, alert type, timestamp) alert.ResolveKey = generateDeduplicationKey(ep, alert) } // Extract alert_source_config_id from URL alertSourceID := strings.TrimPrefix(cfg.URL, restAPIUrl) // Merge metadata: cfg.Metadata + ep.ExtraLabels (if present) mergedMetadata := map[string]interface{}{} // Copy cfg.Metadata maps.Copy(mergedMetadata, cfg.Metadata) // Add extra labels from endpoint (if present) if ep.ExtraLabels != nil && len(ep.ExtraLabels) > 0 { for k, v := range ep.ExtraLabels { mergedMetadata[k] = v } } body, _ := json.Marshal(Body{ AlertSourceConfigID: alertSourceID, Title: "Gatus: " + ep.DisplayName(), Status: status, DeduplicationKey: alert.ResolveKey, Description: message, SourceURL: cfg.SourceURL, Metadata: mergedMetadata, }) fmt.Printf("%v", string(body)) return body } func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/incidentio/incidentio_test.go ================================================ package incidentio import ( "bytes" "encoding/json" "io" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected bool }{ { name: "valid", provider: AlertProvider{ DefaultConfig: Config{ URL: "https://api.incident.io/v2/alert_events/http/some-id", AuthToken: "some-token", }, }, expected: true, }, { name: "invalid-url", provider: AlertProvider{ DefaultConfig: Config{ URL: "id-without-rest-api-url-as-prefix", AuthToken: "some-token", }, }, expected: false, }, { name: "invalid-missing-auth-token", provider: AlertProvider{ DefaultConfig: Config{ URL: "some-id", }, }, expected: false, }, { name: "invalid-missing-alert-source-config-id", provider: AlertProvider{ DefaultConfig: Config{ AuthToken: "some-token", }, }, expected: false, }, { name: "valid-override", provider: AlertProvider{ DefaultConfig: Config{ AuthToken: "some-token", URL: "https://api.incident.io/v2/alert_events/http/some-id", }, Overrides: []Override{{Group: "core", Config: Config{URL: "https://api.incident.io/v2/alert_events/http/another-id"}}}, }, expected: true, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { err := scenario.provider.Validate() if scenario.expected && err != nil { t.Error("expected no error, got", err.Error()) } if !scenario.expected && err == nil { t.Error("expected error, got none") } }) } } func TestAlertProvider_Send(t *testing.T) { defer client.InjectHTTPClient(nil) firstDescription := "description-1" secondDescription := "description-2" restAPIUrl := "https://api.incident.io/v2/alert_events/http/" scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert Resolved bool MockRoundTripper test.MockRoundTripper ExpectedError bool }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{ URL: restAPIUrl + "some-id", AuthToken: "some-token", }}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { var b bytes.Buffer response := Response{DeduplicationKey: "some-key"} json.NewEncoder(&b).Encode(response) reader := io.NopCloser(&b) return &http.Response{StatusCode: http.StatusAccepted, Body: reader} }), ExpectedError: false, }, { Name: "triggered-error", Provider: AlertProvider{DefaultConfig: Config{ URL: restAPIUrl + "some-id", AuthToken: "some-token", }}, 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{DefaultConfig: Config{ URL: restAPIUrl + "some-id", AuthToken: "some-token", }}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { var b bytes.Buffer response := Response{DeduplicationKey: "some-key"} json.NewEncoder(&b).Encode(response) reader := io.NopCloser(&b) return &http.Response{StatusCode: http.StatusAccepted, Body: reader} }), ExpectedError: false, }, { Name: "resolved-error", Provider: AlertProvider{DefaultConfig: Config{}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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" restAPIUrl := "https://api.incident.io/v2/alert_events/http/" scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert Resolved bool ExpectedAlertSourceID string ExpectedStatus string ExpectedTitle string ExpectedDescription string ExpectedSourceURL string ExpectedMetadata map[string]interface{} ShouldHaveDeduplicationKey bool }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{URL: restAPIUrl + "some-id", AuthToken: "some-token"}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedAlertSourceID: "some-id", ExpectedStatus: "firing", ExpectedTitle: "Gatus: endpoint-name", ExpectedDescription: "An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1 and the following conditions: 🔴 [CONNECTED] == true 🔴 [STATUS] == 200 ", ShouldHaveDeduplicationKey: true, }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{URL: restAPIUrl + "some-id", AuthToken: "some-token"}}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedAlertSourceID: "some-id", ExpectedStatus: "resolved", ExpectedTitle: "Gatus: endpoint-name", ExpectedDescription: "An alert has been resolved after passing successfully 5 time(s) in a row with the following description: description-2 and the following conditions: 🟢 [CONNECTED] == true 🟢 [STATUS] == 200 ", ShouldHaveDeduplicationKey: true, }, { Name: "resolved-with-metadata-source-url", Provider: AlertProvider{DefaultConfig: Config{URL: restAPIUrl + "some-id", AuthToken: "some-token", Metadata: map[string]interface{}{"service": "some-service", "team": "very-core"}, SourceURL: "some-source-url"}}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedAlertSourceID: "some-id", ExpectedStatus: "resolved", ExpectedTitle: "Gatus: endpoint-name", ExpectedDescription: "An alert has been resolved after passing successfully 5 time(s) in a row with the following description: description-2 and the following conditions: 🟢 [CONNECTED] == true 🟢 [STATUS] == 200 ", ExpectedSourceURL: "some-source-url", ExpectedMetadata: map[string]interface{}{"service": "some-service", "team": "very-core"}, ShouldHaveDeduplicationKey: true, }, { Name: "group-override", Provider: AlertProvider{DefaultConfig: Config{URL: restAPIUrl + "some-id", AuthToken: "some-token"}, Overrides: []Override{{Group: "g", Config: Config{URL: restAPIUrl + "different-id", AuthToken: "some-token"}}}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedAlertSourceID: "different-id", ExpectedStatus: "firing", ExpectedTitle: "Gatus: endpoint-name", ExpectedDescription: "An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1 and the following conditions: 🔴 [CONNECTED] == true 🔴 [STATUS] == 200 ", ShouldHaveDeduplicationKey: true, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { cfg, err := scenario.Provider.GetConfig("g", &scenario.Alert) if err != nil { t.Error("expected no error, got", err.Error()) } body := scenario.Provider.buildRequestBody( cfg, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) // Parse the JSON body var parsedBody Body if err := json.Unmarshal(body, &parsedBody); err != nil { t.Error("expected body to be valid JSON, got error:", err.Error()) } // Validate individual fields if parsedBody.AlertSourceConfigID != scenario.ExpectedAlertSourceID { t.Errorf("expected alert_source_config_id to be %s, got %s", scenario.ExpectedAlertSourceID, parsedBody.AlertSourceConfigID) } if parsedBody.Status != scenario.ExpectedStatus { t.Errorf("expected status to be %s, got %s", scenario.ExpectedStatus, parsedBody.Status) } if parsedBody.Title != scenario.ExpectedTitle { t.Errorf("expected title to be %s, got %s", scenario.ExpectedTitle, parsedBody.Title) } if parsedBody.Description != scenario.ExpectedDescription { t.Errorf("expected description to be %s, got %s", scenario.ExpectedDescription, parsedBody.Description) } if scenario.ExpectedSourceURL != "" && parsedBody.SourceURL != scenario.ExpectedSourceURL { t.Errorf("expected source_url to be %s, got %s", scenario.ExpectedSourceURL, parsedBody.SourceURL) } if scenario.ExpectedMetadata != nil { metadataJSON, _ := json.Marshal(parsedBody.Metadata) expectedMetadataJSON, _ := json.Marshal(scenario.ExpectedMetadata) if string(metadataJSON) != string(expectedMetadataJSON) { t.Errorf("expected metadata to be %s, got %s", string(expectedMetadataJSON), string(metadataJSON)) } } // Validate that deduplication_key exists and is not empty if scenario.ShouldHaveDeduplicationKey { if parsedBody.DeduplicationKey == "" { t.Error("expected deduplication_key to be present and non-empty") } } }) } } 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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{URL: "https://api.incident.io/v2/alert_events/http/some-id", AuthToken: "some-token"}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{URL: "https://api.incident.io/v2/alert_events/http/some-id", AuthToken: "some-token"}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{URL: "https://api.incident.io/v2/alert_events/http/some-id", AuthToken: "some-token"}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{URL: "https://api.incident.io/v2/alert_events/http/some-id", AuthToken: "some-token"}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{URL: "https://api.incident.io/v2/alert_events/http/some-id", AuthToken: "some-token"}, Overrides: []Override{ { Group: "group", Config: Config{URL: "https://api.incident.io/v2/alert_events/http/diff-id"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{URL: "https://api.incident.io/v2/alert_events/http/some-id", AuthToken: "some-token"}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{URL: "https://api.incident.io/v2/alert_events/http/some-id", AuthToken: "some-token"}, Overrides: []Override{ { Group: "group", Config: Config{URL: "https://api.incident.io/v2/alert_events/http/diff-id", AuthToken: "some-token"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{URL: "https://api.incident.io/v2/alert_events/http/diff-id", AuthToken: "some-token"}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{URL: "https://api.incident.io/v2/alert_events/http/some-id", AuthToken: "some-token"}, Overrides: []Override{ { Group: "group", Config: Config{URL: "https://api.incident.io/v2/alert_events/http/diff-id", AuthToken: "some-token"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"url": "https://api.incident.io/v2/alert_events/http/another-id"}}, ExpectedOutput: Config{URL: "https://api.incident.io/v2/alert_events/http/another-id", AuthToken: "some-token"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.URL != scenario.ExpectedOutput.URL { t.Errorf("expected alert source config to be %s, got %s", scenario.ExpectedOutput.URL, got.URL) } if got.AuthToken != scenario.ExpectedOutput.AuthToken { t.Errorf("expected alert auth token to be %s, got %s", scenario.ExpectedOutput.AuthToken, got.AuthToken) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ Overrides: []Override{ { Config: Config{URL: "https://api.incident.io/v2/alert_events/http/some-id", AuthToken: "some-token"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithInvalidOverrideTo := AlertProvider{ Overrides: []Override{ { Config: Config{URL: "", AuthToken: "some-token"}, Group: "group", }, }, } if err := providerWithInvalidOverrideTo.Validate(); err == nil { t.Error("provider integration key shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{URL: "https://api.incident.io/v2/alert_events/http/nice-id", AuthToken: "some-token"}, Overrides: []Override{ { Config: Config{URL: "https://api.incident.io/v2/alert_events/http/very-good-id", AuthToken: "some-token"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { t.Error("provider should've been valid") } } ================================================ FILE: alerting/provider/line/line.go ================================================ package line import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrChannelAccessTokenNotSet = errors.New("channel-access-token not set") ErrUserIDsNotSet = errors.New("user-ids not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { ChannelAccessToken string `yaml:"channel-access-token"` // Line Messaging API channel access token UserIDs []string `yaml:"user-ids"` // List of Line user IDs to send messages to } func (cfg *Config) Validate() error { if len(cfg.ChannelAccessToken) == 0 { return ErrChannelAccessTokenNotSet } if len(cfg.UserIDs) == 0 { return ErrUserIDsNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.ChannelAccessToken) > 0 { cfg.ChannelAccessToken = override.ChannelAccessToken } if len(override.UserIDs) > 0 { cfg.UserIDs = override.UserIDs } } // AlertProvider is the configuration necessary for sending an alert using Line type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } for _, userID := range cfg.UserIDs { body, err := provider.buildRequestBody(ep, alert, result, resolved, userID) if err != nil { return err } buffer := bytes.NewBuffer(body) request, err := http.NewRequest(http.MethodPost, "https://api.line.me/v2/bot/message/push", buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", cfg.ChannelAccessToken)) response, err := client.GetHTTPClient(nil).Do(request) if err != nil { return err } if response.StatusCode >= 400 { body, _ := io.ReadAll(response.Body) response.Body.Close() return fmt.Errorf("call to line alert returned status code %d: %s", response.StatusCode, string(body)) } response.Body.Close() } return nil } type Body struct { To string `json:"to"` Messages []Message `json:"messages"` } type Message struct { Type string `json:"type"` Text string `json:"text"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool, userID string) ([]byte, error) { var message string if resolved { message = fmt.Sprintf("✅ RESOLVED: %s\n\nAlert has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) } else { message = fmt.Sprintf("⚠️ ALERT: %s\n\nEndpoint has failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) } if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { message += fmt.Sprintf("\n\nDescription: %s", alertDescription) } if len(result.ConditionResults) > 0 { message += "\n\nCondition Results:" for _, conditionResult := range result.ConditionResults { var status string if conditionResult.Success { status = "✅" } else { status = "❌" } message += fmt.Sprintf("\n%s %s", status, conditionResult.Condition) } } body := Body{ To: userID, Messages: []Message{ { Type: "text", Text: message, }, }, } bodyAsJSON, err := json.Marshal(body) if err != nil { return nil, err } return bodyAsJSON, nil } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/line/line_test.go ================================================ package line import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected error }{ { name: "valid", provider: AlertProvider{DefaultConfig: Config{ChannelAccessToken: "token123", UserIDs: []string{"U123"}}}, expected: nil, }, { name: "invalid-channel-access-token", provider: AlertProvider{DefaultConfig: Config{UserIDs: []string{"U123"}}}, expected: ErrChannelAccessTokenNotSet, }, { name: "invalid-user-ids", provider: AlertProvider{DefaultConfig: Config{ChannelAccessToken: "token123"}}, expected: ErrUserIDsNotSet, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { err := scenario.provider.Validate() if err != scenario.expected { t.Errorf("expected %v, got %v", scenario.expected, err) } }) } } 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{DefaultConfig: Config{ChannelAccessToken: "token123", UserIDs: []string{"U123", "U456"}}}, alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: false, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { if r.URL.Path != "/v2/bot/message/push" { t.Errorf("expected path /v2/bot/message/push, got %s", r.URL.Path) } if r.Header.Get("Authorization") != "Bearer token123" { t.Errorf("expected Authorization header to be 'Bearer token123', got %s", r.Header.Get("Authorization")) } body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) if body["to"] == nil { t.Error("expected 'to' field in request body") } messages := body["messages"].([]interface{}) if len(messages) != 1 { t.Errorf("expected 1 message, got %d", len(messages)) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "resolved", provider: AlertProvider{DefaultConfig: Config{ChannelAccessToken: "token123", UserIDs: []string{"U123"}}}, alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: true, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) messages := body["messages"].([]interface{}) message := messages[0].(map[string]interface{}) text := message["text"].(string) if !contains(text, "RESOLVED") { t.Errorf("expected message to contain 'RESOLVED', got %s", text) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "error-response", provider: AlertProvider{DefaultConfig: Config{ChannelAccessToken: "token123", UserIDs: []string{"U123"}}}, 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.StatusBadRequest, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.alert, &endpoint.Result{ ConditionResults: []*endpoint.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_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 contains(s, substr string) bool { return len(s) >= len(substr) && s[0:len(substr)] == substr || len(s) > len(substr) && contains(s[1:], substr) } ================================================ FILE: alerting/provider/matrix/matrix.go ================================================ package matrix import ( "bytes" "encoding/json" "errors" "fmt" "io" "math/rand" "net/http" "net/url" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) const defaultServerURL = "https://matrix-client.matrix.org" var ( ErrAccessTokenNotSet = errors.New("access-token not set") ErrInternalRoomID = errors.New("internal-room-id not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config 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"` } func (cfg *Config) Validate() error { if len(cfg.ServerURL) == 0 { cfg.ServerURL = defaultServerURL } if len(cfg.AccessToken) == 0 { return ErrAccessTokenNotSet } if len(cfg.InternalRoomID) == 0 { return ErrInternalRoomID } return nil } func (cfg *Config) Merge(override *Config) { if len(override.ServerURL) > 0 { cfg.ServerURL = override.ServerURL } if len(override.AccessToken) > 0 { cfg.AccessToken = override.AccessToken } if len(override.InternalRoomID) > 0 { cfg.InternalRoomID = override.InternalRoomID } } // AlertProvider is the configuration necessary for sending an alert using Matrix type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { 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 ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(ep, alert, result, resolved)) // 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", cfg.ServerURL, url.PathEscape(cfg.InternalRoomID), txnId, url.QueryEscape(cfg.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 } defer response.Body.Close() 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 } type Body struct { MsgType string `json:"msgtype"` Format string `json:"format"` Body string `json:"body"` FormattedBody string `json:"formatted_body"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { body, _ := json.Marshal(Body{ MsgType: "m.text", Format: "org.matrix.custom.html", Body: buildPlaintextMessageBody(ep, alert, result, resolved), FormattedBody: buildHTMLMessageBody(ep, alert, result, resolved), }) return body } // buildPlaintextMessageBody builds the message body in plaintext to include in request func buildPlaintextMessageBody(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) string { var message string if resolved { message = fmt.Sprintf("An alert for `%s` has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) } else { message = fmt.Sprintf("An alert for `%s` has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) } var formattedConditionResults string for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = "✓" } else { prefix = "✕" } formattedConditionResults += 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, formattedConditionResults) } // buildHTMLMessageBody builds the message body in HTML to include in request func buildHTMLMessageBody(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) string { var message string if resolved { message = fmt.Sprintf("An alert for
%s has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold)
} else {
message = fmt.Sprintf("An alert for %s has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold)
}
var formattedConditionResults string
if len(result.ConditionResults) > 0 {
formattedConditionResults = "\nCondition results
- "
for _, conditionResult := range result.ConditionResults {
var prefix string
if conditionResult.Success {
prefix = "✅"
} else {
prefix = "❌"
}
formattedConditionResults += fmt.Sprintf("
- %s -
%s", prefix, conditionResult.Condition)
}
formattedConditionResults += "
%s", alertDescription) } return fmt.Sprintf("
%s
%s%s", message, description, formattedConditionResults) } func randStringBytes(n int) string { // All the compatible characters to use in a transaction ID const availableCharacterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" b := make([]byte, n) 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 } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/matrix/matrix_test.go ================================================ package matrix import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{ DefaultConfig: Config{ AccessToken: "", InternalRoomID: "", }, } if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{ DefaultConfig: Config{ AccessToken: "1", InternalRoomID: "!a:example.com", }, } if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } validProviderWithHomeserver := AlertProvider{ DefaultConfig: Config{ ServerURL: "https://example.com", AccessToken: "1", InternalRoomID: "!a:example.com", }, } if err := validProviderWithHomeserver.Validate(); err != nil { t.Error("provider with homeserver should've been valid") } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ Overrides: []Override{ { Group: "", Config: Config{ AccessToken: "", InternalRoomID: "", }, }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithInvalidOverrideTo := AlertProvider{ Overrides: []Override{ { Group: "group", Config: Config{ AccessToken: "", InternalRoomID: "", }, }, }, } if err := providerWithInvalidOverrideTo.Validate(); err == nil { t.Error("provider integration key shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{ AccessToken: "1", InternalRoomID: "!a:example.com", }, Overrides: []Override{ { Group: "group", Config: Config{ ServerURL: "https://example.com", AccessToken: "1", InternalRoomID: "!a:example.com", }, }, }, } if err := providerWithValidOverride.Validate(); err != nil { 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-with-bad-config", 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: true, }, { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{AccessToken: "1", InternalRoomID: "!a:example.com"}}, 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{DefaultConfig: Config{AccessToken: "1", InternalRoomID: "!a:example.com"}}, 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{DefaultConfig: Config{AccessToken: "1", InternalRoomID: "!a:example.com"}}, 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{DefaultConfig: Config{AccessToken: "1", InternalRoomID: "!a:example.com"}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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: "{\"msgtype\":\"m.text\",\"format\":\"org.matrix.custom.html\",\"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\",\"formatted_body\":\"\\u003ch3\\u003eAn alert for \\u003ccode\\u003eendpoint-name\\u003c/code\\u003e has been triggered due to having failed 3 time(s) in a row\\u003c/h3\\u003e\\n\\u003cblockquote\\u003edescription-1\\u003c/blockquote\\u003e\\n\\u003ch5\\u003eCondition results\\u003c/h5\\u003e\\u003cul\\u003e\\u003cli\\u003e❌ - \\u003ccode\\u003e[CONNECTED] == true\\u003c/code\\u003e\\u003c/li\\u003e\\u003cli\\u003e❌ - \\u003ccode\\u003e[STATUS] == 200\\u003c/code\\u003e\\u003c/li\\u003e\\u003c/ul\\u003e\"}", }, { Name: "resolved", Provider: AlertProvider{}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"msgtype\":\"m.text\",\"format\":\"org.matrix.custom.html\",\"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\",\"formatted_body\":\"\\u003ch3\\u003eAn alert for \\u003ccode\\u003eendpoint-name\\u003c/code\\u003e has been resolved after passing successfully 5 time(s) in a row\\u003c/h3\\u003e\\n\\u003cblockquote\\u003edescription-2\\u003c/blockquote\\u003e\\n\\u003ch5\\u003eCondition results\\u003c/h5\\u003e\\u003cul\\u003e\\u003cli\\u003e✅ - \\u003ccode\\u003e[CONNECTED] == true\\u003c/code\\u003e\\u003c/li\\u003e\\u003cli\\u003e✅ - \\u003ccode\\u003e[STATUS] == 200\\u003c/code\\u003e\\u003c/li\\u003e\\u003c/ul\\u003e\"}", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { body := scenario.Provider.buildRequestBody( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{ ServerURL: "https://example.com", AccessToken: "1", InternalRoomID: "!a:example.com", }, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{ ServerURL: "https://example.com", AccessToken: "1", InternalRoomID: "!a:example.com", }, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{ ServerURL: "https://example.com", AccessToken: "1", InternalRoomID: "!a:example.com", }, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{ ServerURL: "https://example.com", AccessToken: "1", InternalRoomID: "!a:example.com", }, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{ ServerURL: "https://example.com", AccessToken: "1", InternalRoomID: "!a:example.com", }, Overrides: []Override{ { Group: "group", Config: Config{ ServerURL: "https://group-example.com", AccessToken: "12", InternalRoomID: "!a:group-example.com", }, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{ ServerURL: "https://example.com", AccessToken: "1", InternalRoomID: "!a:example.com", }, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{ ServerURL: "https://example.com", AccessToken: "1", InternalRoomID: "!a:example.com", }, Overrides: []Override{ { Group: "group", Config: Config{ ServerURL: "https://group-example.com", AccessToken: "12", InternalRoomID: "!a:group-example.com", }, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{ ServerURL: "https://group-example.com", AccessToken: "12", InternalRoomID: "!a:group-example.com", }, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{ ServerURL: "https://example.com", AccessToken: "1", InternalRoomID: "!a:example.com", }, Overrides: []Override{ { Group: "group", Config: Config{ ServerURL: "https://group-example.com", AccessToken: "12", InternalRoomID: "!a:example01.com", }, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"server-url": "https://alert-example.com", "access-token": "123", "internal-room-id": "!a:alert-example.com"}}, ExpectedOutput: Config{ ServerURL: "https://alert-example.com", AccessToken: "123", InternalRoomID: "!a:alert-example.com", }, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { outputConfig, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Errorf("expected no error, got %v", err) } if outputConfig.ServerURL != scenario.ExpectedOutput.ServerURL { t.Errorf("expected ServerURL to be %s, got %s", scenario.ExpectedOutput.ServerURL, outputConfig.ServerURL) } if outputConfig.AccessToken != scenario.ExpectedOutput.AccessToken { t.Errorf("expected AccessToken to be %s, got %s", scenario.ExpectedOutput.AccessToken, outputConfig.AccessToken) } if outputConfig.InternalRoomID != scenario.ExpectedOutput.InternalRoomID { t.Errorf("expected InternalRoomID to be %s, got %s", scenario.ExpectedOutput.InternalRoomID, outputConfig.InternalRoomID) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/mattermost/mattermost.go ================================================ package mattermost import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrWebhookURLNotSet = errors.New("webhook URL not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { WebhookURL string `yaml:"webhook-url"` Channel string `yaml:"channel,omitempty"` ClientConfig *client.Config `yaml:"client,omitempty"` } func (cfg *Config) Validate() error { if len(cfg.WebhookURL) == 0 { return ErrWebhookURLNotSet } return nil } func (cfg *Config) Merge(override *Config) { if override.ClientConfig != nil { cfg.ClientConfig = override.ClientConfig } if len(override.WebhookURL) > 0 { cfg.WebhookURL = override.WebhookURL } if len(override.Channel) > 0 { cfg.Channel = override.Channel } } // AlertProvider is the configuration necessary for sending an alert using Mattermost type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { if provider.Overrides != nil { registeredGroups := make(map[string]bool) for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" || len(override.WebhookURL) == 0 { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer([]byte(provider.buildRequestBody(cfg, ep, alert, result, resolved))) request, err := http.NewRequest(http.MethodPost, cfg.WebhookURL, buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") response, err := client.GetHTTPClient(cfg.ClientConfig).Do(request) if err != nil { return err } defer response.Body.Close() 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 } type Body struct { Channel string `json:"channel,omitempty"` // Optional channel override Text string `json:"text"` Username string `json:"username"` IconURL string `json:"icon_url"` Attachments []Attachment `json:"attachments"` } type Attachment struct { Title string `json:"title"` Fallback string `json:"fallback"` Text string `json:"text"` Short bool `json:"short"` Color string `json:"color"` Fields []Field `json:"fields"` } type Field struct { Title string `json:"title"` Value string `json:"value"` Short bool `json:"short"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var message, color string if resolved { message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) color = "#36A64F" } else { message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) color = "#DD0000" } var formattedConditionResults string if len(result.ConditionResults) > 0 { for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = ":white_check_mark:" } else { prefix = ":x:" } formattedConditionResults += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition) } } var description string if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { description = ":\n> " + alertDescription } body := Body{ Channel: cfg.Channel, Text: "", Username: "gatus", IconURL: "https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png", Attachments: []Attachment{ { Title: ":helmet_with_white_cross: Gatus", Fallback: "Gatus - " + message, Text: message + description, Short: false, Color: color, }, }, } if len(formattedConditionResults) > 0 { body.Attachments[0].Fields = append(body.Attachments[0].Fields, Field{ Title: "Condition results", Value: formattedConditionResults, Short: false, }) } bodyAsJSON, _ := json.Marshal(body) return bodyAsJSON } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/mattermost/mattermost_test.go ================================================ package mattermost import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{WebhookURL: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithInvalidOverrideWebHookUrl := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: ""}, Group: "group", }, }, } if err := providerWithInvalidOverrideWebHookUrl.Validate(); err == nil { t.Error("provider WebHookURL shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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: "{\"text\":\"\",\"username\":\"gatus\",\"icon_url\":\"https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"fallback\":\"Gatus - An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row\",\"text\":\"An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"short\":false,\"color\":\"#DD0000\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\"short\":false}]}]}", }, { Name: "resolved", Provider: AlertProvider{}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"text\":\"\",\"username\":\"gatus\",\"icon_url\":\"https://raw.githubusercontent.com/TwiN/gatus/master/.github/assets/logo.png\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"fallback\":\"Gatus - An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row\",\"text\":\"An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"short\":false,\"color\":\"#36A64F\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\"short\":false}]}]}", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { body := scenario.Provider.buildRequestBody( &scenario.Provider.DefaultConfig, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://example01.com"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://group-example.com"}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"webhook-url": "http://alert-example.com"}}, ExpectedOutput: Config{WebhookURL: "http://alert-example.com"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.WebhookURL != scenario.ExpectedOutput.WebhookURL { t.Errorf("expected webhook URL to be %s, got %s", scenario.ExpectedOutput.WebhookURL, got.WebhookURL) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/messagebird/messagebird.go ================================================ package messagebird import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) const restAPIURL = "https://rest.messagebird.com/messages" var ( ErrorAccessKeyNotSet = errors.New("access-key not set") ErrorOriginatorNotSet = errors.New("originator not set") ErrorRecipientsNotSet = errors.New("recipients not set") ) type Config struct { AccessKey string `yaml:"access-key"` Originator string `yaml:"originator"` Recipients string `yaml:"recipients"` } func (cfg *Config) Validate() error { if len(cfg.AccessKey) == 0 { return ErrorAccessKeyNotSet } if len(cfg.Originator) == 0 { return ErrorOriginatorNotSet } if len(cfg.Recipients) == 0 { return ErrorRecipientsNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.AccessKey) > 0 { cfg.AccessKey = override.AccessKey } if len(override.Originator) > 0 { cfg.Originator = override.Originator } if len(override.Recipients) > 0 { cfg.Recipients = override.Recipients } } // AlertProvider is the configuration necessary for sending an alert using Messagebird type AlertProvider struct { DefaultConfig Config `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"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { return provider.DefaultConfig.Validate() } // Send an alert using the provider // Reference doc for messagebird: https://developers.messagebird.com/api/sms-messaging/#send-outbound-sms func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(cfg, ep, alert, result, resolved)) request, err := http.NewRequest(http.MethodPost, restAPIURL, buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") request.Header.Set("Authorization", fmt.Sprintf("AccessKey %s", cfg.AccessKey)) response, err := client.GetHTTPClient(nil).Do(request) if err != nil { return err } defer response.Body.Close() 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 } type Body struct { Originator string `json:"originator"` Recipients string `json:"recipients"` Body string `json:"body"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var message string if resolved { message = fmt.Sprintf("RESOLVED: %s - %s", ep.DisplayName(), alert.GetDescription()) } else { message = fmt.Sprintf("TRIGGERED: %s - %s", ep.DisplayName(), alert.GetDescription()) } body, _ := json.Marshal(Body{ Originator: cfg.Originator, Recipients: cfg.Recipients, Body: message, }) return body } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/messagebird/messagebird_test.go ================================================ package messagebird import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestMessagebirdAlertProvider_IsValid(t *testing.T) { invalidProvider := AlertProvider{} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{ DefaultConfig: Config{ AccessKey: "1", Originator: "1", Recipients: "1", }, } if err := validProvider.Validate(); err != nil { 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{DefaultConfig: Config{AccessKey: "1", Originator: "2", Recipients: "3"}}, 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{DefaultConfig: Config{AccessKey: "1", Originator: "2", Recipients: "3"}}, 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{DefaultConfig: Config{AccessKey: "1", Originator: "2", Recipients: "3"}}, 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{DefaultConfig: Config{AccessKey: "1", Originator: "2", Recipients: "3"}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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{DefaultConfig: Config{AccessKey: "1", Originator: "2", Recipients: "3"}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"originator\":\"2\",\"recipients\":\"3\",\"body\":\"TRIGGERED: endpoint-name - description-1\"}", }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{AccessKey: "4", Originator: "5", Recipients: "6"}}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"originator\":\"5\",\"recipients\":\"6\",\"body\":\"RESOLVED: endpoint-name - description-2\"}", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { body := scenario.Provider.buildRequestBody( &scenario.Provider.DefaultConfig, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-should-default", Provider: AlertProvider{ DefaultConfig: Config{AccessKey: "1", Originator: "2", Recipients: "3"}, }, InputAlert: alert.Alert{}, ExpectedOutput: Config{AccessKey: "1", Originator: "2", Recipients: "3"}, }, { Name: "provider-with-alert-override", Provider: AlertProvider{ DefaultConfig: Config{AccessKey: "1", Originator: "2", Recipients: "3"}, }, InputAlert: alert.Alert{ProviderOverride: map[string]any{"access-key": "4", "originator": "5", "recipients": "6"}}, ExpectedOutput: Config{AccessKey: "4", Originator: "5", Recipients: "6"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig("", &scenario.InputAlert) if err != nil { t.Error("expected no error, got:", err.Error()) } if got.AccessKey != scenario.ExpectedOutput.AccessKey { t.Errorf("expected access key to be %s, got %s", scenario.ExpectedOutput.AccessKey, got.AccessKey) } if got.Originator != scenario.ExpectedOutput.Originator { t.Errorf("expected originator to be %s, got %s", scenario.ExpectedOutput.Originator, got.Originator) } if got.Recipients != scenario.ExpectedOutput.Recipients { t.Errorf("expected recipients to be %s, got %s", scenario.ExpectedOutput.Recipients, got.Recipients) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides("", &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/n8n/n8n.go ================================================ package n8n import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrWebhookURLNotSet = errors.New("webhook-url not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { WebhookURL string `yaml:"webhook-url"` Title string `yaml:"title,omitempty"` // Title of the message that will be sent } func (cfg *Config) Validate() error { if len(cfg.WebhookURL) == 0 { return ErrWebhookURLNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.WebhookURL) > 0 { cfg.WebhookURL = override.WebhookURL } if len(override.Title) > 0 { cfg.Title = override.Title } } // AlertProvider is the configuration necessary for sending an alert using n8n type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(cfg, ep, alert, result, resolved)) request, err := http.NewRequest(http.MethodPost, cfg.WebhookURL, 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 } defer response.Body.Close() 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 } type Body struct { Title string `json:"title"` EndpointName string `json:"endpoint_name"` EndpointGroup string `json:"endpoint_group,omitempty"` EndpointURL string `json:"endpoint_url"` AlertDescription string `json:"alert_description,omitempty"` Resolved bool `json:"resolved"` Message string `json:"message"` ConditionResults []ConditionResult `json:"condition_results,omitempty"` } type ConditionResult struct { Condition string `json:"condition"` Success bool `json:"success"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var message string if resolved { message = fmt.Sprintf("An alert for %s has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) } else { message = fmt.Sprintf("An alert for %s has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) } title := "Gatus" if cfg.Title != "" { title = cfg.Title } var conditionResults []ConditionResult for _, conditionResult := range result.ConditionResults { conditionResults = append(conditionResults, ConditionResult{ Condition: conditionResult.Condition, Success: conditionResult.Success, }) } body := Body{ Title: title, EndpointName: ep.Name, EndpointGroup: ep.Group, EndpointURL: ep.URL, AlertDescription: alert.GetDescription(), Resolved: resolved, Message: message, ConditionResults: conditionResults, } bodyAsJSON, _ := json.Marshal(body) return bodyAsJSON } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/n8n/n8n_test.go ================================================ package n8n import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{WebhookURL: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{DefaultConfig: Config{WebhookURL: "https://example.com"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithInvalidOverrideTo := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: ""}, Group: "group", }, }, } if err := providerWithInvalidOverrideTo.Validate(); err == nil { t.Error("provider webhook URL shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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 Endpoint endpoint.Endpoint Alert alert.Alert Resolved bool ExpectedBody Body }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}}, Endpoint: endpoint.Endpoint{Name: "name", URL: "https://example.org"}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: Body{ Title: "Gatus", EndpointName: "name", EndpointURL: "https://example.org", AlertDescription: "description-1", Resolved: false, Message: "An alert for name has been triggered due to having failed 3 time(s) in a row", ConditionResults: []ConditionResult{ {Condition: "[CONNECTED] == true", Success: false}, {Condition: "[STATUS] == 200", Success: false}, }, }, }, { Name: "triggered-with-group", Provider: AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}}, Endpoint: endpoint.Endpoint{Name: "name", Group: "group", URL: "https://example.org"}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: Body{ Title: "Gatus", EndpointName: "name", EndpointGroup: "group", EndpointURL: "https://example.org", AlertDescription: "description-1", Resolved: false, Message: "An alert for group/name has been triggered due to having failed 3 time(s) in a row", ConditionResults: []ConditionResult{ {Condition: "[CONNECTED] == true", Success: false}, {Condition: "[STATUS] == 200", Success: false}, }, }, }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}}, Endpoint: endpoint.Endpoint{Name: "name", URL: "https://example.org"}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: Body{ Title: "Gatus", EndpointName: "name", EndpointURL: "https://example.org", AlertDescription: "description-2", Resolved: true, Message: "An alert for name has been resolved after passing successfully 5 time(s) in a row", ConditionResults: []ConditionResult{ {Condition: "[CONNECTED] == true", Success: true}, {Condition: "[STATUS] == 200", Success: true}, }, }, }, { Name: "resolved-with-custom-title", Provider: AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com", Title: "Custom Title"}}, Endpoint: endpoint.Endpoint{Name: "name", URL: "https://example.org"}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: Body{ Title: "Custom Title", EndpointName: "name", EndpointURL: "https://example.org", AlertDescription: "description-2", Resolved: true, Message: "An alert for name has been resolved after passing successfully 5 time(s) in a row", ConditionResults: []ConditionResult{ {Condition: "[CONNECTED] == true", Success: true}, {Condition: "[STATUS] == 200", Success: true}, }, }, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { cfg, err := scenario.Provider.GetConfig(scenario.Endpoint.Group, &scenario.Alert) if err != nil { t.Fatal("couldn't get config:", err.Error()) } body := scenario.Provider.buildRequestBody( cfg, &scenario.Endpoint, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) var actualBody Body if err := json.Unmarshal(body, &actualBody); err != nil { t.Error("expected body to be valid JSON, got error:", err.Error()) } if actualBody.Title != scenario.ExpectedBody.Title { t.Errorf("expected title to be %s, got %s", scenario.ExpectedBody.Title, actualBody.Title) } if actualBody.EndpointName != scenario.ExpectedBody.EndpointName { t.Errorf("expected endpoint name to be %s, got %s", scenario.ExpectedBody.EndpointName, actualBody.EndpointName) } if actualBody.Resolved != scenario.ExpectedBody.Resolved { t.Errorf("expected resolved to be %v, got %v", scenario.ExpectedBody.Resolved, actualBody.Resolved) } if actualBody.Message != scenario.ExpectedBody.Message { t.Errorf("expected message to be %s, got %s", scenario.ExpectedBody.Message, actualBody.Message) } }) } } 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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://example01.com"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://group-example.com"}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"webhook-url": "http://alert-example.com"}}, ExpectedOutput: Config{WebhookURL: "http://alert-example.com"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.WebhookURL != scenario.ExpectedOutput.WebhookURL { t.Errorf("expected webhook URL to be %s, got %s", scenario.ExpectedOutput.WebhookURL, got.WebhookURL) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/newrelic/newrelic.go ================================================ package newrelic import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "time" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrInsertKeyNotSet = errors.New("insert-key not set") ErrAccountIDNotSet = errors.New("account-id not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { InsertKey string `yaml:"insert-key"` // New Relic Insert key AccountID string `yaml:"account-id"` // New Relic account ID Region string `yaml:"region,omitempty"` // Region (US or EU, defaults to US) } func (cfg *Config) Validate() error { if len(cfg.InsertKey) == 0 { return ErrInsertKeyNotSet } if len(cfg.AccountID) == 0 { return ErrAccountIDNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.InsertKey) > 0 { cfg.InsertKey = override.InsertKey } if len(override.AccountID) > 0 { cfg.AccountID = override.AccountID } if len(override.Region) > 0 { cfg.Region = override.Region } } // AlertProvider is the configuration necessary for sending an alert using New Relic type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } // Determine the API endpoint based on region var apiHost string if cfg.Region == "EU" { apiHost = "insights-collector.eu01.nr-data.net" } else { apiHost = "insights-collector.newrelic.com" } body, err := provider.buildRequestBody(cfg, ep, alert, result, resolved) if err != nil { return err } buffer := bytes.NewBuffer(body) url := fmt.Sprintf("https://%s/v1/accounts/%s/events", apiHost, cfg.AccountID) request, err := http.NewRequest(http.MethodPost, url, buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") request.Header.Set("X-Insert-Key", cfg.InsertKey) response, err := client.GetHTTPClient(nil).Do(request) if err != nil { return err } defer response.Body.Close() if response.StatusCode >= 400 { body, _ := io.ReadAll(response.Body) return fmt.Errorf("call to newrelic alert returned status code %d: %s", response.StatusCode, string(body)) } return nil } type Event struct { EventType string `json:"eventType"` Timestamp int64 `json:"timestamp"` Service string `json:"service"` Endpoint string `json:"endpoint"` Group string `json:"group,omitempty"` AlertStatus string `json:"alertStatus"` Message string `json:"message"` Description string `json:"description,omitempty"` Severity string `json:"severity"` Source string `json:"source"` SuccessRate float64 `json:"successRate,omitempty"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) ([]byte, error) { var alertStatus, severity, message string var successRate float64 if resolved { alertStatus = "resolved" severity = "INFO" message = fmt.Sprintf("Alert for %s has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) successRate = 100 } else { alertStatus = "triggered" severity = "CRITICAL" message = fmt.Sprintf("Alert for %s has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) successRate = 0 } // Calculate success rate from condition results if len(result.ConditionResults) > 0 { successCount := 0 for _, conditionResult := range result.ConditionResults { if conditionResult.Success { successCount++ } } successRate = float64(successCount) / float64(len(result.ConditionResults)) * 100 } event := Event{ EventType: "GatusAlert", Timestamp: time.Now().Unix() * 1000, // New Relic expects milliseconds Service: "Gatus", Endpoint: ep.DisplayName(), Group: ep.Group, AlertStatus: alertStatus, Message: message, Description: alert.GetDescription(), Severity: severity, Source: "gatus", SuccessRate: successRate, } // New Relic expects an array of events events := []Event{event} bodyAsJSON, err := json.Marshal(events) if err != nil { return nil, err } return bodyAsJSON, nil } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/newrelic/newrelic_test.go ================================================ package newrelic import ( "encoding/json" "net/http" "strings" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected error }{ { name: "valid", provider: AlertProvider{DefaultConfig: Config{InsertKey: "nr-insert-key-123", AccountID: "123456"}}, expected: nil, }, { name: "valid-with-region", provider: AlertProvider{DefaultConfig: Config{InsertKey: "nr-insert-key-123", AccountID: "123456", Region: "eu"}}, expected: nil, }, { name: "invalid-insert-key", provider: AlertProvider{DefaultConfig: Config{AccountID: "123456"}}, expected: ErrInsertKeyNotSet, }, { name: "invalid-account-id", provider: AlertProvider{DefaultConfig: Config{InsertKey: "nr-insert-key-123"}}, expected: ErrAccountIDNotSet, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { err := scenario.provider.Validate() if err != scenario.expected { t.Errorf("expected %v, got %v", scenario.expected, err) } }) } } 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-us", provider: AlertProvider{DefaultConfig: Config{InsertKey: "nr-insert-key-123", AccountID: "123456"}}, alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: false, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { if r.Host != "insights-collector.newrelic.com" { t.Errorf("expected host insights-collector.newrelic.com, got %s", r.Host) } if r.URL.Path != "/v1/accounts/123456/events" { t.Errorf("expected path /v1/accounts/123456/events, got %s", r.URL.Path) } if r.Header.Get("X-Insert-Key") != "nr-insert-key-123" { t.Errorf("expected X-Insert-Key header to be 'nr-insert-key-123', got %s", r.Header.Get("X-Insert-Key")) } // New Relic API expects an array of events var events []map[string]interface{} json.NewDecoder(r.Body).Decode(&events) if len(events) != 1 { t.Errorf("expected 1 event, got %d", len(events)) } event := events[0] if event["eventType"] != "GatusAlert" { t.Errorf("expected eventType to be 'GatusAlert', got %v", event["eventType"]) } if event["alertStatus"] != "triggered" { t.Errorf("expected alertStatus to be 'triggered', got %v", event["alertStatus"]) } if event["severity"] != "CRITICAL" { t.Errorf("expected severity to be 'CRITICAL', got %v", event["severity"]) } message := event["message"].(string) if !strings.Contains(message, "Alert") { t.Errorf("expected message to contain 'Alert', got %s", message) } if !strings.Contains(message, "failed 3 time(s)") { t.Errorf("expected message to contain failure count, got %s", message) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "triggered-eu", provider: AlertProvider{DefaultConfig: Config{InsertKey: "nr-insert-key-123", AccountID: "123456", Region: "eu"}}, alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: false, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { // Note: Test doesn't actually use EU region, it uses default US region if r.Host != "insights-collector.newrelic.com" { t.Errorf("expected host insights-collector.newrelic.com, got %s", r.Host) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "resolved", provider: AlertProvider{DefaultConfig: Config{InsertKey: "nr-insert-key-123", AccountID: "123456"}}, alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: true, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { // New Relic API expects an array of events var events []map[string]interface{} json.NewDecoder(r.Body).Decode(&events) if len(events) != 1 { t.Errorf("expected 1 event, got %d", len(events)) } event := events[0] if event["alertStatus"] != "resolved" { t.Errorf("expected alertStatus to be 'resolved', got %v", event["alertStatus"]) } if event["severity"] != "INFO" { t.Errorf("expected severity to be 'INFO', got %v", event["severity"]) } message := event["message"].(string) if !strings.Contains(message, "resolved") { t.Errorf("expected message to contain 'resolved', got %s", message) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "error-response", provider: AlertProvider{DefaultConfig: Config{InsertKey: "nr-insert-key-123", AccountID: "123456"}}, 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.StatusUnauthorized, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.alert, &endpoint.Result{ ConditionResults: []*endpoint.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_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") } } ================================================ FILE: alerting/provider/ntfy/ntfy.go ================================================ package ntfy import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "strconv" "strings" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) const ( DefaultURL = "https://ntfy.sh" DefaultPriority = 3 TokenPrefix = "tk_" ) var ( ErrInvalidToken = errors.New("invalid token") ErrTopicNotSet = errors.New("topic not set") ErrInvalidPriority = errors.New("priority must between 1 and 5 inclusively") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { Topic string `yaml:"topic"` URL string `yaml:"url,omitempty"` // Defaults to DefaultURL Priority int `yaml:"priority,omitempty"` // Defaults to DefaultPriority Token string `yaml:"token,omitempty"` // Defaults to "" Email string `yaml:"email,omitempty"` // Defaults to "" Click string `yaml:"click,omitempty"` // Defaults to "" DisableFirebase bool `yaml:"disable-firebase,omitempty"` // Defaults to false DisableCache bool `yaml:"disable-cache,omitempty"` // Defaults to false } func (cfg *Config) Validate() error { if len(cfg.URL) == 0 { cfg.URL = DefaultURL } if cfg.Priority == 0 { cfg.Priority = DefaultPriority } if len(cfg.Token) > 0 && !strings.HasPrefix(cfg.Token, TokenPrefix) { return ErrInvalidToken } if len(cfg.Topic) == 0 { return ErrTopicNotSet } if cfg.Priority < 1 || cfg.Priority > 5 { return ErrInvalidPriority } return nil } func (cfg *Config) Merge(override *Config) { if len(override.Topic) > 0 { cfg.Topic = override.Topic } if len(override.URL) > 0 { cfg.URL = override.URL } if override.Priority > 0 { cfg.Priority = override.Priority } if len(override.Token) > 0 { cfg.Token = override.Token } if len(override.Email) > 0 { cfg.Email = override.Email } if len(override.Click) > 0 { cfg.Click = override.Click } if override.DisableFirebase { cfg.DisableFirebase = true } if override.DisableCache { cfg.DisableCache = true } } // AlertProvider is the configuration necessary for sending an alert using Slack type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if len(override.Group) == 0 { return ErrDuplicateGroupOverride } if _, ok := registeredGroups[override.Group]; ok { return ErrDuplicateGroupOverride } if len(override.Token) > 0 && !strings.HasPrefix(override.Token, TokenPrefix) { return ErrDuplicateGroupOverride } if override.Priority < 0 || override.Priority >= 6 { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(cfg, ep, alert, result, resolved)) url := cfg.URL request, err := http.NewRequest(http.MethodPost, url, buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") if token := cfg.Token; len(token) > 0 { request.Header.Set("Authorization", "Bearer "+token) } if cfg.DisableFirebase { request.Header.Set("Firebase", "no") } if cfg.DisableCache { request.Header.Set("Cache", "no") } response, err := client.GetHTTPClient(nil).Do(request) if err != nil { return err } defer response.Body.Close() 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 } type Body struct { Topic string `json:"topic"` Title string `json:"title"` Message string `json:"message"` Tags []string `json:"tags"` Priority int `json:"priority"` Email string `json:"email,omitempty"` Click string `json:"click,omitempty"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var message, formattedConditionResults, tag string if resolved { tag = "white_check_mark" message = "An alert has been resolved after passing successfully " + strconv.Itoa(alert.SuccessThreshold) + " time(s) in a row" } else { tag = "rotating_light" message = "An alert has been triggered due to having failed " + strconv.Itoa(alert.FailureThreshold) + " time(s) in a row" } for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = "🟢" } else { prefix = "🔴" } formattedConditionResults += fmt.Sprintf("\n%s %s", prefix, conditionResult.Condition) } if len(alert.GetDescription()) > 0 { message += " with the following description: " + alert.GetDescription() } message += formattedConditionResults body, _ := json.Marshal(Body{ Topic: cfg.Topic, Title: "Gatus: " + ep.DisplayName(), Message: message, Tags: []string{tag}, Priority: cfg.Priority, Email: cfg.Email, Click: cfg.Click, }) return body } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/ntfy/ntfy_test.go ================================================ package ntfy import ( "encoding/json" "io" "net/http" "net/http/httptest" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/config/endpoint" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected bool }{ { name: "valid", provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1}}, expected: true, }, { name: "no-url-should-use-default-value", provider: AlertProvider{DefaultConfig: Config{Topic: "example", Priority: 1}}, expected: true, }, { name: "valid-with-token", provider: AlertProvider{DefaultConfig: Config{Topic: "example", Priority: 1, Token: "tk_faketoken"}}, expected: true, }, { name: "invalid-token", provider: AlertProvider{DefaultConfig: Config{Topic: "example", Priority: 1, Token: "xx_faketoken"}}, expected: false, }, { name: "invalid-topic", provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "", Priority: 1}}, expected: false, }, { name: "invalid-priority-too-high", provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 6}}, expected: false, }, { name: "invalid-priority-too-low", provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: -1}}, expected: false, }, { name: "no-priority-should-use-default-value", provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example"}}, expected: true, }, { name: "invalid-override-token", provider: AlertProvider{DefaultConfig: Config{Topic: "example"}, Overrides: []Override{{Group: "g", Config: Config{Token: "xx_faketoken"}}}}, expected: false, }, { name: "invalid-override-priority", provider: AlertProvider{DefaultConfig: Config{Topic: "example"}, Overrides: []Override{{Group: "g", Config: Config{Priority: 8}}}}, expected: false, }, { name: "no-override-group-name", provider: AlertProvider{DefaultConfig: Config{Topic: "example"}, Overrides: []Override{{}}}, expected: false, }, { name: "duplicate-override-group-names", provider: AlertProvider{DefaultConfig: Config{Topic: "example"}, Overrides: []Override{{Group: "g"}, {Group: "g"}}}, expected: false, }, { name: "valid-override", provider: AlertProvider{DefaultConfig: Config{Topic: "example"}, Overrides: []Override{{Group: "g1", Config: Config{Priority: 4, Click: "https://example.com"}}, {Group: "g2", Config: Config{Topic: "Example", Token: "tk_faketoken"}}}}, expected: true, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { err := scenario.provider.Validate() if scenario.expected && err != nil { t.Error("expected no error, got", err.Error()) } if !scenario.expected && err == nil { t.Error("expected error, got none") } }) } } 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{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: `{"topic":"example","title":"Gatus: endpoint-name","message":"An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1\n🔴 [CONNECTED] == true\n🔴 [STATUS] == 200","tags":["rotating_light"],"priority":1}`, }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 2}}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: `{"topic":"example","title":"Gatus: endpoint-name","message":"An alert has been resolved after passing successfully 5 time(s) in a row with the following description: description-2\n🟢 [CONNECTED] == true\n🟢 [STATUS] == 200","tags":["white_check_mark"],"priority":2}`, }, { Name: "triggered-email", Provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1, Email: "test@example.com", Click: "example.com"}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: `{"topic":"example","title":"Gatus: endpoint-name","message":"An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1\n🔴 [CONNECTED] == true\n🔴 [STATUS] == 200","tags":["rotating_light"],"priority":1,"email":"test@example.com","click":"example.com"}`, }, { Name: "resolved-email", Provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 2, Email: "test@example.com", Click: "example.com"}}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: `{"topic":"example","title":"Gatus: endpoint-name","message":"An alert has been resolved after passing successfully 5 time(s) in a row with the following description: description-2\n🟢 [CONNECTED] == true\n🟢 [STATUS] == 200","tags":["white_check_mark"],"priority":2,"email":"test@example.com","click":"example.com"}`, }, { Name: "group-override", Provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 5, Email: "test@example.com", Click: "example.com"}, Overrides: []Override{{Group: "g", Config: Config{Topic: "group-topic", Priority: 4, Email: "override@test.com", Click: "test.com"}}}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: `{"topic":"group-topic","title":"Gatus: endpoint-name","message":"An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1\n🔴 [CONNECTED] == true\n🔴 [STATUS] == 200","tags":["rotating_light"],"priority":4,"email":"override@test.com","click":"test.com"}`, }, { Name: "alert-override", Provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 5, Email: "test@example.com", Click: "example.com"}, Overrides: []Override{{Group: "g", Config: Config{Topic: "group-topic", Priority: 4, Email: "override@test.com", Click: "test.com"}}}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3, ProviderOverride: map[string]any{"topic": "alert-topic"}}, Resolved: false, ExpectedBody: `{"topic":"alert-topic","title":"Gatus: endpoint-name","message":"An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1\n🔴 [CONNECTED] == true\n🔴 [STATUS] == 200","tags":["rotating_light"],"priority":4,"email":"override@test.com","click":"test.com"}`, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { cfg, err := scenario.Provider.GetConfig("g", &scenario.Alert) if err != nil { t.Error("expected no error, got", err.Error()) } body := scenario.Provider.buildRequestBody( cfg, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(body, &out); err != nil { t.Error("expected body to be valid JSON, got error:", err.Error()) } }) } } func TestAlertProvider_Send(t *testing.T) { description := "description-1" scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert Resolved bool Group string ExpectedBody string ExpectedHeaders map[string]string }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1, Email: "test@example.com", Click: "example.com"}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, Group: "", ExpectedBody: `{"topic":"example","title":"Gatus: endpoint-name","message":"An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1\n🔴 [CONNECTED] == true\n🔴 [STATUS] == 200","tags":["rotating_light"],"priority":1,"email":"test@example.com","click":"example.com"}`, ExpectedHeaders: map[string]string{ "Content-Type": "application/json", }, }, { Name: "token", Provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1, Email: "test@example.com", Click: "example.com", Token: "tk_mytoken"}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, Group: "", ExpectedBody: `{"topic":"example","title":"Gatus: endpoint-name","message":"An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1\n🔴 [CONNECTED] == true\n🔴 [STATUS] == 200","tags":["rotating_light"],"priority":1,"email":"test@example.com","click":"example.com"}`, ExpectedHeaders: map[string]string{ "Content-Type": "application/json", "Authorization": "Bearer tk_mytoken", }, }, { Name: "no firebase", Provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1, Email: "test@example.com", Click: "example.com", DisableFirebase: true}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, Group: "", ExpectedBody: `{"topic":"example","title":"Gatus: endpoint-name","message":"An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1\n🔴 [CONNECTED] == true\n🔴 [STATUS] == 200","tags":["rotating_light"],"priority":1,"email":"test@example.com","click":"example.com"}`, ExpectedHeaders: map[string]string{ "Content-Type": "application/json", "Firebase": "no", }, }, { Name: "no cache", Provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1, Email: "test@example.com", Click: "example.com", DisableCache: true}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, Group: "", ExpectedBody: `{"topic":"example","title":"Gatus: endpoint-name","message":"An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1\n🔴 [CONNECTED] == true\n🔴 [STATUS] == 200","tags":["rotating_light"],"priority":1,"email":"test@example.com","click":"example.com"}`, ExpectedHeaders: map[string]string{ "Content-Type": "application/json", "Cache": "no", }, }, { Name: "neither firebase & cache", Provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1, Email: "test@example.com", Click: "example.com", DisableFirebase: true, DisableCache: true}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, Group: "", ExpectedBody: `{"topic":"example","title":"Gatus: endpoint-name","message":"An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1\n🔴 [CONNECTED] == true\n🔴 [STATUS] == 200","tags":["rotating_light"],"priority":1,"email":"test@example.com","click":"example.com"}`, ExpectedHeaders: map[string]string{ "Content-Type": "application/json", "Firebase": "no", "Cache": "no", }, }, { Name: "overrides", Provider: AlertProvider{DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1, Email: "test@example.com", Click: "example.com", Token: "tk_mytoken"}, Overrides: []Override{Override{Group: "other-group", Config: Config{URL: "https://example.com", Token: "tk_othertoken"}}, Override{Group: "test-group", Config: Config{Token: "tk_test_token"}}}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, Group: "test-group", ExpectedBody: `{"topic":"example","title":"Gatus: test-group/endpoint-name","message":"An alert has been triggered due to having failed 3 time(s) in a row with the following description: description-1\n🔴 [CONNECTED] == true\n🔴 [STATUS] == 200","tags":["rotating_light"],"priority":1,"email":"test@example.com","click":"example.com"}`, ExpectedHeaders: map[string]string{ "Content-Type": "application/json", "Authorization": "Bearer tk_test_token", }, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { // Start a local HTTP server server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { // Test request parameters for header, value := range scenario.ExpectedHeaders { if value != req.Header.Get(header) { t.Errorf("expected: %s, got: %s", value, req.Header.Get(header)) } } body, _ := io.ReadAll(req.Body) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } // Send response to be tested rw.Write([]byte(`OK`)) })) // Close the server when test finishes defer server.Close() scenario.Provider.DefaultConfig.URL = server.URL err := scenario.Provider.Send( &endpoint.Endpoint{Name: "endpoint-name", Group: scenario.Group}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) if err != nil { t.Error("Encountered an error on Send: ", err) } }) } } func TestAlertProvider_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1}, Overrides: []Override{ { Group: "group", Config: Config{URL: "https://group-example.com", Topic: "group-topic", Priority: 2}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1}, Overrides: []Override{ { Group: "group", Config: Config{URL: "https://group-example.com", Topic: "group-topic", Priority: 2}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{URL: "https://group-example.com", Topic: "group-topic", Priority: 2}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1}, Overrides: []Override{ { Group: "group", Config: Config{URL: "https://group-example.com", Topic: "group-topic", Priority: 2}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"url": "http://alert-example.com", "topic": "alert-topic", "priority": 3}}, ExpectedOutput: Config{URL: "http://alert-example.com", Topic: "alert-topic", Priority: 3}, }, { Name: "provider-with-partial-overrides", Provider: AlertProvider{ DefaultConfig: Config{URL: "https://ntfy.sh", Topic: "example", Priority: 1}, Overrides: []Override{ { Group: "group", Config: Config{Topic: "group-topic"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"priority": 3}}, ExpectedOutput: Config{URL: "https://ntfy.sh", Topic: "group-topic", Priority: 3}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.URL != scenario.ExpectedOutput.URL { t.Errorf("expected url %s, got %s", scenario.ExpectedOutput.URL, got.URL) } if got.Topic != scenario.ExpectedOutput.Topic { t.Errorf("expected topic %s, got %s", scenario.ExpectedOutput.Topic, got.Topic) } if got.Priority != scenario.ExpectedOutput.Priority { t.Errorf("expected priority %d, got %d", scenario.ExpectedOutput.Priority, got.Priority) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/opsgenie/opsgenie.go ================================================ package opsgenie import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "strconv" "strings" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) const ( restAPI = "https://api.opsgenie.com/v2/alerts" ) var ( ErrAPIKeyNotSet = errors.New("api-key not set") ) type Config struct { // APIKey to use for APIKey string `yaml:"api-key"` // Priority to be used in Opsgenie alert payload // // default: P1 Priority string `yaml:"priority"` // Source define source to be used in Opsgenie alert payload // // default: gatus Source string `yaml:"source"` // EntityPrefix is a prefix to be used in entity argument in Opsgenie alert payload // // default: gatus- EntityPrefix string `yaml:"entity-prefix"` //AliasPrefix is a prefix to be used in alias argument in Opsgenie alert payload // // default: gatus-healthcheck- AliasPrefix string `yaml:"alias-prefix"` // Tags to be used in Opsgenie alert payload // // default: [] Tags []string `yaml:"tags"` } func (cfg *Config) Validate() error { if len(cfg.APIKey) == 0 { return ErrAPIKeyNotSet } if len(cfg.Source) == 0 { cfg.Source = "gatus" } if len(cfg.EntityPrefix) == 0 { cfg.EntityPrefix = "gatus-" } if len(cfg.AliasPrefix) == 0 { cfg.AliasPrefix = "gatus-healthcheck-" } if len(cfg.Priority) == 0 { cfg.Priority = "P1" } return nil } func (cfg *Config) Merge(override *Config) { if len(override.APIKey) > 0 { cfg.APIKey = override.APIKey } if len(override.Priority) > 0 { cfg.Priority = override.Priority } if len(override.Source) > 0 { cfg.Source = override.Source } if len(override.EntityPrefix) > 0 { cfg.EntityPrefix = override.EntityPrefix } if len(override.AliasPrefix) > 0 { cfg.AliasPrefix = override.AliasPrefix } if len(override.Tags) > 0 { cfg.Tags = override.Tags } } type AlertProvider struct { DefaultConfig Config `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"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { return provider.DefaultConfig.Validate() } // Send an alert using the provider // // Relevant: https://docs.opsgenie.com/docs/alert-api func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } err = provider.sendAlertRequest(cfg, ep, alert, result, resolved) if err != nil { return err } if resolved { err = provider.closeAlert(cfg, ep, alert) if err != nil { return err } } if alert.IsSendingOnResolved() { if resolved { // The alert has been resolved and there's no error, so we can clear the alert's ResolveKey alert.ResolveKey = "" } else { alert.ResolveKey = cfg.AliasPrefix + buildKey(ep) } } return nil } func (provider *AlertProvider) sendAlertRequest(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { payload := provider.buildCreateRequestBody(cfg, ep, alert, result, resolved) return provider.sendRequest(cfg, restAPI, http.MethodPost, payload) } func (provider *AlertProvider) closeAlert(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert) error { payload := provider.buildCloseRequestBody(ep, alert) url := restAPI + "/" + cfg.AliasPrefix + buildKey(ep) + "/close?identifierType=alias" return provider.sendRequest(cfg, url, http.MethodPost, payload) } func (provider *AlertProvider) sendRequest(cfg *Config, url, method string, payload interface{}) error { body, err := json.Marshal(payload) if err != nil { return fmt.Errorf("error build alert with payload %v: %w", payload, err) } request, err := http.NewRequest(method, url, bytes.NewBuffer(body)) if err != nil { return err } request.Header.Set("Content-Type", "application/json") request.Header.Set("Authorization", "GenieKey "+cfg.APIKey) response, err := client.GetHTTPClient(nil).Do(request) if err != nil { return err } defer response.Body.Close() if response.StatusCode > 399 { rBody, _ := io.ReadAll(response.Body) return fmt.Errorf("call to provider alert returned status code %d: %s", response.StatusCode, string(rBody)) } return nil } func (provider *AlertProvider) buildCreateRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) alertCreateRequest { var message, description string if resolved { message = fmt.Sprintf("RESOLVED: %s - %s", ep.Name, alert.GetDescription()) description = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) } else { message = fmt.Sprintf("%s - %s", ep.Name, alert.GetDescription()) description = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) } if ep.Group != "" { message = fmt.Sprintf("[%s] %s", ep.Group, message) } var formattedConditionResults string for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = "▣" } else { prefix = "▢" } formattedConditionResults += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition) } description = description + "\n" + formattedConditionResults key := buildKey(ep) details := map[string]string{ "endpoint:url": ep.URL, "endpoint:group": ep.Group, "result:hostname": result.Hostname, "result:ip": result.IP, "result:dns_code": result.DNSRCode, "result:errors": strings.Join(result.Errors, ","), } for k, v := range details { if v == "" { delete(details, k) } } if result.HTTPStatus > 0 { details["result:http_status"] = strconv.Itoa(result.HTTPStatus) } return alertCreateRequest{ Message: message, Description: description, Source: cfg.Source, Priority: cfg.Priority, Alias: cfg.AliasPrefix + key, Entity: cfg.EntityPrefix + key, Tags: cfg.Tags, Details: details, } } func (provider *AlertProvider) buildCloseRequestBody(ep *endpoint.Endpoint, alert *alert.Alert) alertCloseRequest { return alertCloseRequest{ Source: buildKey(ep), Note: fmt.Sprintf("RESOLVED: %s - %s", ep.Name, alert.GetDescription()), } } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } func buildKey(ep *endpoint.Endpoint) string { name := toKebabCase(ep.Name) if ep.Group == "" { return name } return toKebabCase(ep.Group) + "-" + name } func toKebabCase(val string) string { return strings.ToLower(strings.ReplaceAll(val, " ", "-")) } type alertCreateRequest struct { Message string `json:"message"` Priority string `json:"priority"` Source string `json:"source"` Entity string `json:"entity"` Alias string `json:"alias"` Description string `json:"description"` Tags []string `json:"tags,omitempty"` Details map[string]string `json:"details"` } type alertCloseRequest struct { Source string `json:"source"` Note string `json:"note"` } ================================================ FILE: alerting/provider/opsgenie/opsgenie_test.go ================================================ package opsgenie import ( "net/http" "reflect" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{APIKey: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{DefaultConfig: Config{APIKey: "00000000-0000-0000-0000-000000000000"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestAlertProvider_Send(t *testing.T) { defer client.InjectHTTPClient(nil) description := "my bad alert description" scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert Resolved bool MockRoundTripper test.MockRoundTripper ExpectedError bool }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{APIKey: "00000000-0000-0000-0000-000000000000"}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 1, FailureThreshold: 1}, Resolved: false, ExpectedError: false, MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), }, { Name: "triggered-error", Provider: AlertProvider{DefaultConfig: Config{APIKey: "00000000-0000-0000-0000-000000000000"}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedError: true, MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody} }), }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{APIKey: "00000000-0000-0000-0000-000000000000"}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedError: false, MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), }, { Name: "resolved-error", Provider: AlertProvider{DefaultConfig: Config{APIKey: "00000000-0000-0000-0000-000000000000"}}, Alert: alert.Alert{Description: &description, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedError: true, MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { return &http.Response{StatusCode: http.StatusInternalServerError, Body: http.NoBody} }), }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper}) err := scenario.Provider.Send( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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_buildCreateRequestBody(t *testing.T) { t.Parallel() description := "alert description" scenarios := []struct { Name string Provider *AlertProvider Alert *alert.Alert Endpoint *endpoint.Endpoint Result *endpoint.Result Resolved bool want alertCreateRequest }{ { Name: "missing all params (unresolved)", Provider: &AlertProvider{DefaultConfig: Config{APIKey: "00000000-0000-0000-0000-000000000000"}}, Alert: &alert.Alert{}, Endpoint: &endpoint.Endpoint{}, Result: &endpoint.Result{}, Resolved: false, want: alertCreateRequest{ Message: " - ", Priority: "P1", Source: "gatus", Entity: "gatus-", Alias: "gatus-healthcheck-", Description: "An alert for ** has been triggered due to having failed 0 time(s) in a row\n", Tags: nil, Details: map[string]string{}, }, }, { Name: "missing all params (resolved)", Provider: &AlertProvider{DefaultConfig: Config{APIKey: "00000000-0000-0000-0000-000000000000"}}, Alert: &alert.Alert{}, Endpoint: &endpoint.Endpoint{}, Result: &endpoint.Result{}, Resolved: true, want: alertCreateRequest{ Message: "RESOLVED: - ", Priority: "P1", Source: "gatus", Entity: "gatus-", Alias: "gatus-healthcheck-", Description: "An alert for ** has been resolved after passing successfully 0 time(s) in a row\n", Tags: nil, Details: map[string]string{}, }, }, { Name: "with default options (unresolved)", Provider: &AlertProvider{DefaultConfig: Config{APIKey: "00000000-0000-0000-0000-000000000000"}}, Alert: &alert.Alert{ Description: &description, FailureThreshold: 3, }, Endpoint: &endpoint.Endpoint{ Name: "my super app", }, Result: &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ { Condition: "[STATUS] == 200", Success: true, }, { Condition: "[BODY] == OK", Success: false, }, }, }, Resolved: false, want: alertCreateRequest{ Message: "my super app - " + description, Priority: "P1", Source: "gatus", Entity: "gatus-my-super-app", Alias: "gatus-healthcheck-my-super-app", Description: "An alert for *my super app* has been triggered due to having failed 3 time(s) in a row\n▣ - `[STATUS] == 200`\n▢ - `[BODY] == OK`\n", Tags: nil, Details: map[string]string{}, }, }, { Name: "with custom options (resolved)", Provider: &AlertProvider{ DefaultConfig: Config{ Priority: "P5", EntityPrefix: "oompa-", AliasPrefix: "loompa-", Source: "gatus-hc", Tags: []string{"do-ba-dee-doo"}, }, }, Alert: &alert.Alert{ Description: &description, SuccessThreshold: 4, }, Endpoint: &endpoint.Endpoint{ Name: "my mega app", }, Result: &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ { Condition: "[STATUS] == 200", Success: true, }, }, }, Resolved: true, want: alertCreateRequest{ Message: "RESOLVED: my mega app - " + description, Priority: "P5", Source: "gatus-hc", Entity: "oompa-my-mega-app", Alias: "loompa-my-mega-app", Description: "An alert for *my mega app* has been resolved after passing successfully 4 time(s) in a row\n▣ - `[STATUS] == 200`\n", Tags: []string{"do-ba-dee-doo"}, Details: map[string]string{}, }, }, { Name: "with default options and details (unresolved)", Provider: &AlertProvider{ DefaultConfig: Config{Tags: []string{"foo"}, APIKey: "00000000-0000-0000-0000-000000000000"}, }, Alert: &alert.Alert{ Description: &description, FailureThreshold: 6, }, Endpoint: &endpoint.Endpoint{ Name: "my app", Group: "end game", URL: "https://my.go/app", }, Result: &endpoint.Result{ HTTPStatus: 400, Hostname: "my.go", Errors: []string{"error 01", "error 02"}, Success: false, ConditionResults: []*endpoint.ConditionResult{ { Condition: "[STATUS] == 200", Success: false, }, }, }, Resolved: false, want: alertCreateRequest{ Message: "[end game] my app - " + description, Priority: "P1", Source: "gatus", Entity: "gatus-end-game-my-app", Alias: "gatus-healthcheck-end-game-my-app", Description: "An alert for *end game/my app* has been triggered due to having failed 6 time(s) in a row\n▢ - `[STATUS] == 200`\n", Tags: []string{"foo"}, Details: map[string]string{ "endpoint:url": "https://my.go/app", "endpoint:group": "end game", "result:hostname": "my.go", "result:errors": "error 01,error 02", "result:http_status": "400", }, }, }, } for _, scenario := range scenarios { actual := scenario t.Run(actual.Name, func(t *testing.T) { _ = scenario.Provider.Validate() if got := actual.Provider.buildCreateRequestBody(&scenario.Provider.DefaultConfig, actual.Endpoint, actual.Alert, actual.Result, actual.Resolved); !reflect.DeepEqual(got, actual.want) { t.Errorf("got:\n%v\nwant:\n%v", got, actual.want) } }) } } func TestAlertProvider_buildCloseRequestBody(t *testing.T) { t.Parallel() description := "alert description" scenarios := []struct { Name string Provider *AlertProvider Alert *alert.Alert Endpoint *endpoint.Endpoint want alertCloseRequest }{ { Name: "Missing all values", Provider: &AlertProvider{}, Alert: &alert.Alert{}, Endpoint: &endpoint.Endpoint{}, want: alertCloseRequest{ Source: "", Note: "RESOLVED: - ", }, }, { Name: "Basic values", Provider: &AlertProvider{}, Alert: &alert.Alert{ Description: &description, }, Endpoint: &endpoint.Endpoint{ Name: "endpoint name", }, want: alertCloseRequest{ Source: "endpoint-name", Note: "RESOLVED: endpoint name - alert description", }, }, } for _, scenario := range scenarios { actual := scenario t.Run(actual.Name, func(t *testing.T) { if got := actual.Provider.buildCloseRequestBody(actual.Endpoint, actual.Alert); !reflect.DeepEqual(got, actual.want) { t.Errorf("buildCloseRequestBody() = %v, want %v", got, actual.want) } }) } } func TestAlertProvider_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-should-default", Provider: AlertProvider{ DefaultConfig: Config{APIKey: "00000000-0000-0000-0000-000000000000"}, }, InputAlert: alert.Alert{}, ExpectedOutput: Config{APIKey: "00000000-0000-0000-0000-000000000000"}, }, { Name: "provider-with-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{APIKey: "00000000-0000-0000-0000-000000000000"}, }, InputAlert: alert.Alert{ProviderOverride: map[string]any{"api-key": "00000000-0000-0000-0000-000000000001"}}, ExpectedOutput: Config{APIKey: "00000000-0000-0000-0000-000000000001"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig("", &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.APIKey != scenario.ExpectedOutput.APIKey { t.Errorf("expected APIKey to be %s, got %s", scenario.ExpectedOutput.APIKey, got.APIKey) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides("", &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/pagerduty/pagerduty.go ================================================ package pagerduty import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/logr" "gopkg.in/yaml.v3" ) const ( restAPIURL = "https://events.pagerduty.com/v2/enqueue" ) var ( ErrIntegrationKeyNotSet = errors.New("integration-key must have exactly 32 characters") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { IntegrationKey string `yaml:"integration-key"` } func (cfg *Config) Validate() error { if len(cfg.IntegrationKey) != 32 { return ErrIntegrationKeyNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.IntegrationKey) > 0 { cfg.IntegrationKey = override.IntegrationKey } } // AlertProvider is the configuration necessary for sending an alert using PagerDuty type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } // Either the default integration key has the right length, or there are overrides who are properly configured. return provider.DefaultConfig.Validate() } // Send an alert using the provider // // Relevant: https://developer.pagerduty.com/docs/events-api-v2/trigger-events/ func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(cfg, ep, alert, result, resolved)) request, err := http.NewRequest(http.MethodPost, restAPIURL, 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 } defer response.Body.Close() 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)) } if alert.IsSendingOnResolved() { if resolved { // The alert has been resolved and there's no error, so we can clear the alert's ResolveKey alert.ResolveKey = "" } else { // We need to retrieve the resolve key from the response var payload pagerDutyResponsePayload if err = json.NewDecoder(response.Body).Decode(&payload); err != nil { // Silently fail. We don't want to create tons of alerts just because we failed to parse the body. logr.Errorf("[pagerduty.Send] Ran into error decoding pagerduty response: %s", err.Error()) } else { alert.ResolveKey = payload.DedupKey } } } return nil } type Body struct { RoutingKey string `json:"routing_key"` DedupKey string `json:"dedup_key"` EventAction string `json:"event_action"` Payload Payload `json:"payload"` } type Payload struct { Summary string `json:"summary"` Source string `json:"source"` Severity string `json:"severity"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var message, eventAction, resolveKey string if resolved { message = fmt.Sprintf("RESOLVED: %s - %s", ep.DisplayName(), alert.GetDescription()) eventAction = "resolve" resolveKey = alert.ResolveKey } else { message = fmt.Sprintf("TRIGGERED: %s - %s", ep.DisplayName(), alert.GetDescription()) eventAction = "trigger" resolveKey = "" } body, _ := json.Marshal(Body{ RoutingKey: cfg.IntegrationKey, DedupKey: resolveKey, EventAction: eventAction, Payload: Payload{ Summary: message, Source: "Gatus", Severity: "critical", }, }) return body } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } type pagerDutyResponsePayload struct { Status string `json:"status"` Message string `json:"message"` DedupKey string `json:"dedup_key"` } ================================================ FILE: alerting/provider/pagerduty/pagerduty_test.go ================================================ package pagerduty import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{IntegrationKey: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000000"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: []Override{ { Config: Config{IntegrationKey: "00000000000000000000000000000002"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: []Override{ { Config: Config{IntegrationKey: "00000000000000000000000000000002"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { t.Error("provider should've been valid, got error:", err.Error()) } } 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{DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000000"}}, 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{DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000000"}}, 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{DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000000"}}, 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{DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000000"}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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) { description := "test" scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert Resolved bool ExpectedBody string }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000000"}}, Alert: alert.Alert{Description: &description}, Resolved: false, ExpectedBody: "{\"routing_key\":\"00000000000000000000000000000000\",\"dedup_key\":\"\",\"event_action\":\"trigger\",\"payload\":{\"summary\":\"TRIGGERED: endpoint-name - test\",\"source\":\"Gatus\",\"severity\":\"critical\"}}", }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000000"}}, Alert: alert.Alert{Description: &description, ResolveKey: "key"}, Resolved: true, ExpectedBody: "{\"routing_key\":\"00000000000000000000000000000000\",\"dedup_key\":\"key\",\"event_action\":\"resolve\",\"payload\":{\"summary\":\"RESOLVED: endpoint-name - test\",\"source\":\"Gatus\",\"severity\":\"critical\"}}", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { body := scenario.Provider.buildRequestBody(&scenario.Provider.DefaultConfig, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{}, scenario.Resolved) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{IntegrationKey: "00000000000000000000000000000001"}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{IntegrationKey: "00000000000000000000000000000001"}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: []Override{ { Group: "group", Config: Config{IntegrationKey: "00000000000000000000000000000002"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{IntegrationKey: "00000000000000000000000000000001"}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: []Override{ { Group: "group", Config: Config{IntegrationKey: "00000000000000000000000000000002"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{IntegrationKey: "00000000000000000000000000000002"}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{IntegrationKey: "00000000000000000000000000000001"}, Overrides: []Override{ { Group: "group", Config: Config{IntegrationKey: "00000000000000000000000000000002"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"integration-key": "00000000000000000000000000000003"}}, ExpectedOutput: Config{IntegrationKey: "00000000000000000000000000000003"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.IntegrationKey != scenario.ExpectedOutput.IntegrationKey { t.Errorf("expected %s, got %s", scenario.ExpectedOutput.IntegrationKey, got.IntegrationKey) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/plivo/plivo.go ================================================ package plivo import ( "bytes" "encoding/base64" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrAuthIDNotSet = errors.New("auth-id not set") ErrAuthTokenNotSet = errors.New("auth-token not set") ErrFromNotSet = errors.New("from not set") ErrToNotSet = errors.New("to not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { AuthID string `yaml:"auth-id"` AuthToken string `yaml:"auth-token"` From string `yaml:"from"` To []string `yaml:"to"` } func (cfg *Config) Validate() error { if len(cfg.AuthID) == 0 { return ErrAuthIDNotSet } if len(cfg.AuthToken) == 0 { return ErrAuthTokenNotSet } if len(cfg.From) == 0 { return ErrFromNotSet } if len(cfg.To) == 0 { return ErrToNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.AuthID) > 0 { cfg.AuthID = override.AuthID } if len(override.AuthToken) > 0 { cfg.AuthToken = override.AuthToken } if len(override.From) > 0 { cfg.From = override.From } if len(override.To) > 0 { cfg.To = override.To } } // AlertProvider is the configuration necessary for sending an alert using Plivo type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } message := provider.buildMessage(cfg, ep, alert, result, resolved) // Send individual SMS messages to each recipient for _, to := range cfg.To { if err := provider.sendSMS(cfg, to, message); err != nil { return err } } return nil } // sendSMS sends an SMS message to a single recipient func (provider *AlertProvider) sendSMS(cfg *Config, to, message string) error { payload := map[string]string{ "src": cfg.From, "dst": to, "text": message, } payloadBytes, err := json.Marshal(payload) if err != nil { return err } request, err := http.NewRequest(http.MethodPost, fmt.Sprintf("https://api.plivo.com/v1/Account/%s/Message/", cfg.AuthID), bytes.NewBuffer(payloadBytes)) if err != nil { return err } request.Header.Set("Content-Type", "application/json") request.Header.Set("Authorization", fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString([]byte(cfg.AuthID+":"+cfg.AuthToken)))) response, err := client.GetHTTPClient(nil).Do(request) if err != nil { return err } defer response.Body.Close() if response.StatusCode >= 400 { body, _ := io.ReadAll(response.Body) return fmt.Errorf("call to plivo alert returned status code %d: %s", response.StatusCode, string(body)) } return nil } // buildMessage builds the message for the provider func (provider *AlertProvider) buildMessage(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) string { if resolved { return fmt.Sprintf("RESOLVED: %s - %s", ep.DisplayName(), alert.GetDescription()) } else { return fmt.Sprintf("TRIGGERED: %s - %s", ep.DisplayName(), alert.GetDescription()) } } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/plivo/plivo_test.go ================================================ package plivo import ( "encoding/json" "io" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestPlivoAlertProvider_IsValid(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider ExpectedError error }{ { Name: "invalid-provider-missing-config", Provider: AlertProvider{}, ExpectedError: ErrAuthIDNotSet, }, { Name: "valid-provider", Provider: AlertProvider{ DefaultConfig: Config{ AuthID: "1", AuthToken: "1", From: "1234567890", To: []string{"0987654321"}, }, }, ExpectedError: nil, }, { Name: "valid-provider-with-override", Provider: AlertProvider{ DefaultConfig: Config{ AuthID: "1", AuthToken: "1", From: "1234567890", To: []string{"0987654321"}, }, Overrides: []Override{ { Group: "group1", Config: Config{AuthID: "2", AuthToken: "2", From: "2222222222", To: []string{"3333333333"}}, }, }, }, ExpectedError: nil, }, { Name: "invalid-provider-duplicate-group-override", Provider: AlertProvider{ DefaultConfig: Config{ AuthID: "1", AuthToken: "1", From: "1234567890", To: []string{"0987654321"}, }, Overrides: []Override{ { Group: "group1", Config: Config{AuthID: "2", AuthToken: "2", From: "2222222222", To: []string{"3333333333"}}, }, { Group: "group1", Config: Config{AuthID: "3", AuthToken: "3", From: "4444444444", To: []string{"5555555555"}}, }, }, }, ExpectedError: ErrDuplicateGroupOverride, }, { Name: "invalid-provider-empty-group-override", Provider: AlertProvider{ DefaultConfig: Config{ AuthID: "1", AuthToken: "1", From: "1234567890", To: []string{"0987654321"}, }, Overrides: []Override{ { Group: "", Config: Config{AuthID: "2", AuthToken: "2", From: "2222222222", To: []string{"3333333333"}}, }, }, }, ExpectedError: ErrDuplicateGroupOverride, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { err := scenario.Provider.Validate() if scenario.ExpectedError == nil && err != nil { t.Errorf("expected no error, got %v", err) } if scenario.ExpectedError != nil && err == nil { t.Errorf("expected error %v, got none", scenario.ExpectedError) } if scenario.ExpectedError != nil && err != nil && err.Error() != scenario.ExpectedError.Error() { t.Errorf("expected error %v, got %v", scenario.ExpectedError, err) } }) } } 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{DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}}, 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.StatusAccepted, Body: http.NoBody} }), ExpectedError: false, }, { Name: "triggered-error", Provider: AlertProvider{DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}}, 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{DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}}, 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.StatusAccepted, Body: http.NoBody} }), ExpectedError: false, }, { Name: "resolved-error", Provider: AlertProvider{DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}}, 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, }, { Name: "multiple-recipients", Provider: AlertProvider{DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321", "1122334455"}}}, 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.StatusAccepted, Body: http.NoBody} }), ExpectedError: false, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper}) err := scenario.Provider.Send( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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_buildMessage(t *testing.T) { firstDescription := "description-1" secondDescription := "description-2" scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert Resolved bool ExpectedMessage string }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedMessage: "TRIGGERED: endpoint-name - description-1", }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedMessage: "RESOLVED: endpoint-name - description-2", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { message := scenario.Provider.buildMessage( &scenario.Provider.DefaultConfig, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) if message != scenario.ExpectedMessage { t.Errorf("expected %s, got %s", scenario.ExpectedMessage, message) } }) } } func TestAlertProvider_sendSMS(t *testing.T) { defer client.InjectHTTPClient(nil) cfg := &Config{ AuthID: "test-auth-id", AuthToken: "test-auth-token", From: "1234567890", } scenarios := []struct { Name string To string Message string MockRoundTripper test.MockRoundTripper ExpectedError bool }{ { Name: "successful-sms", To: "0987654321", Message: "Test message", MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { // Verify request structure body, _ := io.ReadAll(r.Body) var payload map[string]string json.Unmarshal(body, &payload) if payload["src"] != cfg.From { t.Errorf("expected src %s, got %s", cfg.From, payload["src"]) } if payload["dst"] != "0987654321" { t.Errorf("expected dst %s, got %s", "0987654321", payload["dst"]) } if payload["text"] != "Test message" { t.Errorf("expected text %s, got %s", "Test message", payload["text"]) } return &http.Response{StatusCode: http.StatusAccepted, Body: http.NoBody} }), ExpectedError: false, }, { Name: "failed-sms", To: "0987654321", Message: "Test message", MockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { return &http.Response{StatusCode: http.StatusBadRequest, Body: http.NoBody} }), ExpectedError: true, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper}) provider := AlertProvider{} err := provider.sendSMS(cfg, scenario.To, scenario.Message) 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_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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-should-default", Provider: AlertProvider{ DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}, }, { Name: "provider-with-group-override", Provider: AlertProvider{ DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}, Overrides: []Override{ { Group: "group1", Config: Config{AuthID: "3", AuthToken: "4", From: "3333333333", To: []string{"7777777777"}}, }, }, }, InputGroup: "group1", InputAlert: alert.Alert{}, ExpectedOutput: Config{AuthID: "3", AuthToken: "4", From: "3333333333", To: []string{"7777777777"}}, }, { Name: "provider-with-group-override-no-match", Provider: AlertProvider{ DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}, Overrides: []Override{ { Group: "group1", Config: Config{AuthID: "3", AuthToken: "4", From: "3333333333", To: []string{"7777777777"}}, }, }, }, InputGroup: "group2", InputAlert: alert.Alert{}, ExpectedOutput: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}, }, { Name: "provider-with-alert-override", Provider: AlertProvider{ DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}, }, InputGroup: "", InputAlert: alert.Alert{ProviderOverride: map[string]any{"auth-id": "5", "auth-token": "6", "from": "5555555555", "to": []string{"9999999999"}}}, ExpectedOutput: Config{AuthID: "5", AuthToken: "6", From: "5555555555", To: []string{"9999999999"}}, }, { Name: "provider-with-group-and-alert-override", Provider: AlertProvider{ DefaultConfig: Config{AuthID: "1", AuthToken: "2", From: "1234567890", To: []string{"0987654321"}}, Overrides: []Override{ { Group: "group1", Config: Config{AuthID: "3", AuthToken: "4", From: "3333333333", To: []string{"7777777777"}}, }, }, }, InputGroup: "group1", InputAlert: alert.Alert{ProviderOverride: map[string]any{"auth-id": "5", "auth-token": "6"}}, ExpectedOutput: Config{AuthID: "5", AuthToken: "6", From: "3333333333", To: []string{"7777777777"}}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Error("expected no error, got:", err.Error()) } if got.AuthID != scenario.ExpectedOutput.AuthID { t.Errorf("expected AuthID to be %s, got %s", scenario.ExpectedOutput.AuthID, got.AuthID) } if got.AuthToken != scenario.ExpectedOutput.AuthToken { t.Errorf("expected AuthToken to be %s, got %s", scenario.ExpectedOutput.AuthToken, got.AuthToken) } if got.From != scenario.ExpectedOutput.From { t.Errorf("expected From to be %s, got %s", scenario.ExpectedOutput.From, got.From) } if len(got.To) != len(scenario.ExpectedOutput.To) { t.Errorf("expected To length to be %d, got %d", len(scenario.ExpectedOutput.To), len(got.To)) } for i, to := range got.To { if to != scenario.ExpectedOutput.To[i] { t.Errorf("expected To[%d] to be %s, got %s", i, scenario.ExpectedOutput.To[i], to) } } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } func TestConfig_Validate(t *testing.T) { scenarios := []struct { Name string Config Config ExpectedError error }{ { Name: "valid-config", Config: Config{ AuthID: "test-auth-id", AuthToken: "test-auth-token", From: "1234567890", To: []string{"0987654321"}, }, ExpectedError: nil, }, { Name: "missing-auth-id", Config: Config{ AuthToken: "test-auth-token", From: "1234567890", To: []string{"0987654321"}, }, ExpectedError: ErrAuthIDNotSet, }, { Name: "missing-auth-token", Config: Config{ AuthID: "test-auth-id", From: "1234567890", To: []string{"0987654321"}, }, ExpectedError: ErrAuthTokenNotSet, }, { Name: "missing-from", Config: Config{ AuthID: "test-auth-id", AuthToken: "test-auth-token", To: []string{"0987654321"}, }, ExpectedError: ErrFromNotSet, }, { Name: "missing-to", Config: Config{ AuthID: "test-auth-id", AuthToken: "test-auth-token", From: "1234567890", }, ExpectedError: ErrToNotSet, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { err := scenario.Config.Validate() if scenario.ExpectedError == nil && err != nil { t.Errorf("expected no error, got %v", err) } if scenario.ExpectedError != nil && err == nil { t.Errorf("expected error %v, got none", scenario.ExpectedError) } if scenario.ExpectedError != nil && err != nil && err.Error() != scenario.ExpectedError.Error() { t.Errorf("expected error %v, got %v", scenario.ExpectedError, err) } }) } } func TestConfig_Merge(t *testing.T) { cfg := Config{ AuthID: "original-auth-id", AuthToken: "original-auth-token", From: "1111111111", To: []string{"2222222222"}, } override := Config{ AuthID: "override-auth-id", AuthToken: "override-auth-token", From: "3333333333", To: []string{"4444444444", "5555555555"}, } cfg.Merge(&override) if cfg.AuthID != "override-auth-id" { t.Errorf("expected AuthID to be %s, got %s", "override-auth-id", cfg.AuthID) } if cfg.AuthToken != "override-auth-token" { t.Errorf("expected AuthToken to be %s, got %s", "override-auth-token", cfg.AuthToken) } if cfg.From != "3333333333" { t.Errorf("expected From to be %s, got %s", "3333333333", cfg.From) } if len(cfg.To) != 2 || cfg.To[0] != "4444444444" || cfg.To[1] != "5555555555" { t.Errorf("expected To to be [4444444444, 5555555555], got %v", cfg.To) } } ================================================ FILE: alerting/provider/provider.go ================================================ package provider import ( "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/alerting/provider/awsses" "github.com/TwiN/gatus/v5/alerting/provider/clickup" "github.com/TwiN/gatus/v5/alerting/provider/custom" "github.com/TwiN/gatus/v5/alerting/provider/datadog" "github.com/TwiN/gatus/v5/alerting/provider/discord" "github.com/TwiN/gatus/v5/alerting/provider/email" "github.com/TwiN/gatus/v5/alerting/provider/gitea" "github.com/TwiN/gatus/v5/alerting/provider/github" "github.com/TwiN/gatus/v5/alerting/provider/gitlab" "github.com/TwiN/gatus/v5/alerting/provider/googlechat" "github.com/TwiN/gatus/v5/alerting/provider/gotify" "github.com/TwiN/gatus/v5/alerting/provider/homeassistant" "github.com/TwiN/gatus/v5/alerting/provider/ifttt" "github.com/TwiN/gatus/v5/alerting/provider/ilert" "github.com/TwiN/gatus/v5/alerting/provider/incidentio" "github.com/TwiN/gatus/v5/alerting/provider/line" "github.com/TwiN/gatus/v5/alerting/provider/matrix" "github.com/TwiN/gatus/v5/alerting/provider/mattermost" "github.com/TwiN/gatus/v5/alerting/provider/messagebird" "github.com/TwiN/gatus/v5/alerting/provider/n8n" "github.com/TwiN/gatus/v5/alerting/provider/newrelic" "github.com/TwiN/gatus/v5/alerting/provider/ntfy" "github.com/TwiN/gatus/v5/alerting/provider/opsgenie" "github.com/TwiN/gatus/v5/alerting/provider/pagerduty" "github.com/TwiN/gatus/v5/alerting/provider/plivo" "github.com/TwiN/gatus/v5/alerting/provider/pushover" "github.com/TwiN/gatus/v5/alerting/provider/rocketchat" "github.com/TwiN/gatus/v5/alerting/provider/sendgrid" "github.com/TwiN/gatus/v5/alerting/provider/signal" "github.com/TwiN/gatus/v5/alerting/provider/signl4" "github.com/TwiN/gatus/v5/alerting/provider/slack" "github.com/TwiN/gatus/v5/alerting/provider/splunk" "github.com/TwiN/gatus/v5/alerting/provider/squadcast" "github.com/TwiN/gatus/v5/alerting/provider/teams" "github.com/TwiN/gatus/v5/alerting/provider/teamsworkflows" "github.com/TwiN/gatus/v5/alerting/provider/telegram" "github.com/TwiN/gatus/v5/alerting/provider/twilio" "github.com/TwiN/gatus/v5/alerting/provider/webex" "github.com/TwiN/gatus/v5/alerting/provider/zapier" "github.com/TwiN/gatus/v5/alerting/provider/zulip" "github.com/TwiN/gatus/v5/config/endpoint" ) // AlertProvider is the interface that each provider should implement type AlertProvider interface { // Validate the provider's configuration Validate() error // Send an alert using the provider Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error // GetDefaultAlert returns the provider's default alert configuration GetDefaultAlert() *alert.Alert // ValidateOverrides validates the alert's provider override and, if present, the group override ValidateOverrides(group string, alert *alert.Alert) error } type Config[T any] interface { Validate() error Merge(override *T) } // MergeProviderDefaultAlertIntoEndpointAlert parses an Endpoint alert by using the provider's default alert as a baseline func MergeProviderDefaultAlertIntoEndpointAlert(providerDefaultAlert, endpointAlert *alert.Alert) { if providerDefaultAlert == nil || endpointAlert == nil { return } if endpointAlert.Enabled == nil { endpointAlert.Enabled = providerDefaultAlert.Enabled } if endpointAlert.SendOnResolved == nil { endpointAlert.SendOnResolved = providerDefaultAlert.SendOnResolved } if endpointAlert.Description == nil { endpointAlert.Description = providerDefaultAlert.Description } if endpointAlert.FailureThreshold == 0 { endpointAlert.FailureThreshold = providerDefaultAlert.FailureThreshold } if endpointAlert.SuccessThreshold == 0 { endpointAlert.SuccessThreshold = providerDefaultAlert.SuccessThreshold } if endpointAlert.MinimumReminderInterval == 0 { endpointAlert.MinimumReminderInterval = providerDefaultAlert.MinimumReminderInterval } } var ( // Validate provider interface implementation on compile _ AlertProvider = (*awsses.AlertProvider)(nil) _ AlertProvider = (*clickup.AlertProvider)(nil) _ AlertProvider = (*custom.AlertProvider)(nil) _ AlertProvider = (*datadog.AlertProvider)(nil) _ AlertProvider = (*discord.AlertProvider)(nil) _ AlertProvider = (*email.AlertProvider)(nil) _ AlertProvider = (*gitea.AlertProvider)(nil) _ AlertProvider = (*github.AlertProvider)(nil) _ AlertProvider = (*gitlab.AlertProvider)(nil) _ AlertProvider = (*googlechat.AlertProvider)(nil) _ AlertProvider = (*gotify.AlertProvider)(nil) _ AlertProvider = (*homeassistant.AlertProvider)(nil) _ AlertProvider = (*ifttt.AlertProvider)(nil) _ AlertProvider = (*ilert.AlertProvider)(nil) _ AlertProvider = (*incidentio.AlertProvider)(nil) _ AlertProvider = (*line.AlertProvider)(nil) _ AlertProvider = (*matrix.AlertProvider)(nil) _ AlertProvider = (*mattermost.AlertProvider)(nil) _ AlertProvider = (*messagebird.AlertProvider)(nil) _ AlertProvider = (*n8n.AlertProvider)(nil) _ AlertProvider = (*newrelic.AlertProvider)(nil) _ AlertProvider = (*ntfy.AlertProvider)(nil) _ AlertProvider = (*opsgenie.AlertProvider)(nil) _ AlertProvider = (*pagerduty.AlertProvider)(nil) _ AlertProvider = (*plivo.AlertProvider)(nil) _ AlertProvider = (*pushover.AlertProvider)(nil) _ AlertProvider = (*rocketchat.AlertProvider)(nil) _ AlertProvider = (*sendgrid.AlertProvider)(nil) _ AlertProvider = (*signal.AlertProvider)(nil) _ AlertProvider = (*signl4.AlertProvider)(nil) _ AlertProvider = (*slack.AlertProvider)(nil) _ AlertProvider = (*splunk.AlertProvider)(nil) _ AlertProvider = (*squadcast.AlertProvider)(nil) _ AlertProvider = (*teams.AlertProvider)(nil) _ AlertProvider = (*teamsworkflows.AlertProvider)(nil) _ AlertProvider = (*telegram.AlertProvider)(nil) _ AlertProvider = (*twilio.AlertProvider)(nil) _ AlertProvider = (*webex.AlertProvider)(nil) _ AlertProvider = (*zapier.AlertProvider)(nil) _ AlertProvider = (*zulip.AlertProvider)(nil) // Validate config interface implementation on compile _ Config[awsses.Config] = (*awsses.Config)(nil) _ Config[clickup.Config] = (*clickup.Config)(nil) _ Config[custom.Config] = (*custom.Config)(nil) _ Config[datadog.Config] = (*datadog.Config)(nil) _ Config[discord.Config] = (*discord.Config)(nil) _ Config[email.Config] = (*email.Config)(nil) _ Config[gitea.Config] = (*gitea.Config)(nil) _ Config[github.Config] = (*github.Config)(nil) _ Config[gitlab.Config] = (*gitlab.Config)(nil) _ Config[googlechat.Config] = (*googlechat.Config)(nil) _ Config[gotify.Config] = (*gotify.Config)(nil) _ Config[homeassistant.Config] = (*homeassistant.Config)(nil) _ Config[ifttt.Config] = (*ifttt.Config)(nil) _ Config[ilert.Config] = (*ilert.Config)(nil) _ Config[incidentio.Config] = (*incidentio.Config)(nil) _ Config[line.Config] = (*line.Config)(nil) _ Config[matrix.Config] = (*matrix.Config)(nil) _ Config[mattermost.Config] = (*mattermost.Config)(nil) _ Config[messagebird.Config] = (*messagebird.Config)(nil) _ Config[n8n.Config] = (*n8n.Config)(nil) _ Config[newrelic.Config] = (*newrelic.Config)(nil) _ Config[ntfy.Config] = (*ntfy.Config)(nil) _ Config[opsgenie.Config] = (*opsgenie.Config)(nil) _ Config[pagerduty.Config] = (*pagerduty.Config)(nil) _ Config[plivo.Config] = (*plivo.Config)(nil) _ Config[pushover.Config] = (*pushover.Config)(nil) _ Config[rocketchat.Config] = (*rocketchat.Config)(nil) _ Config[sendgrid.Config] = (*sendgrid.Config)(nil) _ Config[signal.Config] = (*signal.Config)(nil) _ Config[signl4.Config] = (*signl4.Config)(nil) _ Config[slack.Config] = (*slack.Config)(nil) _ Config[splunk.Config] = (*splunk.Config)(nil) _ Config[squadcast.Config] = (*squadcast.Config)(nil) _ Config[teams.Config] = (*teams.Config)(nil) _ Config[teamsworkflows.Config] = (*teamsworkflows.Config)(nil) _ Config[telegram.Config] = (*telegram.Config)(nil) _ Config[twilio.Config] = (*twilio.Config)(nil) _ Config[webex.Config] = (*webex.Config)(nil) _ Config[zapier.Config] = (*zapier.Config)(nil) _ Config[zulip.Config] = (*zulip.Config)(nil) ) ================================================ FILE: alerting/provider/provider_test.go ================================================ package provider import ( "testing" "time" "github.com/TwiN/gatus/v5/alerting/alert" ) func TestParseWithDefaultAlert(t *testing.T) { type Scenario struct { Name string DefaultAlert, EndpointAlert, ExpectedOutputAlert *alert.Alert } enabled := true disabled := false firstDescription := "description-1" secondDescription := "description-2" scenarios := []Scenario{ { Name: "endpoint-alert-type-only", DefaultAlert: &alert.Alert{ Enabled: &enabled, SendOnResolved: &enabled, Description: &firstDescription, FailureThreshold: 5, SuccessThreshold: 10, MinimumReminderInterval: 30 * time.Second, }, EndpointAlert: &alert.Alert{ Type: alert.TypeDiscord, }, ExpectedOutputAlert: &alert.Alert{ Type: alert.TypeDiscord, Enabled: &enabled, SendOnResolved: &enabled, Description: &firstDescription, FailureThreshold: 5, SuccessThreshold: 10, MinimumReminderInterval: 30 * time.Second, }, }, { Name: "endpoint-alert-overwrites-default-alert", DefaultAlert: &alert.Alert{ Enabled: &disabled, SendOnResolved: &disabled, Description: &firstDescription, FailureThreshold: 5, SuccessThreshold: 10, }, EndpointAlert: &alert.Alert{ Type: alert.TypeTelegram, Enabled: &enabled, SendOnResolved: &enabled, Description: &secondDescription, FailureThreshold: 6, SuccessThreshold: 11, }, ExpectedOutputAlert: &alert.Alert{ Type: alert.TypeTelegram, Enabled: &enabled, SendOnResolved: &enabled, Description: &secondDescription, FailureThreshold: 6, SuccessThreshold: 11, }, }, { Name: "endpoint-alert-partially-overwrites-default-alert", DefaultAlert: &alert.Alert{ Enabled: &enabled, SendOnResolved: &enabled, Description: &firstDescription, FailureThreshold: 5, SuccessThreshold: 10, }, EndpointAlert: &alert.Alert{ Type: alert.TypeDiscord, Enabled: nil, SendOnResolved: nil, FailureThreshold: 6, SuccessThreshold: 11, }, ExpectedOutputAlert: &alert.Alert{ Type: alert.TypeDiscord, Enabled: &enabled, SendOnResolved: &enabled, Description: &firstDescription, FailureThreshold: 6, SuccessThreshold: 11, }, }, { Name: "default-alert-type-should-be-ignored", DefaultAlert: &alert.Alert{ Type: alert.TypeTelegram, Enabled: &enabled, SendOnResolved: &enabled, Description: &firstDescription, FailureThreshold: 5, SuccessThreshold: 10, }, EndpointAlert: &alert.Alert{ Type: alert.TypeDiscord, }, ExpectedOutputAlert: &alert.Alert{ Type: alert.TypeDiscord, Enabled: &enabled, SendOnResolved: &enabled, Description: &firstDescription, FailureThreshold: 5, SuccessThreshold: 10, }, }, { Name: "no-default-alert", DefaultAlert: &alert.Alert{ Type: alert.TypeDiscord, Enabled: nil, SendOnResolved: nil, Description: &firstDescription, FailureThreshold: 2, SuccessThreshold: 5, }, EndpointAlert: nil, ExpectedOutputAlert: nil, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { MergeProviderDefaultAlertIntoEndpointAlert(scenario.DefaultAlert, scenario.EndpointAlert) if scenario.ExpectedOutputAlert == nil { if scenario.EndpointAlert != nil { t.Fail() } return } if scenario.EndpointAlert.IsEnabled() != scenario.ExpectedOutputAlert.IsEnabled() { t.Errorf("expected EndpointAlert.IsEnabled() to be %v, got %v", scenario.ExpectedOutputAlert.IsEnabled(), scenario.EndpointAlert.IsEnabled()) } if scenario.EndpointAlert.IsSendingOnResolved() != scenario.ExpectedOutputAlert.IsSendingOnResolved() { t.Errorf("expected EndpointAlert.IsSendingOnResolved() to be %v, got %v", scenario.ExpectedOutputAlert.IsSendingOnResolved(), scenario.EndpointAlert.IsSendingOnResolved()) } if scenario.EndpointAlert.GetDescription() != scenario.ExpectedOutputAlert.GetDescription() { t.Errorf("expected EndpointAlert.GetDescription() to be %v, got %v", scenario.ExpectedOutputAlert.GetDescription(), scenario.EndpointAlert.GetDescription()) } if scenario.EndpointAlert.FailureThreshold != scenario.ExpectedOutputAlert.FailureThreshold { t.Errorf("expected EndpointAlert.FailureThreshold to be %v, got %v", scenario.ExpectedOutputAlert.FailureThreshold, scenario.EndpointAlert.FailureThreshold) } if scenario.EndpointAlert.SuccessThreshold != scenario.ExpectedOutputAlert.SuccessThreshold { t.Errorf("expected EndpointAlert.SuccessThreshold to be %v, got %v", scenario.ExpectedOutputAlert.SuccessThreshold, scenario.EndpointAlert.SuccessThreshold) } if int(scenario.EndpointAlert.MinimumReminderInterval) != int(scenario.ExpectedOutputAlert.MinimumReminderInterval) { t.Errorf("expected EndpointAlert.MinimumReminderInterval to be %v, got %v", scenario.ExpectedOutputAlert.MinimumReminderInterval, scenario.EndpointAlert.MinimumReminderInterval) } }) } } ================================================ FILE: alerting/provider/pushover/pushover.go ================================================ package pushover import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) const ( ApiURL = "https://api.pushover.net/1/messages.json" defaultPriority = 0 ) var ( ErrInvalidApplicationToken = errors.New("application-token must be 30 characters long") ErrInvalidUserKey = errors.New("user-key must be 30 characters long") ErrInvalidPriority = errors.New("priority and resolved-priority must be between -2 and 2") ErrInvalidDevice = errors.New("device name must have 25 characters or less") ) type Config struct { // Key used to authenticate the application sending // See "Your Applications" on the dashboard, or add a new one: https://pushover.net/apps/build ApplicationToken string `yaml:"application-token"` // Key of the user or group the messages should be sent to UserKey string `yaml:"user-key"` // The title of your message // default: "Gatus:"), }, }, } } // buildMessageSubjectAndBody builds the message subject and body func (provider *AlertProvider) buildMessageSubjectAndBody(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) (string, string) { var subject, message string if resolved { subject = fmt.Sprintf("[%s] Alert resolved", ep.DisplayName()) message = fmt.Sprintf("An alert for %s has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) } else { subject = fmt.Sprintf("[%s] Alert triggered", ep.DisplayName()) message = fmt.Sprintf("An alert for %s has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) } var formattedConditionResults string if len(result.ConditionResults) > 0 { formattedConditionResults = "\n\nCondition results:\n" for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = "✅" } else { prefix = "❌" } formattedConditionResults += fmt.Sprintf("%s %s\n", prefix, conditionResult.Condition) } } var description string if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { description = "\n\nAlert description: " + alertDescription } var extraLabels string if len(ep.ExtraLabels) > 0 { extraLabels = "\n\nExtra labels:\n" for key, value := range ep.ExtraLabels { extraLabels += fmt.Sprintf(" %s: %s\n", key, value) } } return subject, message + description + extraLabels + formattedConditionResults } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/sendgrid/sendgrid_test.go ================================================ package sendgrid import ( "io" "net/http" "strings" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{APIKey: "", From: "", To: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{DefaultConfig: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ DefaultConfig: Config{ APIKey: "SG.test", From: "from@example.com", To: "to@example.com", }, Overrides: []Override{ { Config: Config{To: "to@example.com"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider with empty Group should not have been valid") } if err := providerWithInvalidOverrideGroup.Validate(); err != ErrDuplicateGroupOverride { t.Error("provider with empty Group should return ErrDuplicateGroupOverride") } providerWithDuplicateOverrideGroups := AlertProvider{ DefaultConfig: Config{ APIKey: "SG.test", From: "from@example.com", To: "to@example.com", }, Overrides: []Override{ { Config: Config{To: "to1@example.com"}, Group: "group", }, { Config: Config{To: "to2@example.com"}, Group: "group", }, }, } if err := providerWithDuplicateOverrideGroups.Validate(); err == nil { t.Error("provider with duplicate group overrides should not have been valid") } if err := providerWithDuplicateOverrideGroups.Validate(); err != ErrDuplicateGroupOverride { t.Error("provider with duplicate group overrides should return ErrDuplicateGroupOverride") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{ APIKey: "SG.test", From: "from@example.com", To: "to@example.com", }, Overrides: []Override{ { Config: Config{To: "to@example.com"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { t.Error("provider should've been valid") } providerWithValidMultipleOverrides := AlertProvider{ DefaultConfig: Config{ APIKey: "SG.test", From: "from@example.com", To: "to@example.com", }, Overrides: []Override{ { Config: Config{To: "group1@example.com"}, Group: "group1", }, { Config: Config{To: "group2@example.com"}, Group: "group2", }, }, } if err := providerWithValidMultipleOverrides.Validate(); err != nil { t.Error("provider with multiple valid overrides 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{DefaultConfig: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}}, 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.StatusAccepted, Body: http.NoBody} }), ExpectedError: false, }, { Name: "triggered-error", Provider: AlertProvider{DefaultConfig: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}}, 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.StatusBadRequest, Body: io.NopCloser(strings.NewReader(`{"errors": [{"message": "Invalid API key"}]}`))} }), ExpectedError: true, }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}}, 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.StatusAccepted, Body: http.NoBody} }), ExpectedError: false, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper}) err := scenario.Provider.Send( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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_buildSendGridPayload(t *testing.T) { provider := &AlertProvider{} cfg := &Config{ From: "test@example.com", To: "to1@example.com,to2@example.com", } subject := "Test Subject" body := "Test Body\nWith new line" payload := provider.buildSendGridPayload(cfg, subject, body) if payload.Subject != subject { t.Errorf("expected subject to be %s, got %s", subject, payload.Subject) } if payload.From.Email != cfg.From { t.Errorf("expected from email to be %s, got %s", cfg.From, payload.From.Email) } if len(payload.Personalizations) != 1 { t.Errorf("expected 1 personalization, got %d", len(payload.Personalizations)) } if len(payload.Personalizations[0].To) != 2 { t.Errorf("expected 2 recipients, got %d", len(payload.Personalizations[0].To)) } if payload.Personalizations[0].To[0].Email != "to1@example.com" { t.Errorf("expected first recipient to be to1@example.com, got %s", payload.Personalizations[0].To[0].Email) } if payload.Personalizations[0].To[1].Email != "to2@example.com" { t.Errorf("expected second recipient to be to2@example.com, got %s", payload.Personalizations[0].To[1].Email) } if len(payload.Content) != 2 { t.Errorf("expected 2 content types, got %d", len(payload.Content)) } if payload.Content[0].Type != "text/plain" { t.Errorf("expected first content type to be text/plain, got %s", payload.Content[0].Type) } if payload.Content[0].Value != body { t.Errorf("expected plain text content to be %s, got %s", body, payload.Content[0].Value) } if payload.Content[1].Type != "text/html" { t.Errorf("expected second content type to be text/html, got %s", payload.Content[1].Type) } expectedHTML := "Test Body
With new line" if payload.Content[1].Value != expectedHTML { t.Errorf("expected HTML content to be %s, got %s", expectedHTML, payload.Content[1].Value) } } func TestAlertProvider_buildMessageSubjectAndBody(t *testing.T) { firstDescription := "description-1" secondDescription := "description-2" scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert Resolved bool Endpoint *endpoint.Endpoint ExpectedSubject string ExpectedBody string }{ { Name: "triggered", Provider: AlertProvider{}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, Endpoint: &endpoint.Endpoint{Name: "endpoint-name"}, ExpectedSubject: "[endpoint-name] Alert triggered", ExpectedBody: "An alert for endpoint-name has been triggered due to having failed 3 time(s) in a row\n\nAlert description: description-1\n\nCondition results:\n❌ [CONNECTED] == true\n❌ [STATUS] == 200\n", }, { Name: "resolved", Provider: AlertProvider{}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, Endpoint: &endpoint.Endpoint{Name: "endpoint-name"}, ExpectedSubject: "[endpoint-name] Alert resolved", ExpectedBody: "An alert for endpoint-name has been resolved after passing successfully 5 time(s) in a row\n\nAlert description: description-2\n\nCondition results:\n✅ [CONNECTED] == true\n✅ [STATUS] == 200\n", }, { Name: "triggered-with-single-extra-label", Provider: AlertProvider{}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, Endpoint: &endpoint.Endpoint{Name: "endpoint-name", ExtraLabels: map[string]string{"environment": "production"}}, ExpectedSubject: "[endpoint-name] Alert triggered", ExpectedBody: "An alert for endpoint-name has been triggered due to having failed 3 time(s) in a row\n\nAlert description: description-1\n\nExtra labels:\n environment: production\n\n\nCondition results:\n❌ [CONNECTED] == true\n❌ [STATUS] == 200\n", }, { Name: "resolved-with-single-extra-label", Provider: AlertProvider{}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, Endpoint: &endpoint.Endpoint{Name: "endpoint-name", ExtraLabels: map[string]string{"service": "api"}}, ExpectedSubject: "[endpoint-name] Alert resolved", ExpectedBody: "An alert for endpoint-name has been resolved after passing successfully 5 time(s) in a row\n\nAlert description: description-2\n\nExtra labels:\n service: api\n\n\nCondition results:\n✅ [CONNECTED] == true\n✅ [STATUS] == 200\n", }, { Name: "triggered-with-no-extra-labels", Provider: AlertProvider{}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, Endpoint: &endpoint.Endpoint{Name: "endpoint-name", ExtraLabels: map[string]string{}}, ExpectedSubject: "[endpoint-name] Alert triggered", ExpectedBody: "An alert for endpoint-name has been triggered due to having failed 3 time(s) in a row\n\nAlert description: description-1\n\nCondition results:\n❌ [CONNECTED] == true\n❌ [STATUS] == 200\n", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { subject, body := scenario.Provider.buildMessageSubjectAndBody( scenario.Endpoint, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) if subject != scenario.ExpectedSubject { t.Errorf("expected subject to be %s, got %s", scenario.ExpectedSubject, subject) } if body != scenario.ExpectedBody { t.Errorf("expected body to be %s, got %s", scenario.ExpectedBody, body) } }) } } 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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}, Overrides: []Override{ { Group: "group", Config: Config{To: "to01@example.com"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}, Overrides: []Override{ { Group: "group", Config: Config{To: "group-to@example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{APIKey: "SG.test", From: "from@example.com", To: "group-to@example.com"}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com"}, Overrides: []Override{ { Group: "group", Config: Config{To: "group-to@example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"api-key": "SG.override", "to": "alert-to@example.com", "from": "alert-from@example.com"}}, ExpectedOutput: Config{APIKey: "SG.override", From: "alert-from@example.com", To: "alert-to@example.com"}, }, { Name: "provider-with-multiple-overrides-pick-correct-group", Provider: AlertProvider{ DefaultConfig: Config{APIKey: "SG.default", From: "default@example.com", To: "default@example.com"}, Overrides: []Override{ { Group: "group1", Config: Config{APIKey: "SG.group1", To: "group1@example.com"}, }, { Group: "group2", Config: Config{APIKey: "SG.group2", From: "group2@example.com"}, }, }, }, InputGroup: "group2", InputAlert: alert.Alert{}, ExpectedOutput: Config{APIKey: "SG.group2", From: "group2@example.com", To: "default@example.com"}, }, { Name: "provider-partial-override-hierarchy", Provider: AlertProvider{ DefaultConfig: Config{APIKey: "SG.default", From: "default@example.com", To: "default@example.com"}, Overrides: []Override{ { Group: "test-group", Config: Config{From: "group@example.com"}, }, }, }, InputGroup: "test-group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"to": "alert@example.com"}}, ExpectedOutput: Config{APIKey: "SG.default", From: "group@example.com", To: "alert@example.com"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.APIKey != scenario.ExpectedOutput.APIKey { t.Errorf("expected APIKey to be %s, got %s", scenario.ExpectedOutput.APIKey, got.APIKey) } if got.From != scenario.ExpectedOutput.From { t.Errorf("expected From to be %s, got %s", scenario.ExpectedOutput.From, got.From) } if got.To != scenario.ExpectedOutput.To { t.Errorf("expected To to be %s, got %s", scenario.ExpectedOutput.To, got.To) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } func TestConfig_Validate(t *testing.T) { scenarios := []struct { Name string Config Config ExpectedError error }{ { Name: "missing-api-key", Config: Config{APIKey: "", From: "test@example.com", To: "to@example.com"}, ExpectedError: ErrAPIKeyNotSet, }, { Name: "missing-from", Config: Config{APIKey: "SG.test", From: "", To: "to@example.com"}, ExpectedError: ErrFromNotSet, }, { Name: "missing-to", Config: Config{APIKey: "SG.test", From: "test@example.com", To: ""}, ExpectedError: ErrToNotSet, }, { Name: "valid-config", Config: Config{APIKey: "SG.test", From: "test@example.com", To: "to@example.com"}, ExpectedError: nil, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { err := scenario.Config.Validate() if scenario.ExpectedError == nil && err != nil { t.Errorf("expected no error, got %v", err) } if scenario.ExpectedError != nil && err == nil { t.Errorf("expected error %v, got none", scenario.ExpectedError) } if scenario.ExpectedError != nil && err != nil && err.Error() != scenario.ExpectedError.Error() { t.Errorf("expected error %v, got %v", scenario.ExpectedError, err) } }) } } func TestConfig_Merge(t *testing.T) { config := Config{APIKey: "SG.original", From: "from@example.com", To: "to@example.com"} override := Config{APIKey: "SG.override", To: "override@example.com"} config.Merge(&override) if config.APIKey != "SG.override" { t.Errorf("expected APIKey to be SG.override, got %s", config.APIKey) } if config.From != "from@example.com" { t.Errorf("expected From to remain from@example.com, got %s", config.From) } if config.To != "override@example.com" { t.Errorf("expected To to be override@example.com, got %s", config.To) } } func TestConfig_MergeWithClientConfig(t *testing.T) { config := Config{APIKey: "SG.original", From: "from@example.com", To: "to@example.com"} override := Config{APIKey: "SG.override", ClientConfig: &client.Config{Timeout: 30000}} config.Merge(&override) if config.APIKey != "SG.override" { t.Errorf("expected APIKey to be SG.override, got %s", config.APIKey) } if config.ClientConfig == nil { t.Error("expected ClientConfig to be set") } if config.ClientConfig.Timeout != 30000 { t.Errorf("expected ClientConfig.Timeout to be 30000, got %d", config.ClientConfig.Timeout) } config2 := Config{APIKey: "SG.test", From: "from@example.com", To: "to@example.com", ClientConfig: &client.Config{Timeout: 10000}} override2 := Config{APIKey: "SG.override2"} config2.Merge(&override2) if config2.ClientConfig.Timeout != 10000 { t.Errorf("expected ClientConfig.Timeout to remain 10000, got %d", config2.ClientConfig.Timeout) } } ================================================ FILE: alerting/provider/signal/signal.go ================================================ package signal import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "strings" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrApiURLNotSet = errors.New("api-url not set") ErrNumberNotSet = errors.New("number not set") ErrRecipientsNotSet = errors.New("recipients not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { ApiURL string `yaml:"api-url"` // Signal API URL (e.g., signal-cli-rest-api instance) Number string `yaml:"number"` // Sender phone number Recipients []string `yaml:"recipients"` // List of recipient phone numbers } func (cfg *Config) Validate() error { if len(cfg.ApiURL) == 0 { return ErrApiURLNotSet } if !strings.HasSuffix(cfg.ApiURL, "/v2/send") { cfg.ApiURL = cfg.ApiURL + "/v2/send" } if len(cfg.Number) == 0 { return ErrNumberNotSet } if len(cfg.Recipients) == 0 { return ErrRecipientsNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.ApiURL) > 0 { cfg.ApiURL = override.ApiURL } if len(override.Number) > 0 { cfg.Number = override.Number } if len(override.Recipients) > 0 { cfg.Recipients = override.Recipients } } // AlertProvider is the configuration necessary for sending an alert using Signal type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } for _, recipient := range cfg.Recipients { body, err := provider.buildRequestBody(cfg, ep, alert, result, resolved, recipient) if err != nil { return err } buffer := bytes.NewBuffer(body) request, err := http.NewRequest(http.MethodPost, cfg.ApiURL, 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 >= 400 { body, _ := io.ReadAll(response.Body) response.Body.Close() return fmt.Errorf("call to signal alert returned status code %d: %s", response.StatusCode, string(body)) } response.Body.Close() } return nil } type Body struct { Message string `json:"message"` Number string `json:"number"` Recipients []string `json:"recipients"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool, recipient string) ([]byte, error) { var message string if resolved { message = fmt.Sprintf("🟢 RESOLVED: %s\nAlert has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) } else { message = fmt.Sprintf("🔴 ALERT: %s\nEndpoint has failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) } if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { message += fmt.Sprintf("\n\nDescription: %s", alertDescription) } if len(result.ConditionResults) > 0 { message += "\n\nCondition results:" for _, conditionResult := range result.ConditionResults { var status string if conditionResult.Success { status = "✅" } else { status = "❌" } message += fmt.Sprintf("\n%s %s", status, conditionResult.Condition) } } body := Body{ Message: message, Number: cfg.Number, Recipients: []string{recipient}, } bodyAsJSON, err := json.Marshal(body) if err != nil { return nil, err } return bodyAsJSON, nil } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/signal/signal_test.go ================================================ package signal import ( "encoding/json" "net/http" "strings" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected error }{ { name: "valid", provider: AlertProvider{DefaultConfig: Config{ApiURL: "http://localhost:8080", Number: "+1234567890", Recipients: []string{"+0987654321"}}}, expected: nil, }, { name: "invalid-api-url", provider: AlertProvider{DefaultConfig: Config{Number: "+1234567890", Recipients: []string{"+0987654321"}}}, expected: ErrApiURLNotSet, }, { name: "invalid-number", provider: AlertProvider{DefaultConfig: Config{ApiURL: "http://localhost:8080", Recipients: []string{"+0987654321"}}}, expected: ErrNumberNotSet, }, { name: "invalid-recipients", provider: AlertProvider{DefaultConfig: Config{ApiURL: "http://localhost:8080", Number: "+1234567890"}}, expected: ErrRecipientsNotSet, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { err := scenario.provider.Validate() if err != scenario.expected { t.Errorf("expected %v, got %v", scenario.expected, err) } }) } } 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{DefaultConfig: Config{ApiURL: "http://localhost:8080", Number: "+1234567890", Recipients: []string{"+0987654321", "+1111111111"}}}, alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: false, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { if r.URL.Path != "/v2/send" { t.Errorf("expected path /v2/send, got %s", r.URL.Path) } body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) if body["number"] != "+1234567890" { t.Errorf("expected number to be '+1234567890', got %v", body["number"]) } recipients := body["recipients"].([]interface{}) if len(recipients) != 1 { t.Errorf("expected 1 recipient per request, got %d", len(recipients)) } message := body["message"].(string) if !strings.Contains(message, "ALERT") { t.Errorf("expected message to contain 'ALERT', got %s", message) } if !strings.Contains(message, "failed 3 time(s)") { t.Errorf("expected message to contain failure count, got %s", message) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "resolved", provider: AlertProvider{DefaultConfig: Config{ApiURL: "http://localhost:8080", Number: "+1234567890", Recipients: []string{"+0987654321"}}}, alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: true, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) message := body["message"].(string) if !strings.Contains(message, "RESOLVED") { t.Errorf("expected message to contain 'RESOLVED', got %s", message) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "error-response", provider: AlertProvider{DefaultConfig: Config{ApiURL: "http://localhost:8080", Number: "+1234567890", Recipients: []string{"+0987654321"}}}, 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, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { client.InjectHTTPClient(&http.Client{Transport: scenario.mockRoundTripper}) err := scenario.provider.Send( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.alert, &endpoint.Result{ ConditionResults: []*endpoint.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_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") } } ================================================ FILE: alerting/provider/signl4/signl4.go ================================================ package signl4 import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrTeamSecretNotSet = errors.New("team-secret not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { TeamSecret string `yaml:"team-secret"` // SIGNL4 team secret } func (cfg *Config) Validate() error { if len(cfg.TeamSecret) == 0 { return ErrTeamSecretNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.TeamSecret) > 0 { cfg.TeamSecret = override.TeamSecret } } // AlertProvider is the configuration necessary for sending an alert using SIGNL4 type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } body, err := provider.buildRequestBody(ep, alert, result, resolved) if err != nil { return err } buffer := bytes.NewBuffer(body) webhookURL := fmt.Sprintf("https://connect.signl4.com/webhook/%s", cfg.TeamSecret) request, err := http.NewRequest(http.MethodPost, webhookURL, 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 } defer response.Body.Close() if response.StatusCode >= 400 { body, _ := io.ReadAll(response.Body) return fmt.Errorf("call to signl4 alert returned status code %d: %s", response.StatusCode, string(body)) } return nil } type Body struct { Title string `json:"Title"` Message string `json:"Message"` XS4Service string `json:"X-S4-Service"` XS4Status string `json:"X-S4-Status"` XS4ExternalID string `json:"X-S4-ExternalID"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) ([]byte, error) { var title, message, status string if resolved { title = fmt.Sprintf("RESOLVED: %s", ep.DisplayName()) message = fmt.Sprintf("An alert for %s has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) status = "resolved" } else { title = fmt.Sprintf("TRIGGERED: %s", ep.DisplayName()) message = fmt.Sprintf("An alert for %s has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) status = "new" } var conditionResults string if len(result.ConditionResults) > 0 { conditionResults = "\n\nCondition results:\n" for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = "✓" } else { prefix = "✗" } conditionResults += fmt.Sprintf("%s %s\n", prefix, conditionResult.Condition) } } if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { message += "\n\nDescription: " + alertDescription } message += conditionResults body := Body{ Title: title, Message: message, XS4Service: ep.DisplayName(), XS4Status: status, XS4ExternalID: fmt.Sprintf("gatus-%s", ep.Key()), } bodyAsJSON, err := json.Marshal(body) if err != nil { return nil, err } return bodyAsJSON, nil } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/signl4/signl4_test.go ================================================ package signl4 import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{TeamSecret: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{DefaultConfig: Config{TeamSecret: "team-secret-123"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ Overrides: []Override{ { Config: Config{TeamSecret: "team-secret-123"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithInvalidOverrideTo := AlertProvider{ Overrides: []Override{ { Config: Config{TeamSecret: ""}, Group: "group", }, }, } if err := providerWithInvalidOverrideTo.Validate(); err == nil { t.Error("provider team secret shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{TeamSecret: "team-secret-123"}, Overrides: []Override{ { Config: Config{TeamSecret: "team-secret-override"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { 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{DefaultConfig: Config{TeamSecret: "team-secret-123"}}, 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{DefaultConfig: Config{TeamSecret: "team-secret-123"}}, 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{DefaultConfig: Config{TeamSecret: "team-secret-123"}}, 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{DefaultConfig: Config{TeamSecret: "team-secret-123"}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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 Endpoint endpoint.Endpoint Alert alert.Alert NoConditions bool Resolved bool ExpectedBody string }{ { Name: "triggered", Provider: AlertProvider{}, Endpoint: endpoint.Endpoint{Name: "name"}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"Title\":\"TRIGGERED: name\",\"Message\":\"An alert for name has been triggered due to having failed 3 time(s) in a row\\n\\nDescription: description-1\\n\\nCondition results:\\n✗ [CONNECTED] == true\\n✗ [STATUS] == 200\\n\",\"X-S4-Service\":\"name\",\"X-S4-Status\":\"new\",\"X-S4-ExternalID\":\"gatus-_name\"}", }, { Name: "triggered-with-group", Provider: AlertProvider{}, Endpoint: endpoint.Endpoint{Name: "name", Group: "group"}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"Title\":\"TRIGGERED: group/name\",\"Message\":\"An alert for group/name has been triggered due to having failed 3 time(s) in a row\\n\\nDescription: description-1\\n\\nCondition results:\\n✗ [CONNECTED] == true\\n✗ [STATUS] == 200\\n\",\"X-S4-Service\":\"group/name\",\"X-S4-Status\":\"new\",\"X-S4-ExternalID\":\"gatus-group_name\"}", }, { Name: "triggered-with-no-conditions", NoConditions: true, Provider: AlertProvider{}, Endpoint: endpoint.Endpoint{Name: "name"}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"Title\":\"TRIGGERED: name\",\"Message\":\"An alert for name has been triggered due to having failed 3 time(s) in a row\\n\\nDescription: description-1\",\"X-S4-Service\":\"name\",\"X-S4-Status\":\"new\",\"X-S4-ExternalID\":\"gatus-_name\"}", }, { Name: "resolved", Provider: AlertProvider{}, Endpoint: endpoint.Endpoint{Name: "name"}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"Title\":\"RESOLVED: name\",\"Message\":\"An alert for name has been resolved after passing successfully 5 time(s) in a row\\n\\nDescription: description-2\\n\\nCondition results:\\n✓ [CONNECTED] == true\\n✓ [STATUS] == 200\\n\",\"X-S4-Service\":\"name\",\"X-S4-Status\":\"resolved\",\"X-S4-ExternalID\":\"gatus-_name\"}", }, { Name: "resolved-with-group", Provider: AlertProvider{}, Endpoint: endpoint.Endpoint{Name: "name", Group: "group"}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"Title\":\"RESOLVED: group/name\",\"Message\":\"An alert for group/name has been resolved after passing successfully 5 time(s) in a row\\n\\nDescription: description-2\\n\\nCondition results:\\n✓ [CONNECTED] == true\\n✓ [STATUS] == 200\\n\",\"X-S4-Service\":\"group/name\",\"X-S4-Status\":\"resolved\",\"X-S4-ExternalID\":\"gatus-group_name\"}", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { var conditionResults []*endpoint.ConditionResult if !scenario.NoConditions { conditionResults = []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, } } body, err := scenario.Provider.buildRequestBody( &scenario.Endpoint, &scenario.Alert, &endpoint.Result{ ConditionResults: conditionResults, }, scenario.Resolved, ) if err != nil { t.Fatalf("buildRequestBody returned an error: %v", err) } if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{TeamSecret: "team-secret-123"}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{TeamSecret: "team-secret-123"}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{TeamSecret: "team-secret-123"}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{TeamSecret: "team-secret-123"}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{TeamSecret: "team-secret-123"}, Overrides: []Override{ { Group: "group", Config: Config{TeamSecret: "team-secret-override"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{TeamSecret: "team-secret-123"}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{TeamSecret: "team-secret-123"}, Overrides: []Override{ { Group: "group", Config: Config{TeamSecret: "team-secret-override"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{TeamSecret: "team-secret-override"}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{TeamSecret: "team-secret-123"}, Overrides: []Override{ { Group: "group", Config: Config{TeamSecret: "team-secret-override"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"team-secret": "team-secret-alert"}}, ExpectedOutput: Config{TeamSecret: "team-secret-alert"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.TeamSecret != scenario.ExpectedOutput.TeamSecret { t.Errorf("expected team secret to be %s, got %s", scenario.ExpectedOutput.TeamSecret, got.TeamSecret) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } func TestAlertProvider_GetConfigWithInvalidAlertOverride(t *testing.T) { // Test case 1: Empty override should be ignored, default config should be used provider := AlertProvider{ DefaultConfig: Config{TeamSecret: "team-secret-123"}, } alertWithEmptyOverride := alert.Alert{ ProviderOverride: map[string]any{"team-secret": ""}, } cfg, err := provider.GetConfig("", &alertWithEmptyOverride) if err != nil { t.Errorf("unexpected error: %v", err) } if cfg.TeamSecret != "team-secret-123" { t.Errorf("expected team secret to remain default 'team-secret-123', got %s", cfg.TeamSecret) } // Test case 2: Invalid default config with no valid override should fail providerWithInvalidDefault := AlertProvider{ DefaultConfig: Config{TeamSecret: ""}, } alertWithEmptyOverride2 := alert.Alert{ ProviderOverride: map[string]any{"team-secret": ""}, } _, err = providerWithInvalidDefault.GetConfig("", &alertWithEmptyOverride2) if err == nil { t.Error("expected error due to invalid default config, got none") } if err != ErrTeamSecretNotSet { t.Errorf("expected ErrTeamSecretNotSet, got %v", err) } } func TestAlertProvider_ValidateWithDuplicateGroupOverride(t *testing.T) { providerWithDuplicateOverride := AlertProvider{ DefaultConfig: Config{TeamSecret: "team-secret-123"}, Overrides: []Override{ { Group: "group1", Config: Config{TeamSecret: "team-secret-override-1"}, }, { Group: "group1", Config: Config{TeamSecret: "team-secret-override-2"}, }, }, } if err := providerWithDuplicateOverride.Validate(); err == nil { t.Error("provider should not have been valid due to duplicate group override") } if err := providerWithDuplicateOverride.Validate(); err != ErrDuplicateGroupOverride { t.Errorf("expected ErrDuplicateGroupOverride, got %v", providerWithDuplicateOverride.Validate()) } } func TestAlertProvider_ValidateOverridesWithInvalidAlert(t *testing.T) { provider := AlertProvider{ DefaultConfig: Config{TeamSecret: ""}, } alertWithEmptyOverride := alert.Alert{ ProviderOverride: map[string]any{"team-secret": ""}, } err := provider.ValidateOverrides("", &alertWithEmptyOverride) if err == nil { t.Error("expected error due to invalid default config, got none") } if err != ErrTeamSecretNotSet { t.Errorf("expected ErrTeamSecretNotSet, got %v", err) } } ================================================ FILE: alerting/provider/slack/slack.go ================================================ package slack import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrWebhookURLNotSet = errors.New("webhook-url not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { WebhookURL string `yaml:"webhook-url"` // Slack webhook URL Title string `yaml:"title,omitempty"` // Title of the message that will be sent } func (cfg *Config) Validate() error { if len(cfg.WebhookURL) == 0 { return ErrWebhookURLNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.WebhookURL) > 0 { cfg.WebhookURL = override.WebhookURL } if len(override.Title) > 0 { cfg.Title = override.Title } } // AlertProvider is the configuration necessary for sending an alert using Slack type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(cfg, ep, alert, result, resolved)) request, err := http.NewRequest(http.MethodPost, cfg.WebhookURL, 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 } defer response.Body.Close() 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 } type Body struct { Text string `json:"text"` Attachments []Attachment `json:"attachments"` } type Attachment struct { Title string `json:"title"` Text string `json:"text"` Short bool `json:"short"` Color string `json:"color"` Fields []Field `json:"fields,omitempty"` } type Field struct { Title string `json:"title"` Value string `json:"value"` Short bool `json:"short"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var message, color string if resolved { message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) color = "#36A64F" } else { message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) color = "#DD0000" } var formattedConditionResults string for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = ":white_check_mark:" } else { prefix = ":x:" } formattedConditionResults += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition) } var description string if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { description = ":\n> " + alertDescription } body := Body{ Text: "", Attachments: []Attachment{ { Title: cfg.Title, Text: message + description, Short: false, Color: color, }, }, } if len(body.Attachments[0].Title) == 0 { body.Attachments[0].Title = ":helmet_with_white_cross: Gatus" } if len(formattedConditionResults) > 0 { body.Attachments[0].Fields = append(body.Attachments[0].Fields, Field{ Title: "Condition results", Value: formattedConditionResults, Short: false, }) } bodyAsJSON, _ := json.Marshal(body) return bodyAsJSON } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/slack/slack_test.go ================================================ package slack import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{WebhookURL: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{DefaultConfig: Config{WebhookURL: "https://example.com"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithInvalidOverrideTo := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: ""}, Group: "group", }, }, } if err := providerWithInvalidOverrideTo.Validate(); err == nil { t.Error("provider integration key shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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 Endpoint endpoint.Endpoint Alert alert.Alert NoConditions bool Resolved bool ExpectedBody string }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}}, Endpoint: endpoint.Endpoint{Name: "name"}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *name* has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"short\":false,\"color\":\"#DD0000\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\"short\":false}]}]}", }, { Name: "triggered-with-group", Provider: AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}}, Endpoint: endpoint.Endpoint{Name: "name", Group: "group"}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *group/name* has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"short\":false,\"color\":\"#DD0000\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":x: - `[CONNECTED] == true`\\n:x: - `[STATUS] == 200`\\n\",\"short\":false}]}]}", }, { Name: "triggered-with-no-conditions", NoConditions: true, Provider: AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}}, Endpoint: endpoint.Endpoint{Name: "name"}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *name* has been triggered due to having failed 3 time(s) in a row:\\n\\u003e description-1\",\"short\":false,\"color\":\"#DD0000\"}]}", }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}}, Endpoint: endpoint.Endpoint{Name: "name"}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *name* has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"short\":false,\"color\":\"#36A64F\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\"short\":false}]}]}", }, { Name: "resolved-with-group", Provider: AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}}, Endpoint: endpoint.Endpoint{Name: "name", Group: "group"}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\":helmet_with_white_cross: Gatus\",\"text\":\"An alert for *group/name* has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"short\":false,\"color\":\"#36A64F\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\"short\":false}]}]}", }, { Name: "resolved-with-group-and-custom-title", Provider: AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com", Title: "custom title"}}, Endpoint: endpoint.Endpoint{Name: "name", Group: "group"}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"text\":\"\",\"attachments\":[{\"title\":\"custom title\",\"text\":\"An alert for *group/name* has been resolved after passing successfully 5 time(s) in a row:\\n\\u003e description-2\",\"short\":false,\"color\":\"#36A64F\",\"fields\":[{\"title\":\"Condition results\",\"value\":\":white_check_mark: - `[CONNECTED] == true`\\n:white_check_mark: - `[STATUS] == 200`\\n\",\"short\":false}]}]}", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { var conditionResults []*endpoint.ConditionResult if !scenario.NoConditions { conditionResults = []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, } } cfg, err := scenario.Provider.GetConfig(scenario.Endpoint.Group, &scenario.Alert) if err != nil { t.Fatal("couldn't get config:", err.Error()) } body := scenario.Provider.buildRequestBody( cfg, &scenario.Endpoint, &scenario.Alert, &endpoint.Result{ ConditionResults: conditionResults, }, scenario.Resolved, ) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://example01.com"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://group-example.com"}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"webhook-url": "http://alert-example.com"}}, ExpectedOutput: Config{WebhookURL: "http://alert-example.com"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.WebhookURL != scenario.ExpectedOutput.WebhookURL { t.Errorf("expected webhook URL to be %s, got %s", scenario.ExpectedOutput.WebhookURL, got.WebhookURL) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/splunk/splunk.go ================================================ package splunk import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "time" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrHecURLNotSet = errors.New("hec-url not set") ErrHecTokenNotSet = errors.New("hec-token not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { HecURL string `yaml:"hec-url"` // Splunk HEC (HTTP Event Collector) URL HecToken string `yaml:"hec-token"` // Splunk HEC token Source string `yaml:"source,omitempty"` // Event source SourceType string `yaml:"sourcetype,omitempty"` // Event source type Index string `yaml:"index,omitempty"` // Splunk index } func (cfg *Config) Validate() error { if len(cfg.HecURL) == 0 { return ErrHecURLNotSet } if len(cfg.HecToken) == 0 { return ErrHecTokenNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.HecURL) > 0 { cfg.HecURL = override.HecURL } if len(override.HecToken) > 0 { cfg.HecToken = override.HecToken } if len(override.Source) > 0 { cfg.Source = override.Source } if len(override.SourceType) > 0 { cfg.SourceType = override.SourceType } if len(override.Index) > 0 { cfg.Index = override.Index } } // AlertProvider is the configuration necessary for sending an alert using Splunk type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } body, err := provider.buildRequestBody(cfg, ep, alert, result, resolved) if err != nil { return err } buffer := bytes.NewBuffer(body) request, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/services/collector/event", cfg.HecURL), buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") request.Header.Set("Authorization", fmt.Sprintf("Splunk %s", cfg.HecToken)) response, err := client.GetHTTPClient(nil).Do(request) if err != nil { return err } defer response.Body.Close() if response.StatusCode >= 400 { body, _ := io.ReadAll(response.Body) return fmt.Errorf("call to splunk alert returned status code %d: %s", response.StatusCode, string(body)) } return nil } type Body struct { Time int64 `json:"time"` Source string `json:"source,omitempty"` SourceType string `json:"sourcetype,omitempty"` Index string `json:"index,omitempty"` Event Event `json:"event"` } type Event struct { AlertType string `json:"alert_type"` Endpoint string `json:"endpoint"` Group string `json:"group,omitempty"` Status string `json:"status"` Message string `json:"message"` Description string `json:"description,omitempty"` Conditions []*endpoint.ConditionResult `json:"conditions,omitempty"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) ([]byte, error) { var alertType, status, message string if resolved { alertType = "resolved" status = "ok" message = fmt.Sprintf("Alert for %s has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) } else { alertType = "triggered" status = "critical" message = fmt.Sprintf("Alert for %s has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) } event := Event{ AlertType: alertType, Endpoint: ep.DisplayName(), Group: ep.Group, Status: status, Message: message, Description: alert.GetDescription(), } if len(result.ConditionResults) > 0 { event.Conditions = result.ConditionResults } body := Body{ Time: time.Now().Unix(), Event: event, } // Set optional fields if cfg.Source != "" { body.Source = cfg.Source } else { body.Source = "gatus" } if cfg.SourceType != "" { body.SourceType = cfg.SourceType } else { body.SourceType = "gatus:alert" } if cfg.Index != "" { body.Index = cfg.Index } bodyAsJSON, err := json.Marshal(body) if err != nil { return nil, err } return bodyAsJSON, nil } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/splunk/splunk_test.go ================================================ package splunk import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected error }{ { name: "valid", provider: AlertProvider{DefaultConfig: Config{HecURL: "https://splunk.example.com:8088", HecToken: "token123"}}, expected: nil, }, { name: "valid-with-index", provider: AlertProvider{DefaultConfig: Config{HecURL: "https://splunk.example.com:8088", HecToken: "token123", Index: "main"}}, expected: nil, }, { name: "invalid-hec-url", provider: AlertProvider{DefaultConfig: Config{HecToken: "token123"}}, expected: ErrHecURLNotSet, }, { name: "invalid-hec-token", provider: AlertProvider{DefaultConfig: Config{HecURL: "https://splunk.example.com:8088"}}, expected: ErrHecTokenNotSet, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { err := scenario.provider.Validate() if err != scenario.expected { t.Errorf("expected %v, got %v", scenario.expected, err) } }) } } 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{DefaultConfig: Config{HecURL: "https://splunk.example.com:8088", HecToken: "token123"}}, alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: false, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { if r.URL.Path != "/services/collector/event" { t.Errorf("expected path /services/collector/event, got %s", r.URL.Path) } if r.Header.Get("Authorization") != "Splunk token123" { t.Errorf("expected Authorization header to be 'Splunk token123', got %s", r.Header.Get("Authorization")) } body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) if body["time"] == nil { t.Error("expected 'time' field in request body") } event := body["event"].(map[string]interface{}) if event["alert_type"] != "triggered" { t.Errorf("expected alert_type to be 'triggered', got %v", event["alert_type"]) } if event["status"] != "critical" { t.Errorf("expected status to be 'critical', got %v", event["status"]) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "resolved", provider: AlertProvider{DefaultConfig: Config{HecURL: "https://splunk.example.com:8088", HecToken: "token123", Index: "main"}}, alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: true, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) if body["index"] != "main" { t.Errorf("expected index to be 'main', got %v", body["index"]) } event := body["event"].(map[string]interface{}) if event["alert_type"] != "resolved" { t.Errorf("expected alert_type to be 'resolved', got %v", event["alert_type"]) } if event["status"] != "ok" { t.Errorf("expected status to be 'ok', got %v", event["status"]) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "error-response", provider: AlertProvider{DefaultConfig: Config{HecURL: "https://splunk.example.com:8088", HecToken: "token123"}}, 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.StatusForbidden, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.alert, &endpoint.Result{ ConditionResults: []*endpoint.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_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") } } ================================================ FILE: alerting/provider/squadcast/squadcast.go ================================================ package squadcast import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrWebhookURLNotSet = errors.New("webhook-url not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { WebhookURL string `yaml:"webhook-url"` // Squadcast webhook URL } func (cfg *Config) Validate() error { if len(cfg.WebhookURL) == 0 { return ErrWebhookURLNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.WebhookURL) > 0 { cfg.WebhookURL = override.WebhookURL } } // AlertProvider is the configuration necessary for sending an alert using Squadcast type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } body, err := provider.buildRequestBody(ep, alert, result, resolved) if err != nil { return err } buffer := bytes.NewBuffer(body) request, err := http.NewRequest(http.MethodPost, cfg.WebhookURL, 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 } defer response.Body.Close() if response.StatusCode >= 400 { body, _ := io.ReadAll(response.Body) return fmt.Errorf("call to squadcast alert returned status code %d: %s", response.StatusCode, string(body)) } return nil } type Body struct { Message string `json:"message"` Description string `json:"description,omitempty"` EventID string `json:"event_id"` Status string `json:"status"` Tags map[string]string `json:"tags,omitempty"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) ([]byte, error) { var message, status string eventID := fmt.Sprintf("gatus-%s", ep.Key()) if resolved { message = fmt.Sprintf("RESOLVED: %s", ep.DisplayName()) status = "resolve" } else { message = fmt.Sprintf("ALERT: %s", ep.DisplayName()) status = "trigger" } description := fmt.Sprintf("Endpoint: %s\n", ep.DisplayName()) if resolved { description += fmt.Sprintf("Alert has been resolved after passing successfully %d time(s) in a row\n", alert.SuccessThreshold) } else { description += fmt.Sprintf("Endpoint has failed %d time(s) in a row\n", alert.FailureThreshold) } if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { description += fmt.Sprintf("\nDescription: %s", alertDescription) } if len(result.ConditionResults) > 0 { description += "\n\nCondition Results:" for _, conditionResult := range result.ConditionResults { var status string if conditionResult.Success { status = "✅" } else { status = "❌" } description += fmt.Sprintf("\n%s %s", status, conditionResult.Condition) } } body := Body{ Message: message, Description: description, EventID: eventID, Status: status, Tags: map[string]string{ "endpoint": ep.Name, "group": ep.Group, "source": "gatus", }, } bodyAsJSON, err := json.Marshal(body) if err != nil { return nil, err } return bodyAsJSON, nil } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/squadcast/squadcast_test.go ================================================ package squadcast import ( "encoding/json" "net/http" "strings" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected error }{ { name: "valid", provider: AlertProvider{DefaultConfig: Config{WebhookURL: "https://api.squadcast.com/v3/incidents/api/abcd1234"}}, expected: nil, }, { name: "invalid-webhook-url", provider: AlertProvider{DefaultConfig: Config{}}, expected: ErrWebhookURLNotSet, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { err := scenario.provider.Validate() if err != scenario.expected { t.Errorf("expected %v, got %v", scenario.expected, err) } }) } } 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{DefaultConfig: Config{WebhookURL: "https://api.squadcast.com/v3/incidents/api/abcd1234"}}, alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: false, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) if body["status"] != "trigger" { t.Errorf("expected status to be 'trigger', got %v", body["status"]) } if body["event_id"] == nil { t.Error("expected 'event_id' field in request body") } message := body["message"].(string) if !strings.Contains(message, "ALERT") { t.Errorf("expected message to contain 'ALERT', got %s", message) } description := body["description"].(string) if !strings.Contains(description, "failed 3 time(s)") { t.Errorf("expected description to contain failure count, got %s", description) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "resolved", provider: AlertProvider{DefaultConfig: Config{WebhookURL: "https://api.squadcast.com/v3/incidents/api/abcd1234"}}, alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: true, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) if body["status"] != "resolve" { t.Errorf("expected status to be 'resolve', got %v", body["status"]) } message := body["message"].(string) if !strings.Contains(message, "RESOLVED") { t.Errorf("expected message to contain 'RESOLVED', got %s", message) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "error-response", provider: AlertProvider{DefaultConfig: Config{WebhookURL: "https://api.squadcast.com/v3/incidents/api/abcd1234"}}, 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.StatusUnauthorized, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.alert, &endpoint.Result{ ConditionResults: []*endpoint.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_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") } } ================================================ FILE: alerting/provider/teams/teams.go ================================================ package teams import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrWebhookURLNotSet = errors.New("webhook-url not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { WebhookURL string `yaml:"webhook-url"` Title string `yaml:"title,omitempty"` // Title of the message that will be sent // ClientConfig is the configuration of the client used to communicate with the provider's target ClientConfig *client.Config `yaml:"client,omitempty"` } func (cfg *Config) Validate() error { if len(cfg.WebhookURL) == 0 { return ErrWebhookURLNotSet } return nil } func (cfg *Config) Merge(override *Config) { if override.ClientConfig != nil { cfg.ClientConfig = override.ClientConfig } if len(override.WebhookURL) > 0 { cfg.WebhookURL = override.WebhookURL } if len(override.Title) > 0 { cfg.Title = override.Title } } // AlertProvider is the configuration necessary for sending an alert using Teams type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(cfg, ep, alert, result, resolved)) request, err := http.NewRequest(http.MethodPost, cfg.WebhookURL, buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") response, err := client.GetHTTPClient(cfg.ClientConfig).Do(request) if err != nil { return err } defer response.Body.Close() 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 } type Body struct { Type string `json:"@type"` Context string `json:"@context"` ThemeColor string `json:"themeColor"` Title string `json:"title"` Text string `json:"text"` Sections []Section `json:"sections,omitempty"` } type Section struct { ActivityTitle string `json:"activityTitle"` Text string `json:"text"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var message, color string if resolved { message = fmt.Sprintf("An alert for *%s* has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) color = "#36A64F" } else { message = fmt.Sprintf("An alert for *%s* has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) color = "#DD0000" } var formattedConditionResults string for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = "✅" } else { prefix = "❌" } formattedConditionResults += fmt.Sprintf("%s - `%s`
", prefix, conditionResult.Condition) } var description string if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { description = ": " + alertDescription } body := Body{ Type: "MessageCard", Context: "http://schema.org/extensions", ThemeColor: color, Title: cfg.Title, Text: message + description, } if len(body.Title) == 0 { body.Title = "🚨 Gatus" } if len(formattedConditionResults) > 0 { body.Sections = append(body.Sections, Section{ ActivityTitle: "Condition results", Text: formattedConditionResults, }) } bodyAsJSON, _ := json.Marshal(body) return bodyAsJSON } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/teams/teams_test.go ================================================ package teams import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{WebhookURL: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithInvalidOverrideTo := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: ""}, Group: "group", }, }, } if err := providerWithInvalidOverrideTo.Validate(); err == nil { t.Error("provider integration key shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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 NoConditions bool Resolved bool ExpectedBody string }{ { Name: "triggered", Provider: AlertProvider{}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"@type\":\"MessageCard\",\"@context\":\"http://schema.org/extensions\",\"themeColor\":\"#DD0000\",\"title\":\"\\u0026#x1F6A8; Gatus\",\"text\":\"An alert for *endpoint-name* has been triggered due to having failed 3 time(s) in a row: description-1\",\"sections\":[{\"activityTitle\":\"Condition results\",\"text\":\"\\u0026#x274C; - `[CONNECTED] == true`\\u003cbr/\\u003e\\u0026#x274C; - `[STATUS] == 200`\\u003cbr/\\u003e\"}]}", }, { Name: "resolved", Provider: AlertProvider{}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"@type\":\"MessageCard\",\"@context\":\"http://schema.org/extensions\",\"themeColor\":\"#36A64F\",\"title\":\"\\u0026#x1F6A8; Gatus\",\"text\":\"An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row: description-2\",\"sections\":[{\"activityTitle\":\"Condition results\",\"text\":\"\\u0026#x2705; - `[CONNECTED] == true`\\u003cbr/\\u003e\\u0026#x2705; - `[STATUS] == 200`\\u003cbr/\\u003e\"}]}", }, { Name: "resolved-with-no-conditions", NoConditions: true, Provider: AlertProvider{}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"@type\":\"MessageCard\",\"@context\":\"http://schema.org/extensions\",\"themeColor\":\"#36A64F\",\"title\":\"\\u0026#x1F6A8; Gatus\",\"text\":\"An alert for *endpoint-name* has been resolved after passing successfully 5 time(s) in a row: description-2\"}", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { var conditionResults []*endpoint.ConditionResult if !scenario.NoConditions { conditionResults = []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, } } body := scenario.Provider.buildRequestBody( &scenario.Provider.DefaultConfig, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ConditionResults: conditionResults}, scenario.Resolved, ) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://example01.com"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://group-example.com"}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"webhook-url": "http://alert-example.com"}}, ExpectedOutput: Config{WebhookURL: "http://alert-example.com"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.WebhookURL != scenario.ExpectedOutput.WebhookURL { t.Errorf("expected webhook URL to be %s, got %s", scenario.ExpectedOutput.WebhookURL, got.WebhookURL) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/teamsworkflows/teamsworkflows.go ================================================ package teamsworkflows import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrWebhookURLNotSet = errors.New("webhook-url not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { WebhookURL string `yaml:"webhook-url"` Title string `yaml:"title,omitempty"` // Title of the message that will be sent } func (cfg *Config) Validate() error { if len(cfg.WebhookURL) == 0 { return ErrWebhookURLNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.WebhookURL) > 0 { cfg.WebhookURL = override.WebhookURL } if len(override.Title) > 0 { cfg.Title = override.Title } } // AlertProvider is the configuration necessary for sending an alert using Teams type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(cfg, ep, alert, result, resolved)) request, err := http.NewRequest(http.MethodPost, cfg.WebhookURL, 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 } defer response.Body.Close() 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 } // AdaptiveCardBody represents the structure of an Adaptive Card type AdaptiveCardBody struct { Type string `json:"type"` Version string `json:"version"` Body []CardBody `json:"body"` MSTeams MSTeamsBody `json:"msteams"` } // CardBody represents the body of the Adaptive Card type CardBody struct { Type string `json:"type"` Text string `json:"text,omitempty"` Wrap bool `json:"wrap"` Separator bool `json:"separator,omitempty"` Size string `json:"size,omitempty"` Weight string `json:"weight,omitempty"` Items []CardBody `json:"items,omitempty"` Facts []Fact `json:"facts,omitempty"` FactSet *FactSetBody `json:"factSet,omitempty"` Style string `json:"style,omitempty"` } // MSTeamsBody represents the msteams options type MSTeamsBody struct { Width string `json:"width"` } // FactSetBody represents the FactSet in the Adaptive Card type FactSetBody struct { Type string `json:"type"` Facts []Fact `json:"facts"` } // Fact represents an individual fact in the FactSet type Fact struct { Title string `json:"title"` Value string `json:"value"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var message string var themeColor string if resolved { message = fmt.Sprintf("An alert for **%s** has been resolved after passing successfully %d time(s) in a row.", ep.DisplayName(), alert.SuccessThreshold) themeColor = "Good" // green } else { message = fmt.Sprintf("An alert for **%s** has been triggered due to having failed %d time(s) in a row.", ep.DisplayName(), alert.FailureThreshold) themeColor = "Attention" // red } // Configure default title if it's not provided title := "⛑️ Gatus" if cfg.Title != "" { title = cfg.Title } // Build the facts from the condition results var facts []Fact for _, conditionResult := range result.ConditionResults { var key string if conditionResult.Success { key = "✅" } else { key = "❌" } facts = append(facts, Fact{ Title: key, Value: conditionResult.Condition, }) } var description string if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { description = "**Description**: " + alertDescription } cardContent := AdaptiveCardBody{ Type: "AdaptiveCard", Version: "1.4", // Version 1.5 and 1.6 doesn't seem to be supported by Teams as of 27/08/2024 Body: []CardBody{ { Type: "Container", Style: themeColor, Items: []CardBody{ { Type: "Container", Style: "Default", Items: []CardBody{ { Type: "TextBlock", Text: title, Size: "Medium", Weight: "Bolder", }, { Type: "TextBlock", Text: message, Wrap: true, }, { Type: "TextBlock", Text: description, Wrap: true, }, { Type: "FactSet", Facts: facts, }, }, }, }, }, }, MSTeams: MSTeamsBody{ Width: "Full", }, } attachment := map[string]interface{}{ "contentType": "application/vnd.microsoft.card.adaptive", "content": cardContent, } payload := map[string]interface{}{ "type": "message", "attachments": []interface{}{attachment}, } bodyAsJSON, _ := json.Marshal(payload) return bodyAsJSON } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/teamsworkflows/teamsworkflows_test.go ================================================ package teamsworkflows import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{WebhookURL: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{DefaultConfig: Config{WebhookURL: "http://example.com"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid, got", err.Error()) } } func TestAlertProvider_ValidateWithOverride(t *testing.T) { providerWithInvalidOverrideGroup := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "", }, }, } if err := providerWithInvalidOverrideGroup.Validate(); err == nil { t.Error("provider Group shouldn't have been valid") } providerWithInvalidOverrideTo := AlertProvider{ Overrides: []Override{ { Config: Config{WebhookURL: ""}, Group: "group", }, }, } if err := providerWithInvalidOverrideTo.Validate(); err == nil { t.Error("provider integration key shouldn't have been valid") } providerWithValidOverride := AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Config: Config{WebhookURL: "http://example.com"}, Group: "group", }, }, } if err := providerWithValidOverride.Validate(); err != nil { 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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{DefaultConfig: Config{WebhookURL: "http://example.com"}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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 NoConditions bool Resolved bool ExpectedBody string }{ { Name: "triggered", Provider: AlertProvider{}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"attachments\":[{\"content\":{\"type\":\"AdaptiveCard\",\"version\":\"1.4\",\"body\":[{\"type\":\"Container\",\"wrap\":false,\"items\":[{\"type\":\"Container\",\"wrap\":false,\"items\":[{\"type\":\"TextBlock\",\"text\":\"⛑️ Gatus\",\"wrap\":false,\"size\":\"Medium\",\"weight\":\"Bolder\"},{\"type\":\"TextBlock\",\"text\":\"An alert for **endpoint-name** has been triggered due to having failed 3 time(s) in a row.\",\"wrap\":true},{\"type\":\"TextBlock\",\"text\":\"**Description**: description-1\",\"wrap\":true},{\"type\":\"FactSet\",\"wrap\":false,\"facts\":[{\"title\":\"❌\",\"value\":\"[CONNECTED] == true\"},{\"title\":\"❌\",\"value\":\"[STATUS] == 200\"}]}],\"style\":\"Default\"}],\"style\":\"Attention\"}],\"msteams\":{\"width\":\"Full\"}},\"contentType\":\"application/vnd.microsoft.card.adaptive\"}],\"type\":\"message\"}", }, { Name: "resolved", Provider: AlertProvider{}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"attachments\":[{\"content\":{\"type\":\"AdaptiveCard\",\"version\":\"1.4\",\"body\":[{\"type\":\"Container\",\"wrap\":false,\"items\":[{\"type\":\"Container\",\"wrap\":false,\"items\":[{\"type\":\"TextBlock\",\"text\":\"⛑️ Gatus\",\"wrap\":false,\"size\":\"Medium\",\"weight\":\"Bolder\"},{\"type\":\"TextBlock\",\"text\":\"An alert for **endpoint-name** has been resolved after passing successfully 5 time(s) in a row.\",\"wrap\":true},{\"type\":\"TextBlock\",\"text\":\"**Description**: description-2\",\"wrap\":true},{\"type\":\"FactSet\",\"wrap\":false,\"facts\":[{\"title\":\"✅\",\"value\":\"[CONNECTED] == true\"},{\"title\":\"✅\",\"value\":\"[STATUS] == 200\"}]}],\"style\":\"Default\"}],\"style\":\"Good\"}],\"msteams\":{\"width\":\"Full\"}},\"contentType\":\"application/vnd.microsoft.card.adaptive\"}],\"type\":\"message\"}", }, { Name: "resolved-with-no-conditions", NoConditions: true, Provider: AlertProvider{}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"attachments\":[{\"content\":{\"type\":\"AdaptiveCard\",\"version\":\"1.4\",\"body\":[{\"type\":\"Container\",\"wrap\":false,\"items\":[{\"type\":\"Container\",\"wrap\":false,\"items\":[{\"type\":\"TextBlock\",\"text\":\"⛑️ Gatus\",\"wrap\":false,\"size\":\"Medium\",\"weight\":\"Bolder\"},{\"type\":\"TextBlock\",\"text\":\"An alert for **endpoint-name** has been resolved after passing successfully 5 time(s) in a row.\",\"wrap\":true},{\"type\":\"TextBlock\",\"text\":\"**Description**: description-2\",\"wrap\":true},{\"type\":\"FactSet\",\"wrap\":false}],\"style\":\"Default\"}],\"style\":\"Good\"}],\"msteams\":{\"width\":\"Full\"}},\"contentType\":\"application/vnd.microsoft.card.adaptive\"}],\"type\":\"message\"}", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { var conditionResults []*endpoint.ConditionResult if !scenario.NoConditions { conditionResults = []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, } } body := scenario.Provider.buildRequestBody( &scenario.Provider.DefaultConfig, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ConditionResults: conditionResults}, scenario.Resolved, ) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-no-override-specify-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://example01.com"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://example.com"}, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{WebhookURL: "http://group-example.com"}, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{WebhookURL: "http://example.com"}, Overrides: []Override{ { Group: "group", Config: Config{WebhookURL: "http://group-example.com"}, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{"webhook-url": "http://alert-example.com"}}, ExpectedOutput: Config{WebhookURL: "http://alert-example.com"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.WebhookURL != scenario.ExpectedOutput.WebhookURL { t.Errorf("expected webhook URL to be %s, got %s", scenario.ExpectedOutput.WebhookURL, got.WebhookURL) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/telegram/telegram.go ================================================ package telegram import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) const ApiURL = "https://api.telegram.org" var ( ErrTokenNotSet = errors.New("token not set") ErrIDNotSet = errors.New("id not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { Token string `yaml:"token"` ID string `yaml:"id"` TopicID string `yaml:"topic-id,omitempty"` ApiUrl string `yaml:"api-url"` ClientConfig *client.Config `yaml:"client,omitempty"` } func (cfg *Config) Validate() error { if len(cfg.ApiUrl) == 0 { cfg.ApiUrl = ApiURL } if len(cfg.Token) == 0 { return ErrTokenNotSet } if len(cfg.ID) == 0 { return ErrIDNotSet } return nil } func (cfg *Config) Merge(override *Config) { if override.ClientConfig != nil { cfg.ClientConfig = override.ClientConfig } if len(override.Token) > 0 { cfg.Token = override.Token } if len(override.ID) > 0 { cfg.ID = override.ID } if len(override.TopicID) > 0 { cfg.TopicID = override.TopicID } if len(override.ApiUrl) > 0 { cfg.ApiUrl = override.ApiUrl } } // AlertProvider is the configuration necessary for sending an alert using Telegram type AlertProvider struct { DefaultConfig Config `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 overrides that may be prioritized over the default configuration Overrides []*Override `yaml:"overrides,omitempty"` } // Override is a configuration that may be prioritized over the default configuration type Override struct { Group string `yaml:"group"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer(provider.buildRequestBody(cfg, ep, alert, result, resolved)) request, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/bot%s/sendMessage", cfg.ApiUrl, cfg.Token), buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") response, err := client.GetHTTPClient(cfg.ClientConfig).Do(request) if err != nil { return err } defer response.Body.Close() 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 } type Body struct { ChatID string `json:"chat_id"` Text string `json:"text"` ParseMode string `json:"parse_mode"` TopicID string `json:"message_thread_id,omitempty"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) []byte { var message string if resolved { message = fmt.Sprintf("An alert for *%s* has been resolved:\n—\n _healthcheck passing successfully %d time(s) in a row_\n— ", ep.DisplayName(), alert.SuccessThreshold) } else { message = fmt.Sprintf("An alert for *%s* has been triggered:\n—\n _healthcheck failed %d time(s) in a row_\n— ", ep.DisplayName(), alert.FailureThreshold) } var formattedConditionResults string if len(result.ConditionResults) > 0 { formattedConditionResults = "\n*Condition results*\n" for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = "✅" } else { prefix = "❌" } formattedConditionResults += fmt.Sprintf("%s - `%s`\n", prefix, conditionResult.Condition) } } var text string if len(alert.GetDescription()) > 0 { text = fmt.Sprintf("⛑ *Gatus* \n%s \n*Description* \n%s \n%s", message, alert.GetDescription(), formattedConditionResults) } else { text = fmt.Sprintf("⛑ *Gatus* \n%s%s", message, formattedConditionResults) } bodyAsJSON, _ := json.Marshal(Body{ ChatID: cfg.ID, Text: text, ParseMode: "MARKDOWN", TopicID: cfg.TopicID, }) return bodyAsJSON } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/telegram/telegram_test.go ================================================ package telegram import ( "encoding/json" "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { t.Run("invalid-provider", func(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{Token: "", ID: ""}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } }) t.Run("valid-provider", func(t *testing.T) { validProvider := AlertProvider{DefaultConfig: Config{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}} if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } }) t.Run("invalid-provider-override-nonexist-group", func(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}, Overrides: []*Override{{Config: Config{Token: "token", ID: "id"}}}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } }) t.Run("invalid-provider-override-duplicate-group", func(t *testing.T) { invalidProvider := AlertProvider{DefaultConfig: Config{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}, Overrides: []*Override{{Group: "group1", Config: Config{Token: "token", ID: "id"}}, {Group: "group1", Config: Config{ID: "id2"}}}} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } }) t.Run("valid-provider-with-overrides", func(t *testing.T) { validProvider := AlertProvider{DefaultConfig: Config{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}, Overrides: []*Override{{Group: "group", Config: Config{Token: "token", ID: "id"}}}} if err := validProvider.Validate(); err != nil { 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{DefaultConfig: Config{ID: "123", Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"}}, 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{DefaultConfig: Config{ID: "123", Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"}}, 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{DefaultConfig: Config{ID: "123", Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"}}, 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{DefaultConfig: Config{ID: "123", Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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" descriptionWithLink := "[link](https://example.org/)" scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert NoConditions bool Resolved bool ExpectedBody string }{ { Name: "triggered", Provider: AlertProvider{DefaultConfig: Config{ID: "123"}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"chat_id\":\"123\",\"text\":\"⛑ *Gatus* \\nAn alert for *endpoint-name* has been triggered:\\n—\\n _healthcheck failed 3 time(s) in a row_\\n— \\n*Description* \\ndescription-1 \\n\\n*Condition results*\\n❌ - `[CONNECTED] == true`\\n❌ - `[STATUS] == 200`\\n\",\"parse_mode\":\"MARKDOWN\"}", }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{ID: "123"}}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"chat_id\":\"123\",\"text\":\"⛑ *Gatus* \\nAn alert for *endpoint-name* has been resolved:\\n—\\n _healthcheck passing successfully 5 time(s) in a row_\\n— \\n*Description* \\ndescription-2 \\n\\n*Condition results*\\n✅ - `[CONNECTED] == true`\\n✅ - `[STATUS] == 200`\\n\",\"parse_mode\":\"MARKDOWN\"}", }, { Name: "resolved-with-no-conditions", NoConditions: true, Provider: AlertProvider{DefaultConfig: Config{ID: "123"}}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "{\"chat_id\":\"123\",\"text\":\"⛑ *Gatus* \\nAn alert for *endpoint-name* has been resolved:\\n—\\n _healthcheck passing successfully 5 time(s) in a row_\\n— \\n*Description* \\ndescription-2 \\n\",\"parse_mode\":\"MARKDOWN\"}", }, { Name: "send to topic", Provider: AlertProvider{DefaultConfig: Config{ID: "123", TopicID: "7"}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"chat_id\":\"123\",\"text\":\"⛑ *Gatus* \\nAn alert for *endpoint-name* has been triggered:\\n—\\n _healthcheck failed 3 time(s) in a row_\\n— \\n*Description* \\ndescription-1 \\n\\n*Condition results*\\n❌ - `[CONNECTED] == true`\\n❌ - `[STATUS] == 200`\\n\",\"parse_mode\":\"MARKDOWN\",\"message_thread_id\":\"7\"}", }, { Name: "triggered with link in description", Provider: AlertProvider{DefaultConfig: Config{ID: "123"}}, Alert: alert.Alert{Description: &descriptionWithLink, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "{\"chat_id\":\"123\",\"text\":\"⛑ *Gatus* \\nAn alert for *endpoint-name* has been triggered:\\n—\\n _healthcheck failed 3 time(s) in a row_\\n— \\n*Description* \\n[link](https://example.org/) \\n\\n*Condition results*\\n❌ - `[CONNECTED] == true`\\n❌ - `[STATUS] == 200`\\n\",\"parse_mode\":\"MARKDOWN\"}", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { var conditionResults []*endpoint.ConditionResult if !scenario.NoConditions { conditionResults = []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, } } body := scenario.Provider.buildRequestBody( &scenario.Provider.DefaultConfig, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ConditionResults: conditionResults}, scenario.Resolved, ) if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n%s\ngot:\n%s", scenario.ExpectedBody, body) } out := make(map[string]interface{}) if err := json.Unmarshal(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_GetConfig(t *testing.T) { t.Run("get-token-with-override", func(t *testing.T) { provider := AlertProvider{DefaultConfig: Config{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}, Overrides: []*Override{{Group: "group", Config: Config{Token: "groupToken", ID: "overrideID"}}}} cfg, err := provider.GetConfig("group", &alert.Alert{}) if err != nil { t.Error("expected no error, got", err) } if cfg.Token != "groupToken" { t.Error("token should have been 'groupToken'") } if cfg.ID != "overrideID" { t.Error("id should have been 'overrideID'") } }) t.Run("get-default-token-with-overridden-id", func(t *testing.T) { provider := AlertProvider{DefaultConfig: Config{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}, Overrides: []*Override{{Group: "group", Config: Config{ID: "overrideID"}}}} cfg, err := provider.GetConfig("group", &alert.Alert{}) if err != nil { t.Error("expected no error, got", err) } if cfg.Token != provider.DefaultConfig.Token { t.Error("token should have been the default token") } if cfg.ID != "overrideID" { t.Error("id should have been 'overrideID'") } }) t.Run("get-default-token-with-overridden-token", func(t *testing.T) { provider := AlertProvider{DefaultConfig: Config{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}, Overrides: []*Override{{Group: "group", Config: Config{Token: "groupToken"}}}} cfg, err := provider.GetConfig("group", &alert.Alert{}) if err != nil { t.Error("expected no error, got", err) } if cfg.Token != "groupToken" { t.Error("token should have been 'groupToken'") } if cfg.ID != provider.DefaultConfig.ID { t.Error("id should have been the default id") } }) t.Run("get-default-token-with-overridden-token-and-alert-token-override", func(t *testing.T) { provider := AlertProvider{DefaultConfig: Config{Token: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", ID: "12345678"}, Overrides: []*Override{{Group: "group", Config: Config{Token: "groupToken"}}}} alert := &alert.Alert{ProviderOverride: map[string]any{"token": "alertToken"}} cfg, err := provider.GetConfig("group", alert) if err != nil { t.Error("expected no error, got", err) } if cfg.Token != "alertToken" { t.Error("token should have been 'alertToken'") } if cfg.ID != provider.DefaultConfig.ID { t.Error("id should have been the default id") } // Test ValidateOverrides as well, since it really just calls GetConfig if err = provider.ValidateOverrides("group", alert); err != nil { t.Errorf("unexpected error: %s", err) } }) } ================================================ FILE: alerting/provider/twilio/twilio.go ================================================ package twilio import ( "bytes" "encoding/base64" "errors" "fmt" "io" "net/http" "net/url" "strings" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrSIDNotSet = errors.New("sid not set") ErrTokenNotSet = errors.New("token not set") ErrFromNotSet = errors.New("from not set") ErrToNotSet = errors.New("to not set") ) type Config struct { SID string `yaml:"sid"` Token string `yaml:"token"` From string `yaml:"from"` To string `yaml:"to"` // TODO in v6.0.0: Rename this to text-triggered TextTwilioTriggered string `yaml:"text-twilio-triggered,omitempty"` // String used in the SMS body and subject (optional) // TODO in v6.0.0: Rename this to text-resolved TextTwilioResolved string `yaml:"text-twilio-resolved,omitempty"` // String used in the SMS body and subject (optional) } func (cfg *Config) Validate() error { if len(cfg.SID) == 0 { return ErrSIDNotSet } if len(cfg.Token) == 0 { return ErrTokenNotSet } if len(cfg.From) == 0 { return ErrFromNotSet } if len(cfg.To) == 0 { return ErrToNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.SID) > 0 { cfg.SID = override.SID } if len(override.Token) > 0 { cfg.Token = override.Token } if len(override.From) > 0 { cfg.From = override.From } if len(override.To) > 0 { cfg.To = override.To } if len(override.TextTwilioTriggered) > 0 { cfg.TextTwilioTriggered = override.TextTwilioTriggered } if len(override.TextTwilioResolved) > 0 { cfg.TextTwilioResolved = override.TextTwilioResolved } } // AlertProvider is the configuration necessary for sending an alert using Twilio type AlertProvider struct { DefaultConfig Config `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"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBuffer([]byte(provider.buildRequestBody(cfg, ep, alert, result, resolved))) request, err := http.NewRequest(http.MethodPost, fmt.Sprintf("https://api.twilio.com/2010-04-01/Accounts/%s/Messages.json", cfg.SID), buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/x-www-form-urlencoded") request.Header.Set("Authorization", fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString([]byte(cfg.SID+":"+cfg.Token)))) response, err := client.GetHTTPClient(nil).Do(request) if err != nil { return err } defer response.Body.Close() 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(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) string { var message string if resolved { if len(cfg.TextTwilioResolved) > 0 { // Support both old {endpoint}/{description} and new [ENDPOINT]/[ALERT_DESCRIPTION] formats message = cfg.TextTwilioResolved message = strings.Replace(message, "{endpoint}", ep.DisplayName(), 1) message = strings.Replace(message, "{description}", alert.GetDescription(), 1) message = strings.Replace(message, "[ENDPOINT]", ep.DisplayName(), 1) message = strings.Replace(message, "[ALERT_DESCRIPTION]", alert.GetDescription(), 1) } else { message = fmt.Sprintf("RESOLVED: %s - %s", ep.DisplayName(), alert.GetDescription()) } } else { if len(cfg.TextTwilioTriggered) > 0 { // Support both old {endpoint}/{description} and new [ENDPOINT]/[ALERT_DESCRIPTION] formats message = cfg.TextTwilioTriggered message = strings.Replace(message, "{endpoint}", ep.DisplayName(), 1) message = strings.Replace(message, "{description}", alert.GetDescription(), 1) message = strings.Replace(message, "[ENDPOINT]", ep.DisplayName(), 1) message = strings.Replace(message, "[ALERT_DESCRIPTION]", alert.GetDescription(), 1) } else { message = fmt.Sprintf("TRIGGERED: %s - %s", ep.DisplayName(), alert.GetDescription()) } } return url.Values{ "To": {cfg.To}, "From": {cfg.From}, "Body": {message}, }.Encode() } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/twilio/twilio_test.go ================================================ package twilio import ( "net/http" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestTwilioAlertProvider_IsValid(t *testing.T) { invalidProvider := AlertProvider{} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{ DefaultConfig: Config{ SID: "1", Token: "1", From: "1", To: "1", }, } if err := validProvider.Validate(); err != nil { 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{DefaultConfig: Config{SID: "1", Token: "2", From: "3", To: "4"}}, 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{DefaultConfig: Config{SID: "1", Token: "2", From: "3", To: "4"}}, 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{DefaultConfig: Config{SID: "1", Token: "2", From: "3", To: "4"}}, 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{DefaultConfig: Config{SID: "1", Token: "2", From: "3", To: "4"}}, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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{DefaultConfig: Config{SID: "1", Token: "2", From: "3", To: "4"}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "Body=TRIGGERED%3A+endpoint-name+-+description-1&From=3&To=4", }, { Name: "resolved", Provider: AlertProvider{DefaultConfig: Config{SID: "1", Token: "2", From: "3", To: "4"}}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "Body=RESOLVED%3A+endpoint-name+-+description-2&From=3&To=4", }, { Name: "triggered-with-old-placeholders", Provider: AlertProvider{DefaultConfig: Config{SID: "1", Token: "2", From: "3", To: "4", TextTwilioTriggered: "Alert: {endpoint} - {description}"}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "Body=Alert%3A+endpoint-name+-+description-1&From=3&To=4", }, { Name: "triggered-with-new-placeholders", Provider: AlertProvider{DefaultConfig: Config{SID: "1", Token: "2", From: "3", To: "4", TextTwilioTriggered: "Alert: [ENDPOINT] - [ALERT_DESCRIPTION]"}}, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedBody: "Body=Alert%3A+endpoint-name+-+description-1&From=3&To=4", }, { Name: "resolved-with-mixed-placeholders", Provider: AlertProvider{DefaultConfig: Config{SID: "1", Token: "2", From: "3", To: "4", TextTwilioResolved: "Resolved: {endpoint} and [ENDPOINT] - {description} and [ALERT_DESCRIPTION]"}}, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedBody: "Body=Resolved%3A+endpoint-name+and+endpoint-name+-+description-2+and+description-2&From=3&To=4", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { body := scenario.Provider.buildRequestBody( &scenario.Provider.DefaultConfig, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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) } }) } } 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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-should-default", Provider: AlertProvider{ DefaultConfig: Config{SID: "1", Token: "2", From: "3", To: "4"}, }, InputAlert: alert.Alert{}, ExpectedOutput: Config{SID: "1", Token: "2", From: "3", To: "4"}, }, { Name: "provider-with-alert-override", Provider: AlertProvider{ DefaultConfig: Config{SID: "1", Token: "2", From: "3", To: "4"}, }, InputAlert: alert.Alert{ProviderOverride: map[string]any{"sid": "5", "token": "6", "from": "7", "to": "8"}}, ExpectedOutput: Config{SID: "5", Token: "6", From: "7", To: "8"}, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig("", &scenario.InputAlert) if err != nil { t.Error("expected no error, got:", err.Error()) } if got.SID != scenario.ExpectedOutput.SID { t.Errorf("expected SID to be %s, got %s", scenario.ExpectedOutput.SID, got.SID) } if got.Token != scenario.ExpectedOutput.Token { t.Errorf("expected token to be %s, got %s", scenario.ExpectedOutput.Token, got.Token) } if got.From != scenario.ExpectedOutput.From { t.Errorf("expected from to be %s, got %s", scenario.ExpectedOutput.From, got.From) } if got.To != scenario.ExpectedOutput.To { t.Errorf("expected to to be %s, got %s", scenario.ExpectedOutput.To, got.To) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides("", &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/vonage/vonage.go ================================================ package vonage import ( "encoding/json" "errors" "fmt" "io" "net/http" "net/url" "strings" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) const ApiURL = "https://rest.nexmo.com/sms/json" var ( ErrAPIKeyNotSet = errors.New("api-key not set") ErrAPISecretNotSet = errors.New("api-secret not set") ErrFromNotSet = errors.New("from not set") ErrToNotSet = errors.New("to not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { APIKey string `yaml:"api-key"` APISecret string `yaml:"api-secret"` From string `yaml:"from"` To []string `yaml:"to"` } func (cfg *Config) Validate() error { if len(cfg.APIKey) == 0 { return ErrAPIKeyNotSet } if len(cfg.APISecret) == 0 { return ErrAPISecretNotSet } if len(cfg.From) == 0 { return ErrFromNotSet } if len(cfg.To) == 0 { return ErrToNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.APIKey) > 0 { cfg.APIKey = override.APIKey } if len(override.APISecret) > 0 { cfg.APISecret = override.APISecret } if len(override.From) > 0 { cfg.From = override.From } if len(override.To) > 0 { cfg.To = override.To } } // AlertProvider is the configuration necessary for sending an alert using Vonage type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } message := provider.buildMessage(cfg, ep, alert, result, resolved) // Send SMS to each recipient for _, recipient := range cfg.To { if err := provider.sendSMS(cfg, recipient, message); err != nil { return err } } return nil } // sendSMS sends an individual SMS message func (provider *AlertProvider) sendSMS(cfg *Config, to, message string) error { data := url.Values{} data.Set("api_key", cfg.APIKey) data.Set("api_secret", cfg.APISecret) data.Set("from", cfg.From) data.Set("to", to) data.Set("text", message) request, err := http.NewRequest(http.MethodPost, ApiURL, strings.NewReader(data.Encode())) if err != nil { return err } request.Header.Set("Content-Type", "application/x-www-form-urlencoded") response, err := client.GetHTTPClient(nil).Do(request) if err != nil { return err } defer response.Body.Close() // Read response body once and use it for both error handling and JSON processing body, err := io.ReadAll(response.Body) if err != nil { return err } if response.StatusCode >= 400 { return fmt.Errorf("call to vonage alert returned status code %d: %s", response.StatusCode, string(body)) } // Check response for errors in messages array var vonageResponse Response if err := json.Unmarshal(body, &vonageResponse); err != nil { return err } // Check if any message failed for _, msg := range vonageResponse.Messages { if msg.Status != "0" { return fmt.Errorf("vonage SMS failed with status %s: %s", msg.Status, msg.ErrorText) } } return nil } type Response struct { MessageCount string `json:"message-count"` Messages []Message `json:"messages"` } type Message struct { To string `json:"to"` MessageID string `json:"message-id"` Status string `json:"status"` ErrorText string `json:"error-text"` RemainingBalance string `json:"remaining-balance"` MessagePrice string `json:"message-price"` Network string `json:"network"` } // buildMessage builds the SMS message content func (provider *AlertProvider) buildMessage(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) string { if resolved { return fmt.Sprintf("RESOLVED: %s - %s", ep.DisplayName(), alert.GetDescription()) } else { return fmt.Sprintf("TRIGGERED: %s - %s", ep.DisplayName(), alert.GetDescription()) } } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/vonage/vonage_test.go ================================================ package vonage import ( "io" "net/http" "strings" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestVonageAlertProvider_IsValid(t *testing.T) { invalidProvider := AlertProvider{} if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } validProvider := AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, } if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestVonageAlertProvider_IsValidWithOverride(t *testing.T) { validProvider := AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, Overrides: []Override{ { Group: "test-group", Config: Config{ APIKey: "override-key", APISecret: "override-secret", From: "Override", To: []string{"+9876543210"}, }, }, }, } if err := validProvider.Validate(); err != nil { t.Error("provider should've been valid") } } func TestVonageAlertProvider_IsNotValidWithInvalidOverrideGroup(t *testing.T) { invalidProvider := AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, Overrides: []Override{ { Group: "", Config: Config{ APIKey: "override-key", APISecret: "override-secret", From: "Override", To: []string{"+9876543210"}, }, }, }, } if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } } func TestVonageAlertProvider_IsNotValidWithDuplicateOverrideGroup(t *testing.T) { invalidProvider := AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, Overrides: []Override{ { Group: "test-group", Config: Config{ APIKey: "override-key1", APISecret: "override-secret1", From: "Override1", To: []string{"+9876543210"}, }, }, { Group: "test-group", Config: Config{ APIKey: "override-key2", APISecret: "override-secret2", From: "Override2", To: []string{"+1234567890"}, }, }, }, } if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } } func TestVonageAlertProvider_IsValidWithInvalidFrom(t *testing.T) { invalidProvider := AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "", To: []string{"+1234567890"}, }, } if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have been valid") } } func TestVonageAlertProvider_IsValidWithInvalidTo(t *testing.T) { invalidProvider := AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{}, }, } if err := invalidProvider.Validate(); err == nil { t.Error("provider shouldn't have 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{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, }, 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: io.NopCloser(strings.NewReader(`{"message-count":"1","messages":[{"to":"+1234567890","message-id":"test-id","status":"0","remaining-balance":"10.50","message-price":"0.10","network":"12345"}]}`)), } }), ExpectedError: false, }, { Name: "triggered-error-status-code", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, }, 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: "triggered-error-vonage-response", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, }, 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: io.NopCloser(strings.NewReader(`{"message-count":"1","messages":[{"to":"+1234567890","message-id":"","status":"2","error-text":"Missing from param"}]}`)), } }), ExpectedError: true, }, { Name: "resolved", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, }, 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: io.NopCloser(strings.NewReader(`{"message-count":"1","messages":[{"to":"+1234567890","message-id":"test-id","status":"0","remaining-balance":"10.40","message-price":"0.10","network":"12345"}]}`)), } }), ExpectedError: false, }, { Name: "multiple-recipients", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890", "+0987654321"}, }, }, 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: io.NopCloser(strings.NewReader(`{"message-count":"1","messages":[{"to":"+1234567890","message-id":"test-id","status":"0","remaining-balance":"10.30","message-price":"0.10","network":"12345"}]}`)), } }), ExpectedError: false, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { client.InjectHTTPClient(&http.Client{Transport: scenario.MockRoundTripper}) err := scenario.Provider.Send( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.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_buildMessage(t *testing.T) { firstDescription := "description-1" secondDescription := "description-2" scenarios := []struct { Name string Provider AlertProvider Alert alert.Alert Resolved bool ExpectedMessage string }{ { Name: "triggered", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, }, Alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: false, ExpectedMessage: "TRIGGERED: endpoint-name - description-1", }, { Name: "resolved", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, }, Alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, Resolved: true, ExpectedMessage: "RESOLVED: endpoint-name - description-2", }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { message := scenario.Provider.buildMessage( &scenario.Provider.DefaultConfig, &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.Alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: scenario.Resolved}, {Condition: "[STATUS] == 200", Success: scenario.Resolved}, }, }, scenario.Resolved, ) if message != scenario.ExpectedMessage { t.Errorf("expected %s, got %s", scenario.ExpectedMessage, message) } }) } } 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_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-override-should-default", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, }, { Name: "provider-with-group-override", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, Overrides: []Override{ { Group: "test-group", Config: Config{ APIKey: "group-override-key", APISecret: "group-override-secret", From: "GroupOverride", To: []string{"+9876543210"}, }, }, }, }, InputGroup: "test-group", InputAlert: alert.Alert{}, ExpectedOutput: Config{ APIKey: "group-override-key", APISecret: "group-override-secret", From: "GroupOverride", To: []string{"+9876543210"}, }, }, { Name: "provider-with-group-override-partial", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, Overrides: []Override{ { Group: "test-group", Config: Config{ To: []string{"+9876543210"}, }, }, }, }, InputGroup: "test-group", InputAlert: alert.Alert{}, ExpectedOutput: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+9876543210"}, }, }, { Name: "provider-with-alert-override", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, }, InputGroup: "", InputAlert: alert.Alert{ProviderOverride: map[string]any{ "api-key": "override-key", "api-secret": "override-secret", "from": "Override", "to": []string{"+9876543210"}, }}, ExpectedOutput: Config{ APIKey: "override-key", APISecret: "override-secret", From: "Override", To: []string{"+9876543210"}, }, }, { Name: "provider-with-both-group-and-alert-override", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, Overrides: []Override{ { Group: "test-group", Config: Config{ APIKey: "group-override-key", From: "GroupOverride", }, }, }, }, InputGroup: "test-group", InputAlert: alert.Alert{ProviderOverride: map[string]any{ "api-secret": "alert-override-secret", "to": []string{"+9876543210"}, }}, ExpectedOutput: Config{ APIKey: "group-override-key", APISecret: "alert-override-secret", From: "GroupOverride", To: []string{"+9876543210"}, }, }, { Name: "provider-with-group-override-no-match", Provider: AlertProvider{ DefaultConfig: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, Overrides: []Override{ { Group: "different-group", Config: Config{ APIKey: "group-override-key", }, }, }, }, InputGroup: "test-group", InputAlert: alert.Alert{}, ExpectedOutput: Config{ APIKey: "test-key", APISecret: "test-secret", From: "Gatus", To: []string{"+1234567890"}, }, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Error("expected no error, got:", err.Error()) } if got.APIKey != scenario.ExpectedOutput.APIKey { t.Errorf("expected APIKey to be %s, got %s", scenario.ExpectedOutput.APIKey, got.APIKey) } if got.APISecret != scenario.ExpectedOutput.APISecret { t.Errorf("expected APISecret to be %s, got %s", scenario.ExpectedOutput.APISecret, got.APISecret) } if got.From != scenario.ExpectedOutput.From { t.Errorf("expected From to be %s, got %s", scenario.ExpectedOutput.From, got.From) } if len(got.To) != len(scenario.ExpectedOutput.To) { t.Errorf("expected To to have length %d, got %d", len(scenario.ExpectedOutput.To), len(got.To)) } else { for i, to := range got.To { if to != scenario.ExpectedOutput.To[i] { t.Errorf("expected To[%d] to be %s, got %s", i, scenario.ExpectedOutput.To[i], to) } } } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: alerting/provider/webex/webex.go ================================================ package webex import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrWebhookURLNotSet = errors.New("webhook-url not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { WebhookURL string `yaml:"webhook-url"` // Webex Teams webhook URL } func (cfg *Config) Validate() error { if len(cfg.WebhookURL) == 0 { return ErrWebhookURLNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.WebhookURL) > 0 { cfg.WebhookURL = override.WebhookURL } } // AlertProvider is the configuration necessary for sending an alert using Webex type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } body, err := provider.buildRequestBody(ep, alert, result, resolved) if err != nil { return err } buffer := bytes.NewBuffer(body) request, err := http.NewRequest(http.MethodPost, cfg.WebhookURL, 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 } defer response.Body.Close() if response.StatusCode >= 400 { body, _ := io.ReadAll(response.Body) return fmt.Errorf("call to webex alert returned status code %d: %s", response.StatusCode, string(body)) } return nil } type Body struct { RoomID string `json:"roomId,omitempty"` Text string `json:"text,omitempty"` Markdown string `json:"markdown"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) ([]byte, error) { var message string if resolved { message = fmt.Sprintf("✅ **RESOLVED**: %s\n\nAlert has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) } else { message = fmt.Sprintf("🚨 **ALERT**: %s\n\nEndpoint has failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) } if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { message += fmt.Sprintf("\n\n**Description**: %s", alertDescription) } if len(result.ConditionResults) > 0 { message += "\n\n**Condition Results:**" for _, conditionResult := range result.ConditionResults { var status string if conditionResult.Success { status = "✅" } else { status = "❌" } message += fmt.Sprintf("\n- %s `%s`", status, conditionResult.Condition) } } body := Body{ Markdown: message, } bodyAsJSON, err := json.Marshal(body) if err != nil { return nil, err } return bodyAsJSON, nil } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/webex/webex_test.go ================================================ package webex import ( "encoding/json" "net/http" "strings" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected error }{ { name: "valid", provider: AlertProvider{DefaultConfig: Config{WebhookURL: "https://webexapis.com/v1/webhooks/incoming/123"}}, expected: nil, }, { name: "invalid-webhook-url", provider: AlertProvider{DefaultConfig: Config{}}, expected: ErrWebhookURLNotSet, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { err := scenario.provider.Validate() if err != scenario.expected { t.Errorf("expected %v, got %v", scenario.expected, err) } }) } } 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{DefaultConfig: Config{WebhookURL: "https://webexapis.com/v1/webhooks/incoming/123"}}, alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: false, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) if body["markdown"] == nil { t.Error("expected 'markdown' field in request body") } markdown := body["markdown"].(string) if !strings.Contains(markdown, "ALERT") { t.Errorf("expected markdown to contain 'ALERT', got %s", markdown) } if !strings.Contains(markdown, "failed 3 time(s)") { t.Errorf("expected markdown to contain failure count, got %s", markdown) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "resolved", provider: AlertProvider{DefaultConfig: Config{WebhookURL: "https://webexapis.com/v1/webhooks/incoming/123"}}, alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: true, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) markdown := body["markdown"].(string) if !strings.Contains(markdown, "RESOLVED") { t.Errorf("expected markdown to contain 'RESOLVED', got %s", markdown) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "error-response", provider: AlertProvider{DefaultConfig: Config{WebhookURL: "https://webexapis.com/v1/webhooks/incoming/123"}}, 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.StatusUnauthorized, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.alert, &endpoint.Result{ ConditionResults: []*endpoint.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_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") } } ================================================ FILE: alerting/provider/zapier/zapier.go ================================================ package zapier import ( "bytes" "encoding/json" "errors" "fmt" "io" "net/http" "time" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrWebhookURLNotSet = errors.New("webhook-url not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { WebhookURL string `yaml:"webhook-url"` // Zapier webhook URL } func (cfg *Config) Validate() error { if len(cfg.WebhookURL) == 0 { return ErrWebhookURLNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.WebhookURL) > 0 { cfg.WebhookURL = override.WebhookURL } } // AlertProvider is the configuration necessary for sending an alert using Zapier type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } body, err := provider.buildRequestBody(ep, alert, result, resolved) if err != nil { return err } buffer := bytes.NewBuffer(body) request, err := http.NewRequest(http.MethodPost, cfg.WebhookURL, 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 } defer response.Body.Close() if response.StatusCode >= 400 { body, _ := io.ReadAll(response.Body) return fmt.Errorf("call to zapier alert returned status code %d: %s", response.StatusCode, string(body)) } return nil } type Body struct { AlertType string `json:"alert_type"` Status string `json:"status"` Endpoint string `json:"endpoint"` Group string `json:"group,omitempty"` Message string `json:"message"` Description string `json:"description,omitempty"` Timestamp string `json:"timestamp"` SuccessThreshold int `json:"success_threshold,omitempty"` FailureThreshold int `json:"failure_threshold,omitempty"` ConditionResults []*endpoint.ConditionResult `json:"condition_results,omitempty"` TotalConditions int `json:"total_conditions"` PassedConditions int `json:"passed_conditions"` FailedConditions int `json:"failed_conditions"` } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) ([]byte, error) { var alertType, status, message string var successThreshold, failureThreshold int if resolved { alertType = "resolved" status = "ok" message = fmt.Sprintf("Alert for %s has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) successThreshold = alert.SuccessThreshold } else { alertType = "triggered" status = "critical" message = fmt.Sprintf("Alert for %s has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) failureThreshold = alert.FailureThreshold } // Process condition results passedConditions := 0 failedConditions := 0 for _, cr := range result.ConditionResults { if cr.Success { passedConditions++ } else { failedConditions++ } } body := Body{ AlertType: alertType, Status: status, Endpoint: ep.DisplayName(), Group: ep.Group, Message: message, Description: alert.GetDescription(), Timestamp: time.Now().Format(time.RFC3339), SuccessThreshold: successThreshold, FailureThreshold: failureThreshold, ConditionResults: result.ConditionResults, TotalConditions: len(result.ConditionResults), PassedConditions: passedConditions, FailedConditions: failedConditions, } bodyAsJSON, err := json.Marshal(body) if err != nil { return nil, err } return bodyAsJSON, nil } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/zapier/zapier_test.go ================================================ package zapier import ( "encoding/json" "net/http" "strings" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { name string provider AlertProvider expected error }{ { name: "valid", provider: AlertProvider{DefaultConfig: Config{WebhookURL: "https://hooks.zapier.com/hooks/catch/123456/abcdef/"}}, expected: nil, }, { name: "invalid-webhook-url", provider: AlertProvider{DefaultConfig: Config{}}, expected: ErrWebhookURLNotSet, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { err := scenario.provider.Validate() if err != scenario.expected { t.Errorf("expected %v, got %v", scenario.expected, err) } }) } } 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{DefaultConfig: Config{WebhookURL: "https://hooks.zapier.com/hooks/catch/123456/abcdef/"}}, alert: alert.Alert{Description: &firstDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: false, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { if r.Host != "hooks.zapier.com" { t.Errorf("expected host hooks.zapier.com, got %s", r.Host) } if r.URL.Path != "/hooks/catch/123456/abcdef/" { t.Errorf("expected path /hooks/catch/123456/abcdef/, got %s", r.URL.Path) } body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) if body["alert_type"] != "triggered" { t.Errorf("expected alert_type to be 'triggered', got %v", body["alert_type"]) } if body["status"] != "critical" { t.Errorf("expected status to be 'critical', got %v", body["status"]) } if body["endpoint"] != "endpoint-name" { t.Errorf("expected endpoint to be 'endpoint-name', got %v", body["endpoint"]) } message := body["message"].(string) if !strings.Contains(message, "Alert") { t.Errorf("expected message to contain 'Alert', got %s", message) } if !strings.Contains(message, "failed 3 time(s)") { t.Errorf("expected message to contain failure count, got %s", message) } if body["description"] != firstDescription { t.Errorf("expected description to be '%s', got %v", firstDescription, body["description"]) } conditionResults := body["condition_results"].([]interface{}) if len(conditionResults) != 2 { t.Errorf("expected 2 condition results, got %d", len(conditionResults)) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "resolved", provider: AlertProvider{DefaultConfig: Config{WebhookURL: "https://hooks.zapier.com/hooks/catch/123456/abcdef/"}}, alert: alert.Alert{Description: &secondDescription, SuccessThreshold: 5, FailureThreshold: 3}, resolved: true, mockRoundTripper: test.MockRoundTripper(func(r *http.Request) *http.Response { body := make(map[string]interface{}) json.NewDecoder(r.Body).Decode(&body) if body["alert_type"] != "resolved" { t.Errorf("expected alert_type to be 'resolved', got %v", body["alert_type"]) } if body["status"] != "ok" { t.Errorf("expected status to be 'ok', got %v", body["status"]) } message := body["message"].(string) if !strings.Contains(message, "resolved") { t.Errorf("expected message to contain 'resolved', got %s", message) } if body["description"] != secondDescription { t.Errorf("expected description to be '%s', got %v", secondDescription, body["description"]) } return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody} }), expectedError: false, }, { name: "error-response", provider: AlertProvider{DefaultConfig: Config{WebhookURL: "https://hooks.zapier.com/hooks/catch/123456/abcdef/"}}, 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.StatusUnauthorized, 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( &endpoint.Endpoint{Name: "endpoint-name"}, &scenario.alert, &endpoint.Result{ ConditionResults: []*endpoint.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_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") } } ================================================ FILE: alerting/provider/zulip/zulip.go ================================================ package zulip import ( "bytes" "errors" "fmt" "io" "net/http" "net/url" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "gopkg.in/yaml.v3" ) var ( ErrBotEmailNotSet = errors.New("bot-email not set") ErrBotAPIKeyNotSet = errors.New("bot-api-key not set") ErrDomainNotSet = errors.New("domain not set") ErrChannelIDNotSet = errors.New("channel-id not set") ErrDuplicateGroupOverride = errors.New("duplicate group override") ) type Config struct { BotEmail string `yaml:"bot-email"` // Email of the bot user BotAPIKey string `yaml:"bot-api-key"` // API key of the bot user Domain string `yaml:"domain"` // Domain of the Zulip server ChannelID string `yaml:"channel-id"` // ID of the channel to send the message to } func (cfg *Config) Validate() error { if len(cfg.BotEmail) == 0 { return ErrBotEmailNotSet } if len(cfg.BotAPIKey) == 0 { return ErrBotAPIKeyNotSet } if len(cfg.Domain) == 0 { return ErrDomainNotSet } if len(cfg.ChannelID) == 0 { return ErrChannelIDNotSet } return nil } func (cfg *Config) Merge(override *Config) { if len(override.BotEmail) > 0 { cfg.BotEmail = override.BotEmail } if len(override.BotAPIKey) > 0 { cfg.BotAPIKey = override.BotAPIKey } if len(override.Domain) > 0 { cfg.Domain = override.Domain } if len(override.ChannelID) > 0 { cfg.ChannelID = override.ChannelID } } // AlertProvider is the configuration necessary for sending an alert using Zulip type AlertProvider struct { DefaultConfig Config `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"` Config `yaml:",inline"` } // Validate the provider's configuration func (provider *AlertProvider) Validate() error { registeredGroups := make(map[string]bool) if provider.Overrides != nil { for _, override := range provider.Overrides { if isAlreadyRegistered := registeredGroups[override.Group]; isAlreadyRegistered || override.Group == "" { return ErrDuplicateGroupOverride } registeredGroups[override.Group] = true } } return provider.DefaultConfig.Validate() } // Send an alert using the provider func (provider *AlertProvider) Send(ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) error { cfg, err := provider.GetConfig(ep.Group, alert) if err != nil { return err } buffer := bytes.NewBufferString(provider.buildRequestBody(cfg, ep, alert, result, resolved)) zulipEndpoint := fmt.Sprintf("https://%s/api/v1/messages", cfg.Domain) request, err := http.NewRequest(http.MethodPost, zulipEndpoint, buffer) if err != nil { return err } request.SetBasicAuth(cfg.BotEmail, cfg.BotAPIKey) request.Header.Set("Content-Type", "application/x-www-form-urlencoded") request.Header.Set("User-Agent", "Gatus") response, err := client.GetHTTPClient(nil).Do(request) if err != nil { return err } defer response.Body.Close() 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 nil } // buildRequestBody builds the request body for the provider func (provider *AlertProvider) buildRequestBody(cfg *Config, ep *endpoint.Endpoint, alert *alert.Alert, result *endpoint.Result, resolved bool) string { var message string if resolved { message = fmt.Sprintf("An alert for **%s** has been resolved after passing successfully %d time(s) in a row", ep.DisplayName(), alert.SuccessThreshold) } else { message = fmt.Sprintf("An alert for **%s** has been triggered due to having failed %d time(s) in a row", ep.DisplayName(), alert.FailureThreshold) } if alertDescription := alert.GetDescription(); len(alertDescription) > 0 { message += "\n> " + alertDescription + "\n" } for _, conditionResult := range result.ConditionResults { var prefix string if conditionResult.Success { prefix = ":check:" } else { prefix = ":cross_mark:" } message += fmt.Sprintf("\n%s - `%s`", prefix, conditionResult.Condition) } return url.Values{ "type": {"channel"}, "to": {cfg.ChannelID}, "topic": {"Gatus"}, "content": {message}, }.Encode() } // GetDefaultAlert returns the provider's default alert configuration func (provider *AlertProvider) GetDefaultAlert() *alert.Alert { return provider.DefaultAlert } // GetConfig returns the configuration for the provider with the overrides applied func (provider *AlertProvider) GetConfig(group string, alert *alert.Alert) (*Config, error) { cfg := provider.DefaultConfig // Handle group overrides if provider.Overrides != nil { for _, override := range provider.Overrides { if group == override.Group { cfg.Merge(&override.Config) break } } } // Handle alert overrides if len(alert.ProviderOverride) != 0 { overrideConfig := Config{} if err := yaml.Unmarshal(alert.ProviderOverrideAsBytes(), &overrideConfig); err != nil { return nil, err } cfg.Merge(&overrideConfig) } // Validate the configuration err := cfg.Validate() return &cfg, err } // ValidateOverrides validates the alert's provider override and, if present, the group override func (provider *AlertProvider) ValidateOverrides(group string, alert *alert.Alert) error { _, err := provider.GetConfig(group, alert) return err } ================================================ FILE: alerting/provider/zulip/zulip_test.go ================================================ package zulip import ( "errors" "fmt" "net/http" "net/url" "testing" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/test" ) func TestAlertProvider_Validate(t *testing.T) { scenarios := []struct { Name string AlertProvider AlertProvider ExpectedError error }{ { Name: "Empty provider", AlertProvider: AlertProvider{}, ExpectedError: ErrBotEmailNotSet, }, { Name: "Empty channel id", AlertProvider: AlertProvider{ DefaultConfig: Config{ BotEmail: "something", BotAPIKey: "something", Domain: "something", }, }, ExpectedError: ErrChannelIDNotSet, }, { Name: "Empty domain", AlertProvider: AlertProvider{ DefaultConfig: Config{ BotEmail: "something", BotAPIKey: "something", ChannelID: "something", }, }, ExpectedError: ErrDomainNotSet, }, { Name: "Empty bot api key", AlertProvider: AlertProvider{ DefaultConfig: Config{ BotEmail: "something", Domain: "something", ChannelID: "something", }, }, ExpectedError: ErrBotAPIKeyNotSet, }, { Name: "Empty bot email", AlertProvider: AlertProvider{ DefaultConfig: Config{ BotAPIKey: "something", Domain: "something", ChannelID: "something", }, }, ExpectedError: ErrBotEmailNotSet, }, { Name: "Valid provider", AlertProvider: AlertProvider{ DefaultConfig: Config{ BotEmail: "something", BotAPIKey: "something", Domain: "something", ChannelID: "something", }, }, ExpectedError: nil, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { if err := scenario.AlertProvider.Validate(); !errors.Is(err, scenario.ExpectedError) { t.Errorf("ExpectedError error %v, got %v", scenario.ExpectedError, err) } }) } } func TestAlertProvider_buildRequestBody(t *testing.T) { basicConfig := Config{ BotEmail: "bot-email", BotAPIKey: "bot-api-key", Domain: "domain", ChannelID: "channel-id", } alertDesc := "Description" basicAlert := alert.Alert{ SuccessThreshold: 2, FailureThreshold: 3, Description: &alertDesc, } testCases := []struct { name string provider AlertProvider alert alert.Alert resolved bool hasConditions bool expectedBody url.Values }{ { name: "Resolved alert with no conditions", provider: AlertProvider{ DefaultConfig: basicConfig, }, alert: basicAlert, resolved: true, hasConditions: false, expectedBody: url.Values{ "content": {`An alert for **endpoint-Name** has been resolved after passing successfully 2 time(s) in a row > Description `}, "to": {"channel-id"}, "topic": {"Gatus"}, "type": {"channel"}, }, }, { name: "Resolved alert with conditions", provider: AlertProvider{ DefaultConfig: basicConfig, }, alert: basicAlert, resolved: true, hasConditions: true, expectedBody: url.Values{ "content": {`An alert for **endpoint-Name** has been resolved after passing successfully 2 time(s) in a row > Description :check: - ` + "`[CONNECTED] == true`" + ` :check: - ` + "`[STATUS] == 200`" + ` :check: - ` + "`[BODY] != \"\"`"}, "to": {"channel-id"}, "topic": {"Gatus"}, "type": {"channel"}, }, }, { name: "Failed alert with no conditions", provider: AlertProvider{ DefaultConfig: basicConfig, }, alert: basicAlert, resolved: false, hasConditions: false, expectedBody: url.Values{ "content": {`An alert for **endpoint-Name** has been triggered due to having failed 3 time(s) in a row > Description `}, "to": {"channel-id"}, "topic": {"Gatus"}, "type": {"channel"}, }, }, { name: "Failed alert with conditions", provider: AlertProvider{ DefaultConfig: basicConfig, }, alert: basicAlert, resolved: false, hasConditions: true, expectedBody: url.Values{ "content": {`An alert for **endpoint-Name** has been triggered due to having failed 3 time(s) in a row > Description :cross_mark: - ` + "`[CONNECTED] == true`" + ` :cross_mark: - ` + "`[STATUS] == 200`" + ` :cross_mark: - ` + "`[BODY] != \"\"`"}, "to": {"channel-id"}, "topic": {"Gatus"}, "type": {"channel"}, }, }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { var conditionResults []*endpoint.ConditionResult if tc.hasConditions { conditionResults = []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: tc.resolved}, {Condition: "[STATUS] == 200", Success: tc.resolved}, {Condition: "[BODY] != \"\"", Success: tc.resolved}, } } body := tc.provider.buildRequestBody( &tc.provider.DefaultConfig, &endpoint.Endpoint{Name: "endpoint-Name"}, &tc.alert, &endpoint.Result{ ConditionResults: conditionResults, }, tc.resolved, ) valuesResult, err := url.ParseQuery(body) if err != nil { t.Error(err) } if fmt.Sprintf("%v", valuesResult) != fmt.Sprintf("%v", tc.expectedBody) { t.Errorf("Expected body:\n%v\ngot:\n%v", tc.expectedBody, valuesResult) } }) } } func TestAlertProvider_GetDefaultAlert(t *testing.T) { if (&AlertProvider{DefaultAlert: &alert.Alert{}}).GetDefaultAlert() == nil { t.Error("ExpectedError default alert to be not nil") } if (&AlertProvider{DefaultAlert: nil}).GetDefaultAlert() != nil { t.Error("ExpectedError default alert to be nil") } } func TestAlertProvider_Send(t *testing.T) { defer client.InjectHTTPClient(nil) validateRequest := func(req *http.Request) { if req.URL.String() != "https://custom-domain/api/v1/messages" { t.Errorf("ExpectedError url https://custom-domain.zulipchat.com/api/v1/messages, got %s", req.URL.String()) } if req.Method != http.MethodPost { t.Errorf("ExpectedError POST request, got %s", req.Method) } if req.Header.Get("Content-Type") != "application/x-www-form-urlencoded" { t.Errorf("ExpectedError Content-Type header to be application/x-www-form-urlencoded, got %s", req.Header.Get("Content-Type")) } if req.Header.Get("User-Agent") != "Gatus" { t.Errorf("ExpectedError User-Agent header to be Gatus, got %s", req.Header.Get("User-Agent")) } } basicConfig := Config{ BotEmail: "bot-email", BotAPIKey: "bot-api-key", Domain: "custom-domain", ChannelID: "channel-id", } basicAlert := alert.Alert{ SuccessThreshold: 2, FailureThreshold: 3, } testCases := []struct { name string provider AlertProvider alert alert.Alert resolved bool mockRoundTripper test.MockRoundTripper expectedError bool }{ { name: "resolved", provider: AlertProvider{ DefaultConfig: basicConfig, }, alert: basicAlert, resolved: true, mockRoundTripper: test.MockRoundTripper(func(req *http.Request) *http.Response { validateRequest(req) return &http.Response{StatusCode: http.StatusOK} }), expectedError: false, }, { name: "resolved error", provider: AlertProvider{ DefaultConfig: basicConfig, }, alert: basicAlert, resolved: true, mockRoundTripper: test.MockRoundTripper(func(req *http.Request) *http.Response { validateRequest(req) return &http.Response{StatusCode: http.StatusInternalServerError} }), expectedError: true, }, { name: "triggered", provider: AlertProvider{ DefaultConfig: basicConfig, }, alert: basicAlert, resolved: false, mockRoundTripper: test.MockRoundTripper(func(req *http.Request) *http.Response { validateRequest(req) return &http.Response{StatusCode: http.StatusOK} }), expectedError: false, }, { name: "triggered error", provider: AlertProvider{ DefaultConfig: basicConfig, }, alert: basicAlert, resolved: false, mockRoundTripper: test.MockRoundTripper(func(req *http.Request) *http.Response { validateRequest(req) return &http.Response{StatusCode: http.StatusInternalServerError} }), expectedError: true, }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { client.InjectHTTPClient(&http.Client{Transport: tc.mockRoundTripper}) err := tc.provider.Send( &endpoint.Endpoint{Name: "endpoint-Name"}, &tc.alert, &endpoint.Result{ ConditionResults: []*endpoint.ConditionResult{ {Condition: "[CONNECTED] == true", Success: tc.resolved}, {Condition: "[STATUS] == 200", Success: tc.resolved}, }, }, tc.resolved, ) if tc.expectedError && err == nil { t.Error("ExpectedError error, got none") } if !tc.expectedError && err != nil { t.Errorf("ExpectedError no error, got: %v", err) } }) } } func TestAlertProvider_GetConfig(t *testing.T) { scenarios := []struct { Name string Provider AlertProvider InputGroup string InputAlert alert.Alert ExpectedOutput Config }{ { Name: "provider-no-overrides", Provider: AlertProvider{ DefaultConfig: Config{ BotEmail: "default-bot-email", BotAPIKey: "default-bot-api-key", Domain: "default-domain", ChannelID: "default-channel-id", }, Overrides: nil, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{ BotEmail: "default-bot-email", BotAPIKey: "default-bot-api-key", Domain: "default-domain", ChannelID: "default-channel-id", }, }, { Name: "provider-with-override-specify-no-group-should-default", Provider: AlertProvider{ DefaultConfig: Config{ BotEmail: "default-bot-email", BotAPIKey: "default-bot-api-key", Domain: "default-domain", ChannelID: "default-channel-id", }, Overrides: []Override{ { Group: "group", Config: Config{ChannelID: "group-channel-id"}, }, }, }, InputGroup: "", InputAlert: alert.Alert{}, ExpectedOutput: Config{ BotEmail: "default-bot-email", BotAPIKey: "default-bot-api-key", Domain: "default-domain", ChannelID: "default-channel-id", }, }, { Name: "provider-with-override-specify-group-should-override", Provider: AlertProvider{ DefaultConfig: Config{ BotEmail: "default-bot-email", BotAPIKey: "default-bot-api-key", Domain: "default-domain", ChannelID: "default-channel-id", }, Overrides: []Override{ { Group: "group", Config: Config{ BotEmail: "group-bot-email", BotAPIKey: "group-bot-api-key", Domain: "group-domain", ChannelID: "group-channel-id", }, }, }, }, InputGroup: "group", InputAlert: alert.Alert{}, ExpectedOutput: Config{ BotEmail: "group-bot-email", BotAPIKey: "group-bot-api-key", Domain: "group-domain", ChannelID: "group-channel-id", }, }, { Name: "provider-with-group-override-and-alert-override--alert-override-should-take-precedence", Provider: AlertProvider{ DefaultConfig: Config{ BotEmail: "default-bot-email", BotAPIKey: "default-bot-api-key", Domain: "default-domain", ChannelID: "default-channel-id", }, Overrides: []Override{ { Group: "group", Config: Config{ BotEmail: "group-bot-email", BotAPIKey: "group-bot-api-key", Domain: "group-domain", ChannelID: "group-channel-id", }, }, }, }, InputGroup: "group", InputAlert: alert.Alert{ProviderOverride: map[string]any{ "bot-email": "alert-bot-email", "bot-api-key": "alert-bot-api-key", "domain": "alert-domain", "channel-id": "alert-channel-id", }}, ExpectedOutput: Config{ BotEmail: "alert-bot-email", BotAPIKey: "alert-bot-api-key", Domain: "alert-domain", ChannelID: "alert-channel-id", }, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { got, err := scenario.Provider.GetConfig(scenario.InputGroup, &scenario.InputAlert) if err != nil { t.Fatalf("unexpected error: %s", err) } if got.BotEmail != scenario.ExpectedOutput.BotEmail { t.Errorf("expected %s, got %s", scenario.ExpectedOutput.BotEmail, got.BotEmail) } if got.BotAPIKey != scenario.ExpectedOutput.BotAPIKey { t.Errorf("expected %s, got %s", scenario.ExpectedOutput.BotAPIKey, got.BotAPIKey) } if got.Domain != scenario.ExpectedOutput.Domain { t.Errorf("expected %s, got %s", scenario.ExpectedOutput.Domain, got.Domain) } if got.ChannelID != scenario.ExpectedOutput.ChannelID { t.Errorf("expected %s, got %s", scenario.ExpectedOutput.ChannelID, got.ChannelID) } // Test ValidateOverrides as well, since it really just calls GetConfig if err = scenario.Provider.ValidateOverrides(scenario.InputGroup, &scenario.InputAlert); err != nil { t.Errorf("unexpected error: %s", err) } }) } } ================================================ FILE: api/api.go ================================================ package api import ( "io/fs" "net/http" "os" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/ui" "github.com/TwiN/gatus/v5/config/web" static "github.com/TwiN/gatus/v5/web" "github.com/TwiN/health" "github.com/TwiN/logr" fiber "github.com/gofiber/fiber/v2" "github.com/gofiber/fiber/v2/middleware/adaptor" "github.com/gofiber/fiber/v2/middleware/compress" "github.com/gofiber/fiber/v2/middleware/cors" fiberfs "github.com/gofiber/fiber/v2/middleware/filesystem" "github.com/gofiber/fiber/v2/middleware/recover" "github.com/gofiber/fiber/v2/middleware/redirect" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promhttp" ) type API struct { router *fiber.App } func New(cfg *config.Config) *API { api := &API{} if cfg.Web == nil { logr.Warnf("[api.New] nil web config passed as parameter. This should only happen in tests. Using default web configuration") cfg.Web = web.GetDefaultConfig() } if cfg.UI == nil { logr.Warnf("[api.New] nil ui config passed as parameter. This should only happen in tests. Using default ui configuration") cfg.UI = ui.GetDefaultConfig() } api.router = api.createRouter(cfg) return api } func (a *API) Router() *fiber.App { return a.router } func (a *API) createRouter(cfg *config.Config) *fiber.App { app := fiber.New(fiber.Config{ ErrorHandler: func(c *fiber.Ctx, err error) error { logr.Errorf("[api.ErrorHandler] %s", err.Error()) return fiber.DefaultErrorHandler(c, err) }, ReadBufferSize: cfg.Web.ReadBufferSize, Network: fiber.NetworkTCP, Immutable: true, // If not enabled, will cause issues due to fiber's zero allocation. See #1268 and https://docs.gofiber.io/#zero-allocation }) if os.Getenv("ENVIRONMENT") == "dev" { app.Use(cors.New(cors.Config{ AllowOrigins: "http://localhost:8081", AllowCredentials: true, })) } // Middlewares app.Use(recover.New()) app.Use(compress.New()) // Define metrics handler, if necessary if cfg.Metrics { metricsHandler := promhttp.InstrumentMetricHandler(prometheus.DefaultRegisterer, promhttp.HandlerFor(prometheus.DefaultGatherer, promhttp.HandlerOpts{ DisableCompression: true, })) app.Get("/metrics", adaptor.HTTPHandler(metricsHandler)) } // Define main router apiRouter := app.Group("/api") //////////////////////// // UNPROTECTED ROUTES // //////////////////////// unprotectedAPIRouter := apiRouter.Group("/") unprotectedAPIRouter.Get("/v1/config", ConfigHandler{securityConfig: cfg.Security, config: cfg}.GetConfig) unprotectedAPIRouter.Get("/v1/endpoints/:key/health/badge.svg", HealthBadge) unprotectedAPIRouter.Get("/v1/endpoints/:key/health/badge.shields", HealthBadgeShields) unprotectedAPIRouter.Get("/v1/endpoints/:key/uptimes/:duration", UptimeRaw) unprotectedAPIRouter.Get("/v1/endpoints/:key/uptimes/:duration/badge.svg", UptimeBadge) unprotectedAPIRouter.Get("/v1/endpoints/:key/response-times/:duration", ResponseTimeRaw) unprotectedAPIRouter.Get("/v1/endpoints/:key/response-times/:duration/badge.svg", ResponseTimeBadge(cfg)) unprotectedAPIRouter.Get("/v1/endpoints/:key/response-times/:duration/chart.svg", ResponseTimeChart) unprotectedAPIRouter.Get("/v1/endpoints/:key/response-times/:duration/history", ResponseTimeHistory) // This endpoint requires authz with bearer token, so technically it is protected unprotectedAPIRouter.Post("/v1/endpoints/:key/external", CreateExternalEndpointResult(cfg)) // SPA app.Get("/", SinglePageApplication(cfg.UI)) app.Get("/endpoints/:key", SinglePageApplication(cfg.UI)) app.Get("/suites/:key", SinglePageApplication(cfg.UI)) // Health endpoint healthHandler := health.Handler().WithJSON(true) app.Get("/health", func(c *fiber.Ctx) error { statusCode, body := healthHandler.GetResponseStatusCodeAndBody() return c.Status(statusCode).Send(body) }) // Custom CSS app.Get("/css/custom.css", CustomCSSHandler{customCSS: cfg.UI.CustomCSS}.GetCustomCSS) // Everything else falls back on static content app.Use(redirect.New(redirect.Config{ Rules: map[string]string{ "/index.html": "/", }, StatusCode: 301, })) staticFileSystem, err := fs.Sub(static.FileSystem, static.RootPath) if err != nil { panic(err) } app.Use("/", fiberfs.New(fiberfs.Config{ Root: http.FS(staticFileSystem), Index: "index.html", Browse: true, })) ////////////////////// // PROTECTED ROUTES // ////////////////////// // ORDER IS IMPORTANT: all routes applied AFTER the security middleware will require authn protectedAPIRouter := apiRouter.Group("/") if cfg.Security != nil { if err := cfg.Security.RegisterHandlers(app); err != nil { panic(err) } if err := cfg.Security.ApplySecurityMiddleware(protectedAPIRouter); err != nil { panic(err) } } protectedAPIRouter.Get("/v1/endpoints/statuses", EndpointStatuses(cfg)) protectedAPIRouter.Get("/v1/endpoints/:key/statuses", EndpointStatus(cfg)) protectedAPIRouter.Get("/v1/suites/statuses", SuiteStatuses(cfg)) protectedAPIRouter.Get("/v1/suites/:key/statuses", SuiteStatus(cfg)) return app } ================================================ FILE: api/api_test.go ================================================ package api import ( "net/http" "net/http/httptest" "testing" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/ui" "github.com/TwiN/gatus/v5/security" "github.com/gofiber/fiber/v2" ) func TestNew(t *testing.T) { type Scenario struct { Name string Path string ExpectedCode int Gzip bool WithSecurity bool } scenarios := []Scenario{ { Name: "health", Path: "/health", ExpectedCode: fiber.StatusOK, }, { Name: "custom.css", Path: "/css/custom.css", ExpectedCode: fiber.StatusOK, }, { Name: "custom.css-gzipped", Path: "/css/custom.css", ExpectedCode: fiber.StatusOK, Gzip: true, }, { Name: "metrics", Path: "/metrics", ExpectedCode: fiber.StatusOK, }, { Name: "favicon.ico", Path: "/favicon.ico", ExpectedCode: fiber.StatusOK, }, { Name: "app.js", Path: "/js/app.js", ExpectedCode: fiber.StatusOK, }, { Name: "app.js-gzipped", Path: "/js/app.js", ExpectedCode: fiber.StatusOK, Gzip: true, }, { Name: "chunk-vendors.js", Path: "/js/chunk-vendors.js", ExpectedCode: fiber.StatusOK, }, { Name: "chunk-vendors.js-gzipped", Path: "/js/chunk-vendors.js", ExpectedCode: fiber.StatusOK, Gzip: true, }, { Name: "index", Path: "/", ExpectedCode: fiber.StatusOK, }, { Name: "index-html-redirect", Path: "/index.html", ExpectedCode: fiber.StatusMovedPermanently, }, { Name: "index-should-return-200-even-if-not-authenticated", Path: "/", ExpectedCode: fiber.StatusOK, WithSecurity: true, }, { Name: "endpoints-should-return-401-if-not-authenticated", Path: "/api/v1/endpoints/statuses", ExpectedCode: fiber.StatusUnauthorized, WithSecurity: true, }, { Name: "config-should-return-200-even-if-not-authenticated", Path: "/api/v1/config", ExpectedCode: fiber.StatusOK, WithSecurity: true, }, { Name: "config-should-always-return-200", Path: "/api/v1/config", ExpectedCode: fiber.StatusOK, WithSecurity: false, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { cfg := &config.Config{Metrics: true, UI: &ui.Config{}} if scenario.WithSecurity { cfg.Security = &security.Config{ Basic: &security.BasicConfig{ Username: "john.doe", PasswordBcryptHashBase64Encoded: "JDJhJDA4JDFoRnpPY1hnaFl1OC9ISlFsa21VS09wOGlPU1ZOTDlHZG1qeTFvb3dIckRBUnlHUmNIRWlT", }, } } api := New(cfg) router := api.Router() request := httptest.NewRequest("GET", scenario.Path, http.NoBody) if scenario.Gzip { request.Header.Set("Accept-Encoding", "gzip") } response, err := router.Test(request) if err != nil { t.Fatal(err) } if response.StatusCode != scenario.ExpectedCode { t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode) } }) } } ================================================ FILE: api/badge.go ================================================ package api import ( "encoding/json" "errors" "fmt" "net/url" "strconv" "strings" "time" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/endpoint/ui" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/storage/store/common" "github.com/TwiN/gatus/v5/storage/store/common/paging" "github.com/gofiber/fiber/v2" ) const ( badgeColorHexAwesome = "#40cc11" badgeColorHexGreat = "#94cc11" badgeColorHexGood = "#ccd311" badgeColorHexPassable = "#ccb311" badgeColorHexBad = "#cc8111" badgeColorHexVeryBad = "#c7130a" ) const ( HealthStatusUp = "up" HealthStatusDown = "down" 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 -> 30d, 7d, 24h, 1h func UptimeBadge(c *fiber.Ctx) error { duration := c.Params("duration") var from time.Time switch duration { case "30d": from = time.Now().Add(-30 * 24 * time.Hour) 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 uptime metrics are stored by hour, we have to cheat a little default: return c.Status(400).SendString("Durations supported: 30d, 7d, 24h, 1h") } key, err := url.QueryUnescape(c.Params("key")) if err != nil { return c.Status(400).SendString("invalid key encoding") } uptime, err := store.Get().GetUptimeByKey(key, from, time.Now()) if err != nil { if errors.Is(err, common.ErrEndpointNotFound) { return c.Status(404).SendString(err.Error()) } else if errors.Is(err, common.ErrInvalidTimeRange) { return c.Status(400).SendString(err.Error()) } return c.Status(500).SendString(err.Error()) } c.Set("Content-Type", "image/svg+xml") c.Set("Cache-Control", "no-cache, no-store, must-revalidate") c.Set("Expires", "0") return c.Status(200).Send(generateUptimeBadgeSVG(duration, uptime)) } // ResponseTimeBadge handles the automatic generation of badge based on the group name and endpoint name passed. // // Valid values for :duration -> 30d, 7d, 24h, 1h func ResponseTimeBadge(cfg *config.Config) fiber.Handler { return func(c *fiber.Ctx) error { duration := c.Params("duration") var from time.Time switch duration { case "30d": from = time.Now().Add(-30 * 24 * time.Hour) 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: return c.Status(400).SendString("Durations supported: 30d, 7d, 24h, 1h") } key, err := url.QueryUnescape(c.Params("key")) if err != nil { return c.Status(400).SendString("invalid key encoding") } averageResponseTime, err := store.Get().GetAverageResponseTimeByKey(key, from, time.Now()) if err != nil { if errors.Is(err, common.ErrEndpointNotFound) { return c.Status(404).SendString(err.Error()) } else if errors.Is(err, common.ErrInvalidTimeRange) { return c.Status(400).SendString(err.Error()) } return c.Status(500).SendString(err.Error()) } c.Set("Content-Type", "image/svg+xml") c.Set("Cache-Control", "no-cache, no-store, must-revalidate") c.Set("Expires", "0") return c.Status(200).Send(generateResponseTimeBadgeSVG(duration, averageResponseTime, key, cfg)) } } // HealthBadge handles the automatic generation of badge based on the group name and endpoint name passed. func HealthBadge(c *fiber.Ctx) error { key, err := url.QueryUnescape(c.Params("key")) if err != nil { return c.Status(400).SendString("invalid key encoding") } pagingConfig := paging.NewEndpointStatusParams() status, err := store.Get().GetEndpointStatusByKey(key, pagingConfig.WithResults(1, 1)) if err != nil { if errors.Is(err, common.ErrEndpointNotFound) { return c.Status(404).SendString(err.Error()) } else if errors.Is(err, common.ErrInvalidTimeRange) { return c.Status(400).SendString(err.Error()) } return c.Status(500).SendString(err.Error()) } healthStatus := HealthStatusUnknown if len(status.Results) > 0 { if status.Results[0].Success { healthStatus = HealthStatusUp } else { healthStatus = HealthStatusDown } } c.Set("Content-Type", "image/svg+xml") c.Set("Cache-Control", "no-cache, no-store, must-revalidate") c.Set("Expires", "0") return c.Status(200).Send(generateHealthBadgeSVG(healthStatus)) } func HealthBadgeShields(c *fiber.Ctx) error { key, err := url.QueryUnescape(c.Params("key")) if err != nil { return c.Status(400).SendString("invalid key encoding") } pagingConfig := paging.NewEndpointStatusParams() status, err := store.Get().GetEndpointStatusByKey(key, pagingConfig.WithResults(1, 1)) if err != nil { if errors.Is(err, common.ErrEndpointNotFound) { return c.Status(404).SendString(err.Error()) } else if errors.Is(err, common.ErrInvalidTimeRange) { return c.Status(400).SendString(err.Error()) } return c.Status(500).SendString(err.Error()) } healthStatus := HealthStatusUnknown if len(status.Results) > 0 { if status.Results[0].Success { healthStatus = HealthStatusUp } else { healthStatus = HealthStatusDown } } c.Set("Content-Type", "application/json") c.Set("Cache-Control", "no-cache, no-store, must-revalidate") c.Set("Expires", "0") jsonData, err := generateHealthBadgeShields(healthStatus) if err != nil { return c.Status(500).SendString(err.Error()) } return c.Status(200).Send(jsonData) } func generateUptimeBadgeSVG(duration string, uptime float64) []byte { var labelWidth, valueWidth, valueWidthAdjustment int switch duration { case "30d": labelWidth = 70 case "7d": labelWidth = 65 case "24h": labelWidth = 70 case "1h": labelWidth = 65 default: } color := getBadgeColorFromUptime(uptime) sanitizedValue := strings.TrimRight(strings.TrimRight(fmt.Sprintf("%.2f", uptime*100), "0"), ".") + "%" if strings.Contains(sanitizedValue, ".") { valueWidthAdjustment = -10 } valueWidth = (len(sanitizedValue) * 11) + valueWidthAdjustment width := labelWidth + valueWidth labelX := labelWidth / 2 valueX := labelWidth + (valueWidth / 2) svg := []byte(fmt.Sprintf(``, width, width, labelWidth, color, labelWidth, valueWidth, labelWidth, width, labelX, duration, labelX, duration, valueX, sanitizedValue, valueX, sanitizedValue)) return svg } func getBadgeColorFromUptime(uptime float64) string { if uptime >= 0.975 { return badgeColorHexAwesome } else if uptime >= 0.95 { return badgeColorHexGreat } else if uptime >= 0.9 { return badgeColorHexGood } else if uptime >= 0.8 { return badgeColorHexPassable } else if uptime >= 0.65 { return badgeColorHexBad } return badgeColorHexVeryBad } func generateResponseTimeBadgeSVG(duration string, averageResponseTime int, key string, cfg *config.Config) []byte { var labelWidth, valueWidth int switch duration { case "30d": labelWidth = 110 case "7d": labelWidth = 105 case "24h": labelWidth = 110 case "1h": labelWidth = 105 default: } color := getBadgeColorFromResponseTime(averageResponseTime, key, cfg) sanitizedValue := strconv.Itoa(averageResponseTime) + "ms" valueWidth = len(sanitizedValue) * 11 width := labelWidth + valueWidth labelX := labelWidth / 2 valueX := labelWidth + (valueWidth / 2) svg := []byte(fmt.Sprintf(``, width, width, labelWidth, color, labelWidth, valueWidth, labelWidth, width, labelX, duration, labelX, duration, valueX, sanitizedValue, valueX, sanitizedValue)) return svg } func getBadgeColorFromResponseTime(responseTime int, key string, cfg *config.Config) string { thresholds := ui.GetDefaultConfig().Badge.ResponseTime.Thresholds if endpoint := cfg.GetEndpointByKey(key); endpoint != nil { thresholds = endpoint.UIConfig.Badge.ResponseTime.Thresholds } // the threshold config requires 5 values, so we can be sure it's set here for i := range 5 { if responseTime <= thresholds[i] { return badgeColors[i] } } return badgeColorHexVeryBad } func generateHealthBadgeSVG(healthStatus string) []byte { var labelWidth, valueWidth int switch healthStatus { case HealthStatusUp: valueWidth = 28 case HealthStatusDown: valueWidth = 44 case HealthStatusUnknown: valueWidth = 10 default: } color := getBadgeColorFromHealth(healthStatus) labelWidth = 48 width := labelWidth + valueWidth labelX := labelWidth / 2 valueX := labelWidth + (valueWidth / 2) svg := []byte(fmt.Sprintf(``, width, width, labelWidth, color, labelWidth, valueWidth, labelWidth, width, labelX, labelX, valueX, healthStatus, valueX, healthStatus)) return svg } func generateHealthBadgeShields(healthStatus string) ([]byte, error) { color := getBadgeShieldsColorFromHealth(healthStatus) data := map[string]interface{}{ "schemaVersion": 1, "label": "gatus", "message": healthStatus, "color": color, } return json.Marshal(data) } func getBadgeColorFromHealth(healthStatus string) string { if healthStatus == HealthStatusUp { return badgeColorHexAwesome } else if healthStatus == HealthStatusDown { return badgeColorHexVeryBad } return badgeColorHexPassable } func getBadgeShieldsColorFromHealth(healthStatus string) string { if healthStatus == HealthStatusUp { return "brightgreen" } else if healthStatus == HealthStatusDown { return "red" } return "yellow" } ================================================ FILE: api/badge_test.go ================================================ package api import ( "net/http" "net/http/httptest" "strconv" "testing" "time" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/config/endpoint/ui" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/watchdog" ) func TestBadge(t *testing.T) { defer store.Get().Clear() defer cache.Clear() cfg := &config.Config{ Metrics: true, Endpoints: []*endpoint.Endpoint{ { Name: "frontend", Group: "core", }, { Name: "backend", Group: "core", }, }, } cfg.Endpoints[0].UIConfig = ui.GetDefaultConfig() cfg.Endpoints[1].UIConfig = ui.GetDefaultConfig() watchdog.UpdateEndpointStatus(cfg.Endpoints[0], &endpoint.Result{Success: true, Connected: true, Duration: time.Millisecond, Timestamp: time.Now()}) watchdog.UpdateEndpointStatus(cfg.Endpoints[1], &endpoint.Result{Success: false, Connected: false, Duration: time.Second, Timestamp: time.Now()}) api := New(cfg) router := api.Router() type Scenario struct { Name string Path string ExpectedCode int Gzip bool } scenarios := []Scenario{ { Name: "badge-uptime-1h", Path: "/api/v1/endpoints/core_frontend/uptimes/1h/badge.svg", ExpectedCode: http.StatusOK, }, { Name: "badge-uptime-24h", Path: "/api/v1/endpoints/core_backend/uptimes/24h/badge.svg", ExpectedCode: http.StatusOK, }, { Name: "badge-uptime-7d", Path: "/api/v1/endpoints/core_frontend/uptimes/7d/badge.svg", ExpectedCode: http.StatusOK, }, { Name: "badge-uptime-with-invalid-duration", Path: "/api/v1/endpoints/core_backend/uptimes/3d/badge.svg", ExpectedCode: http.StatusBadRequest, }, { Name: "badge-uptime-for-invalid-key", Path: "/api/v1/endpoints/invalid_key/uptimes/7d/badge.svg", ExpectedCode: http.StatusNotFound, }, { Name: "badge-response-time-1h", Path: "/api/v1/endpoints/core_frontend/response-times/1h/badge.svg", ExpectedCode: http.StatusOK, }, { Name: "badge-response-time-24h", Path: "/api/v1/endpoints/core_backend/response-times/24h/badge.svg", ExpectedCode: http.StatusOK, }, { Name: "badge-response-time-7d", Path: "/api/v1/endpoints/core_frontend/response-times/7d/badge.svg", ExpectedCode: http.StatusOK, }, { Name: "badge-response-time-with-invalid-duration", Path: "/api/v1/endpoints/core_backend/response-times/3d/badge.svg", ExpectedCode: http.StatusBadRequest, }, { Name: "badge-response-time-for-invalid-key", Path: "/api/v1/endpoints/invalid_key/response-times/7d/badge.svg", ExpectedCode: http.StatusNotFound, }, { Name: "badge-health-up", Path: "/api/v1/endpoints/core_frontend/health/badge.svg", ExpectedCode: http.StatusOK, }, { Name: "badge-health-down", Path: "/api/v1/endpoints/core_backend/health/badge.svg", ExpectedCode: http.StatusOK, }, { Name: "badge-health-for-invalid-key", Path: "/api/v1/endpoints/invalid_key/health/badge.svg", ExpectedCode: http.StatusNotFound, }, { Name: "badge-shields-health-up", Path: "/api/v1/endpoints/core_frontend/health/badge.shields", ExpectedCode: http.StatusOK, }, { Name: "badge-shields-health-down", Path: "/api/v1/endpoints/core_backend/health/badge.shields", ExpectedCode: http.StatusOK, }, { Name: "badge-shields-health-for-invalid-key", Path: "/api/v1/endpoints/invalid_key/health/badge.shields", ExpectedCode: http.StatusNotFound, }, { Name: "chart-response-time-24h", 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) { request := httptest.NewRequest("GET", scenario.Path, http.NoBody) if scenario.Gzip { request.Header.Set("Accept-Encoding", "gzip") } response, err := router.Test(request) if err != nil { return } if response.StatusCode != scenario.ExpectedCode { t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode) } }) } } func TestGetBadgeColorFromUptime(t *testing.T) { scenarios := []struct { Uptime float64 ExpectedColor string }{ { Uptime: 1, ExpectedColor: badgeColorHexAwesome, }, { Uptime: 0.99, ExpectedColor: badgeColorHexAwesome, }, { Uptime: 0.97, ExpectedColor: badgeColorHexGreat, }, { Uptime: 0.95, ExpectedColor: badgeColorHexGreat, }, { Uptime: 0.93, ExpectedColor: badgeColorHexGood, }, { Uptime: 0.9, ExpectedColor: badgeColorHexGood, }, { Uptime: 0.85, ExpectedColor: badgeColorHexPassable, }, { Uptime: 0.7, ExpectedColor: badgeColorHexBad, }, { Uptime: 0.65, ExpectedColor: badgeColorHexBad, }, { Uptime: 0.6, ExpectedColor: badgeColorHexVeryBad, }, } for _, scenario := range scenarios { t.Run("uptime-"+strconv.Itoa(int(scenario.Uptime*100)), func(t *testing.T) { if getBadgeColorFromUptime(scenario.Uptime) != scenario.ExpectedColor { t.Errorf("expected %s from %f, got %v", scenario.ExpectedColor, scenario.Uptime, getBadgeColorFromUptime(scenario.Uptime)) } }) } } func TestGetBadgeColorFromResponseTime(t *testing.T) { defer store.Get().Clear() defer cache.Clear() var ( firstCondition = endpoint.Condition("[STATUS] == 200") secondCondition = endpoint.Condition("[RESPONSE_TIME] < 500") thirdCondition = endpoint.Condition("[CERTIFICATE_EXPIRATION] < 72h") ) firstTestEndpoint := endpoint.Endpoint{ Name: "a", URL: "https://example.org/what/ever", Method: "GET", Body: "body", Interval: 30 * time.Second, Conditions: []endpoint.Condition{firstCondition, secondCondition, thirdCondition}, Alerts: nil, NumberOfFailuresInARow: 0, NumberOfSuccessesInARow: 0, UIConfig: ui.GetDefaultConfig(), } secondTestEndpoint := endpoint.Endpoint{ Name: "b", URL: "https://example.org/what/ever", Method: "GET", Body: "body", Interval: 30 * time.Second, Conditions: []endpoint.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: []*endpoint.Endpoint{&firstTestEndpoint, &secondTestEndpoint}, } testSuccessfulResult := endpoint.Result{ Hostname: "example.org", IP: "127.0.0.1", HTTPStatus: 200, Errors: nil, Connected: true, Success: true, Timestamp: time.Now(), Duration: 150 * time.Millisecond, CertificateExpiration: 10 * time.Hour, ConditionResults: []*endpoint.ConditionResult{ { Condition: "[STATUS] == 200", Success: true, }, { Condition: "[RESPONSE_TIME] < 500", Success: true, }, { Condition: "[CERTIFICATE_EXPIRATION] < 72h", Success: true, }, }, } store.Get().InsertEndpointResult(&firstTestEndpoint, &testSuccessfulResult) store.Get().InsertEndpointResult(&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(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)) } }) } } func TestGetBadgeColorFromHealth(t *testing.T) { scenarios := []struct { HealthStatus string ExpectedColor string }{ { HealthStatus: HealthStatusUp, ExpectedColor: badgeColorHexAwesome, }, { HealthStatus: HealthStatusDown, ExpectedColor: badgeColorHexVeryBad, }, { HealthStatus: HealthStatusUnknown, ExpectedColor: badgeColorHexPassable, }, } for _, scenario := range scenarios { t.Run("health-"+scenario.HealthStatus, func(t *testing.T) { if getBadgeColorFromHealth(scenario.HealthStatus) != scenario.ExpectedColor { t.Errorf("expected %s from %s, got %v", scenario.ExpectedColor, scenario.HealthStatus, getBadgeColorFromHealth(scenario.HealthStatus)) } }) } } ================================================ FILE: api/cache.go ================================================ package api import ( "time" "github.com/TwiN/gocache/v2" ) const ( cacheTTL = 10 * time.Second ) var ( cache = gocache.NewCache().WithMaxSize(100).WithEvictionPolicy(gocache.FirstInFirstOut) ) ================================================ FILE: api/chart.go ================================================ package api import ( "errors" "math" "net/http" "net/url" "sort" "time" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/storage/store/common" "github.com/TwiN/logr" "github.com/gofiber/fiber/v2" "github.com/wcharczuk/go-chart/v2" "github.com/wcharczuk/go-chart/v2/drawing" ) const timeFormat = "3:04PM" var ( gridStyle = chart.Style{ StrokeColor: drawing.Color{R: 119, G: 119, B: 119, A: 40}, StrokeWidth: 1.0, } axisStyle = chart.Style{ FontColor: drawing.Color{R: 119, G: 119, B: 119, A: 255}, } transparentStyle = chart.Style{ FillColor: drawing.Color{R: 255, G: 255, B: 255, A: 0}, } ) func ResponseTimeChart(c *fiber.Ctx) error { duration := c.Params("duration") chartTimestampFormatter := chart.TimeValueFormatterWithFormat(timeFormat) var from time.Time switch duration { case "30d": from = time.Now().Truncate(time.Hour).Add(-30 * 24 * time.Hour) chartTimestampFormatter = chart.TimeDateValueFormatter case "7d": from = time.Now().Truncate(time.Hour).Add(-7 * 24 * time.Hour) case "24h": from = time.Now().Truncate(time.Hour).Add(-24 * time.Hour) default: return c.Status(400).SendString("Durations supported: 30d, 7d, 24h") } key, err := url.QueryUnescape(c.Params("key")) if err != nil { return c.Status(400).SendString("invalid key encoding") } hourlyAverageResponseTime, err := store.Get().GetHourlyAverageResponseTimeByKey(key, from, time.Now()) if err != nil { if errors.Is(err, common.ErrEndpointNotFound) { return c.Status(404).SendString(err.Error()) } else if errors.Is(err, common.ErrInvalidTimeRange) { return c.Status(400).SendString(err.Error()) } return c.Status(500).SendString(err.Error()) } if len(hourlyAverageResponseTime) == 0 { return c.Status(204).SendString("") } series := chart.TimeSeries{ Name: "Average response time per hour", Style: chart.Style{ StrokeWidth: 1.5, DotWidth: 2.0, }, } keys := make([]int, 0, len(hourlyAverageResponseTime)) earliestTimestamp := int64(0) for hourlyTimestamp := range hourlyAverageResponseTime { keys = append(keys, int(hourlyTimestamp)) if earliestTimestamp == 0 || hourlyTimestamp < earliestTimestamp { earliestTimestamp = hourlyTimestamp } } for earliestTimestamp > from.Unix() { earliestTimestamp -= int64(time.Hour.Seconds()) keys = append(keys, int(earliestTimestamp)) } sort.Ints(keys) var maxAverageResponseTime float64 for _, key := range keys { averageResponseTime := float64(hourlyAverageResponseTime[int64(key)]) if maxAverageResponseTime < averageResponseTime { maxAverageResponseTime = averageResponseTime } series.XValues = append(series.XValues, time.Unix(int64(key), 0)) series.YValues = append(series.YValues, averageResponseTime) } graph := chart.Chart{ Canvas: transparentStyle, Background: transparentStyle, Width: 1280, Height: 300, XAxis: chart.XAxis{ ValueFormatter: chartTimestampFormatter, GridMajorStyle: gridStyle, GridMinorStyle: gridStyle, Style: axisStyle, NameStyle: axisStyle, }, YAxis: chart.YAxis{ Name: "Average response time", GridMajorStyle: gridStyle, GridMinorStyle: gridStyle, Style: axisStyle, NameStyle: axisStyle, Range: &chart.ContinuousRange{ Min: 0, Max: math.Ceil(maxAverageResponseTime * 1.25), }, }, Series: []chart.Series{series}, } c.Set("Content-Type", "image/svg+xml") c.Set("Cache-Control", "no-cache, no-store") c.Set("Expires", "0") c.Status(http.StatusOK) if err := graph.Render(chart.SVG, c); err != nil { logr.Errorf("[api.ResponseTimeChart] Failed to render response time chart: %s", err.Error()) return c.Status(500).SendString(err.Error()) } return nil } func ResponseTimeHistory(c *fiber.Ctx) error { duration := c.Params("duration") var from time.Time switch duration { case "30d": from = time.Now().Truncate(time.Hour).Add(-30 * 24 * time.Hour) case "7d": from = time.Now().Truncate(time.Hour).Add(-7 * 24 * time.Hour) case "24h": from = time.Now().Truncate(time.Hour).Add(-24 * time.Hour) default: return c.Status(400).SendString("Durations supported: 30d, 7d, 24h") } endpointKey, err := url.QueryUnescape(c.Params("key")) if err != nil { return c.Status(400).SendString("invalid key encoding") } hourlyAverageResponseTime, err := store.Get().GetHourlyAverageResponseTimeByKey(endpointKey, from, time.Now()) if err != nil { if errors.Is(err, common.ErrEndpointNotFound) { return c.Status(404).SendString(err.Error()) } if errors.Is(err, common.ErrInvalidTimeRange) { return c.Status(400).SendString(err.Error()) } return c.Status(500).SendString(err.Error()) } if len(hourlyAverageResponseTime) == 0 { return c.Status(200).JSON(map[string]interface{}{ "timestamps": []int64{}, "values": []int{}, }) } hourlyTimestamps := make([]int, 0, len(hourlyAverageResponseTime)) earliestTimestamp := int64(0) for hourlyTimestamp := range hourlyAverageResponseTime { hourlyTimestamps = append(hourlyTimestamps, int(hourlyTimestamp)) if earliestTimestamp == 0 || hourlyTimestamp < earliestTimestamp { earliestTimestamp = hourlyTimestamp } } for earliestTimestamp > from.Unix() { earliestTimestamp -= int64(time.Hour.Seconds()) hourlyTimestamps = append(hourlyTimestamps, int(earliestTimestamp)) } sort.Ints(hourlyTimestamps) timestamps := make([]int64, 0, len(hourlyTimestamps)) values := make([]int, 0, len(hourlyTimestamps)) for _, hourlyTimestamp := range hourlyTimestamps { timestamp := int64(hourlyTimestamp) averageResponseTime := hourlyAverageResponseTime[timestamp] timestamps = append(timestamps, timestamp*1000) values = append(values, averageResponseTime) } return c.Status(http.StatusOK).JSON(map[string]interface{}{ "timestamps": timestamps, "values": values, }) } ================================================ FILE: api/chart_test.go ================================================ package api import ( "net/http" "net/http/httptest" "testing" "time" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/watchdog" ) func TestResponseTimeChart(t *testing.T) { defer store.Get().Clear() defer cache.Clear() cfg := &config.Config{ Metrics: true, Endpoints: []*endpoint.Endpoint{ { Name: "frontend", Group: "core", }, { Name: "backend", Group: "core", }, }, } watchdog.UpdateEndpointStatus(cfg.Endpoints[0], &endpoint.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()}) watchdog.UpdateEndpointStatus(cfg.Endpoints[1], &endpoint.Result{Success: false, Duration: time.Second, Timestamp: time.Now()}) api := New(cfg) router := api.Router() type Scenario struct { Name string Path string ExpectedCode int Gzip bool } scenarios := []Scenario{ { Name: "chart-response-time-24h", 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-30d", Path: "/api/v1/endpoints/core_frontend/response-times/30d/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, }, { Name: "chart-response-time-for-invalid-key", Path: "/api/v1/endpoints/invalid_key/response-times/7d/chart.svg", ExpectedCode: http.StatusNotFound, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { request := httptest.NewRequest("GET", scenario.Path, http.NoBody) if scenario.Gzip { request.Header.Set("Accept-Encoding", "gzip") } response, err := router.Test(request) if err != nil { return } if response.StatusCode != scenario.ExpectedCode { t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode) } }) } } func TestResponseTimeHistory(t *testing.T) { defer store.Get().Clear() defer cache.Clear() cfg := &config.Config{ Metrics: true, Endpoints: []*endpoint.Endpoint{ { Name: "frontend", Group: "core", }, { Name: "backend", Group: "core", }, }, } watchdog.UpdateEndpointStatus(cfg.Endpoints[0], &endpoint.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()}) watchdog.UpdateEndpointStatus(cfg.Endpoints[1], &endpoint.Result{Success: false, Duration: time.Second, Timestamp: time.Now()}) api := New(cfg) router := api.Router() type Scenario struct { Name string Path string ExpectedCode int } scenarios := []Scenario{ { Name: "history-response-time-24h", Path: "/api/v1/endpoints/core_backend/response-times/24h/history", ExpectedCode: http.StatusOK, }, { Name: "history-response-time-7d", Path: "/api/v1/endpoints/core_frontend/response-times/7d/history", ExpectedCode: http.StatusOK, }, { Name: "history-response-time-30d", Path: "/api/v1/endpoints/core_frontend/response-times/30d/history", ExpectedCode: http.StatusOK, }, { Name: "history-response-time-with-invalid-duration", Path: "/api/v1/endpoints/core_backend/response-times/3d/history", ExpectedCode: http.StatusBadRequest, }, { Name: "history-response-time-for-invalid-key", Path: "/api/v1/endpoints/invalid_key/response-times/7d/history", ExpectedCode: http.StatusNotFound, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { request := httptest.NewRequest("GET", scenario.Path, http.NoBody) response, err := router.Test(request) if err != nil { t.Fatal(err) } if response.StatusCode != scenario.ExpectedCode { t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode) } }) } } ================================================ FILE: api/config.go ================================================ package api import ( "encoding/json" "fmt" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/security" "github.com/gofiber/fiber/v2" ) type ConfigHandler struct { securityConfig *security.Config config *config.Config } func (handler ConfigHandler) GetConfig(c *fiber.Ctx) error { hasOIDC := false isAuthenticated := true // Default to true if no security config is set if handler.securityConfig != nil { hasOIDC = handler.securityConfig.OIDC != nil isAuthenticated = handler.securityConfig.IsAuthenticated(c) } // Prepare response with announcements response := map[string]interface{}{ "oidc": hasOIDC, "authenticated": isAuthenticated, } // Add announcements if available, otherwise use empty slice if handler.config != nil && handler.config.Announcements != nil && len(handler.config.Announcements) > 0 { response["announcements"] = handler.config.Announcements } else { response["announcements"] = []interface{}{} } // Return the config as JSON c.Set("Content-Type", "application/json") responseBytes, err := json.Marshal(response) if err != nil { return c.Status(500).SendString(fmt.Sprintf(`{"error":"Failed to marshal response: %s"}`, err.Error())) } return c.Status(200).Send(responseBytes) } ================================================ FILE: api/config_test.go ================================================ package api import ( "io" "net/http" "testing" "github.com/TwiN/gatus/v5/security" "github.com/gofiber/fiber/v2" ) func TestConfigHandler_ServeHTTP(t *testing.T) { securityConfig := &security.Config{ OIDC: &security.OIDCConfig{ IssuerURL: "https://sso.gatus.io/", RedirectURL: "http://localhost:80/authorization-code/callback", Scopes: []string{"openid"}, AllowedSubjects: []string{"user1@example.com"}, }, } handler := ConfigHandler{securityConfig: securityConfig} // Create a fake router. We're doing this because I need the gate to be initialized. app := fiber.New() app.Get("/api/v1/config", handler.GetConfig) err := securityConfig.ApplySecurityMiddleware(app) if err != nil { t.Error("expected err to be nil, but was", err) } // Test the config handler request, _ := http.NewRequest("GET", "/api/v1/config", http.NoBody) response, err := app.Test(request) if err != nil { t.Error("expected err to be nil, but was", err) } defer response.Body.Close() if response.StatusCode != http.StatusOK { t.Error("expected code to be 200, but was", response.StatusCode) } body, err := io.ReadAll(response.Body) if err != nil { t.Error("expected err to be nil, but was", err) } if string(body) != `{"announcements":[],"authenticated":false,"oidc":true}` { t.Error("expected body to be `{\"announcements\":[],\"authenticated\":false,\"oidc\":true}`, but was", string(body)) } } ================================================ FILE: api/custom_css.go ================================================ package api import ( "github.com/gofiber/fiber/v2" ) type CustomCSSHandler struct { customCSS string } func (handler CustomCSSHandler) GetCustomCSS(c *fiber.Ctx) error { c.Set("Content-Type", "text/css") return c.Status(200).SendString(handler.customCSS) } ================================================ FILE: api/endpoint_status.go ================================================ package api import ( "encoding/json" "errors" "fmt" "net/url" "github.com/TwiN/gatus/v5/client" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/config/remote" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/storage/store/common" "github.com/TwiN/gatus/v5/storage/store/common/paging" "github.com/TwiN/logr" "github.com/gofiber/fiber/v2" ) // EndpointStatuses handles requests to retrieve all EndpointStatus // Due to how intensive this operation can be on the storage, this function leverages a cache. func EndpointStatuses(cfg *config.Config) fiber.Handler { return func(c *fiber.Ctx) error { page, pageSize := extractPageAndPageSizeFromRequest(c, cfg.Storage.MaximumNumberOfResults) value, exists := cache.Get(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize)) var data []byte if !exists { endpointStatuses, err := store.Get().GetAllEndpointStatuses(paging.NewEndpointStatusParams().WithResults(page, pageSize)) if err != nil { logr.Errorf("[api.EndpointStatuses] Failed to retrieve endpoint statuses: %s", err.Error()) return c.Status(500).SendString(err.Error()) } // ALPHA: Retrieve endpoint statuses from remote instances if endpointStatusesFromRemote, err := getEndpointStatusesFromRemoteInstances(cfg.Remote); err != nil { logr.Errorf("[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 { logr.Errorf("[api.EndpointStatuses] Unable to marshal object to JSON: %s", err.Error()) return c.Status(500).SendString("unable to marshal object to JSON") } cache.SetWithTTL(fmt.Sprintf("endpoint-status-%d-%d", page, pageSize), data, cacheTTL) } else { data = value.([]byte) } c.Set("Content-Type", "application/json") return c.Status(200).Send(data) } } func getEndpointStatusesFromRemoteInstances(remoteConfig *remote.Config) ([]*endpoint.Status, error) { if remoteConfig == nil || len(remoteConfig.Instances) == 0 { return nil, nil } var endpointStatusesFromAllRemotes []*endpoint.Status httpClient := client.GetHTTPClient(remoteConfig.ClientConfig) for _, instance := range remoteConfig.Instances { response, err := httpClient.Get(instance.URL) if err != nil { // Log the error but continue with other instances logr.Errorf("[api.getEndpointStatusesFromRemoteInstances] Failed to retrieve endpoint statuses from %s: %s", instance.URL, err.Error()) continue } var endpointStatuses []*endpoint.Status if err = json.NewDecoder(response.Body).Decode(&endpointStatuses); err != nil { _ = response.Body.Close() logr.Errorf("[api.getEndpointStatusesFromRemoteInstances] Failed to decode 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...) } // Only return nil, error if no remote instances were successfully processed if len(endpointStatusesFromAllRemotes) == 0 && remoteConfig.Instances != nil { return nil, fmt.Errorf("failed to retrieve endpoint statuses from all remote instances") } return endpointStatusesFromAllRemotes, nil } // EndpointStatus retrieves a single endpoint.Status by group and endpoint name func EndpointStatus(cfg *config.Config) fiber.Handler { return func(c *fiber.Ctx) error { page, pageSize := extractPageAndPageSizeFromRequest(c, cfg.Storage.MaximumNumberOfResults) key, err := url.QueryUnescape(c.Params("key")) if err != nil { logr.Errorf("[api.EndpointStatus] Failed to decode key: %s", err.Error()) return c.Status(400).SendString("invalid key encoding") } endpointStatus, err := store.Get().GetEndpointStatusByKey(key, paging.NewEndpointStatusParams().WithResults(page, pageSize).WithEvents(1, cfg.Storage.MaximumNumberOfEvents)) if err != nil { if errors.Is(err, common.ErrEndpointNotFound) { return c.Status(404).SendString(err.Error()) } logr.Errorf("[api.EndpointStatus] Failed to retrieve endpoint status: %s", err.Error()) return c.Status(500).SendString(err.Error()) } if endpointStatus == nil { // XXX: is this check necessary? logr.Errorf("[api.EndpointStatus] Endpoint with key=%s not found", key) return c.Status(404).SendString("not found") } output, err := json.Marshal(endpointStatus) if err != nil { logr.Errorf("[api.EndpointStatus] Unable to marshal object to JSON: %s", err.Error()) return c.Status(500).SendString("unable to marshal object to JSON") } c.Set("Content-Type", "application/json") return c.Status(200).Send(output) } } ================================================ FILE: api/endpoint_status_test.go ================================================ package api import ( "io" "net/http" "net/http/httptest" "testing" "time" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/storage" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/watchdog" ) var ( timestamp = time.Now() testEndpoint = endpoint.Endpoint{ Name: "name", Group: "group", URL: "https://example.org/what/ever", Method: "GET", Body: "body", Interval: 30 * time.Second, Conditions: []endpoint.Condition{endpoint.Condition("[STATUS] == 200"), endpoint.Condition("[RESPONSE_TIME] < 500"), endpoint.Condition("[CERTIFICATE_EXPIRATION] < 72h")}, Alerts: nil, NumberOfFailuresInARow: 0, NumberOfSuccessesInARow: 0, } testSuccessfulResult = endpoint.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: []*endpoint.ConditionResult{ { Condition: "[STATUS] == 200", Success: true, }, { Condition: "[RESPONSE_TIME] < 500", Success: true, }, { Condition: "[CERTIFICATE_EXPIRATION] < 72h", Success: true, }, }, } testUnsuccessfulResult = endpoint.Result{ Hostname: "example.org", IP: "127.0.0.1", HTTPStatus: 200, Errors: []string{"error-1", "error-2"}, Connected: true, Success: false, Timestamp: timestamp, Duration: 750 * time.Millisecond, CertificateExpiration: 10 * time.Hour, ConditionResults: []*endpoint.ConditionResult{ { Condition: "[STATUS] == 200", Success: true, }, { Condition: "[RESPONSE_TIME] < 500", Success: false, }, { Condition: "[CERTIFICATE_EXPIRATION] < 72h", Success: false, }, }, } ) func TestEndpointStatus(t *testing.T) { defer store.Get().Clear() defer cache.Clear() cfg := &config.Config{ Metrics: true, Endpoints: []*endpoint.Endpoint{ { Name: "frontend", Group: "core", }, { Name: "backend", Group: "core", }, }, Storage: &storage.Config{ MaximumNumberOfResults: storage.DefaultMaximumNumberOfResults, MaximumNumberOfEvents: storage.DefaultMaximumNumberOfEvents, }, } watchdog.UpdateEndpointStatus(cfg.Endpoints[0], &endpoint.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()}) watchdog.UpdateEndpointStatus(cfg.Endpoints[1], &endpoint.Result{Success: false, Duration: time.Second, Timestamp: time.Now()}) api := New(cfg) router := api.Router() type Scenario struct { Name string Path string ExpectedCode int Gzip bool } scenarios := []Scenario{ { Name: "endpoint-status", Path: "/api/v1/endpoints/core_frontend/statuses", ExpectedCode: http.StatusOK, }, { Name: "endpoint-status-gzip", Path: "/api/v1/endpoints/core_frontend/statuses", ExpectedCode: http.StatusOK, Gzip: true, }, { Name: "endpoint-status-pagination", Path: "/api/v1/endpoints/core_frontend/statuses?page=1&pageSize=20", ExpectedCode: http.StatusOK, }, { Name: "endpoint-status-for-invalid-key", Path: "/api/v1/endpoints/invalid_key/statuses", ExpectedCode: http.StatusNotFound, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { request := httptest.NewRequest("GET", scenario.Path, http.NoBody) if scenario.Gzip { request.Header.Set("Accept-Encoding", "gzip") } response, err := router.Test(request) if err != nil { return } if response.StatusCode != scenario.ExpectedCode { t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode) } }) } } func TestEndpointStatuses(t *testing.T) { defer store.Get().Clear() defer cache.Clear() firstResult := &testSuccessfulResult secondResult := &testUnsuccessfulResult store.Get().InsertEndpointResult(&testEndpoint, firstResult) store.Get().InsertEndpointResult(&testEndpoint, secondResult) // Can't be bothered dealing with timezone issues on the worker that runs the automated tests firstResult.Timestamp = time.Time{} secondResult.Timestamp = time.Time{} api := New(&config.Config{ Metrics: true, Storage: &storage.Config{ MaximumNumberOfResults: storage.DefaultMaximumNumberOfResults, MaximumNumberOfEvents: storage.DefaultMaximumNumberOfEvents, }, }) router := api.Router() type Scenario struct { Name string Path string ExpectedCode int ExpectedBody string } scenarios := []Scenario{ { Name: "no-pagination", Path: "/api/v1/endpoints/statuses", ExpectedCode: http.StatusOK, ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}]}]`, }, { Name: "pagination-first-result", Path: "/api/v1/endpoints/statuses?page=1&pageSize=1", ExpectedCode: http.StatusOK, ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}]}]`, }, { Name: "pagination-second-result", Path: "/api/v1/endpoints/statuses?page=2&pageSize=1", ExpectedCode: http.StatusOK, ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"}]}]`, }, { Name: "pagination-no-results", Path: "/api/v1/endpoints/statuses?page=5&pageSize=20", ExpectedCode: http.StatusOK, ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[]}]`, }, { Name: "invalid-pagination-should-fall-back-to-default", Path: "/api/v1/endpoints/statuses?page=INVALID&pageSize=INVALID", ExpectedCode: http.StatusOK, ExpectedBody: `[{"name":"name","group":"group","key":"group_name","results":[{"status":200,"hostname":"example.org","duration":150000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":750000000,"errors":["error-1","error-2"],"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":false},{"condition":"[CERTIFICATE_EXPIRATION] \u003c 72h","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}]}]`, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { request := httptest.NewRequest("GET", scenario.Path, http.NoBody) response, err := router.Test(request) if err != nil { return } defer response.Body.Close() if response.StatusCode != scenario.ExpectedCode { t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode) } body, err := io.ReadAll(response.Body) if err != nil { t.Error("expected err to be nil, but was", err) } if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n %s\n\ngot:\n %s", scenario.ExpectedBody, string(body)) } }) } } ================================================ FILE: api/external_endpoint.go ================================================ package api import ( "errors" "strings" "time" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/metrics" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/storage/store/common" "github.com/TwiN/gatus/v5/watchdog" "github.com/TwiN/logr" "github.com/gofiber/fiber/v2" ) func CreateExternalEndpointResult(cfg *config.Config) fiber.Handler { extraLabels := cfg.GetUniqueExtraMetricLabels() return func(c *fiber.Ctx) error { // Check if the success query parameter is present success, exists := c.Queries()["success"] if !exists || (success != "true" && success != "false") { return c.Status(400).SendString("missing or invalid success query parameter") } // Check if the authorization bearer token header is correct authorizationHeader := string(c.Request().Header.Peek("Authorization")) if !strings.HasPrefix(authorizationHeader, "Bearer ") { return c.Status(401).SendString("invalid Authorization header") } token := strings.TrimSpace(strings.TrimPrefix(authorizationHeader, "Bearer ")) if len(token) == 0 { return c.Status(401).SendString("bearer token must not be empty") } key := c.Params("key") externalEndpoint := cfg.GetExternalEndpointByKey(key) if externalEndpoint == nil { logr.Errorf("[api.CreateExternalEndpointResult] External endpoint with key=%s not found", key) return c.Status(404).SendString("not found") } if externalEndpoint.Token != token { logr.Errorf("[api.CreateExternalEndpointResult] Invalid token for external endpoint with key=%s", key) return c.Status(401).SendString("invalid token") } // Persist the result in the storage result := &endpoint.Result{ Timestamp: time.Now(), Success: c.QueryBool("success"), Errors: []string{}, } if len(c.Query("duration")) > 0 { parsedDuration, err := time.ParseDuration(c.Query("duration")) if err != nil { logr.Errorf("[api.CreateExternalEndpointResult] Invalid duration from string=%s with error: %s", c.Query("duration"), err.Error()) return c.Status(400).SendString("invalid duration: " + err.Error()) } result.Duration = parsedDuration } if errorFromQuery := c.Query("error"); !result.Success && len(errorFromQuery) > 0 { result.AddError(errorFromQuery) } convertedEndpoint := externalEndpoint.ToEndpoint() if err := store.Get().InsertEndpointResult(convertedEndpoint, result); err != nil { if errors.Is(err, common.ErrEndpointNotFound) { return c.Status(404).SendString(err.Error()) } logr.Errorf("[api.CreateExternalEndpointResult] Failed to insert result in storage: %s", err.Error()) return c.Status(500).SendString(err.Error()) } logr.Infof("[api.CreateExternalEndpointResult] Successfully inserted result for external endpoint with key=%s and success=%s", c.Params("key"), success) inEndpointMaintenanceWindow := false for _, maintenanceWindow := range externalEndpoint.MaintenanceWindows { if maintenanceWindow.IsUnderMaintenance() { logr.Debug("[api.CreateExternalEndpointResult] Under endpoint maintenance window") inEndpointMaintenanceWindow = true } } // Check if an alert should be triggered or resolved if !cfg.Maintenance.IsUnderMaintenance() && !inEndpointMaintenanceWindow { watchdog.HandleAlerting(convertedEndpoint, result, cfg.Alerting) externalEndpoint.NumberOfSuccessesInARow = convertedEndpoint.NumberOfSuccessesInARow externalEndpoint.NumberOfFailuresInARow = convertedEndpoint.NumberOfFailuresInARow } else { logr.Debug("[api.CreateExternalEndpointResult] Not handling alerting because currently in the maintenance window") } if cfg.Metrics { metrics.PublishMetricsForEndpoint(convertedEndpoint, result, extraLabels) } // Return the result return c.Status(200).SendString("") } } ================================================ FILE: api/external_endpoint_test.go ================================================ package api import ( "net/http" "net/http/httptest" "testing" "github.com/TwiN/gatus/v5/alerting" "github.com/TwiN/gatus/v5/alerting/alert" "github.com/TwiN/gatus/v5/alerting/provider/discord" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/config/maintenance" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/storage/store/common/paging" ) func TestCreateExternalEndpointResult(t *testing.T) { defer store.Get().Clear() defer cache.Clear() cfg := &config.Config{ Alerting: &alerting.Config{ Discord: &discord.AlertProvider{}, }, ExternalEndpoints: []*endpoint.ExternalEndpoint{ { Name: "n", Group: "g", Token: "token", Alerts: []*alert.Alert{ { Type: alert.TypeDiscord, FailureThreshold: 2, SuccessThreshold: 2, }, }, }, }, Maintenance: &maintenance.Config{}, } api := New(cfg) router := api.Router() scenarios := []struct { Name string Path string AuthorizationHeaderBearerToken string ExpectedCode int }{ { Name: "no-token", Path: "/api/v1/endpoints/g_n/external?success=true", AuthorizationHeaderBearerToken: "", ExpectedCode: 401, }, { Name: "bad-token", Path: "/api/v1/endpoints/g_n/external?success=true", AuthorizationHeaderBearerToken: "Bearer bad-token", ExpectedCode: 401, }, { Name: "bad-key", Path: "/api/v1/endpoints/bad_key/external?success=true", AuthorizationHeaderBearerToken: "Bearer token", ExpectedCode: 404, }, { Name: "bad-success-value", Path: "/api/v1/endpoints/g_n/external?success=invalid", AuthorizationHeaderBearerToken: "Bearer token", ExpectedCode: 400, }, { Name: "bad-duration-value", Path: "/api/v1/endpoints/g_n/external?success=true&duration=invalid", AuthorizationHeaderBearerToken: "Bearer token", ExpectedCode: 400, }, { Name: "good-token-success-true", Path: "/api/v1/endpoints/g_n/external?success=true", AuthorizationHeaderBearerToken: "Bearer token", ExpectedCode: 200, }, { Name: "good-token-success-true-with-ignored-error-because-success-true", Path: "/api/v1/endpoints/g_n/external?success=true&error=failed", AuthorizationHeaderBearerToken: "Bearer token", ExpectedCode: 200, }, { Name: "good-duration-success-true", Path: "/api/v1/endpoints/g_n/external?success=true&duration=10s", AuthorizationHeaderBearerToken: "Bearer token", ExpectedCode: 200, }, { Name: "good-token-success-false", Path: "/api/v1/endpoints/g_n/external?success=false", AuthorizationHeaderBearerToken: "Bearer token", ExpectedCode: 200, }, { Name: "good-token-success-false-again", Path: "/api/v1/endpoints/g_n/external?success=false", AuthorizationHeaderBearerToken: "Bearer token", ExpectedCode: 200, }, { Name: "good-token-success-false-with-error", Path: "/api/v1/endpoints/g_n/external?success=false&error=failed", AuthorizationHeaderBearerToken: "Bearer token", ExpectedCode: 200, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { request := httptest.NewRequest("POST", scenario.Path, http.NoBody) if len(scenario.AuthorizationHeaderBearerToken) > 0 { request.Header.Set("Authorization", scenario.AuthorizationHeaderBearerToken) } response, err := router.Test(request) if err != nil { return } defer response.Body.Close() if response.StatusCode != scenario.ExpectedCode { t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode) } }) } t.Run("verify-end-results", func(t *testing.T) { endpointStatus, err := store.Get().GetEndpointStatus("g", "n", paging.NewEndpointStatusParams().WithResults(1, 11)) if err != nil { t.Errorf("failed to get endpoint status: %s", err.Error()) return } if endpointStatus.Key != "g_n" { t.Errorf("expected key to be g_n but got %s", endpointStatus.Key) } if len(endpointStatus.Results) != 6 { t.Errorf("expected 6 results but got %d", len(endpointStatus.Results)) } if !endpointStatus.Results[0].Success { t.Errorf("expected first result to be successful") } if !endpointStatus.Results[1].Success { t.Errorf("expected second result to be successful") } if len(endpointStatus.Results[1].Errors) > 0 { t.Errorf("expected second result to have no errors") } if endpointStatus.Results[2].Duration == 0 || endpointStatus.Results[2].Duration.Seconds() != 10 { t.Errorf("expected third result to have a duration of 10 seconds") } if endpointStatus.Results[3].Success { t.Errorf("expected fourth result to be unsuccessful") } if endpointStatus.Results[4].Success { t.Errorf("expected fifth result to be unsuccessful") } if endpointStatus.Results[5].Success { t.Errorf("expected sixth result to be unsuccessful") } if len(endpointStatus.Results[5].Errors) == 0 || endpointStatus.Results[5].Errors[0] != "failed" { t.Errorf("expected sixth result to have errors: failed") } externalEndpointFromConfig := cfg.GetExternalEndpointByKey("g_n") if externalEndpointFromConfig.NumberOfFailuresInARow != 3 { t.Errorf("expected 3 failures in a row but got %d", externalEndpointFromConfig.NumberOfFailuresInARow) } if externalEndpointFromConfig.NumberOfSuccessesInARow != 0 { t.Errorf("expected 0 successes in a row but got %d", externalEndpointFromConfig.NumberOfSuccessesInARow) } }) } ================================================ FILE: api/raw.go ================================================ package api import ( "errors" "fmt" "net/url" "time" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/storage/store/common" "github.com/gofiber/fiber/v2" ) func UptimeRaw(c *fiber.Ctx) error { duration := c.Params("duration") var from time.Time switch duration { case "30d": from = time.Now().Add(-30 * 24 * time.Hour) 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 uptime metrics are stored by hour, we have to cheat a little default: return c.Status(400).SendString("Durations supported: 30d, 7d, 24h, 1h") } key, err := url.QueryUnescape(c.Params("key")) if err != nil { return c.Status(400).SendString("invalid key encoding") } uptime, err := store.Get().GetUptimeByKey(key, from, time.Now()) if err != nil { if errors.Is(err, common.ErrEndpointNotFound) { return c.Status(404).SendString(err.Error()) } else if errors.Is(err, common.ErrInvalidTimeRange) { return c.Status(400).SendString(err.Error()) } return c.Status(500).SendString(err.Error()) } c.Set("Content-Type", "text/plain") c.Set("Cache-Control", "no-cache, no-store, must-revalidate") c.Set("Expires", "0") return c.Status(200).Send([]byte(fmt.Sprintf("%f", uptime))) } func ResponseTimeRaw(c *fiber.Ctx) error { duration := c.Params("duration") var from time.Time switch duration { case "30d": from = time.Now().Add(-30 * 24 * time.Hour) 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 uptime metrics are stored by hour, we have to cheat a little default: return c.Status(400).SendString("Durations supported: 30d, 7d, 24h, 1h") } key, err := url.QueryUnescape(c.Params("key")) if err != nil { return c.Status(400).SendString("invalid key encoding") } responseTime, err := store.Get().GetAverageResponseTimeByKey(key, from, time.Now()) if err != nil { if errors.Is(err, common.ErrEndpointNotFound) { return c.Status(404).SendString(err.Error()) } else if errors.Is(err, common.ErrInvalidTimeRange) { return c.Status(400).SendString(err.Error()) } return c.Status(500).SendString(err.Error()) } c.Set("Content-Type", "text/plain") c.Set("Cache-Control", "no-cache, no-store, must-revalidate") c.Set("Expires", "0") return c.Status(200).Send([]byte(fmt.Sprintf("%d", responseTime))) } ================================================ FILE: api/raw_test.go ================================================ package api import ( "net/http" "net/http/httptest" "testing" "time" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/config/endpoint/ui" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/watchdog" ) func TestRawDataEndpoint(t *testing.T) { defer store.Get().Clear() defer cache.Clear() cfg := &config.Config{ Metrics: true, Endpoints: []*endpoint.Endpoint{ { Name: "frontend", Group: "core", }, { Name: "backend", Group: "core", }, }, } cfg.Endpoints[0].UIConfig = ui.GetDefaultConfig() cfg.Endpoints[1].UIConfig = ui.GetDefaultConfig() watchdog.UpdateEndpointStatus(cfg.Endpoints[0], &endpoint.Result{Success: true, Connected: true, Duration: time.Millisecond, Timestamp: time.Now()}) watchdog.UpdateEndpointStatus(cfg.Endpoints[1], &endpoint.Result{Success: false, Connected: false, Duration: time.Second, Timestamp: time.Now()}) api := New(cfg) router := api.Router() type Scenario struct { Name string Path string ExpectedCode int Gzip bool } scenarios := []Scenario{ { Name: "raw-uptime-1h", Path: "/api/v1/endpoints/core_frontend/uptimes/1h", ExpectedCode: http.StatusOK, }, { Name: "raw-uptime-24h", Path: "/api/v1/endpoints/core_backend/uptimes/24h", ExpectedCode: http.StatusOK, }, { Name: "raw-uptime-7d", Path: "/api/v1/endpoints/core_frontend/uptimes/7d", ExpectedCode: http.StatusOK, }, { Name: "raw-uptime-30d", Path: "/api/v1/endpoints/core_frontend/uptimes/30d", ExpectedCode: http.StatusOK, }, { Name: "raw-uptime-with-invalid-duration", Path: "/api/v1/endpoints/core_backend/uptimes/3d", ExpectedCode: http.StatusBadRequest, }, { Name: "raw-uptime-for-invalid-key", Path: "/api/v1/endpoints/invalid_key/uptimes/7d", ExpectedCode: http.StatusNotFound, }, { Name: "raw-response-times-1h", Path: "/api/v1/endpoints/core_frontend/response-times/1h", ExpectedCode: http.StatusOK, }, { Name: "raw-response-times-24h", Path: "/api/v1/endpoints/core_backend/response-times/24h", ExpectedCode: http.StatusOK, }, { Name: "raw-response-times-7d", Path: "/api/v1/endpoints/core_frontend/response-times/7d", ExpectedCode: http.StatusOK, }, { Name: "raw-response-times-30d", Path: "/api/v1/endpoints/core_frontend/response-times/30d", ExpectedCode: http.StatusOK, }, { Name: "raw-response-times-with-invalid-duration", Path: "/api/v1/endpoints/core_backend/response-times/3d", ExpectedCode: http.StatusBadRequest, }, { Name: "raw-response-times-for-invalid-key", Path: "/api/v1/endpoints/invalid_key/response-times/7d", ExpectedCode: http.StatusNotFound, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { request := httptest.NewRequest("GET", scenario.Path, http.NoBody) if scenario.Gzip { request.Header.Set("Accept-Encoding", "gzip") } response, err := router.Test(request) if err != nil { return } if response.StatusCode != scenario.ExpectedCode { t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode) } }) } } ================================================ FILE: api/spa.go ================================================ package api import ( _ "embed" "html/template" "github.com/TwiN/gatus/v5/config/ui" static "github.com/TwiN/gatus/v5/web" "github.com/TwiN/logr" "github.com/gofiber/fiber/v2" ) func SinglePageApplication(uiConfig *ui.Config) fiber.Handler { return func(c *fiber.Ctx) error { vd := ui.ViewData{UI: uiConfig} { themeFromCookie := string(c.Request().Header.Cookie("theme")) if len(themeFromCookie) > 0 { if themeFromCookie == "dark" { vd.Theme = "dark" } } else if uiConfig.IsDarkMode() { // Since there's no theme cookie, we'll rely on ui.DarkMode vd.Theme = "dark" } } t, err := template.ParseFS(static.FileSystem, static.IndexPath) if err != nil { // This should never happen, because ui.ValidateAndSetDefaults validates that the template works. logr.Errorf("[api.SinglePageApplication] Failed to parse template. This should never happen, because the template is validated on start. Error: %s", err.Error()) return c.Status(500).SendString("Failed to parse template. This should never happen, because the template is validated on start.") } c.Set("Content-Type", "text/html") err = t.Execute(c, vd) if err != nil { // This should never happen, because ui.ValidateAndSetDefaults validates that the template works. logr.Errorf("[api.SinglePageApplication] Failed to execute template. This should never happen, because the template is validated on start. Error: %s", err.Error()) return c.Status(500).SendString("Failed to parse template. This should never happen, because the template is validated on start.") } return c.SendStatus(200) } } ================================================ FILE: api/spa_test.go ================================================ package api import ( "io" "net/http" "net/http/httptest" "strings" "testing" "time" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/config/ui" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/watchdog" ) func TestSinglePageApplication(t *testing.T) { defer store.Get().Clear() defer cache.Clear() cfg := &config.Config{ Metrics: true, Endpoints: []*endpoint.Endpoint{ { Name: "frontend", Group: "core", }, { Name: "backend", Group: "core", }, }, UI: &ui.Config{ Title: "example-title", }, } watchdog.UpdateEndpointStatus(cfg.Endpoints[0], &endpoint.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now()}) watchdog.UpdateEndpointStatus(cfg.Endpoints[1], &endpoint.Result{Success: false, Duration: time.Second, Timestamp: time.Now()}) api := New(cfg) router := api.Router() type Scenario struct { Name string Path string Gzip bool CookieDarkMode bool UIDarkMode bool ExpectedCode int ExpectedDarkTheme bool } scenarios := []Scenario{ { Name: "frontend-home", Path: "/", CookieDarkMode: true, UIDarkMode: false, ExpectedDarkTheme: true, ExpectedCode: 200, }, { Name: "frontend-endpoint-light", Path: "/endpoints/core_frontend", CookieDarkMode: false, UIDarkMode: false, ExpectedDarkTheme: false, ExpectedCode: 200, }, { Name: "frontend-endpoint-dark", Path: "/endpoints/core_frontend", CookieDarkMode: false, UIDarkMode: true, ExpectedDarkTheme: true, ExpectedCode: 200, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { cfg.UI.DarkMode = &scenario.UIDarkMode request := httptest.NewRequest("GET", scenario.Path, http.NoBody) if scenario.Gzip { request.Header.Set("Accept-Encoding", "gzip") } if scenario.CookieDarkMode { request.Header.Set("Cookie", "theme=dark") } response, err := router.Test(request) if err != nil { return } defer response.Body.Close() if response.StatusCode != scenario.ExpectedCode { t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode) } body, _ := io.ReadAll(response.Body) strBody := string(body) if !strings.Contains(strBody, cfg.UI.Title) { t.Errorf("%s %s should have contained the title", request.Method, request.URL) } if scenario.ExpectedDarkTheme && !strings.Contains(strBody, "class=\"dark\"") { t.Errorf("%s %s should have responded with dark mode headers", request.Method, request.URL) } if !scenario.ExpectedDarkTheme && strings.Contains(strBody, "class=\"dark\"") { t.Errorf("%s %s should not have responded with dark mode headers", request.Method, request.URL) } }) } } ================================================ FILE: api/suite_status.go ================================================ package api import ( "fmt" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/suite" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/storage/store/common/paging" "github.com/gofiber/fiber/v2" ) // SuiteStatuses handles requests to retrieve all suite statuses func SuiteStatuses(cfg *config.Config) fiber.Handler { return func(c *fiber.Ctx) error { page, pageSize := extractPageAndPageSizeFromRequest(c, 100) params := paging.NewSuiteStatusParams().WithPagination(page, pageSize) suiteStatuses, err := store.Get().GetAllSuiteStatuses(params) if err != nil { return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{ "error": fmt.Sprintf("Failed to retrieve suite statuses: %v", err), }) } // If no statuses exist yet, create empty ones from config if len(suiteStatuses) == 0 { for _, s := range cfg.Suites { if s.IsEnabled() { suiteStatuses = append(suiteStatuses, suite.NewStatus(s)) } } } return c.Status(fiber.StatusOK).JSON(suiteStatuses) } } // SuiteStatus handles requests to retrieve a single suite's status func SuiteStatus(cfg *config.Config) fiber.Handler { return func(c *fiber.Ctx) error { page, pageSize := extractPageAndPageSizeFromRequest(c, 100) key := c.Params("key") params := paging.NewSuiteStatusParams().WithPagination(page, pageSize) status, err := store.Get().GetSuiteStatusByKey(key, params) if err != nil || status == nil { // Try to find the suite in config for _, s := range cfg.Suites { if s.Key() == key { status = suite.NewStatus(s) break } } if status == nil { return c.Status(404).JSON(fiber.Map{ "error": fmt.Sprintf("Suite with key '%s' not found", key), }) } } return c.Status(fiber.StatusOK).JSON(status) } } ================================================ FILE: api/suite_status_test.go ================================================ package api import ( "io" "net/http" "net/http/httptest" "testing" "time" "github.com/TwiN/gatus/v5/config" "github.com/TwiN/gatus/v5/config/endpoint" "github.com/TwiN/gatus/v5/config/suite" "github.com/TwiN/gatus/v5/storage" "github.com/TwiN/gatus/v5/storage/store" "github.com/TwiN/gatus/v5/watchdog" ) var ( suiteTimestamp = time.Now() testSuiteEndpoint1 = endpoint.Endpoint{ Name: "endpoint1", Group: "suite-group", URL: "https://example.org/endpoint1", Method: "GET", Interval: 30 * time.Second, Conditions: []endpoint.Condition{endpoint.Condition("[STATUS] == 200"), endpoint.Condition("[RESPONSE_TIME] < 500")}, NumberOfFailuresInARow: 0, NumberOfSuccessesInARow: 0, } testSuiteEndpoint2 = endpoint.Endpoint{ Name: "endpoint2", Group: "suite-group", URL: "https://example.org/endpoint2", Method: "GET", Interval: 30 * time.Second, Conditions: []endpoint.Condition{endpoint.Condition("[STATUS] == 200"), endpoint.Condition("[RESPONSE_TIME] < 300")}, NumberOfFailuresInARow: 0, NumberOfSuccessesInARow: 0, } testSuite = suite.Suite{ Name: "test-suite", Group: "suite-group", Interval: 60 * time.Second, Endpoints: []*endpoint.Endpoint{ &testSuiteEndpoint1, &testSuiteEndpoint2, }, } testSuccessfulSuiteResult = suite.Result{ Name: "test-suite", Group: "suite-group", Success: true, Timestamp: suiteTimestamp, Duration: 250 * time.Millisecond, EndpointResults: []*endpoint.Result{ { Hostname: "example.org", IP: "127.0.0.1", HTTPStatus: 200, Success: true, Timestamp: suiteTimestamp, Duration: 100 * time.Millisecond, ConditionResults: []*endpoint.ConditionResult{ { Condition: "[STATUS] == 200", Success: true, }, { Condition: "[RESPONSE_TIME] < 500", Success: true, }, }, }, { Hostname: "example.org", IP: "127.0.0.1", HTTPStatus: 200, Success: true, Timestamp: suiteTimestamp, Duration: 150 * time.Millisecond, ConditionResults: []*endpoint.ConditionResult{ { Condition: "[STATUS] == 200", Success: true, }, { Condition: "[RESPONSE_TIME] < 300", Success: true, }, }, }, }, } testUnsuccessfulSuiteResult = suite.Result{ Name: "test-suite", Group: "suite-group", Success: false, Timestamp: suiteTimestamp, Duration: 850 * time.Millisecond, Errors: []string{"suite-error-1", "suite-error-2"}, EndpointResults: []*endpoint.Result{ { Hostname: "example.org", IP: "127.0.0.1", HTTPStatus: 200, Success: true, Timestamp: suiteTimestamp, Duration: 100 * time.Millisecond, ConditionResults: []*endpoint.ConditionResult{ { Condition: "[STATUS] == 200", Success: true, }, { Condition: "[RESPONSE_TIME] < 500", Success: true, }, }, }, { Hostname: "example.org", IP: "127.0.0.1", HTTPStatus: 500, Errors: []string{"endpoint-error-1"}, Success: false, Timestamp: suiteTimestamp, Duration: 750 * time.Millisecond, ConditionResults: []*endpoint.ConditionResult{ { Condition: "[STATUS] == 200", Success: false, }, { Condition: "[RESPONSE_TIME] < 300", Success: false, }, }, }, }, } ) func TestSuiteStatus(t *testing.T) { defer store.Get().Clear() defer cache.Clear() cfg := &config.Config{ Metrics: true, Suites: []*suite.Suite{ { Name: "frontend-suite", Group: "core", }, { Name: "backend-suite", Group: "core", }, }, Storage: &storage.Config{ MaximumNumberOfResults: storage.DefaultMaximumNumberOfResults, MaximumNumberOfEvents: storage.DefaultMaximumNumberOfEvents, }, } watchdog.UpdateSuiteStatus(cfg.Suites[0], &suite.Result{Success: true, Duration: time.Millisecond, Timestamp: time.Now(), Name: cfg.Suites[0].Name, Group: cfg.Suites[0].Group}) watchdog.UpdateSuiteStatus(cfg.Suites[1], &suite.Result{Success: false, Duration: time.Second, Timestamp: time.Now(), Name: cfg.Suites[1].Name, Group: cfg.Suites[1].Group}) api := New(cfg) router := api.Router() type Scenario struct { Name string Path string ExpectedCode int Gzip bool } scenarios := []Scenario{ { Name: "suite-status", Path: "/api/v1/suites/core_frontend-suite/statuses", ExpectedCode: http.StatusOK, }, { Name: "suite-status-gzip", Path: "/api/v1/suites/core_frontend-suite/statuses", ExpectedCode: http.StatusOK, Gzip: true, }, { Name: "suite-status-pagination", Path: "/api/v1/suites/core_frontend-suite/statuses?page=1&pageSize=20", ExpectedCode: http.StatusOK, }, { Name: "suite-status-for-invalid-key", Path: "/api/v1/suites/invalid_key/statuses", ExpectedCode: http.StatusNotFound, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { request := httptest.NewRequest("GET", scenario.Path, http.NoBody) if scenario.Gzip { request.Header.Set("Accept-Encoding", "gzip") } response, err := router.Test(request) if err != nil { return } if response.StatusCode != scenario.ExpectedCode { t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode) } }) } } func TestSuiteStatus_SuiteNotInStoreButInConfig(t *testing.T) { defer store.Get().Clear() defer cache.Clear() tests := []struct { name string suiteKey string cfg *config.Config expectedCode int expectJSON bool expectError string }{ { name: "suite-not-in-store-but-exists-in-config-enabled", suiteKey: "test-group_test-suite", cfg: &config.Config{ Metrics: true, Suites: []*suite.Suite{ { Name: "test-suite", Group: "test-group", Enabled: boolPtr(true), Endpoints: []*endpoint.Endpoint{ { Name: "endpoint-1", Group: "test-group", URL: "https://example.com", }, }, }, }, Storage: &storage.Config{ MaximumNumberOfResults: storage.DefaultMaximumNumberOfResults, MaximumNumberOfEvents: storage.DefaultMaximumNumberOfEvents, }, }, expectedCode: http.StatusOK, expectJSON: true, }, { name: "suite-not-in-store-but-exists-in-config-disabled", suiteKey: "test-group_disabled-suite", cfg: &config.Config{ Metrics: true, Suites: []*suite.Suite{ { Name: "disabled-suite", Group: "test-group", Enabled: boolPtr(false), }, }, Storage: &storage.Config{ MaximumNumberOfResults: storage.DefaultMaximumNumberOfResults, MaximumNumberOfEvents: storage.DefaultMaximumNumberOfEvents, }, }, expectedCode: http.StatusOK, expectJSON: true, }, { name: "suite-not-in-store-and-not-in-config", suiteKey: "nonexistent_suite", cfg: &config.Config{ Metrics: true, Suites: []*suite.Suite{ { Name: "different-suite", Group: "different-group", }, }, Storage: &storage.Config{ MaximumNumberOfResults: storage.DefaultMaximumNumberOfResults, MaximumNumberOfEvents: storage.DefaultMaximumNumberOfEvents, }, }, expectedCode: http.StatusNotFound, expectError: "Suite with key 'nonexistent_suite' not found", }, { name: "suite-with-empty-group-in-config", suiteKey: "_empty-group-suite", cfg: &config.Config{ Metrics: true, Suites: []*suite.Suite{ { Name: "empty-group-suite", Group: "", }, }, Storage: &storage.Config{ MaximumNumberOfResults: storage.DefaultMaximumNumberOfResults, MaximumNumberOfEvents: storage.DefaultMaximumNumberOfEvents, }, }, expectedCode: http.StatusOK, expectJSON: true, }, { name: "suite-nil-enabled-defaults-to-true", suiteKey: "default_enabled-suite", cfg: &config.Config{ Metrics: true, Suites: []*suite.Suite{ { Name: "enabled-suite", Group: "default", Enabled: nil, }, }, Storage: &storage.Config{ MaximumNumberOfResults: storage.DefaultMaximumNumberOfResults, MaximumNumberOfEvents: storage.DefaultMaximumNumberOfEvents, }, }, expectedCode: http.StatusOK, expectJSON: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { api := New(tt.cfg) router := api.Router() request := httptest.NewRequest("GET", "/api/v1/suites/"+tt.suiteKey+"/statuses", http.NoBody) response, err := router.Test(request) if err != nil { t.Fatalf("Router test failed: %v", err) } defer response.Body.Close() if response.StatusCode != tt.expectedCode { t.Errorf("Expected status code %d, got %d", tt.expectedCode, response.StatusCode) } body, err := io.ReadAll(response.Body) if err != nil { t.Fatalf("Failed to read response body: %v", err) } bodyStr := string(body) if tt.expectJSON { if response.Header.Get("Content-Type") != "application/json" { t.Errorf("Expected JSON content type, got %s", response.Header.Get("Content-Type")) } if len(bodyStr) == 0 || bodyStr[0] != '{' { t.Errorf("Expected JSON response, got: %s", bodyStr) } } if tt.expectError != "" { if !contains(bodyStr, tt.expectError) { t.Errorf("Expected error message '%s' in response, got: %s", tt.expectError, bodyStr) } } }) } } func TestSuiteStatuses(t *testing.T) { defer store.Get().Clear() defer cache.Clear() firstResult := &testSuccessfulSuiteResult secondResult := &testUnsuccessfulSuiteResult store.Get().InsertSuiteResult(&testSuite, firstResult) store.Get().InsertSuiteResult(&testSuite, secondResult) // Can't be bothered dealing with timezone issues on the worker that runs the automated tests firstResult.Timestamp = time.Time{} secondResult.Timestamp = time.Time{} for i := range firstResult.EndpointResults { firstResult.EndpointResults[i].Timestamp = time.Time{} } for i := range secondResult.EndpointResults { secondResult.EndpointResults[i].Timestamp = time.Time{} } api := New(&config.Config{ Metrics: true, Storage: &storage.Config{ MaximumNumberOfResults: storage.DefaultMaximumNumberOfResults, MaximumNumberOfEvents: storage.DefaultMaximumNumberOfEvents, }, }) router := api.Router() type Scenario struct { Name string Path string ExpectedCode int ExpectedBody string } scenarios := []Scenario{ { Name: "no-pagination", Path: "/api/v1/suites/statuses", ExpectedCode: http.StatusOK, ExpectedBody: `[{"name":"test-suite","group":"suite-group","key":"suite-group_test-suite","results":[{"name":"test-suite","group":"suite-group","success":true,"timestamp":"0001-01-01T00:00:00Z","duration":250000000,"endpointResults":[{"status":200,"hostname":"example.org","duration":100000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":150000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 300","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"}]},{"name":"test-suite","group":"suite-group","success":false,"timestamp":"0001-01-01T00:00:00Z","duration":850000000,"endpointResults":[{"status":200,"hostname":"example.org","duration":100000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":500,"hostname":"example.org","duration":750000000,"errors":["endpoint-error-1"],"conditionResults":[{"condition":"[STATUS] == 200","success":false},{"condition":"[RESPONSE_TIME] \u003c 300","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}],"errors":["suite-error-1","suite-error-2"]}]}]`, }, { Name: "pagination-first-result", Path: "/api/v1/suites/statuses?page=1&pageSize=1", ExpectedCode: http.StatusOK, ExpectedBody: `[{"name":"test-suite","group":"suite-group","key":"suite-group_test-suite","results":[{"name":"test-suite","group":"suite-group","success":false,"timestamp":"0001-01-01T00:00:00Z","duration":850000000,"endpointResults":[{"status":200,"hostname":"example.org","duration":100000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":500,"hostname":"example.org","duration":750000000,"errors":["endpoint-error-1"],"conditionResults":[{"condition":"[STATUS] == 200","success":false},{"condition":"[RESPONSE_TIME] \u003c 300","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}],"errors":["suite-error-1","suite-error-2"]}]}]`, }, { Name: "pagination-second-result", Path: "/api/v1/suites/statuses?page=2&pageSize=1", ExpectedCode: http.StatusOK, ExpectedBody: `[{"name":"test-suite","group":"suite-group","key":"suite-group_test-suite","results":[{"name":"test-suite","group":"suite-group","success":true,"timestamp":"0001-01-01T00:00:00Z","duration":250000000,"endpointResults":[{"status":200,"hostname":"example.org","duration":100000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":150000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 300","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"}]}]}]`, }, { Name: "pagination-no-results", Path: "/api/v1/suites/statuses?page=5&pageSize=20", ExpectedCode: http.StatusOK, ExpectedBody: `[{"name":"test-suite","group":"suite-group","key":"suite-group_test-suite","results":[]}]`, }, { Name: "invalid-pagination-should-fall-back-to-default", Path: "/api/v1/suites/statuses?page=INVALID&pageSize=INVALID", ExpectedCode: http.StatusOK, ExpectedBody: `[{"name":"test-suite","group":"suite-group","key":"suite-group_test-suite","results":[{"name":"test-suite","group":"suite-group","success":true,"timestamp":"0001-01-01T00:00:00Z","duration":250000000,"endpointResults":[{"status":200,"hostname":"example.org","duration":100000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":200,"hostname":"example.org","duration":150000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 300","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"}]},{"name":"test-suite","group":"suite-group","success":false,"timestamp":"0001-01-01T00:00:00Z","duration":850000000,"endpointResults":[{"status":200,"hostname":"example.org","duration":100000000,"conditionResults":[{"condition":"[STATUS] == 200","success":true},{"condition":"[RESPONSE_TIME] \u003c 500","success":true}],"success":true,"timestamp":"0001-01-01T00:00:00Z"},{"status":500,"hostname":"example.org","duration":750000000,"errors":["endpoint-error-1"],"conditionResults":[{"condition":"[STATUS] == 200","success":false},{"condition":"[RESPONSE_TIME] \u003c 300","success":false}],"success":false,"timestamp":"0001-01-01T00:00:00Z"}],"errors":["suite-error-1","suite-error-2"]}]}]`, }, } for _, scenario := range scenarios { t.Run(scenario.Name, func(t *testing.T) { request := httptest.NewRequest("GET", scenario.Path, http.NoBody) response, err := router.Test(request) if err != nil { return } defer response.Body.Close() if response.StatusCode != scenario.ExpectedCode { t.Errorf("%s %s should have returned %d, but returned %d instead", request.Method, request.URL, scenario.ExpectedCode, response.StatusCode) } body, err := io.ReadAll(response.Body) if err != nil { t.Error("expected err to be nil, but was", err) } if string(body) != scenario.ExpectedBody { t.Errorf("expected:\n %s\n\ngot:\n %s", scenario.ExpectedBody, string(body)) } }) } } func TestSuiteStatuses_NoSuitesInStoreButExistInConfig(t *testing.T) { defer store.Get().Clear() defer cache.Clear() cfg := &config.Config{ Metrics: true, Suites: []*suite.Suite{ { Name: "config-only-suite-1", Group: "test-group", Enabled: boolPtr(true), }, { Name: "config-only-suite-2", Group: "test-group", Enabled: boolPtr(true), }, { Name: "disabled-suite", Group: "test-group", Enabled: boolPtr(false), }, }, Storage: &storage.Config{ MaximumNumberOfResults: storage.DefaultMaximumNumberOfResults, MaximumNumberOfEvents: storage.DefaultMaximumNumberOfEvents, }, } api := New(cfg) router := api.Router() request := httptest.NewRequest("GET", "/api/v1/suites/statuses", http.NoBody) response, err := router.Test(request) if err != nil { t.Fatalf("Router test failed: %v", err) } defer response.Body.Close() if response.StatusCode != http.StatusOK { t.Errorf("Expected status code %d, got %d", http.StatusOK, response.StatusCode) } body, err := io.ReadAll(response.Body) if err != nil { t.Fatalf("Failed to read response body: %v", err) } bodyStr := string(body) if !contains(bodyStr, "config-only-suite-1") { t.Error("Expected config-only-suite-1 in response") } if !contains(bodyStr, "config-only-suite-2") { t.Error("Expected config-only-suite-2 in response") } if contains(bodyStr, "disabled-suite") { t.Error("Should not include disabled-suite in response") } } func boolPtr(b bool) *bool { return &b } func contains(s, substr string) bool { return len(s) >= len(substr) && (s == substr || len(substr) == 0 || (len(s) > len(substr) && (s[:len(substr)] == substr || s[len(s)-len(substr):] == substr || func() bool { for i := 1; i <= len(s)-len(substr); i++ { if s[i:i+len(substr)] == substr { return true } } return false }()))) } ================================================ FILE: api/util.go ================================================ package api import ( "strconv" "github.com/gofiber/fiber/v2" ) const ( // DefaultPage is the default page to use if none is specified or an invalid value is provided DefaultPage = 1 // DefaultPageSize is the default page size to use if none is specified or an invalid value is provided DefaultPageSize = 50 ) func extractPageAndPageSizeFromRequest(c *fiber.Ctx, maximumNumberOfResults int) (page, pageSize int) { var err error if pageParameter := c.Query("page"); len(pageParameter) == 0 { page = DefaultPage } else { page, err = strconv.Atoi(pageParameter) if err != nil { page = DefaultPage } if page < 1 { page = DefaultPage } } if pageSizeParameter := c.Query("pageSize"); len(pageSizeParameter) == 0 { pageSize = DefaultPageSize } else { pageSize, err = strconv.Atoi(pageSizeParameter) if err != nil { pageSize = DefaultPageSize } } if page == 1 && pageSize > maximumNumberOfResults { // If the page is 1 and the page size is greater than the maximum number of results, return // no more than the maximum number of results pageSize = maximumNumberOfResults } else if pageSize < 1 { pageSize = DefaultPageSize } return } ================================================ FILE: api/util_test.go ================================================ package api import ( "fmt" "testing" "github.com/TwiN/gatus/v5/storage" "github.com/gofiber/fiber/v2" "github.com/valyala/fasthttp" ) func TestExtractPageAndPageSizeFromRequest(t *testing.T) { type Scenario struct { Name string Page string PageSize string ExpectedPage int ExpectedPageSize int MaximumNumberOfResults int } scenarios := []Scenario{ { Page: "1", PageSize: "20", ExpectedPage: 1, ExpectedPageSize: 20, MaximumNumberOfResults: 20, }, { Page: "2", PageSize: "10", ExpectedPage: 2, ExpectedPageSize: 10, MaximumNumberOfResults: 40, }, { Page: "2", PageSize: "10", ExpectedPage: 2, ExpectedPageSize: 10, MaximumNumberOfResults: 200, }, { Page: "1", PageSize: "999999", ExpectedPage: 1, ExpectedPageSize: storage.DefaultMaximumNumberOfResults, MaximumNumberOfResults: 100, }, { Page: "-1", PageSize: "-1", ExpectedPage: DefaultPage, ExpectedPageSize: DefaultPageSize, MaximumNumberOfResults: 20, }, { Page: "invalid", PageSize: "invalid", ExpectedPage: DefaultPage, ExpectedPageSize: DefaultPageSize, MaximumNumberOfResults: 100, }, } for _, scenario := range scenarios { t.Run("page-"+scenario.Page+"-pageSize-"+scenario.PageSize, func(t *testing.T) { //request := httptest.NewRequest("GET", fmt.Sprintf("/api/v1/statuses?page=%s&pageSize=%s", scenario.Page, scenario.PageSize), http.NoBody) app := fiber.New() c := app.AcquireCtx(&fasthttp.RequestCtx{}) defer app.ReleaseCtx(c) c.Request().SetRequestURI(fmt.Sprintf("/api/v1/statuses?page=%s&pageSize=%s", scenario.Page, scenario.PageSize)) actualPage, actualPageSize := extractPageAndPageSizeFromRequest(c, scenario.MaximumNumberOfResults) if actualPage != scenario.ExpectedPage { t.Errorf("expected %d, got %d", scenario.ExpectedPage, actualPage) } if actualPageSize != scenario.ExpectedPageSize { t.Errorf("expected %d, got %d", scenario.ExpectedPageSize, actualPageSize) } }) } } ================================================ FILE: client/client.go ================================================ package client import ( "bytes" "context" "crypto/tls" "crypto/x509" "encoding/hex" "encoding/json" "errors" "fmt" "io" "net" "net/http" "net/smtp" "os" "runtime" "strings" "time" "github.com/TwiN/gocache/v2" "github.com/TwiN/logr" "github.com/TwiN/whois" "github.com/gorilla/websocket" "github.com/ishidawataru/sctp" "github.com/miekg/dns" ping "github.com/prometheus-community/pro-bing" "github.com/registrobr/rdap" "github.com/registrobr/rdap/protocol" "golang.org/x/crypto/ssh" ) const ( dnsPort = 53 ) var ( // injectedHTTPClient is used for testing purposes injectedHTTPClient *http.Client whoisClient = whois.NewClient().WithReferralCache(true) whoisExpirationDateCache = gocache.NewCache().WithMaxSize(10000).WithDefaultTTL(24 * time.Hour) rdapClient = rdap.NewClient(nil) ) // GetHTTPClient returns the shared HTTP client, or the client from the configuration passed func GetHTTPClient(config *Config) *http.Client { if injectedHTTPClient != nil { return injectedHTTPClient } if config == nil { return defaultConfig.getHTTPClient() } return config.getHTTPClient() } // GetDomainExpiration retrieves the duration until the domain provided expires func GetDomainExpiration(hostname string) (domainExpiration time.Duration, err error) { var retrievedCachedValue bool if v, exists := whoisExpirationDateCache.Get(hostname); exists { domainExpiration = time.Until(v.(time.Time)) retrievedCachedValue = true // If the domain OR the TTL is not going to expire in less than 24 hours // we don't have to refresh the cache. Otherwise, we'll refresh it. cacheEntryTTL, _ := whoisExpirationDateCache.TTL(hostname) if cacheEntryTTL > 24*time.Hour && domainExpiration > 24*time.Hour { // No need to refresh, so we'll just return the cached values return domainExpiration, nil } } whoisResponse, err := rdapQuery(hostname) if err != nil { // fallback to WHOIS protocol whoisResponse, err = whoisClient.QueryAndParse(hostname) } if err != nil { if !retrievedCachedValue { // Add an error unless we already retrieved a cached value return 0, fmt.Errorf("error querying and parsing hostname using whois client: %w", err) } } else { domainExpiration = time.Until(whoisResponse.ExpirationDate) if domainExpiration > 720*time.Hour { whoisExpirationDateCache.SetWithTTL(hostname, whoisResponse.ExpirationDate, 240*time.Hour) } else { whoisExpirationDateCache.SetWithTTL(hostname, whoisResponse.ExpirationDate, 72*time.Hour) } } return domainExpiration, nil } // parseLocalAddressPlaceholder returns a string with the local address replaced func parseLocalAddressPlaceholder(item string, localAddr net.Addr) string { item = strings.ReplaceAll(item, "[LOCAL_ADDRESS]", localAddr.String()) return item } // CanCreateNetworkConnection checks whether a connection can be established with a TCP or UDP endpoint func CanCreateNetworkConnection(netType string, address string, body string, config *Config) (bool, []byte) { const ( MaximumMessageSize = 1024 // in bytes ) connection, err := net.DialTimeout(netType, address, config.Timeout) if err != nil { return false, nil } defer connection.Close() if body != "" { body = parseLocalAddressPlaceholder(body, connection.LocalAddr()) connection.SetDeadline(time.Now().Add(config.Timeout)) _, err = connection.Write([]byte(body)) if err != nil { return false, nil } buf := make([]byte, MaximumMessageSize) n, err := connection.Read(buf) if err != nil { return false, nil } return true, buf[:n] } return true, nil } // CanCreateSCTPConnection checks whether a connection can be established with a SCTP endpoint func CanCreateSCTPConnection(address string, config *Config) bool { ch := make(chan bool, 1) go (func(res chan bool) { addr, err := sctp.ResolveSCTPAddr("sctp", address) if err != nil { res <- false return } conn, err := sctp.DialSCTP("sctp", nil, addr) if err != nil { res <- false return } _ = conn.Close() res <- true })(ch) select { case result := <-ch: return result case <-time.After(config.Timeout): return false } } // CanPerformStartTLS checks whether a connection can be established to an address using the STARTTLS protocol func CanPerformStartTLS(address string, config *Config) (connected bool, certificate *x509.Certificate, err error) { hostAndPort := strings.Split(address, ":") if len(hostAndPort) != 2 { return false, nil, errors.New("invalid address for starttls, format must be host:port") } var connection net.Conn var dnsResolver *DNSResolverConfig if config.HasCustomDNSResolver() { dnsResolver, err = config.parseDNSResolver() if err != nil { // We're ignoring the error, because it should have been validated on startup ValidateAndSetDefaults. // It shouldn't happen, but if it does, we'll log it... Better safe than sorry ;) logr.Errorf("[client.getHTTPClient] THIS SHOULD NOT HAPPEN. Silently ignoring invalid DNS resolver due to error: %s", err.Error()) } else { dialer := &net.Dialer{ Resolver: &net.Resolver{ PreferGo: true, Dial: func(ctx context.Context, network, address string) (net.Conn, error) { d := net.Dialer{} return d.DialContext(ctx, dnsResolver.Protocol, dnsResolver.Host+":"+dnsResolver.Port) }, }, } connection, err = dialer.DialContext(context.Background(), "tcp", address) if err != nil { return } } } else { connection, err = net.DialTimeout("tcp", address, config.Timeout) if err != nil { return } } smtpClient, err := smtp.NewClient(connection, hostAndPort[0]) if err != nil { return } err = smtpClient.StartTLS(&tls.Config{ InsecureSkipVerify: config.Insecure, ServerName: hostAndPort[0], }) if err != nil { return } if state, ok := smtpClient.TLSConnectionState(); ok { certificate = state.PeerCertificates[0] } else { return false, nil, errors.New("could not get TLS connection state") } return true, certificate, nil } // CanPerformTLS checks whether a connection can be established to an address using the TLS protocol func CanPerformTLS(address string, body string, config *Config) (connected bool, response []byte, certificate *x509.Certificate, err error) { const ( MaximumMessageSize = 1024 // in bytes ) connection, err := tls.DialWithDialer(&net.Dialer{Timeout: config.Timeout}, "tcp", address, &tls.Config{ InsecureSkipVerify: config.Insecure, }) if err != nil { return } defer connection.Close() verifiedChains := connection.ConnectionState().VerifiedChains // If config.Insecure is set to true, verifiedChains will be an empty list [] // We should get the parsed certificates from PeerCertificates, it can't be empty on the client side // Reference: https://pkg.go.dev/crypto/tls#PeerCertificates if len(verifiedChains) == 0 || len(verifiedChains[0]) == 0 { peerCertificates := connection.ConnectionState().PeerCertificates certificate = peerCertificates[0] } else { certificate = verifiedChains[0][0] } connected = true if body != "" { body = parseLocalAddressPlaceholder(body, connection.LocalAddr()) connection.SetDeadline(time.Now().Add(config.Timeout)) _, err = connection.Write([]byte(body)) if err != nil { return } buf := make([]byte, MaximumMessageSize) var n int n, err = connection.Read(buf) if err != nil { return } response = buf[:n] } return } // CanCreateSSHConnection checks whether a connection can be established and a command can be executed to an address // using the SSH protocol. func CanCreateSSHConnection(address, username, password, privateKey string, config *Config) (bool, *ssh.Client, error) { var port string if strings.Contains(address, ":") { addressAndPort := strings.Split(address, ":") if len(addressAndPort) != 2 { return false, nil, errors.New("invalid address for ssh, format must be host:port") } address = addressAndPort[0] port = addressAndPort[1] } else { port = "22" } // Build auth methods: prefer parsed private key if provided, fall back to password. var authMethods []ssh.AuthMethod if len(privateKey) > 0 { if signer, err := ssh.ParsePrivateKey([]byte(privateKey)); err == nil { authMethods = append(authMethods, ssh.PublicKeys(signer)) } else { return false, nil, fmt.Errorf("invalid private key: %w", err) } } if len(password) > 0 { authMethods = append(authMethods, ssh.Password(password)) } cli, err := ssh.Dial("tcp", net.JoinHostPort(address, port), &ssh.ClientConfig{ HostKeyCallback: ssh.InsecureIgnoreHostKey(), User: username, Auth: authMethods, Timeout: config.Timeout, }) if err != nil { return false, nil, err } return true, cli, nil } func CheckSSHBanner(address string, cfg *Config) (bool, int, error) { var port string if strings.Contains(address, ":") { addressAndPort := strings.Split(address, ":") if len(addressAndPort) != 2 { return false, 1, errors.New("invalid address for ssh, format must be ssh://host:port") } address = addressAndPort[0] port = addressAndPort[1] } else { port = "22" } dialer := net.Dialer{} connStr := net.JoinHostPort(address, port) conn, err := dialer.Dial("tcp", connStr) if err != nil { return false, 1, err } defer conn.Close() conn.SetReadDeadline(time.Now().Add(time.Second)) buf := make([]byte, 256) _, err = io.ReadAtLeast(conn, buf, 1) if err != nil { return false, 1, err } return true, 0, err } // ExecuteSSHCommand executes a command to an address using the SSH protocol. func ExecuteSSHCommand(sshClient *ssh.Client, body string, config *Config) (bool, int, []byte, error) { type Body struct { Command string `json:"command"` } defer sshClient.Close() var b Body body = parseLocalAddressPlaceholder(body, sshClient.Conn.LocalAddr()) if err := json.Unmarshal([]byte(body), &b); err != nil { return false, 0, nil, err } sess, err := sshClient.NewSession() if err != nil { return false, 0, nil, err } // Capture stdout var stdout bytes.Buffer sess.Stdout = &stdout err = sess.Start(b.Command) if err != nil { return false, 0, nil, err } defer sess.Close() err = sess.Wait() output := stdout.Bytes() if err == nil { return true, 0, output, nil } var exitErr *ssh.ExitError if ok := errors.As(err, &exitErr); !ok { return false, 0, nil, err } return true, exitErr.ExitStatus(), output, nil } // Ping checks if an address can be pinged and returns the round-trip time if the address can be pinged // // Note that this function takes at least 100ms, even if the address is 127.0.0.1 func Ping(address string, config *Config) (bool, time.Duration) { pinger := ping.New(address) pinger.Count = 1 pinger.Timeout = config.Timeout pinger.SetPrivileged(ShouldRunPingerAsPrivileged()) pinger.SetNetwork(config.Network) err := pinger.Run() if err != nil { return false, 0 } if pinger.Statistics() != nil { // If the packet loss is 100, it means that the packet didn't reach the host if pinger.Statistics().PacketLoss == 100 { return false, pinger.Timeout } return true, pinger.Statistics().MaxRtt } return true, 0 } // ShouldRunPingerAsPrivileged will determine whether or not to run pinger in privileged mode. // It should be set to privileged when running as root, and always on windows. See https://pkg.go.dev/github.com/macrat/go-parallel-pinger#Pinger.SetPrivileged func ShouldRunPingerAsPrivileged() bool { // Set the pinger's privileged mode to false for darwin // See https://github.com/TwiN/gatus/issues/132 // linux should also be set to false, but there are potential complications // See https://github.com/TwiN/gatus/pull/748 and https://github.com/TwiN/gatus/issues/697#issuecomment-2081700989 // // Note that for this to work on Linux, Gatus must run with sudo privileges. (in certain cases) // See https://github.com/prometheus-community/pro-bing#linux if runtime.GOOS == "windows" { return true } // To actually check for cap_net_raw capabilities, we would need to add "kernel.org/pub/linux/libs/security/libcap/cap" to gatus. // Or use a syscall and check for permission errors, but this requires platform specific compilation // As a backstop we can simply check the effective user id and run as privileged when running as root return os.Geteuid() == 0 } // QueryWebSocket opens a websocket connection, write `body` and return a message from the server func QueryWebSocket(address, body string, headers map[string]string, config *Config) (bool, []byte, error) { const ( Origin = "http://localhost/" ) var ( dialer = websocket.Dialer{ EnableCompression: true, } wsHeaders = make(http.Header) ) wsHeaders.Set("Origin", Origin) for name, value := range headers { wsHeaders.Set(name, value) } ctx := context.Background() if config != nil { if config.Timeout > 0 { var cancel context.CancelFunc ctx, cancel = context.WithTimeout(ctx, config.Timeout) defer cancel() } dialer.TLSClientConfig = &tls.Config{ InsecureSkipVerify: config.Insecure, } if config.HasTLSConfig() && config.TLS.isValid() == nil { dialer.TLSClientConfig = configureTLS(dialer.TLSClientConfig, *config.TLS) } } // Dial URL ws, _, err := dialer.DialContext(ctx, address, wsHeaders) if err != nil { return false, nil, fmt.Errorf("error dialing websocket: %w", err) } defer ws.Close() body = parseLocalAddressPlaceholder(body, ws.LocalAddr()) // Write message if err := ws.WriteMessage(websocket.TextMessage, []byte(body)); err != nil { return false, nil, fmt.Errorf("error writing websocket body: %w", err) } // Read message msgType, msg, err := ws.ReadMessage() if err != nil { return false, nil, fmt.Errorf("error reading websocket message: %w", err) } else if msgType != websocket.TextMessage && msgType != websocket.BinaryMessage { return false, nil, fmt.Errorf("unexpected websocket message type: %d, expected %d or %d", msgType, websocket.TextMessage, websocket.BinaryMessage) } return true, msg, nil } func QueryDNS(queryType, queryName, url string) (connected bool, dnsRcode string, body []byte, err error) { if !strings.Contains(url, ":") { url = fmt.Sprintf("%s:%d", url, dnsPort) } queryTypeAsUint16 := dns.StringToType[queryType] // Special handling: if this is a PTR query and queryName looks like a plain IP, // convert it to the proper reverse lookup domain automatically. if queryTypeAsUint16 == dns.TypePTR && !strings.HasSuffix(queryName, ".in-addr.arpa.") && !strings.HasSuffix(queryName, ".ip6.arpa.") { if rev, convErr := reverseNameForIP(queryName); convErr == nil { queryName = rev } else { return false, "", nil, convErr } } c := new(dns.Client) m := new(dns.Msg) m.SetQuestion(queryName, queryTypeAsUint16) r, _, err := c.Exchange(m, url) if err != nil { logr.Infof("[client.QueryDNS] Error exchanging DNS message: %v", err) return false, "", nil, err } connected = true dnsRcode = dns.RcodeToString[r.Rcode] for _, rr := range r.Answer { switch rr.Header().Rrtype { case dns.TypeA: if a, ok := rr.(*dns.A); ok { body = []byte(a.A.String()) } case dns.TypeAAAA: if aaaa, ok := rr.(*dns.AAAA); ok { body = []byte(aaaa.AAAA.String()) } case dns.TypeCNAME: if cname, ok := rr.(*dns.CNAME); ok { body = []byte(cname.Target) } case dns.TypeMX: if mx, ok := rr.(*dns.MX); ok { body = []byte(mx.Mx) } case dns.TypeNS: if ns, ok := rr.(*dns.NS); ok { body = []byte(ns.Ns) } case dns.TypePTR: if ptr, ok := rr.(*dns.PTR); ok { body = []byte(ptr.Ptr) } case dns.TypeSRV: if srv, ok := rr.(*dns.SRV); ok { body = []byte(fmt.Sprintf("%s:%d", srv.Target, srv.Port)) } default: body = []byte("query type is not supported yet") } } return connected, dnsRcode, body, nil } // InjectHTTPClient is used to inject a custom HTTP client for testing purposes func InjectHTTPClient(httpClient *http.Client) { injectedHTTPClient = httpClient } // rdapQuery returns domain expiration via RDAP protocol func rdapQuery(hostname string) (*whois.Response, error) { data, _, err := rdapClient.Query(hostname, nil, nil) if err != nil { return nil, err } domain, ok := data.(*protocol.Domain) if !ok { return nil, errors.New("invalid domain type") } response := whois.Response{} for _, e := range domain.Events { if e.Action == "expiration" { response.ExpirationDate = e.Date.Time break } } return &response, nil } // helper to reverse IP and add in-addr.arpa. IPv4 and IPv6 func reverseNameForIP(ipStr string) (string, error) { ip := net.ParseIP(ipStr) if ip == nil { return "", fmt.Errorf("invalid IP: %s", ipStr) } if ipv4 := ip.To4(); ipv4 != nil { parts := strings.Split(ipv4.String(), ".") for i, j := 0, len(parts)-1; i < j; i, j = i+1, j-1 { parts[i], parts[j] = parts[j], parts[i] } return strings.Join(parts, ".") + ".in-addr.arpa.", nil } ip = ip.To16() hexStr := hex.EncodeToString(ip) nibbles := strings.Split(hexStr, "") for i, j := 0, len(nibbles)-1; i < j; i, j = i+1, j-1 { nibbles[i], nibbles[j] = nibbles[j], nibbles[i] } return strings.Join(nibbles, ".") + ".ip6.arpa.", nil } ================================================ FILE: client/client_test.go ================================================ package client import ( "bytes" "crypto/tls" "io" "net/http" "net/netip" "os" "runtime" "testing" "time" "github.com/TwiN/gatus/v5/config/endpoint/dns" "github.com/TwiN/gatus/v5/pattern" "github.com/TwiN/gatus/v5/test" ) func TestGetHTTPClient(t *testing.T) { t.Parallel() cfg := &Config{ Insecure: false, IgnoreRedirect: false, Timeout: 0, DNSResolver: "tcp://1.1.1.1:53", OAuth2Config: &OAuth2Config{ ClientID: "00000000-0000-0000-0000-000000000000", ClientSecret: "secretsauce", TokenURL: "https://token-server.local/token", Scopes: []string{"https://application.local/.default"}, }, } err := cfg.ValidateAndSetDefaults() if err != nil { t.Errorf("expected error to be nil, but got: `%s`", err) } if GetHTTPClient(cfg) == nil { t.Error("expected client to not be nil") } if GetHTTPClient(nil) == nil { t.Error("expected client to not be nil") } } func TestRdapQuery(t *testing.T) { t.Parallel() if _, err := rdapQuery("1.1.1.1"); err == nil { t.Error("expected an error due to the invalid domain type") } if _, err := rdapQuery("eurid.eu"); err == nil { t.Error("expected an error as there is no RDAP support currently in .eu") } if response, err := rdapQuery("example.com"); err != nil { t.Fatal("expected no error, got", err.Error()) } else if response.ExpirationDate.Unix() <= 0 { t.Error("expected to have a valid expiry date, got", response.ExpirationDate.Unix()) } } func TestGetDomainExpiration(t *testing.T) { t.Parallel() if domainExpiration, err := GetDomainExpiration("gatus.io"); err != nil { t.Fatalf("expected error to be nil, but got: `%s`", err) } else if domainExpiration <= 0 { t.Error("expected domain expiration to be higher than 0") } if domainExpiration, err := GetDomainExpiration("gatus.io"); err != nil { t.Errorf("expected error to be nil, but got: `%s`", err) } else if domainExpiration <= 0 { t.Error("expected domain expiration to be higher than 0") } // Hack to pretend like the domain is expiring in 1 hour, which should trigger a refresh whoisExpirationDateCache.SetWithTTL("gatus.io", time.Now().Add(time.Hour), 25*time.Hour) if domainExpiration, err := GetDomainExpiration("gatus.io"); err != nil { t.Errorf("expected error to be nil, but got: `%s`", err) } else if domainExpiration <= 0 { t.Error("expected domain expiration to be higher than 0") } // Make sure the refresh works when the ttl is <24 hours whoisExpirationDateCache.SetWithTTL("gatus.io", time.Now().Add(35*time.Hour), 23*time.Hour) if domainExpiration, err := GetDomainExpiration("gatus.io"); err != nil { t.Errorf("expected error to be nil, but got: `%s`", err) } else if domainExpiration <= 0 { t.Error("expected domain expiration to be higher than 0") } } func TestPing(t *testing.T) { t.Parallel() if success, rtt := Ping("127.0.0.1", &Config{Timeout: 500 * time.Millisecond}); !success { t.Error("expected true") if rtt == 0 { t.Error("Round-trip time returned on success should've higher than 0") } } if success, rtt := Ping("256.256.256.256", &Config{Timeout: 500 * time.Millisecond}); success { t.Error("expected false, because the IP is invalid") if rtt != 0 { t.Error("Round-trip time returned on failure should've been 0") } } if success, rtt := Ping("192.168.152.153", &Config{Timeout: 500 * time.Millisecond}); success { t.Error("expected false, because the IP is valid but the host should be unreachable") if rtt != 0 { t.Error("Round-trip time returned on failure should've been 0") } } // Can't perform integration tests (e.g. pinging public targets by single-stacked hostname) here, // because ICMP is blocked in the network of GitHub-hosted runners. if success, rtt := Ping("127.0.0.1", &Config{Timeout: 500 * time.Millisecond, Network: "ip"}); !success { t.Error("expected true") if rtt == 0 { t.Error("Round-trip time returned on failure should've been 0") } } if success, rtt := Ping("::1", &Config{Timeout: 500 * time.Millisecond, Network: "ip"}); !success { t.Error("expected true") if rtt == 0 { t.Error("Round-trip time returned on failure should've been 0") } } if success, rtt := Ping("::1", &Config{Timeout: 500 * time.Millisecond, Network: "ip4"}); success { t.Error("expected false, because the IP isn't an IPv4 address") if rtt != 0 { t.Error("Round-trip time returned on failure should've been 0") } } if success, rtt := Ping("127.0.0.1", &Config{Timeout: 500 * time.Millisecond, Network: "ip6"}); success { t.Error("expected false, because the IP isn't an IPv6 address") if rtt != 0 { t.Error("Round-trip time returned on failure should've been 0") } } } func TestShouldRunPingerAsPrivileged(t *testing.T) { // Don't run in parallel since we're testing system-dependent behavior if runtime.GOOS == "windows" { result := ShouldRunPingerAsPrivileged() if !result { t.Error("On Windows, ShouldRunPingerAsPrivileged() should return true") } return } // Non-Windows tests result := ShouldRunPingerAsPrivileged() isRoot := os.Geteuid() == 0 // Test cases based on current environment if isRoot { if !result { t.Error("When running as root, ShouldRunPingerAsPrivileged() should return true") } } else { // When not root, the result depends on raw socket creation // We can at least verify the function runs without panic t.Logf("Non-root privileged result: %v", result) } } func TestCanPerformStartTLS(t *testing.T) { type args struct { address string insecure bool dnsresolver string } tests := []struct { name string args args wantConnected bool wantErr bool }{ { name: "invalid address", args: args{ address: "test", }, wantConnected: false, wantErr: true, }, { name: "error dial", args: args{ address: "test:1234", }, wantConnected: false, wantErr: true, }, { name: "valid starttls", args: args{ address: "smtp.gmail.com:587", }, wantConnected: true, wantErr: false, }, { name: "dns resolver", args: args{ address: "smtp.gmail.com:587", dnsresolver: "tcp://1.1.1.1:53", }, wantConnected: true, wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() connected, _, err := CanPerformStartTLS(tt.args.address, &Config{Insecure: tt.args.insecure, Timeout: 5 * time.Second, DNSResolver: tt.args.dnsresolver}) if (err != nil) != tt.wantErr { t.Errorf("CanPerformStartTLS() err=%v, wantErr=%v", err, tt.wantErr) return } if connected != tt.wantConnected { t.Errorf("CanPerformStartTLS() connected=%v, wantConnected=%v", connected, tt.wantConnected) } }) } } func TestCanPerformTLS(t *testing.T) { type args struct { address string insecure bool } tests := []struct { name string args args wantConnected bool wantErr bool }{ { name: "invalid address", args: args{ address: "test", }, wantConnected: false, wantErr: true, }, { name: "error dial", args: args{ address: "test:1234", }, wantConnected: false, wantErr: true, }, { name: "valid tls", args: args{ address: "smtp.gmail.com:465", }, wantConnected: true, wantErr: false, }, { name: "bad cert with insecure true", args: args{ address: "expired.badssl.com:443", insecure: true, }, wantConnected: true, wantErr: false, }, { name: "bad cert with insecure false", args: args{ address: "expired.badssl.com:443", insecure: false, }, wantConnected: false, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() connected, _, _, err := CanPerformTLS(tt.args.address, "", &Config{Insecure: tt.args.insecure, Timeout: 5 * time.Second}) if (err != nil) != tt.wantErr { t.Errorf("CanPerformTLS() err=%v, wantErr=%v", err, tt.wantErr) return } if connected != tt.wantConnected { t.Errorf("CanPerformTLS() connected=%v, wantConnected=%v", connected, tt.wantConnected) } }) } } func TestCanCreateConnection(t *testing.T) { t.Parallel() connected, _ := CanCreateNetworkConnection("tcp", "127.0.0.1", "", &Config{Timeout: 5 * time.Second}) if connected { t.Error("should've failed, because there's no port in the address") } connected, _ = CanCreateNetworkConnection("tcp", "1.1.1.1:53", "", &Config{Timeout: 5 * time.Second}) if !connected { t.Error("should've succeeded, because that IP should always™ be up") } } // This test checks if a HTTP client configured with `configureOAuth2()` automatically // performs a Client Credentials OAuth2 flow and adds the obtained token as a `Authorization` // header to all outgoing HTTP calls. func TestHttpClientProvidesOAuth2BearerToken(t *testing.T) { t.Parallel() defer InjectHTTPClient(nil) oAuth2Config := &OAuth2Config{ ClientID: "00000000-0000-0000-0000-000000000000", ClientSecret: "secretsauce", TokenURL: "https://token-server.local/token", Scopes: []string{"https://application.local/.default"}, } mockHttpClient := &http.Client{ Transport: test.MockRoundTripper(func(r *http.Request) *http.Response { // if the mock HTTP client tries to get a token from the `token-server` // we provide the expected token response if r.Host == "token-server.local" { return &http.Response{ StatusCode: http.StatusOK, Body: io.NopCloser(bytes.NewReader( []byte( `{"token_type":"Bearer","expires_in":3599,"ext_expires_in":3599,"access_token":"secret-token"}`, ), )), } } // to verify the headers were sent as expected, we echo them back in the // `X-Org-Authorization` header and check if the token value matches our // mocked `token-server` response return &http.Response{ StatusCode: http.StatusOK, Header: map[string][]string{ "X-Org-Authorization": {r.Header.Get("Authorization")}, }, Body: http.NoBody, } }), } mockHttpClientWithOAuth := configureOAuth2(mockHttpClient, *oAuth2Config) InjectHTTPClient(mockHttpClientWithOAuth) request, err := http.NewRequest(http.MethodPost, "http://127.0.0.1:8282", http.NoBody) if err != nil { t.Error("expected no error, got", err.Error()) } response, err := mockHttpClientWithOAuth.Do(request) if err != nil { t.Error("expected no error, got", err.Error()) } if response.Header == nil { t.Error("expected response headers, but got nil") } // the mock response echos the Authorization header used in the request back // to us as `X-Org-Authorization` header, we check here if the value matches // our expected token `secret-token` if response.Header.Get("X-Org-Authorization") != "Bearer secret-token" { t.Error("expected `secret-token` as Bearer token in the mocked response header `X-Org-Authorization`, but got", response.Header.Get("X-Org-Authorization")) } } func TestQueryWebSocket(t *testing.T) { t.Parallel() _, _, err := QueryWebSocket("", "body", nil, &Config{Timeout: 2 * time.Second}) if err == nil { t.Error("expected an error due to the address being invalid") } _, _, err = QueryWebSocket("ws://example.org", "body", nil, &Config{Timeout: 2 * time.Second}) if err == nil { t.Error("expected an error due to the target not being websocket-friendly") } } func TestTlsRenegotiation(t *testing.T) { t.Parallel() scenarios := []struct { name string cfg TLSConfig expectedConfig tls.RenegotiationSupport }{ { name: "default", cfg: TLSConfig{CertificateFile: "../testdata/cert.pem", PrivateKeyFile: "../testdata/cert.key"}, expectedConfig: tls.RenegotiateNever, }, { name: "never", cfg: TLSConfig{RenegotiationSupport: "never", CertificateFile: "../testdata/cert.pem", PrivateKeyFile: "../testdata/cert.key"}, expectedConfig: tls.RenegotiateNever, }, { name: "once", cfg: TLSConfig{RenegotiationSupport: "once", CertificateFile: "../testdata/cert.pem", PrivateKeyFile: "../testdata/cert.key"}, expectedConfig: tls.RenegotiateOnceAsClient, }, { name: "freely", cfg: TLSConfig{RenegotiationSupport: "freely", CertificateFile: "../testdata/cert.pem", PrivateKeyFile: "../testdata/cert.key"}, expectedConfig: tls.RenegotiateFreelyAsClient, }, { name: "not-valid-and-broken", cfg: TLSConfig{RenegotiationSupport: "invalid", CertificateFile: "../testdata/cert.pem", PrivateKeyFile: "../testdata/cert.key"}, expectedConfig: tls.RenegotiateNever, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { tls := &tls.Config{} tlsConfig := configureTLS(tls, scenario.cfg) if tlsConfig.Renegotiation != scenario.expectedConfig { t.Errorf("expected tls renegotiation to be %v, but got %v", scenario.expectedConfig, tls.Renegotiation) } }) } } func TestQueryDNS(t *testing.T) { t.Parallel() scenarios := []struct { name string inputDNS dns.Config inputURL string expectedDNSCode string expectedBody string isErrExpected bool }{ { name: "test Config with type A", inputDNS: dns.Config{ QueryType: "A", QueryName: "example.com.", }, inputURL: "8.8.8.8", expectedDNSCode: "NOERROR", expectedBody: "__IPV4__", }, { name: "test Config with type AAAA", inputDNS: dns.Config{ QueryType: "AAAA", QueryName: "example.com.", }, inputURL: "8.8.8.8", expectedDNSCode: "NOERROR", expectedBody: "__IPV6__", }, { name: "test Config with type CNAME", inputDNS: dns.Config{ QueryType: "CNAME", QueryName: "en.wikipedia.org.", }, inputURL: "8.8.8.8", expectedDNSCode: "NOERROR", expectedBody: "dyna.wikimedia.org.", }, { name: "test Config with type MX", inputDNS: dns.Config{ QueryType: "MX", QueryName: "example.com.", }, inputURL: "8.8.8.8", expectedDNSCode: "NOERROR", expectedBody: ".", }, { name: "test Config with type NS", inputDNS: dns.Config{ QueryType: "NS", QueryName: "example.com.", }, inputURL: "8.8.8.8", expectedDNSCode: "NOERROR", expectedBody: "*.ns.cloudflare.com.", }, { name: "test Config with type PTR", inputDNS: dns.Config{ QueryType: "PTR", QueryName: "8.8.8.8.in-addr.arpa.", }, inputURL: "8.8.8.8", expectedDNSCode: "NOERROR", expectedBody: "dns.google.", }, { name: "test Config with type PTR and forward IP / no in-addr", inputDNS: dns.Config{ QueryType: "PTR", QueryName: "1.0.0.1", }, inputURL: "1.1.1.1", expectedDNSCode: "NOERROR", expectedBody: "one.one.one.one.", }, { name: "test Config with fake type and retrieve error", inputDNS: dns.Config{ QueryType: "B", QueryName: "example", }, inputURL: "8.8.8.8", isErrExpected: true, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t *testing.T) { _, dnsRCode, body, err := QueryDNS(scenario.inputDNS.QueryType, scenario.inputDNS.QueryName, scenario.inputURL) if scenario.isErrExpected && err == nil { t.Errorf("there should be an error") } if dnsRCode != scenario.expectedDNSCode { t.Errorf("expected DNSRCode to be %s, got %s", scenario.expectedDNSCode, dnsRCode) } if scenario.inputDNS.QueryType == "NS" { // Because there are often multiple nameservers backing a single domain, we'll only look at the suffix if !pattern.Match(scenario.expectedBody, string(body)) { t.Errorf("got %s, expected result %s,", string(body), scenario.expectedBody) } } else { if string(body) != scenario.expectedBody { // little hack to validate arbitrary ipv4/ipv6 switch scenario.expectedBody { case "__IPV4__": if addr, err := netip.ParseAddr(string(body)); err != nil { t.Errorf("got %s, expected result %s", string(body), scenario.expectedBody) } else if !addr.Is4() { t.Errorf("got %s, expected valid IPv4", string(body)) } case "__IPV6__": if addr, err := netip.ParseAddr(string(body)); err != nil { t.Errorf("got %s, expected result %s", string(body), scenario.expectedBody) } else if !addr.Is6() { t.Errorf("got %s, expected valid IPv6", string(body)) } default: t.Errorf("got %s, expected result %s", string(body), scenario.expectedBody) } } } }) time.Sleep(10 * time.Millisecond) } } func TestCheckSSHBanner(t *testing.T) { t.Parallel() cfg := &Config{Timeout: 3} t.Run("no-auth-ssh", func(t *testing.T) { connected, status, err := CheckSSHBanner("tty.sdf.org", cfg) if err != nil { t.Errorf("Expected: error != nil, got: %v ", err) } if connected == false { t.Errorf("Expected: connected == true, got: %v", connected) } if status != 0 { t.Errorf("Expected: 0, got: %v", status) } }) t.Run("invalid-address", func(t *testing.T) { connected, status, err := CheckSSHBanner("idontplaytheodds.com", cfg) if err == nil { t.Errorf("Expected: error, got: %v ", err) } if connected != false { t.Errorf("Expected: connected == false, got: %v", connected) } if status != 1 { t.Errorf("Expected: 1, got: %v", status) } }) } ================================================ FILE: client/config.go ================================================ package client import ( "context" "crypto/tls" "errors" "net" "net/http" "net/url" "regexp" "strconv" "time" "github.com/TwiN/gatus/v5/config/tunneling/sshtunnel" "github.com/TwiN/logr" "golang.org/x/oauth2" "golang.org/x/oauth2/clientcredentials" "google.golang.org/api/idtoken" ) const ( defaultTimeout = 10 * time.Second ) var ( ErrInvalidDNSResolver = errors.New("invalid DNS resolver specified. Required format is {proto}://{ip}:{port}") ErrInvalidDNSResolverPort = errors.New("invalid DNS resolver port") ErrInvalidClientOAuth2Config = errors.New("invalid oauth2 configuration: must define all fields for client credentials flow (token-url, client-id, client-secret, scopes)") ErrInvalidClientIAPConfig = errors.New("invalid Identity-Aware-Proxy configuration: must define all fields for Google Identity-Aware-Proxy programmatic authentication (audience)") ErrInvalidClientTLSConfig = errors.New("invalid TLS configuration: certificate-file and private-key-file must be specified") defaultConfig = Config{ Insecure: false, IgnoreRedirect: false, Timeout: defaultTimeout, Network: "ip", } ) // GetDefaultConfig returns a copy of the default configuration func GetDefaultConfig() *Config { cfg := defaultConfig return &cfg } // Config is the configuration for clients type Config struct { // ProxyURL is the URL of the proxy to use for the client ProxyURL string `yaml:"proxy-url,omitempty"` // Insecure determines whether to skip verifying the server's certificate chain and host name Insecure bool `yaml:"insecure,omitempty"` // IgnoreRedirect determines whether to ignore redirects (true) or follow them (false, default) IgnoreRedirect bool `yaml:"ignore-redirect,omitempty"` // Timeout for the client Timeout time.Duration `yaml:"timeout"` // DNSResolver override for the HTTP client // Expected format is {protocol}://{host}:{port}, e.g. tcp://8.8.8.8:53 DNSResolver string `yaml:"dns-resolver,omitempty"` // OAuth2Config is the OAuth2 configuration used for the client. // // If non-nil, the http.Client returned by getHTTPClient will automatically retrieve a token if necessary. // See configureOAuth2 for more details. OAuth2Config *OAuth2Config `yaml:"oauth2,omitempty"` // IAPConfig is the Google Cloud Identity-Aware-Proxy configuration used for the client. (e.g. audience) IAPConfig *IAPConfig `yaml:"identity-aware-proxy,omitempty"` // Network (ip, ip4 or ip6) for the ICMP client Network string `yaml:"network"` // TLS configuration (optional) TLS *TLSConfig `yaml:"tls,omitempty"` // Tunnel is the name of the SSH tunnel to use for the client Tunnel string `yaml:"tunnel,omitempty"` // ResolvedTunnel is the resolved SSH tunnel for this specific Config ResolvedTunnel *sshtunnel.SSHTunnel `yaml:"-"` httpClient *http.Client } // DNSResolverConfig is the parsed configuration from the DNSResolver config string. type DNSResolverConfig struct { Protocol string Host string Port string } // OAuth2Config is the configuration for the OAuth2 client credentials flow type OAuth2Config struct { TokenURL string `yaml:"token-url"` // e.g. https://dev-12345678.okta.com/token ClientID string `yaml:"client-id"` ClientSecret string `yaml:"client-secret"` Scopes []string `yaml:"scopes"` // e.g. ["openid"] } // IAPConfig is the configuration for the Google Cloud Identity-Aware-Proxy type IAPConfig struct { Audience string `yaml:"audience"` // e.g. "toto.apps.googleusercontent.com" } // TLSConfig is the configuration for mTLS configurations type TLSConfig struct { // CertificateFile is the public certificate for TLS in PEM format. CertificateFile string `yaml:"certificate-file,omitempty"` // PrivateKeyFile is the private key file for TLS in PEM format. PrivateKeyFile string `yaml:"private-key-file,omitempty"` RenegotiationSupport string `yaml:"renegotiation,omitempty"` } // ValidateAndSetDefaults validates the client configuration and sets the default values if necessary func (c *Config) ValidateAndSetDefaults() error { if c.Timeout < time.Millisecond { c.Timeout = 10 * time.Second } if c.HasCustomDNSResolver() { // Validate the DNS resolver now to make sure it will not return an error later. if _, err := c.parseDNSResolver(); err != nil { return err } } if c.HasOAuth2Config() && !c.OAuth2Config.isValid() { return ErrInvalidClientOAuth2Config } if c.HasIAPConfig() && !c.IAPConfig.isValid() { return ErrInvalidClientIAPConfig } if c.HasTLSConfig() { if err := c.TLS.isValid(); err != nil { return err } } return nil } // HasCustomDNSResolver returns whether a custom DNSResolver is configured func (c *Config) HasCustomDNSResolver() bool { return len(c.DNSResolver) > 0 } // parseDNSResolver parses the DNS resolver into the DNSResolverConfig struct func (c *Config) parseDNSResolver() (*DNSResolverConfig, error) { re := regexp.MustCompile(`^(?P
john.doe
*)"),
Result: &Result{Body: []byte(`john.doe
`)},
ExpectedSuccess: true,
ExpectedOutput: "[BODY] == pat(*john.doe
*)",
},
{
Name: "pat-body-html-failure",
Condition: Condition("[BODY] == pat(*john.doe
*)"),
Result: &Result{Body: []byte(`jane.doe
`)},
ExpectedSuccess: false,
ExpectedOutput: "[BODY] (john.doe*)",
},
{
Name: "pat-body-html-failure-alt",
Condition: Condition("pat(*john.doe
*) == [BODY]"),
Result: &Result{Body: []byte(`jane.doe
`)},
ExpectedSuccess: false,
ExpectedOutput: "pat(*john.doe
*) == [BODY] ( 
{{ header }}
System Monitoring Dashboard
System Monitoring Dashboard
You do not have access to this status page {{ route.query.error }}
Announcements
({{ announcements.length }})
{{ endpoint.group }}
•
{{ hostname }}
{{ formattedResponseTime }}
{{ oldestResultTime }}
{{ newestResultTime }}
{{ step.name }}
{{ formatDuration(step.duration) }}
Page {{ currentPage }} of {{ maxPages }}
================================================
FILE: web/app/src/components/PastAnnouncements.vue
================================================
Past Announcements
{{ formatDate(date) }}
No incidents reported on this day
{{ error }}
Start
End
{{ completedSteps }}/{{ totalSteps }} steps successful
{{ formatDuration(totalDuration) }} total
Status Legend
Step {{ index + 1 }} • {{ formatDuration(step.duration) }}
Always Run
This endpoint is configured to execute even after failures
{{ error }}
{{ prettifyTimestamp(step.result.timestamp) }}
Duration:
{{ formatDuration(step.result.duration) }}
Success:
{{ step.result.success ? 'Yes' : 'No' }}
{{ conditionResult.condition }}
{{ conditionResult.success ? 'Passed' : 'Failed' }}
URL:
{{ step.endpoint.url }}
Method:
{{ step.endpoint.method }}
Interval:
{{ step.endpoint.interval }}
Timeout:
{{ step.endpoint.timeout }}
{{ error }}
{{ suite.group }}
•
{{ endpointCount }} endpoint{{ endpointCount !== 1 ? 's' : '' }}
Success Rate: {{ successRate }}%
{{ averageDuration }}ms avg
{{ oldestResultTime }}
{{ newestResultTime }}
{{ result.success ? 'Suite Passed' : 'Suite Failed' }}
Timestamp
{{ prettifyTimestamp(result.timestamp) }}
Endpoints
{{ successCount }}/{{ endpointCount }} passed
{{ endpoint.success ? '✓' : '✗' }}
{{ endpoint.name }}
({{ Math.trunc(endpoint.duration / 1000000) }}ms)
... and {{ result.endpointResults.length - 5 }} more
{{ isSuiteResult ? 'Total Duration' : 'Response Time' }}
{{ Math.trunc(result.duration / 1000000) }}ms
Conditions
{{ conditionResult.success ? '✓' : '✗' }}
{{ conditionResult.condition }}
Errors
• {{ error }}
{{ endpointStatus.name }}
Group: {{ endpointStatus.group }}
•
{{ hostname }}
{{ currentHealthStatus === 'healthy' ? 'Operational' : 'Issues Detected' }}
{{ pageAverageResponseTime }}
{{ pageResponseTimeRange }}
{{ lastCheckTime }}
{{ period === '30d' ? 'Last 30 days' : period === '7d' ? 'Last 7 days' : period === '24h' ? 'Last 24 hours' : 'Last hour' }}
{{ event.fancyText }}
{{ prettifyTimestamp(event.timestamp) }} • {{ event.fancyTimeAgo }}
{{ dashboardHeading }}
{{ dashboardSubheading }}
No endpoints or suites found
{{ searchQuery || showOnlyFailing || showRecentFailures ? 'Try adjusting your filters' : 'No endpoints or suites are configured' }}
{{ group }}
{{ calculateUnhealthyCount(items.endpoints) + calculateFailingSuitesCount(items.suites) }}
Suites
Endpoints
Suites
Endpoints
{{ suite?.name || 'Loading...' }}
{{ suite.group }} • {{ selectedResult && selectedResult.timestamp !== sortedResults[0]?.timestamp ? 'Ran' : 'Last run' }} {{ formatRelativeTime(latestResult.timestamp) }}
Suite not found
The requested suite could not be found.
Status
{{ latestResult.success ? 'Success' : 'Failed' }}
Duration
{{ formatDuration(latestResult.duration) }}
Endpoints
{{ latestResult.endpointResults?.length || 0 }}
Success Rate
{{ calculateSuccessRate(latestResult) }}%
Execution Flow
Suite Errors
{{ error }}
{{ formatTimestamp(result.timestamp) }}
{{ result.endpointResults?.length || 0 }} endpoints • {{ formatDuration(result.duration) }}
No execution history available
'+(n?r:mt(r,!0))+""+(n?r:mt(r,!0))+"\n${this.parser.parse(t)}\n`}html({text:t}){return t}def(t){return""}heading({tokens:t,depth:e}){return`
\n"}list(t){let e=t.ordered,n=t.start,i="";for(let s=0;s
${this.parser.parseInline(t)}
\n`}table(t){let e="",n="";for(let r=0;r${mt(t,!0)}`}br(t){return""}del({tokens:t}){return`
An error occurred:
"+mt(n.message+"",!0)+"";return e?Promise.resolve(t):t}if(e)return Promise.reject(n);throw n}}},Ot=new At;function Pt(t,e){return Ot.parse(t,e)}Pt.options=Pt.setOptions=function(t){return Ot.setOptions(t),Pt.defaults=Ot.defaults,o(Pt.defaults),Pt},Pt.getDefaults=i,Pt.defaults=r,Pt.use=function(...t){return Ot.use(...t),Pt.defaults=Ot.defaults,o(Pt.defaults),Pt},Pt.walkTokens=function(t,e){return Ot.walkTokens(t,e)},Pt.parseInline=Ot.parseInline,Pt.Parser=Dt,Pt.parser=Dt.parse,Pt.Renderer=St,Pt.TextRenderer=Tt,Pt.Lexer=Mt,Pt.lexer=Mt.lex,Pt.Tokenizer=_t,Pt.Hooks=Ct,Pt.parse=Pt;Pt.options,Pt.setOptions,Pt.use,Pt.walkTokens,Pt.parseInline,Dt.parse,Mt.lex},388:function(t,e,n){n.d(e,{m6:function(){return gt}});const i="-",r=t=>{const e=l(t),{conflictingClassGroups:n,conflictingClassGroupModifiers:r}=t,s=t=>{const n=t.split(i);return""===n[0]&&1!==n.length&&n.shift(),o(n,e)||a(t)},c=(t,e)=>{const i=n[t]||[];return e&&r[t]?[...i,...r[t]]:i};return{getClassGroupId:s,getConflictingClassGroupIds:c}},o=(t,e)=>{if(0===t.length)return e.classGroupId;const n=t[0],r=e.nextPart.get(n),s=r?o(t.slice(1),r):void 0;if(s)return s;if(0===e.validators.length)return;const a=t.join(i);return e.validators.find((({validator:t})=>t(a)))?.classGroupId},s=/^\[(.+)\]$/,a=t=>{if(s.test(t)){const e=s.exec(t)[1],n=e?.substring(0,e.indexOf(":"));if(n)return"arbitrary.."+n}},l=t=>{const{theme:e,classGroups:n}=t,i={nextPart:new Map,validators:[]};for(const r in n)c(n[r],i,r,e);return i},c=(t,e,n,i)=>{t.forEach((t=>{if("string"!==typeof t){if("function"===typeof t)return h(t)?void c(t(i),e,n,i):void e.validators.push({validator:t,classGroupId:n});Object.entries(t).forEach((([t,r])=>{c(r,u(e,t),n,i)}))}else{const i=""===t?e:u(e,t);i.classGroupId=n}}))},u=(t,e)=>{let n=t;return e.split(i).forEach((t=>{n.nextPart.has(t)||n.nextPart.set(t,{nextPart:new Map,validators:[]}),n=n.nextPart.get(t)})),n},h=t=>t.isThemeGetter,d=t=>{if(t<1)return{get:()=>{},set:()=>{}};let e=0,n=new Map,i=new Map;const r=(r,o)=>{n.set(r,o),e++,e>t&&(e=0,i=n,n=new Map)};return{get(t){let e=n.get(t);return void 0!==e?e:void 0!==(e=i.get(t))?(r(t,e),e):void 0},set(t,e){n.has(t)?n.set(t,e):r(t,e)}}},f="!",p=":",g=p.length,m=t=>{const{prefix:e,experimentalParseClassName:n}=t;let i=t=>{const e=[];let n,i=0,r=0,o=0;for(let u=0;u