levee / internal /webhook /webhook.go
runitx's picture
Claude Opus 5.5
Add Levee: open-source flood zone determination and monitoring
b5754ad unverified
Raw History Blame Contribute Delete
2.63 kB
// Package webhook delivers monitoring events to an HTTP endpoint, signed with
// HMAC-SHA256 so receivers can verify they came from this Levee instance.
package webhook
import (
"bytes"
"context"
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"net/http"
"strconv"
"time"
"levee/internal/store"
"levee/internal/version"
)
// MaxAttempts is how many times an event is tried before it is left for manual review.
const MaxAttempts = 10
// Webhook posts events as JSON.
type Webhook struct {
URL string
Secret string
HTTP *http.Client
}
// New returns a webhook sender.
func New(url, secret string) *Webhook {
return &Webhook{URL: url, Secret: secret, HTTP: &http.Client{Timeout: 20 * time.Second}}
}
// Payload is the JSON body sent for each event.
type Payload struct {
Event store.Event `json:"event"`
SentAt time.Time `json:"sent_at"`
Source string `json:"source"`
}
// Sign returns the X-Levee-Signature header value for body.
func Sign(secret string, body []byte) string {
m := hmac.New(sha256.New, []byte(secret))
m.Write(body)
return "sha256=" + hex.EncodeToString(m.Sum(nil))
}
// Send posts one event.
func (w *Webhook) Send(ctx context.Context, e store.Event) error {
body, err := json.Marshal(Payload{Event: e, SentAt: time.Now().UTC(), Source: "levee/" + version.Version})
if err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, w.URL, bytes.NewReader(body))
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("User-Agent", version.UserAgent())
req.Header.Set("X-Levee-Event", e.Kind)
req.Header.Set("X-Levee-Delivery", strconv.FormatInt(e.ID, 10))
if w.Secret != "" {
req.Header.Set("X-Levee-Signature", Sign(w.Secret, body))
}
res, err := w.HTTP.Do(req)
if err != nil {
return err
}
io.Copy(io.Discard, io.LimitReader(res.Body, 64<<10))
res.Body.Close()
if res.StatusCode < 200 || res.StatusCode > 299 {
return fmt.Errorf("webhook: HTTP %d", res.StatusCode)
}
return nil
}
// Deliver sends undelivered events in order, stopping at the first failure so
// receivers see events in sequence. It returns the number delivered.
func (w *Webhook) Deliver(ctx context.Context, st *store.Store) (int, error) {
events, err := st.UndeliveredEvents(ctx, MaxAttempts, 500)
if err != nil {
return 0, err
}
n := 0
for _, e := range events {
if err := w.Send(ctx, e); err != nil {
st.MarkDeliveryFailed(ctx, e.ID, err.Error())
return n, err
}
if err := st.MarkDelivered(ctx, e.ID); err != nil {
return n, err
}
n++
}
return n, nil
}