notifier

Documentation

Index

• func ExecTemplate(q templates.QueryFn, annotations map[string]string, tplData AlertTplData) (map[string]string, error)
• func GetTargets() map[TargetType][]Target
• func Init(gen AlertURLGenerator, extLabels map[string]string, extURL string) (func() []Notifier, error)
• func InitSecretFlags()
• func Reload() error
• func ValidateTemplates(annotations map[string]string) error
• type Alert
  • func (a *Alert) ExecTemplate(q templates.QueryFn, labels, annotations map[string]string) (map[string]string, error)
• type AlertManager
  • func NewAlertManager(alertManagerURL string, fn AlertURLGenerator, ...) (*AlertManager, error)
  • func (am AlertManager) Addr() string
  • func (am *AlertManager) Close()
  • func (am *AlertManager) Send(ctx context.Context, alerts []Alert, headers map[string]string) error
• type AlertState
  • func (as AlertState) String() string
• type AlertTplData
• type AlertURLGenerator
• type Config
  • func (cfg *Config) UnmarshalYAML(unmarshal func(interface{}) error) error
• type FakeNotifier
  • func (*FakeNotifier) Addr() string
  • func (*FakeNotifier) Close()
  • func (fn *FakeNotifier) GetAlerts() []Alert
  • func (fn *FakeNotifier) GetCounter() int
  • func (fn *FakeNotifier) Send(_ context.Context, alerts []Alert, _ map[string]string) error
• type FaultyNotifier
  • func (fn *FaultyNotifier) Send(ctx context.Context, _ []Alert, _ map[string]string) error
• type Notifier
• type StaticConfig
• type Target
• type TargetType

Functions

func ExecTemplate

func ExecTemplate(q templates.QueryFn, annotations map[string]string, tplData AlertTplData) (map[string]string, error)

ExecTemplate executes the given template for given annotations map.

func GetTargets

func GetTargets() map[TargetType][]Target

GetTargets returns list of static or discovered targets via notifier configuration.

func Init

func Init(gen AlertURLGenerator, extLabels map[string]string, extURL string) (func() []Notifier, error)

Init returns a function for retrieving actual list of Notifier objects. Init works in two mods:

• configuration via flags (for backward compatibility). Is always static and don't support live reloads.
• configuration via file. Supports live reloads and service discovery.

Init returns an error if both mods are used.

func InitSecretFlags

func InitSecretFlags()

InitSecretFlags must be called after flag.Parse and before any logging

func Reload

func Reload() error

Reload checks the changes in configPath configuration file and applies changes if any.

func ValidateTemplates

func ValidateTemplates(annotations map[string]string) error

ValidateTemplates validate annotations for possible template error, uses empty data for template population

Types

type Alert

type Alert struct {
	// GroupID contains the ID of the parent rules group
	GroupID uint64
	// Name represents Alert name
	Name string
	// Labels is the list of label-value pairs attached to the Alert
	Labels map[string]string
	// Annotations is the list of annotations generated on Alert evaluation
	Annotations map[string]string
	// State represents the current state of the Alert
	State AlertState
	// Expr contains expression that was executed to generate the Alert
	Expr string
	// ActiveAt defines the moment of time when Alert has become active
	ActiveAt time.Time
	// Start defines the moment of time when Alert has become firing
	Start time.Time
	// End defines the moment of time when Alert supposed to expire
	End time.Time
	// ResolvedAt defines the moment when Alert was switched from Firing to Inactive
	ResolvedAt time.Time
	// LastSent defines the moment when Alert was sent last time
	LastSent time.Time
	// KeepFiringSince defines the moment when StateFiring was kept because of `keep_firing_for` instead of real alert
	KeepFiringSince time.Time
	// Value stores the value returned from evaluating expression from Expr field
	Value float64
	// ID is the unique identifier for the Alert
	ID uint64
	// Restored is true if Alert was restored after restart
	Restored bool
	// For defines for how long Alert needs to be active to become StateFiring
	For time.Duration
}

Alert the triggered alert TODO: Looks like alert name isn't unique

func (*Alert) ExecTemplate

func (a *Alert) ExecTemplate(q templates.QueryFn, labels, annotations map[string]string) (map[string]string, error)

ExecTemplate executes the Alert template for given map of annotations. Every alert could have a different datasource, so function requires a queryFunction as an argument.

type AlertManager

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

AlertManager represents integration provider with Prometheus alert manager https://github.com/prometheus/alertmanager

func NewAlertManager

func NewAlertManager(alertManagerURL string, fn AlertURLGenerator, authCfg promauth.HTTPClientConfig,
	relabelCfg *promrelabel.ParsedConfigs, timeout time.Duration,
) (*AlertManager, error)

NewAlertManager is a constructor for AlertManager

func (AlertManager) Addr

func (am AlertManager) Addr() string

Addr returns address where alerts are sent.

func (*AlertManager) Close

func (am *AlertManager) Close()

Close is a destructor method for AlertManager

func (*AlertManager) Send

func (am *AlertManager) Send(ctx context.Context, alerts []Alert, headers map[string]string) error

Send an alert or resolve message

type AlertState

type AlertState int

AlertState type indicates the Alert state

const (
	// StateInactive is the state of an alert that is neither firing nor pending.
	StateInactive AlertState = iota
	// StatePending is the state of an alert that has been active for less than
	// the configured threshold duration.
	StatePending
	// StateFiring is the state of an alert that has been active for longer than
	// the configured threshold duration.
	StateFiring
)

func (AlertState) String

func (as AlertState) String() string

String stringer for AlertState

type AlertTplData

type AlertTplData struct {
	Labels   map[string]string
	Value    float64
	Expr     string
	AlertID  uint64
	GroupID  uint64
	ActiveAt time.Time
	For      time.Duration
}

AlertTplData is used to execute templating

type AlertURLGenerator

type AlertURLGenerator func(Alert) string

AlertURLGenerator returns URL to single alert by given name

type Config

type Config struct {
	// Scheme defines the HTTP scheme for Notifier address
	Scheme string `yaml:"scheme,omitempty"`
	// PathPrefix is added to URL path before adding alertManagerPath value
	PathPrefix string `yaml:"path_prefix,omitempty"`

	// ConsulSDConfigs contains list of settings for service discovery via Consul
	// see https://prometheus.io/docs/prometheus/latest/configuration/configuration/#consul_sd_config
	ConsulSDConfigs []consul.SDConfig `yaml:"consul_sd_configs,omitempty"`
	// DNSSDConfigs contains list of settings for service discovery via DNS.
	// See https://prometheus.io/docs/prometheus/latest/configuration/configuration/#dns_sd_config
	DNSSDConfigs []dns.SDConfig `yaml:"dns_sd_configs,omitempty"`

	// StaticConfigs contains list of static targets
	StaticConfigs []StaticConfig `yaml:"static_configs,omitempty"`

	// HTTPClientConfig contains HTTP configuration for Notifier clients
	HTTPClientConfig promauth.HTTPClientConfig `yaml:",inline"`
	// RelabelConfigs contains list of relabeling rules for entities discovered via SD
	RelabelConfigs []promrelabel.RelabelConfig `yaml:"relabel_configs,omitempty"`
	// AlertRelabelConfigs contains list of relabeling rules alert labels
	AlertRelabelConfigs []promrelabel.RelabelConfig `yaml:"alert_relabel_configs,omitempty"`
	// The timeout used when sending alerts.
	Timeout *promutils.Duration `yaml:"timeout,omitempty"`

	// Checksum stores the hash of yaml definition for the config.
	// May be used to detect any changes to the config file.
	Checksum string

	// Catches all undefined fields and must be empty after parsing.
	XXX map[string]interface{} `yaml:",inline"`
	// contains filtered or unexported fields
}

Config contains list of supported configuration settings for Notifier

func (*Config) UnmarshalYAML

func (cfg *Config) UnmarshalYAML(unmarshal func(interface{}) error) error

UnmarshalYAML implements the yaml.Unmarshaler interface.

type FakeNotifier

type FakeNotifier struct {
	sync.Mutex
	// contains filtered or unexported fields
}

FakeNotifier is a mock notifier

func (*FakeNotifier) Addr

func (*FakeNotifier) Addr() string

Addr returns ""

func (*FakeNotifier) Close

func (*FakeNotifier) Close()

Close does nothing

func (*FakeNotifier) GetAlerts

func (fn *FakeNotifier) GetAlerts() []Alert

GetAlerts returns stored alerts

func (*FakeNotifier) GetCounter

func (fn *FakeNotifier) GetCounter() int

GetCounter returns received alerts count

func (*FakeNotifier) Send

func (fn *FakeNotifier) Send(_ context.Context, alerts []Alert, _ map[string]string) error

Send sets alerts and increases counter

type FaultyNotifier

type FaultyNotifier struct {
	FakeNotifier
}

FaultyNotifier is a mock notifier that Send() will return failed response

func (*FaultyNotifier) Send

func (fn *FaultyNotifier) Send(ctx context.Context, _ []Alert, _ map[string]string) error

Send returns failed response

type Notifier

type Notifier interface {
	// Send sends the given list of alerts.
	// Returns an error if fails to send the alerts.
	// Must unblock if the given ctx is cancelled.
	Send(ctx context.Context, alerts []Alert, notifierHeaders map[string]string) error
	// Addr returns address where alerts are sent.
	Addr() string
	// Close is a destructor for the Notifier
	Close()
}

Notifier is a common interface for alert manager provider

type StaticConfig

type StaticConfig struct {
	Targets []string `yaml:"targets"`
	// HTTPClientConfig contains HTTP configuration for the Targets
	HTTPClientConfig promauth.HTTPClientConfig `yaml:",inline"`
}

StaticConfig contains list of static targets in the following form:

targets:
[ - '<host>' ]

type Target

type Target struct {
	Notifier
	Labels *promutils.Labels
}

Target represents a Notifier and optional list of labels added during discovery.

type TargetType

type TargetType string

TargetType defines how the Target was discovered

const (
	// TargetStatic is for targets configured statically
	TargetStatic TargetType = "static"
	// TargetConsul is for targets discovered via Consul
	TargetConsul TargetType = "consulSD"
	// TargetDNS is for targets discovered via DNS
	TargetDNS TargetType = "DNSSD"
)