relay

type Config struct {
	// Secrets are the signing secrets to verify with: the current one, and the previous one during a
	// rotation. Required.
	Secrets []string
	// Tolerance is how far a request's timestamp may be from the relay's clock; zero means
	// notify.DefaultTolerance.
	Tolerance time.Duration
	// Sinks are where a verified notification goes. At least one is required.
	Sinks []Sink
	// DedupeSize bounds the delivery IDs remembered; zero means DefaultDedupeSize. When the cache is
	// full the least recently seen ID is forgotten, and an old event redelivered after that is
	// forwarded again: the bound trades memory for a rare repeat, never for a lost notification.
	DedupeSize int
	// ClearsID says whether p is a clear and the ID of the event it ends ("" when it is not); nil
	// means ClearsID. The relay remembers the IDs it saw cleared (as many as DedupeSize) and drops a
	// later notification of such an event instead of forwarding it: a trigger that arrives after its
	// clear (the event was cleared while its request failed, or its reply was lost) would reopen an
	// incident that is over.
	ClearsID func(notify.Payload) string
	// StatePath, if set, is a file the Handler keeps its memory in, so the delivery IDs it forwarded
	// and the event IDs it saw cleared survive a restart: without it a trigger that arrives after a
	// restart, for an event cleared before it, is forwarded and reopens the incident, and a
	// redelivery is forwarded again. The file is written atomically after each change (bounded by
	// DedupeSize, like the in-memory sets), holds IDs and sink names only, and is read at New: a
	// missing file is a first start, an unreadable or invalid one is an error. If a later write
	// fails the Handler logs it and carries on, with its memory in the process as without a file.
	// StateFlushDelay is how long a change to the forwarded-delivery set waits before the file is
	// rewritten, so a burst of events costs one write, not one each (the whole file is rewritten and
	// synced, which grows with DedupeSize). Zero means DefaultStateFlushDelay; negative writes through
	// on every change. A clear is never delayed: its ID is written at once, because a late trigger
	// after a crash is the failure the file exists to prevent. Close writes what is pending. A crash
	// (not Close) can lose the forwarded-delivery entries of the last StateFlushDelay, so a redelivery
	// of those events is forwarded once more: a repeat, never a lost notification.
	StateFlushDelay time.Duration
	// The Handler holds an exclusive operating-system lock on StatePath+".lock" until Close or the
	// process ends (a crash releases it), and New fails if another relay holds it: two relays
	// sharing one file would overwrite each other's memory.
	StatePath string
	// ForwardTimeout bounds the forwarding of one delivery; zero means DefaultForwardTimeout. Forwarding
	// continues after the sender gives up, so a retry finds it done.
	ForwardTimeout time.Duration
	// Logf, if set, receives one line per rejection, duplicate and failure. Lines hold delivery IDs,
	// sink names and error classes; they never hold a secret, a URL or a payload.
	Logf func(format string, args ...any)
}

type Handler struct {
	// contains filtered or unexported fields
}

type PagerDuty struct {
	// contains filtered or unexported fields
}

type PagerDutyConfig struct {
	// RoutingKey is the integration key of an Events API v2 integration. It is a credential: it
	// is never put in an error or a log line. Required.
	RoutingKey string
	// URL overrides DefaultPagerDutyURL (the EU endpoint, or a test server).
	URL string
	// Source is the event's source field; empty means "bide".
	Source string
	// Severity, if set, picks the severity ("critical", "error", "warning" or "info") of a trigger;
	// nil means DefaultSeverity.
	Severity func(notify.Payload) string
	// ResolveTarget, if set, says whether p is a clear that ends an incident, and the dedup key of the
	// incident it ends. nil means DefaultResolveTarget. See ResolveKind.
	ResolveTarget func(notify.Payload) (dedupKey string, ok bool)
	// HTTPClient, Attempts, Timeout and Backoff tune the outbound call, as for SlackConfig.
	HTTPClient *http.Client
	Attempts   int
	Timeout    time.Duration
	Backoff    time.Duration
}

type PagerDutyEvent struct {
	RoutingKey  string            `json:"routing_key"`
	EventAction string            `json:"event_action"`
	DedupKey    string            `json:"dedup_key"`
	Payload     *PagerDutyPayload `json:"payload,omitempty"`
	Links       []PagerDutyLink   `json:"links,omitempty"`
}

type PagerDutyLink struct {
	Href string `json:"href"`
	Text string `json:"text"`
}

type PagerDutyPayload struct {
	Summary       string         `json:"summary"`
	Source        string         `json:"source"`
	Severity      string         `json:"severity"`
	Timestamp     string         `json:"timestamp,omitempty"`
	Component     string         `json:"component,omitempty"`
	Group         string         `json:"group,omitempty"`
	Class         string         `json:"class,omitempty"`
	CustomDetails map[string]any `json:"custom_details,omitempty"`
}

type Sink interface {
	Name() string
	Send(ctx context.Context, p notify.Payload) error
}

type Slack struct {
	// contains filtered or unexported fields
}

type SlackConfig struct {
	// WebhookURL is the Slack incoming webhook URL. It is a credential: keep it in the relay's
	// configuration, and it is never put in an error or a log line. Required.
	WebhookURL string
	// ViewURL, if set, is the base of the run viewer, used for the "Open in viewer" button when the
	// notification carries no view.url of its own (bide's WithViewURL). The button is the base, a
	// slash and the escaped run ID.
	ViewURL string
	// HTTPClient, Attempts, Timeout and Backoff tune the outbound call; the zero values mean
	// http.DefaultClient-like defaults, DefaultAttempts, DefaultRequestTimeout and DefaultBackoff.
	HTTPClient *http.Client
	Attempts   int
	Timeout    time.Duration
	Backoff    time.Duration
}

type SlackMsg struct {
	Text   string       `json:"text"`
	Blocks []slackBlock `json:"blocks"`
}

type StatusError struct {
	Sink   string
	Status int
	Code   string
}