rules

type ActiveSet interface {
	Matcher
	Fetcher
	ReverseMatcher
}

type Fetcher interface {
	// LatestRollupRules returns the latest rollup rules for a given time.
	LatestRollupRules(namespace []byte, timeNanos int64) ([]view.RollupRule, error)
}

type IDWithMetadatas struct {
	ID        []byte
	Metadatas metadata.StagedMetadatas
}

type IDWithMetadatasByIDAsc []IDWithMetadatas

type MatchOptions struct {
	NameAndTagsFn       id.NameAndTagsFn
	SortedTagIteratorFn id.SortedTagIteratorFn
}

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

type Matcher interface {
	// ForwardMatch matches the applicable policies for a metric id between [fromNanos, toNanos).
	ForwardMatch(id metricid.ID, fromNanos, toNanos int64, opts MatchOptions) (MatchResult, error)
}

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

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

type MutableRuleSet interface {
	RuleSet

	// Clone returns a copy of this MutableRuleSet.
	Clone() MutableRuleSet

	// AppendMappingRule creates a new mapping rule and adds it to this ruleset.
	// Should return the id of the newly created rule.
	AddMappingRule(view.MappingRule, UpdateMetadata) (string, error)

	// UpdateMappingRule creates a new mapping rule and adds it to this ruleset.
	UpdateMappingRule(view.MappingRule, UpdateMetadata) error

	// DeleteMappingRule deletes a mapping rule
	DeleteMappingRule(string, UpdateMetadata) error

	// AppendRollupRule creates a new rollup rule and adds it to this ruleset.
	// Should return the id of the newly created rule.
	AddRollupRule(view.RollupRule, UpdateMetadata) (string, error)

	// UpdateRollupRule creates a new rollup rule and adds it to this ruleset.
	UpdateRollupRule(view.RollupRule, UpdateMetadata) error

	// DeleteRollupRule deletes a rollup rule
	DeleteRollupRule(string, UpdateMetadata) error

	// Tombstone tombstones this ruleset and all of its rules.
	Delete(UpdateMetadata) error

	// Revive removes the tombstone from this ruleset. It does not revive any rules.
	Revive(UpdateMetadata) error

	// ApplyRuleSetChanges takes set of rule set changes and applies them to a ruleset.
	ApplyRuleSetChanges(changes.RuleSetChanges, UpdateMetadata) error
}

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

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

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

type Options interface {
	// SetTagsFilterOptions sets the tags filter options.
	SetTagsFilterOptions(value filters.TagsFilterOptions) Options

	// TagsFilterOptions returns the tags filter options.
	TagsFilterOptions() filters.TagsFilterOptions

	// SetNewRollupIDFn sets the new rollup id function.
	SetNewRollupIDFn(value id.NewIDFn) Options

	// NewRollupIDFn returns the new rollup id function.
	NewRollupIDFn() id.NewIDFn

	// SetIsRollupIDFn sets the function that determines whether an id is a rollup id.
	SetIsRollupIDFn(value id.MatchIDFn) Options

	// IsRollupIDFn returns the function that determines whether an id is a rollup id.
	IsRollupIDFn() id.MatchIDFn
}

type ReverseMatcher interface {
	// ReverseMatch reverse matches the applicable policies for a metric id between [fromNanos, toNanos),
	// with aware of the metric type and aggregation type for the given id.
	ReverseMatch(
		id metricid.ID,
		fromNanos, toNanos int64,
		mt metric.Type,
		at aggregation.Type,
		isMultiAggregationTypesAllowed bool,
		aggTypesOpts aggregation.TypesOptions,
	) (MatchResult, error)
}

type RuleSet interface {
	// Namespace is the metrics namespace the ruleset applies to.
	Namespace() []byte

	// Version returns the ruleset version.
	Version() int

	// CutoverNanos returns when the ruleset takes effect.
	CutoverNanos() int64

	// TombStoned returns whether the ruleset is tombstoned.
	Tombstoned() bool

	// CreatedAtNanos returns the creation time for this ruleset.
	CreatedAtNanos() int64

	// LastUpdatedAtNanos returns the time when this ruleset was last updated.
	LastUpdatedAtNanos() int64

	// Proto returns the rulepb.Ruleset representation of this ruleset.
	Proto() (*rulepb.RuleSet, error)

	// MappingRuleHistory returns a map of mapping rule id to states that rule has been in.
	MappingRules() (view.MappingRules, error)

	// RollupRuleHistory returns a map of rollup rule id to states that rule has been in.
	RollupRules() (view.RollupRules, error)

	// Latest returns the latest snapshot of a ruleset containing the latest snapshots
	// of each rule in the ruleset.
	Latest() (view.RuleSet, error)

	// ActiveSet returns the active ruleset at a given time.
	ActiveSet(timeNanos int64) ActiveSet

	// ToMutableRuleSet returns a mutable version of this ruleset.
	ToMutableRuleSet() MutableRuleSet
}

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

type Store interface {
	// ReadNamespaces returns the persisted namespaces in kv store.
	ReadNamespaces() (*Namespaces, error)

	// ReadRuleSet returns the persisted ruleset in kv store.
	ReadRuleSet(nsName string) (RuleSet, error)

	// WriteRuleSet saves the given ruleset to the backing store.
	WriteRuleSet(rs MutableRuleSet) error

	// WriteNamespaces saves the given namespaces to the backing store.
	WriteNamespaces(nss *Namespaces) error

	// WriteAll saves both the given ruleset and namespace to the backing store.
	WriteAll(nss *Namespaces, rs MutableRuleSet) error

	// Close closes the store.
	Close()
}

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

type Validator interface {
	// Validate validates a ruleset.
	Validate(rs RuleSet) error

	// ValidateSnapshot validates a ruleset snapshot.
	ValidateSnapshot(snapshot view.RuleSet) error

	// Close closes the validator.
	Close()
}