feat(alerting): Add new providers for Datadog, IFTTT, Line, NewRelic, Plivo, RocketChat, SendGrid, Signal, SIGNL4, Splunk, Squadcast, Vonage, Webex and Zapier (#1224)

* feat(alerting): Add new providers for Datadog, IFTTT, Line, NewRelic, Plivo, RocketChat, SendGrid, Signal, SIGNL4, Splunk, Squadcast, Vonage, Webex and Zapier Relevant: https://github.com/TwiN/gatus/discussions/1223 Fixes #1073 Fixes #1074 * chore: Clean up code * docs: Fix table formatting * Update alerting/provider/datadog/datadog.go * Update alerting/provider/signal/signal.go * Update alerting/provider/ifttt/ifttt.go * Update alerting/provider/newrelic/newrelic.go * Update alerting/provider/squadcast/squadcast.go * Update alerting/provider/squadcast/squadcast.go
2025-08-25 13:22:17 -04:00
parent 6e888430fa
commit a49b9145d2
39 changed files with 7321 additions and 84 deletions
--- a/alerting/provider/line/line.go
+++ b/alerting/provider/line/line.go
@@ -0,0 +1,193 @@
+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
+}
--- a/alerting/provider/line/line_test.go
+++ b/alerting/provider/line/line_test.go
@@ -0,0 +1,147 @@
+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)
+}