// 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 }