metrics

Documentation

Overview

Building promethues / cortex alerting rules

Index

• Constants
• Variables
• func PostProcessRuleString(inputString string) string
• func WithSloId(sloId, alertType, suffix string) string
• type AlertRuleBuilder
• type AlertingRule
  • func NewCpuRule(nodeFilters map[string]*alertingv1.Cores, cpuStates []string, operation string, ...) (*AlertingRule, error)
  • func NewCpuSpikeRule(nodeFilters map[string]*alertingv1.Cores, cpuStates []string, operation string, ...) (*AlertingRule, error)
  • func NewFsRule(nodeFilters map[string]*alertingv1.FilesystemInfo, operation string, ...) (*AlertingRule, error)
  • func NewFsSpikeRule(nodeFilters map[string]*alertingv1.FilesystemInfo, operation string, ...) (*AlertingRule, error)
  • func NewKubeStateRule(objType string, objName string, namespace string, podState string, ...) (*AlertingRule, error)
  • func NewMemRule(deviceFilters map[string]*alertingv1.MemoryInfo, usageTypes []string, ...) (*AlertingRule, error)
  • func NewMemSpikeRule(deviceFilters map[string]*alertingv1.MemoryInfo, usageTypes []string, ...) (*AlertingRule, error)
  • func (a *AlertingRule) And(other *AlertingRule) AlertRuleBuilder
  • func (a *AlertingRule) AsRuleFmt() *rulefmt.RuleNode
  • func (a *AlertingRule) Build(id string) (*rulefmt.RuleNode, error)
  • func (a *AlertingRule) IfForSecondsThen(_ *AlertingRule, _ time.Duration) AlertRuleBuilder
  • func (a *AlertingRule) IfNotForSecondsThen(_ *AlertingRule, _ time.Duration) AlertRuleBuilder
  • func (a *AlertingRule) Or(other *AlertingRule) AlertRuleBuilder
  • func (a *AlertingRule) Validate() error
• type Filter
  • func NewFilter() Filter
  • func (f Filter) And(value string) Filter
  • func (f Filter) Equals(key string) Filter
  • func (f Filter) IsEmpty() bool
  • func (f Filter) Match(key string) Filter
  • func (f Filter) NotEquals(key string) Filter
  • func (f Filter) Or(value string) Filter
• type PrometheusFilters
  • func NewPrometheusFilters() *PrometheusFilters
  • func (p *PrometheusFilters) AddFilter(key string)
  • func (p *PrometheusFilters) And(key string, value string)
  • func (p *PrometheusFilters) Build() string
  • func (p *PrometheusFilters) Equals(key string)
  • func (p *PrometheusFilters) Match(key string)
  • func (p *PrometheusFilters) NotEquals(key string)
  • func (p *PrometheusFilters) Or(key string, value string)

Constants

const CPUMatcherName = "node_cpu_seconds_total"

const CpuFilter = "cpu"

const FilesystemMatcherName = "node_filesystem_free_bytes"

const KubeMetricsIsDefinedMetricName = "kube_namespace_created"

const KubeObjMetricNameMatcher = "kube_.*_status_phase"

KubeObjMetricNameMatcher

PromQl Matcher for kube state metrics

const KubePodStatusMetricName = "kube_pod_status_phase"

const MemoryDeviceFilter = "device"

const MemoryMatcherName = "node_memory_.*_bytes"

const ModeFilter = "mode"

const NodeExportFilesystemDeviceLabel = "device"

const NodeExporterMountpointLabel = "mountpoint"

const NodeExporterNodeLabel = "instance"

const NodeFilter = "instance"

const UnlabelledNode = "unidentified_node"

Variables

var CpuRuleAnnotations = map[string]string{}

var FilesystemRuleAnnotations = map[string]string{}

var KubeObjMetricCreator = template.Must(template.New("KubeObject").Parse("kube_{{.ObjType}}_status_phase"))

var KubeObjTypeExtractor = regexp.MustCompile("kube_(.*)_status_phase")

KubeObjTypeExtractor

Group 1 extracts the object type

var KubeStateAlertIdLabels = []string{}

var KubeStateAnnotations = map[string]string{}

var MemRuleAnnotations = map[string]string{}

var MemoryMatcherRegexFilter = []string{"Buffers", "Cached", "MemFree", "Slab"}

var MemoryUsageTypeExtractor = regexp.MustCompile("node_memory_(.*)_bytes")

Functions

func PostProcessRuleString

func PostProcessRuleString(inputString string) string

func WithSloId

func WithSloId(sloId, alertType, suffix string) string

Types

type AlertRuleBuilder

type AlertRuleBuilder interface {
	And(rule *AlertingRule) AlertRuleBuilder
	Or(rule *AlertingRule) AlertRuleBuilder
	IfForSecondsThen(*AlertingRule, time.Duration) AlertRuleBuilder
	IfNotForSecondsThen(*AlertingRule, time.Duration) AlertRuleBuilder
	Build(id string) (*rulefmt.RuleNode, error)
}

type AlertingRule

type AlertingRule struct {
	Alert       string
	Expr        string
	For         model.Duration
	Labels      map[string]string
	Annotations map[string]string
}

AlertingRule

Wrapper around rulefmt.Rule that implements the AlertingRuleBuilder interface.

func NewCpuRule

func NewCpuRule(
	nodeFilters map[string]*alertingv1.Cores,
	cpuStates []string,
	operation string,
	expectedRatio float64,
	duration *durationpb.Duration,
	annotations map[string]string,
) (*AlertingRule, error)

func NewCpuSpikeRule

func NewCpuSpikeRule(
	nodeFilters map[string]*alertingv1.Cores,
	cpuStates []string,
	operation string,
	expectedRatio float64,
	numSpikes int64,
	duration *durationpb.Duration,
	spikeWindow *durationpb.Duration,
	annotations map[string]string,
) (*AlertingRule, error)

func NewFsRule

func NewFsRule(
	nodeFilters map[string]*alertingv1.FilesystemInfo,
	operation string,
	expectedValue float64,
	duration *durationpb.Duration,
	annotations map[string]string,
) (*AlertingRule, error)

func NewFsSpikeRule

func NewFsSpikeRule(
	nodeFilters map[string]*alertingv1.FilesystemInfo,
	operation string,
	expectedValue float64,
	numSpikes int64,
	duration *durationpb.Duration,
	spikeWindow *durationpb.Duration,
	annotations map[string]string,
) (*AlertingRule, error)

func NewKubeStateRule

func NewKubeStateRule(
	objType string,
	objName string,
	namespace string,
	podState string,
	forDuration string,
	annotations map[string]string,
) (*AlertingRule, error)

func NewMemRule

func NewMemRule(
	deviceFilters map[string]*alertingv1.MemoryInfo,
	usageTypes []string,
	operation string,
	expectedRatio float64,
	duration *durationpb.Duration,
	annotations map[string]string,
) (*AlertingRule, error)

func NewMemSpikeRule

func NewMemSpikeRule(
	deviceFilters map[string]*alertingv1.MemoryInfo,
	usageTypes []string,
	operation string,
	expectedRatio float64,
	numSpikes int64,
	duration *durationpb.Duration,
	spikeWindow *durationpb.Duration,
	annotations map[string]string,
) (*AlertingRule, error)

func (*AlertingRule) And

func (a *AlertingRule) And(other *AlertingRule) AlertRuleBuilder

func (*AlertingRule) AsRuleFmt

func (a *AlertingRule) AsRuleFmt() *rulefmt.RuleNode

func (*AlertingRule) Build

func (a *AlertingRule) Build(id string) (*rulefmt.RuleNode, error)

func (*AlertingRule) IfForSecondsThen

func (a *AlertingRule) IfForSecondsThen(_ *AlertingRule, _ time.Duration) AlertRuleBuilder

func (*AlertingRule) IfNotForSecondsThen

func (a *AlertingRule) IfNotForSecondsThen(_ *AlertingRule, _ time.Duration) AlertRuleBuilder

func (*AlertingRule) Or

func (a *AlertingRule) Or(other *AlertingRule) AlertRuleBuilder

func (*AlertingRule) Validate

func (a *AlertingRule) Validate() error

type Filter

type Filter string

func NewFilter

func NewFilter() Filter

func (Filter) And

func (f Filter) And(value string) Filter

func (Filter) Equals

func (f Filter) Equals(key string) Filter

func (Filter) IsEmpty

func (f Filter) IsEmpty() bool

func (Filter) Match

func (f Filter) Match(key string) Filter

func (Filter) NotEquals

func (f Filter) NotEquals(key string) Filter

func (Filter) Or

func (f Filter) Or(value string) Filter

type PrometheusFilters

type PrometheusFilters struct {
	Filters map[string]Filter
}

func NewPrometheusFilters

func NewPrometheusFilters() *PrometheusFilters

func (*PrometheusFilters) AddFilter

func (p *PrometheusFilters) AddFilter(key string)

func (*PrometheusFilters) And

func (p *PrometheusFilters) And(key string, value string)

func (*PrometheusFilters) Build

func (p *PrometheusFilters) Build() string

func (*PrometheusFilters) Equals

func (p *PrometheusFilters) Equals(key string)

func (*PrometheusFilters) Match

func (p *PrometheusFilters) Match(key string)

func (*PrometheusFilters) NotEquals

func (p *PrometheusFilters) NotEquals(key string)

func (*PrometheusFilters) Or

func (p *PrometheusFilters) Or(key string, value string)