engine

type AlertEvent struct {
	RuleID        string
	RuleVersion   int
	BundleVersion string
	Class         string
	Scope         string
	Transition    string
	// InstanceKey is the resource UID for state rules and the canonical label set otherwise.
	InstanceKey  string
	Labels       map[string]string
	Annotations  map[string]string
	Value        float64
	ActiveAt     time.Time
	FiredAt      time.Time
	ResolvedAt   time.Time
	EvalTime     time.Time
	ResourceUIDs []string
	Severity     string
	Category     string
	Summary      string
	// Incomplete is set when the evaluation behind the event did not see all of its inputs.
	Incomplete bool
}

type BundleResult struct {
	// Unsupported maps rule IDs to the reason they cannot run on this agent.
	Unsupported map[string]string
}

type Coverage int

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

type LogProgram interface {
	Eval(ts time.Time) (promql.Vector, error)
}

type LogProgramFunc func(ts time.Time) (promql.Vector, error)

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

type Options struct {
	// Role is RoleNode, RoleCoordinator, or RoleHost (the default, which evaluates everything locally).
	Role  string
	Store kv.Store
	Clock func() time.Time
	Sink  func(AlertEvent)
	// Push receives node contributions to cluster rules (node role).
	Push       func(Part)
	KubeSubset map[string]bool
	// CompileLogQL compiles LogQL rule expressions; it may register the program with the log tailer.
	CompileLogQL func(expr string, b bundle.Budget) (LogProgram, error)
	Queryable    storage.Queryable
	// StateSource returns a state snapshot that is not mutated while the cycle runs.
	StateSource func() *protocol.State
	// ScopeMatch reports whether a state scope key covers resources of kind in namespace.
	ScopeMatch      func(scopeKey, kind, namespace string) bool
	ResolveResource func(kind, namespace, name string) (uid string, ok bool)
	// Coverage reports local telemetry coverage for node-local rules.
	Coverage func() Coverage
	// ClusterCoverage reports whether every node contributes to a cluster rule on a compatible version.
	ClusterCoverage func(ruleID string, ruleVersion int) Coverage
	EvidenceLimited func(ruleID string) bool
	Policy          Policy
	DefaultInterval time.Duration
	BudgetBackoff   time.Duration
	// OutageTolerance bounds the downtime after which persisted pending state is not resumed.
	OutageTolerance time.Duration
	LookbackDelta   time.Duration
}

type Part struct {
	RuleID        string
	RuleVersion   int
	BundleVersion string
	EvalTime      time.Time
	Vector        promql.Vector
}

type Policy struct {
	MaxEvalTime     time.Duration
	MaxSamples      int
	MaxSeries       int
	MaxComplexity   int
	MaxCounterBytes int
	DisabledRules   []string
	// Capabilities lists the capabilities available to rules; nil means all.
	Capabilities []string
}

type RuleState struct {
	RuleID       string
	Version      int
	Class        string
	Scope        string
	State        string
	Reason       string
	LastEval     time.Time
	LastDuration time.Duration
	Pending      int
	Firing       int
	BackoffUntil time.Time
}

type Sample struct {
	T int64
	F float64
}

type Series struct {
	Labels  labels.Labels
	Samples []Sample
}

type Split struct {
	NodeExpr  string
	CoordExpr string
	Outer     string
	Grouping  []string
	Without   bool
}

type ValidationError struct {
	RuleID string
	Reason string
}