prometheus

type AlertMeta ¶

type AlertMeta struct {
	Disable     bool
	Name        string            `validate:"required_if_enabled"`
	Labels      map[string]string `validate:"dive,keys,prom_label_key,endkeys,required,prom_label_value"`
	Annotations map[string]string `validate:"dive,keys,prom_annot_key,endkeys,required"`
}

AlertMeta is the metadata of an alert settings.

type FileManager ¶ added in v0.3.0

type FileManager interface {
	FindFiles(ctx context.Context, root string, matcher *regexp.Regexp) (paths []string, err error)
	ReadFile(ctx context.Context, path string) (data []byte, err error)
}

FileManager knows how to manage files.

type FileSLIPluginRepo ¶ added in v0.3.0

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

FileSLIPluginRepo will provide the plugins loaded from files. To be able to provide a simple and safe plugin system to the user we have set some rules/requirements that a plugin must implement:

- The plugin must be in a `plugin.go` file inside a directory. - All the plugin must be in the `plugin.go` file. - The plugin can't import anything apart from the Go standard library. - `reflect` and `unsafe` packages can't be used.

These rules provide multiple things: - Easy discovery of plugins without the need to provide extra data (import paths, path sanitization...). - Safety because we don't allow adding external packages easily. - Force keeping the plugins simple, small and without smart code. - Force avoiding DRY in small plugins and embrace WET to have independent plugins.

func NewFileSLIPluginRepo(config FileSLIPluginRepoConfig) (*FileSLIPluginRepo, error)

func (f *FileSLIPluginRepo) GetSLIPlugin(ctx context.Context, id string) (*SLIPlugin, error)

func (f *FileSLIPluginRepo) ListSLIPlugins(ctx context.Context) (map[string]SLIPlugin, error)

func (f *FileSLIPluginRepo) Reload(ctx context.Context) error

type FileSLIPluginRepoConfig ¶ added in v0.3.0

type FileSLIPluginRepoConfig struct {
	FileManager FileManager
	Paths       []string
	Logger      log.Logger
}

type IOWriterGroupedRulesYAMLRepo ¶

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

IOWriterGroupedRulesYAMLRepo knows to store all the SLO rules (recordings and alerts) grouped in an IOWriter in YAML format, that is compatible with Prometheus.

func NewIOWriterGroupedRulesYAMLRepo(writer io.Writer, logger log.Logger) IOWriterGroupedRulesYAMLRepo

func (i IOWriterGroupedRulesYAMLRepo) StoreSLOs(ctx context.Context, slos []StorageSLO) error

type SLI ¶

type SLI struct {
	Raw    *SLIRaw
	Events *SLIEvents
}

SLI reprensents an SLI with custom error and total expressions.

type SLIEvents ¶

type SLIEvents struct {
	ErrorQuery string `validate:"required,prom_expr,template_vars"`
	TotalQuery string `validate:"required,prom_expr,template_vars"`
}

type SLIPlugin ¶ added in v0.3.0

type SLIPlugin struct {
	ID   string
	Func pluginv1.SLIPlugin
}

type SLIPluginRepo ¶ added in v0.5.0

type SLIPluginRepo interface {
	GetSLIPlugin(ctx context.Context, id string) (*SLIPlugin, error)
}

type SLIRaw ¶

type SLIRaw struct {
	ErrorRatioQuery string `validate:"required,prom_expr,template_vars"`
}

type SLO ¶

type SLO struct {
	ID              string `validate:"required,name"`
	Name            string `validate:"required,name"`
	Description     string
	Service         string            `validate:"required,name"`
	SLI             SLI               `validate:"required"`
	TimeWindow      time.Duration     `validate:"required"`
	Objective       float64           `validate:"gt=0,lte=100"`
	Labels          map[string]string `validate:"dive,keys,prom_label_key,endkeys,required,prom_label_value"`
	PageAlertMeta   AlertMeta
	TicketAlertMeta AlertMeta
}

SLO represents a service level objective configuration.

func (s SLO) GetSLIErrorMetric(window time.Duration) string

func (s SLO) GetSLOIDPromLabels() map[string]string

type SLOGroup ¶

type SLOGroup struct {
	SLOs []SLO `validate:"required,dive"`
}

func (s SLOGroup) Validate() error

type SLORules ¶

type SLORules struct {
	SLIErrorRecRules []rulefmt.Rule
	MetadataRecRules []rulefmt.Rule
	AlertRules       []rulefmt.Rule
}

SLORules are the prometheus rules required by an SLO.

type StorageSLO ¶

type StorageSLO struct {
	SLO   SLO
	Rules SLORules
}

type YAMLSpecLoader ¶

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

YAMLSpecLoader knows how to load YAML specs and converts them to a model.

func NewYAMLSpecLoader(pluginsRepo SLIPluginRepo, windowPeriod time.Duration) YAMLSpecLoader

func (y YAMLSpecLoader) IsSpecType(ctx context.Context, data []byte) bool

func (y YAMLSpecLoader) LoadSpec(ctx context.Context, data []byte) (*SLOGroup, error)