historian

type AnnotationBackend ¶

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

AnnotationBackend is an implementation of state.Historian that uses Grafana Annotations as the backing datastore.

func NewAnnotationBackend(annotations AnnotationStore, rules RuleStore, metrics *metrics.Historian) *AnnotationBackend

func (h *AnnotationBackend) Query(ctx context.Context, query ngmodels.HistoryQuery) (*data.Frame, error)

func (h *AnnotationBackend) Record(ctx context.Context, rule history_model.RuleMeta, states []state.StateTransition) <-chan error

type AnnotationService ¶

type AnnotationService interface {
	Find(ctx context.Context, query *annotations.ItemQuery) ([]*annotations.ItemDTO, error)
	SaveMany(ctx context.Context, items []annotations.Item) error
}

type AnnotationServiceStore ¶

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

func NewAnnotationStore(svc AnnotationService, dashboards dashboards.DashboardService, metrics *metrics.Historian) *AnnotationServiceStore

func (s *AnnotationServiceStore) Find(ctx context.Context, query *annotations.ItemQuery) ([]*annotations.ItemDTO, error)

func (s *AnnotationServiceStore) Save(ctx context.Context, panel *PanelKey, annotations []annotations.Item, orgID int64, logger log.Logger) error

type AnnotationStore ¶

type AnnotationStore interface {
	Find(ctx context.Context, query *annotations.ItemQuery) ([]*annotations.ItemDTO, error)
	Save(ctx context.Context, panel *PanelKey, annotations []annotations.Item, orgID int64, logger log.Logger) error
}

type Backend ¶

type Backend interface {
	Record(ctx context.Context, rule history_model.RuleMeta, states []state.StateTransition) <-chan error
	Query(ctx context.Context, query ngmodels.HistoryQuery) (*data.Frame, error)
}

type BackendType ¶

type BackendType string

BackendType identifies different kinds of state history backends.

const (
	BackendTypeAnnotations BackendType = "annotations"
	BackendTypeLoki        BackendType = "loki"
	BackendTypeMultiple    BackendType = "multiple"
	BackendTypeNoop        BackendType = "noop"
)

func ParseBackendType(s string) (BackendType, error)

func (bt BackendType) String() string

type JsonEncoder ¶

type JsonEncoder struct{}

type LokiConfig ¶

type LokiConfig struct {
	ReadPathURL       *url.URL
	WritePathURL      *url.URL
	BasicAuthUser     string
	BasicAuthPassword string
	TenantID          string
	ExternalLabels    map[string]string
	Encoder           encoder
}

func NewLokiConfig(cfg setting.UnifiedAlertingStateHistorySettings) (LokiConfig, error)

type MultipleBackend ¶

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

MultipleBackend is a state.Historian that records history to multiple backends at once. Only one backend is used for reads. The backend selected for read traffic is called the primary and all others are called secondaries.

func NewMultipleBackend(primary Backend, secondaries ...Backend) *MultipleBackend

func (h *MultipleBackend) Query(ctx context.Context, query ngmodels.HistoryQuery) (*data.Frame, error)

func (h *MultipleBackend) Record(ctx context.Context, rule history_model.RuleMeta, states []state.StateTransition) <-chan error

type NoOpHistorian ¶

type NoOpHistorian struct{}

NoOpHistorian is a state.Historian that does nothing with the resulting data, to be used in contexts where history is not needed.

func NewNopHistorian() *NoOpHistorian

func (f *NoOpHistorian) Query(ctx context.Context, query models.HistoryQuery) (*data.Frame, error)

func (f *NoOpHistorian) Record(ctx context.Context, _ history_model.RuleMeta, _ []state.StateTransition) <-chan error

type Operator ¶

type Operator string

Kind of Operation (=, !=, =~, !~)

const (
	// Equal operator (=)
	Eq Operator = "="
	// Not Equal operator (!=)
	Neq Operator = "!="
	// Equal operator supporting RegEx (=~)
	EqRegEx Operator = "=~"
	// Not Equal operator supporting RegEx (!~)
	NeqRegEx Operator = "!~"
)

type PanelKey ¶

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

PanelKey uniquely identifies a panel.

func NewPanelKey(orgID int64, dashUID string, panelID int64) PanelKey

func (p PanelKey) DashUID() string

func (p PanelKey) OrgID() int64

func (p PanelKey) PanelID() int64

type Querier ¶

type Querier interface {
	Query(ctx context.Context, query models.HistoryQuery) (*data.Frame, error)
}

Querier represents the ability to query state history. TODO: This package also contains implementations of this interface. TODO: This type should be moved to the side of the consumer, when the consumer is created in the future. We add it here temporarily to more clearly define this package's interface.

type RemoteLokiBackend ¶

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

RemoteLokibackend is a state.Historian that records state history to an external Loki instance.

func NewRemoteLokiBackend(cfg LokiConfig, req client.Requester, metrics *metrics.Historian) *RemoteLokiBackend

func (h *RemoteLokiBackend) Query(ctx context.Context, query models.HistoryQuery) (*data.Frame, error)

func (h *RemoteLokiBackend) Record(ctx context.Context, rule history_model.RuleMeta, states []state.StateTransition) <-chan error

func (h *RemoteLokiBackend) TestConnection(ctx context.Context) error

type RuleStore ¶

type RuleStore interface {
	GetAlertRuleByUID(ctx context.Context, query *ngmodels.GetAlertRuleByUIDQuery) (*ngmodels.AlertRule, error)
}

type Selector ¶

type Selector struct {
	// Label to Select
	Label string
	Op    Operator
	// Value that is expected
	Value string
}

func NewSelector(label, op, value string) (Selector, error)

type SnappyProtoEncoder ¶

type SnappyProtoEncoder struct{}