99 lines
3.0 KiB
Go
99 lines
3.0 KiB
Go
package notification
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"time"
|
|
)
|
|
|
|
// WebhookConfig is the per-channel JSON shape stored AEAD-encrypted
|
|
// in notification_channels.config.
|
|
type WebhookConfig struct {
|
|
URL string `json:"url"`
|
|
BearerToken string `json:"bearer_token,omitempty"`
|
|
HeaderName string `json:"header_name,omitempty"`
|
|
HeaderValue string `json:"header_value,omitempty"`
|
|
}
|
|
|
|
// WebhookChannel is the HTTP-POST channel. One per configured channel
|
|
// row. Reused across sends — the http.Client is goroutine-safe.
|
|
type WebhookChannel struct {
|
|
cfg WebhookConfig
|
|
client *http.Client
|
|
}
|
|
|
|
// NewWebhookChannel builds a webhook with a 5s overall timeout enforced
|
|
// by the http.Client; ctx in Send is layered on top for caller-driven
|
|
// cancel.
|
|
func NewWebhookChannel(cfg WebhookConfig) *WebhookChannel {
|
|
return &WebhookChannel{
|
|
cfg: cfg,
|
|
client: &http.Client{Timeout: 5 * time.Second},
|
|
}
|
|
}
|
|
|
|
// Kind returns "webhook" for log enrichment and dispatcher routing.
|
|
func (c *WebhookChannel) Kind() string { return "webhook" }
|
|
|
|
// webhookBody is the wire-stable envelope. Documented in the spec; do
|
|
// not reorder fields freely — operators write switch statements on
|
|
// "event" and "severity".
|
|
type webhookBody struct {
|
|
Event string `json:"event"`
|
|
AlertID string `json:"alert_id"`
|
|
Severity string `json:"severity"`
|
|
Kind string `json:"kind"`
|
|
HostID string `json:"host_id"`
|
|
HostName string `json:"host_name"`
|
|
Message string `json:"message"`
|
|
RaisedAt string `json:"raised_at"`
|
|
Link string `json:"link"`
|
|
}
|
|
|
|
// Send delivers the payload as a JSON POST. Returns (statusCode, latency, err).
|
|
// 4xx/5xx responses are returned as errors with the status code set.
|
|
func (c *WebhookChannel) Send(ctx context.Context, p Payload) (int, time.Duration, error) {
|
|
body := webhookBody{
|
|
Event: string(p.Event), AlertID: p.AlertID,
|
|
Severity: p.Severity, Kind: p.Kind,
|
|
HostID: p.HostID, HostName: p.HostName,
|
|
Message: p.Message,
|
|
RaisedAt: p.RaisedAt.UTC().Format(time.RFC3339Nano),
|
|
Link: p.Link,
|
|
}
|
|
buf, err := json.Marshal(body)
|
|
if err != nil {
|
|
return 0, 0, fmt.Errorf("webhook: marshal body: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.cfg.URL, bytes.NewReader(buf))
|
|
if err != nil {
|
|
return 0, 0, fmt.Errorf("webhook: build request: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
if c.cfg.BearerToken != "" {
|
|
req.Header.Set("Authorization", "Bearer "+c.cfg.BearerToken)
|
|
}
|
|
if c.cfg.HeaderName != "" {
|
|
req.Header.Set(c.cfg.HeaderName, c.cfg.HeaderValue)
|
|
}
|
|
|
|
t0 := time.Now()
|
|
res, err := c.client.Do(req)
|
|
latency := time.Since(t0)
|
|
if err != nil {
|
|
return 0, latency, fmt.Errorf("webhook: do: %w", err)
|
|
}
|
|
defer func() { _ = res.Body.Close() }()
|
|
// Drain body — keep the connection reusable.
|
|
_, _ = io.Copy(io.Discard, res.Body)
|
|
if res.StatusCode >= 400 {
|
|
return res.StatusCode, latency, fmt.Errorf("webhook: http %d", res.StatusCode)
|
|
}
|
|
return res.StatusCode, latency, nil
|
|
}
|