notify

type Audience string

type Classification struct {
	// MemberMessage is the user-safe text shown to the Space's members.
	MemberMessage string
	// Operational reports whether the operator has to act. When true, an
	// anonymous operator event is recorded alongside the member event.
	Operational bool
	// OperatorMessage is the operator's text. It must not identify a Space or
	// a user; the Reporter rejects the event if it somehow does.
	OperatorMessage string
	// Silent suppresses notification entirely. Some "failures" are not news to
	// anybody — a run skipped because another was already going, or one cut
	// short by shutdown.
	Silent bool
}

type Classifier func(err error) Classification

type Clock interface {
	Now() time.Time
}

type Event struct {
	ID       string   `json:"id"`
	Kind     Kind     `json:"kind"`
	Audience Audience `json:"audience"`
	// SpaceID is set for space-scoped events only, and must be empty for
	// operator events.
	SpaceID string `json:"space_id,omitempty"`
	// Message is user-safe text. It never contains internal detail.
	Message   string    `json:"message"`
	CreatedAt time.Time `json:"created_at"`
}

type Kind string

type LogSink struct {
	Logger *slog.Logger
}

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

type MonitorDeps struct {
	Configs  spacecfg.Store
	Jobs     jobs.Store
	Events   Store
	Notifier *Notifier
	Logger   *slog.Logger
}

type MonitorOptions struct {
	// MinStaleAfter is the floor on the threshold; zero uses the default.
	MinStaleAfter time.Duration
	// RepeatAfter is the re-notification interval; zero uses the default.
	RepeatAfter time.Duration
}

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

type Options struct {
	// Sinks deliver events; may be empty, in which case events are recorded
	// only (and still visible through the API).
	Sinks []Sink
	// Clock is injected for deterministic tests.
	Clock Clock
	// Logger receives delivery diagnostics.
	Logger *slog.Logger
}

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

type SMTPConfig struct {
	// Host and Port address the mail server, e.g. "smtp.example.org", 587.
	Host string
	Port int
	// Username and Password authenticate; leave empty for an open relay on a
	// trusted network.
	Username string
	Password string
	// From is the envelope sender.
	From string
	// OperatorTo receives operator-audience events. When empty, operator events
	// are recorded but not mailed.
	OperatorTo string
	// Timeout bounds one delivery, from dialling to QUIT. Zero uses
	// DefaultSMTPTimeout.
	Timeout time.Duration
}

type SMTPEnv struct {
	Host       string        `env:"SMTP_HOST" doc:"Mail server for operator notifications."`
	Port       int           `env:"SMTP_PORT" doc:"Mail server port, such as 587. 0 disables mail."`
	Username   string        `env:"SMTP_USERNAME" doc:"Mail server login, if it requires one."`
	Password   config.Secret `env:"SMTP_PASSWORD" doc:"Mail server password."`
	From       string        `env:"SMTP_FROM" doc:"Sender address."`
	OperatorTo string        `env:"NOTIFY_OPERATOR_EMAIL" doc:"Where operator notifications go. They never name a Space."`
}

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

type Sink interface {
	// Deliver sends one event. Name it in errors, never its recipients' data.
	Deliver(ctx context.Context, e Event) error
}

type StaleRule struct {
	// MinStaleAfter is the floor on the threshold; zero or less uses the
	// default.
	MinStaleAfter time.Duration
}

type Staleness struct {
	// Stale reports whether the Space has gone too long without a successful
	// backup.
	Stale bool
	// Since is the last successful backup or, if there has never been one,
	// when the Space was configured. Zero when there is nothing to measure
	// from.
	Since time.Time
}

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

type Store interface {
	// Append records an event, filling in id and timestamp when absent.
	Append(ctx context.Context, e Event) (Event, error)
	// List returns the events of one scope, newest first. A scope is a space
	// id for member events; use ListOperator for operator events. A limit of
	// zero or less means "all".
	List(ctx context.Context, spaceID string, limit int) ([]Event, error)
	// ListOperator returns operator events, newest first.
	ListOperator(ctx context.Context, limit int) ([]Event, error)
	// PruneBefore deletes events created before cutoff.
	PruneBefore(ctx context.Context, cutoff time.Time) (int, error)
}