alert

package
v1.2.0-rc1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 11, 2017 License: MIT Imports: 35 Imported by: 50

Documentation

Overview

Alert provides an implementation of the HTTP API for managing alert topics, handlers and events.

Responsibilities of this package include:

* Providing and HTTP API for the management of handlers * Storing handler definitions * Providing implementations of several simple handlers * Mapping external handler implementations to handler definitions

The last item needs some more clarification. Handlers can be implemented in external packages. In order for the HTTP API to consume those implementations a mapping needs to be defined from the HandlerAction definition to the expected configuration of the handler implementation. This package provides that mapping.

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrHandlerSpecExists   = errors.New("handler spec already exists")
	ErrNoHandlerSpecExists = errors.New("no handler spec exists")
)
View Source 
var (
	ErrNoTopicStateExists = errors.New("no topic state exists")
)

Functions

func NewAggregateHandler 

func NewAggregateHandler(c AggregateHandlerConfig, l *log.Logger) handlerAction

func NewExecHandler 

func NewExecHandler(c ExecHandlerConfig, l *log.Logger) alert.Handler

func NewLogHandler 

func NewLogHandler(c LogHandlerConfig, l *log.Logger) (alert.Handler, error)

func NewPostHandler 

func NewPostHandler(c PostHandlerConfig, l *log.Logger) alert.Handler

func NewTCPHandler 

func NewTCPHandler(c TCPHandlerConfig, l *log.Logger) alert.Handler

Types

type AggregateHandlerConfig 

type AggregateHandlerConfig struct {
	Interval time.Duration `mapstructure:"interval"`
}

type AlertData 

type AlertData struct {
	ID       string          `json:"id"`
	Message  string          `json:"message"`
	Details  string          `json:"details"`
	Time     time.Time       `json:"time"`
	Duration time.Duration   `json:"duration"`
	Level    alert.Level     `json:"level"`
	Data     influxql.Result `json:"data"`
}

AlertData is a structure that contains relevant data about an alert event. The structure is intended to be JSON encoded, providing a consistent data format.

type Config 

type Config struct {
}

func NewConfig 

func NewConfig() Config

type EventState 

type EventState struct {
	Message  string        `json:"message"`
	Details  string        `json:"details"`
	Time     time.Time     `json:"time"`
	Duration time.Duration `json:"duration"`
	Level    alert.Level   `json:"level"`
}

type ExecHandlerConfig 

type ExecHandlerConfig struct {
	Prog      string            `mapstructure:"prog"`
	Args      []string          `mapstructure:"args"`
	Commander command.Commander `mapstructure:"-"`
}

type HandlerActionSpec 

type HandlerActionSpec struct {
	Kind    string                 `json:"kind"`
	Options map[string]interface{} `json:"options"`
}

HandlerActionSpec defines an action an handler can take.

type HandlerSpec 

type HandlerSpec struct {
	ID      string              `json:"id"`
	Topics  []string            `json:"topics"`
	Actions []HandlerActionSpec `json:"actions"`
}

HandlerSpec provides all the necessary information to create a handler.

func (HandlerSpec) HasTopic 

func (h HandlerSpec) HasTopic(topic string) bool

func (HandlerSpec) MarshalBinary 

func (h HandlerSpec) MarshalBinary() ([]byte, error)

func (HandlerSpec) ObjectID 

func (h HandlerSpec) ObjectID() string

func (*HandlerSpec) UnmarshalBinary 

func (h *HandlerSpec) UnmarshalBinary(data []byte) error

func (HandlerSpec) Validate 

func (h HandlerSpec) Validate() error

type HandlerSpecDAO 

type HandlerSpecDAO interface {
	// Retrieve a handler
	Get(id string) (HandlerSpec, error)

	// Create a handler.
	// ErrHandlerSpecExists is returned if a handler already exists with the same ID.
	Create(h HandlerSpec) error

	// Replace an existing handler.
	// ErrNoHandlerSpecExists is returned if the handler does not exist.
	Replace(h HandlerSpec) error

	// Delete a handler.
	// It is not an error to delete an non-existent handler.
	Delete(id string) error

	// List handlers matching a pattern.
	// The pattern is shell/glob matching see https://golang.org/pkg/path/#Match
	// Offset and limit are pagination bounds. Offset is inclusive starting at index 0.
	// More results may exist while the number of returned items is equal to limit.
	List(pattern string, offset, limit int) ([]HandlerSpec, error)
}

Data access object for HandlerSpec data.

type LogHandlerConfig 

type LogHandlerConfig struct {
	Path string      `mapstructure:"path"`
	Mode os.FileMode `mapstructure:"mode"`
}

func DefaultLogHandlerConfig 

func DefaultLogHandlerConfig() LogHandlerConfig

func (LogHandlerConfig) Validate 

func (c LogHandlerConfig) Validate() error

type PostHandlerConfig 

type PostHandlerConfig struct {
	URL string `mapstructure:"url"`
}

type Service 

type Service struct {
	HTTPDService interface {
		AddPreviewRoutes([]httpd.Route) error
		DelRoutes([]httpd.Route)
	}
	StorageService interface {
		Store(namespace string) storage.Interface
	}

	Commander command.Commander

	AlertaService interface {
		DefaultHandlerConfig() alerta.HandlerConfig
		Handler(alerta.HandlerConfig, *log.Logger) (alert.Handler, error)
	}
	HipChatService interface {
		Handler(hipchat.HandlerConfig, *log.Logger) alert.Handler
	}
	OpsGenieService interface {
		Handler(opsgenie.HandlerConfig, *log.Logger) alert.Handler
	}
	PagerDutyService interface {
		Handler(pagerduty.HandlerConfig, *log.Logger) alert.Handler
	}
	SensuService interface {
		Handler(*log.Logger) alert.Handler
	}
	SlackService interface {
		Handler(slack.HandlerConfig, *log.Logger) alert.Handler
	}
	SMTPService interface {
		Handler(smtp.HandlerConfig, *log.Logger) alert.Handler
	}
	SNMPTrapService interface {
		Handler(snmptrap.HandlerConfig, *log.Logger) (alert.Handler, error)
	}
	TalkService interface {
		Handler(*log.Logger) alert.Handler
	}
	TelegramService interface {
		Handler(telegram.HandlerConfig, *log.Logger) alert.Handler
	}
	VictorOpsService interface {
		Handler(victorops.HandlerConfig, *log.Logger) alert.Handler
	}
	// contains filtered or unexported fields
}

func NewService 

func NewService(c Config, l *log.Logger) *Service

func (*Service) Close 

func (s *Service) Close() error

func (*Service) CloseTopic 

func (s *Service) CloseTopic(topic string) error

func (*Service) Collect 

func (s *Service) Collect(event alert.Event) error

func (*Service) DeleteTopic 

func (s *Service) DeleteTopic(topic string) error

func (*Service) DeregisterHandler 

func (s *Service) DeregisterHandler(topics []string, h alert.Handler)

func (*Service) DeregisterHandlerSpec 

func (s *Service) DeregisterHandlerSpec(id string) error

func (*Service) EventState 

func (s *Service) EventState(topic, event string) (alert.EventState, bool)

func (*Service) Handlers 

func (s *Service) Handlers(pattern string) []client.Handler

func (*Service) Open 

func (s *Service) Open() error

func (*Service) RegisterHandler 

func (s *Service) RegisterHandler(topics []string, h alert.Handler)

func (*Service) RegisterHandlerSpec 

func (s *Service) RegisterHandlerSpec(spec HandlerSpec) error

func (*Service) ReplaceHandlerSpec 

func (s *Service) ReplaceHandlerSpec(oldSpec, newSpec HandlerSpec) error

func (*Service) RestoreTopic 

func (s *Service) RestoreTopic(topic string) error

func (*Service) TopicStatus 

func (s *Service) TopicStatus(pattern string, minLevel alert.Level) []client.Topic

TopicStatus returns the max alert level for each topic matching 'pattern', not returning any topics with max alert levels less severe than 'minLevel'

func (*Service) TopicStatusEvents 

func (s *Service) TopicStatusEvents(pattern string, minLevel alert.Level) map[string]map[string]alert.EventState

TopicStatusDetails is similar to TopicStatus, but will additionally return at least 'minLevel' severity

func (*Service) UpdateEvent 

func (s *Service) UpdateEvent(topic string, event alert.EventState) error

type TCPHandlerConfig 

type TCPHandlerConfig struct {
	Address string `mapstructure:"address"`
}

type TopicState 

type TopicState struct {
	Topic       string                `json:"topic"`
	EventStates map[string]EventState `json:"event-states"`
}

func (TopicState) MarshalBinary 

func (t TopicState) MarshalBinary() ([]byte, error)

func (TopicState) ObjectID 

func (t TopicState) ObjectID() string

func (*TopicState) UnmarshalBinary 

func (t *TopicState) UnmarshalBinary(data []byte) error

type TopicStateDAO 

type TopicStateDAO interface {
	// Retrieve a handler
	Get(id string) (TopicState, error)

	// Put a topic state, replaces any existing state.
	Put(h TopicState) error

	// Delete a handler.
	// It is not an error to delete an non-existent handler.
	Delete(id string) error

	// List handlers matching a pattern.
	// The pattern is shell/glob matching see https://golang.org/pkg/path/#Match
	// Offset and limit are pagination bounds. Offset is inclusive starting at index 0.
	// More results may exist while the number of returned items is equal to limit.
	List(pattern string, offset, limit int) ([]TopicState, error)
}

Data access object for TopicState data.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.