servergroup

Documentation

Index

• Variables
• type AbsoluteTimeRangeConfig
  • func (tr *AbsoluteTimeRangeConfig) UnmarshalYAML(unmarshal func(interface{}) error) error
• type Config
  • func (c *Config) GetAntiAffinity() model.Time
  • func (c *Config) GetScheme() string
  • func (c *Config) UnmarshalYAML(unmarshal func(interface{}) error) error
• type HTTPClientConfig
• type RelativeTimeRangeConfig
  • func (tr *RelativeTimeRangeConfig) UnmarshalYAML(unmarshal func(interface{}) error) error
• type ServerGroup
  • func New() *ServerGroup
  • func (s *ServerGroup) ApplyConfig(cfg *Config) error
  • func (s *ServerGroup) Cancel()
  • func (s *ServerGroup) GetValue(ctx context.Context, start, end time.Time, matchers []*labels.Matcher) (model.Value, error)
  • func (s *ServerGroup) LabelValues(ctx context.Context, label string) (model.LabelValues, error)
  • func (s *ServerGroup) Query(ctx context.Context, query string, ts time.Time) (model.Value, error)
  • func (s *ServerGroup) QueryRange(ctx context.Context, query string, r v1.Range) (model.Value, error)
  • func (s *ServerGroup) Series(ctx context.Context, matches []string, startTime, endTime time.Time) ([]model.LabelSet, error)
  • func (s *ServerGroup) State() *ServerGroupState
  • func (s *ServerGroup) Sync()
• type ServerGroupState

Variables

var (
	// DefaultConfig is the Default base promxy configuration
	DefaultConfig = Config{
		AntiAffinity: time.Second * 10,
		Scheme:       "http",
		HTTPConfig: HTTPClientConfig{
			DialTimeout: time.Millisecond * 2000,
		},
	}
)

Types

type AbsoluteTimeRangeConfig

type AbsoluteTimeRangeConfig struct {
	Start time.Time `yaml:"start"`
	End   time.Time `yaml:"end"`
}

AbsoluteTimeRangeConfig contains absolute times to define a servergroup's time range

func (*AbsoluteTimeRangeConfig) UnmarshalYAML

func (tr *AbsoluteTimeRangeConfig) UnmarshalYAML(unmarshal func(interface{}) error) error

UnmarshalYAML implements the yaml.Unmarshaler interface.

type Config

type Config struct {
	// RemoteRead directs promxy to load data (from the storage API) through the
	// remoteread API on prom.
	// Pros:
	//  - StaleNaNs work
	//  - ~2x faster (in my local testing, more so if you are using default JSON marshaler in prom)
	//
	// Cons:
	//  - proto marshaling prom side doesn't stream, so the data being sent
	//      over the wire will be 2x its size in memory on the remote prom host.
	//  - "experimental" API (according to docs) -- meaning this might break
	//      without much (if any) warning
	//
	// Upstream prom added a StaleNan to determine if a given timeseries has gone
	// NaN -- the problem being that for range vectors they filter out all "stale" samples
	// meaning that it isn't possible to get a "raw" dump of data through the query/query_range v1 API
	// The only option that exists in reality is the "remote read" API -- which suffers
	// from the same memory-balooning problems that the HTTP+JSON API originally had.
	// It has **less** of a problem (its 2x memory instead of 14x) so it is a viable option.
	RemoteRead bool `yaml:"remote_read"`
	// HTTP client config for promxy to use when connecting to the various server_groups
	// this is the same config as prometheus
	HTTPConfig HTTPClientConfig `yaml:"http_client"`
	// Scheme defines how promxy talks to this server group (http, https, etc.)
	Scheme string `yaml:"scheme"`
	// Labels is a set of labels that will be added to all metrics retrieved
	// from this server group
	Labels model.LabelSet `json:"labels"`
	// RelabelConfigs are similar in function and identical in configuration as prometheus'
	// relabel config for scrape jobs. The difference here being that the source labels
	// you can pull from are from the downstream servergroup target and the labels you are
	// relabeling are that of the timeseries being returned. This allows you to mutate the
	// labelsets returned by that target at runtime.
	// To further illustrate the difference we'll look at an example:
	//
	//      relabel_configs:
	//    - source_labels: [__meta_consul_tags]
	//      regex: '.*,prod,.*'
	//      action: keep
	//    - source_labels: [__meta_consul_dc]
	//      regex: '.+'
	//      action: replace
	//      target_label: datacenter
	//
	// If we saw this in a scrape-config we would expect:
	//   (1) the scrape would only target hosts with a prod consul label
	//   (2) it would add a label to all returned series of datacenter with the value set to whatever the value of __meat_consul_dc was.
	//
	// If we saw this same config in promxy (pointing at prometheus hosts instead of some exporter), we'd expect a similar behavior:
	//   (1) only targets with the prod consul label would be included in the servergroup
	//   (2) it would add a label to all returned series of this servergroup of datacenter with the value set to whatever the value of __meat_consul_dc was.
	//
	// So in reality its "the same", the difference is in prometheus these apply to the labels/targets of a scrape job,
	// in promxy they apply to the prometheus hosts in the servergroup - but the behavior is the same.
	RelabelConfigs []*config.RelabelConfig `yaml:"relabel_configs,omitempty"`
	// Hosts is a set of ServiceDiscoveryConfig options that allow promxy to discover
	// all hosts in the server_group
	Hosts sd_config.ServiceDiscoveryConfig `yaml:",inline"`
	// PathPrefix to prepend to all queries to hosts in this servergroup
	PathPrefix string `yaml:"path_prefix"`
	// TODO cache this as a model.Time after unmarshal
	// AntiAffinity defines how large of a gap in the timeseries will cause promxy
	// to merge series from 2 hosts in a server_group. This required for a couple reasons
	// (1) Promxy cannot make assumptions on downstream clock-drift and
	// (2) two prometheus hosts scraping the same target may have different times
	// #2 is caused by prometheus storing the time of the scrape as the time the scrape **starts**.
	// in practice this is actually quite frequent as there are a variety of situations that
	// cause variable scrape completion time (slow exporter, serial exporter, network latency, etc.)
	// any one of these can cause the resulting data in prometheus to have the same time but in reality
	// come from different points in time. Best practice for this value is to set it to your scrape interval
	AntiAffinity time.Duration `yaml:"anti_affinity,omitempty"`

	// IgnoreError will hide all errors from this given servergroup effectively making
	// the responses from this servergroup "not required" for the result.
	// Note: this allows you to make the tradeoff between availability of queries and consistency of results
	IgnoreError bool `yaml:"ignore_error"`

	// RelativeTimeRangeConfig defines a relative time range that this servergroup will respond to
	// An example use-case would be if a specific servergroup was long-term storage, it might only
	// have data 3d old and retain 90d of data.
	*RelativeTimeRangeConfig `yaml:"relative_time_range"`

	// AbsoluteTimeRangeConfig defines an absolute time range that this servergroup will respond to
	// An example use-case would be if a specific servergroup was was "deprecated" and wasn't getting
	// any new data after a specific given point in time
	*AbsoluteTimeRangeConfig `yaml:"absolute_time_range"`
}

Config is the configuration for a ServerGroup that promxy will talk to. This is where the vast majority of options exist.

func (*Config) GetAntiAffinity

func (c *Config) GetAntiAffinity() model.Time

GetAntiAffinity returns the AntiAffinity time for this servergroup

func (*Config) GetScheme

func (c *Config) GetScheme() string

GetScheme returns the scheme for this servergroup

func (*Config) UnmarshalYAML

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

UnmarshalYAML implements the yaml.Unmarshaler interface.

type HTTPClientConfig

type HTTPClientConfig struct {
	DialTimeout time.Duration                `yaml:"dial_timeout"`
	HTTPConfig  config_util.HTTPClientConfig `yaml:",inline"`
}

HTTPClientConfig extends prometheus' HTTPClientConfig

type RelativeTimeRangeConfig

type RelativeTimeRangeConfig struct {
	Start *time.Duration `yaml:"start"`
	End   *time.Duration `yaml:"end"`
}

RelativeTimeRangeConfig configures durations relative from "now" to define a servergroup's time range

func (*RelativeTimeRangeConfig) UnmarshalYAML

func (tr *RelativeTimeRangeConfig) UnmarshalYAML(unmarshal func(interface{}) error) error

UnmarshalYAML implements the yaml.Unmarshaler interface.

type ServerGroup

type ServerGroup struct {
	Ready chan struct{}

	// TODO: lock/atomics on cfg and client
	Cfg    *Config
	Client *http.Client

	OriginalURLs []string
	// contains filtered or unexported fields
}

ServerGroup encapsulates a set of prometheus downstreams to query/aggregate

func New

func New() *ServerGroup

New creates a new servergroup

func (*ServerGroup) ApplyConfig

func (s *ServerGroup) ApplyConfig(cfg *Config) error

ApplyConfig applies new configuration to the ServerGroup TODO: move config + client into state object to be swapped with atomics

func (*ServerGroup) Cancel

func (s *ServerGroup) Cancel()

Cancel stops backround processes (e.g. discovery manager)

func (*ServerGroup) GetValue

func (s *ServerGroup) GetValue(ctx context.Context, start, end time.Time, matchers []*labels.Matcher) (model.Value, error)

GetValue loads the raw data for a given set of matchers in the time range

func (*ServerGroup) LabelValues

func (s *ServerGroup) LabelValues(ctx context.Context, label string) (model.LabelValues, error)

LabelValues performs a query for the values of the given label.

func (*ServerGroup) Query

func (s *ServerGroup) Query(ctx context.Context, query string, ts time.Time) (model.Value, error)

Query performs a query for the given time.

func (*ServerGroup) QueryRange

func (s *ServerGroup) QueryRange(ctx context.Context, query string, r v1.Range) (model.Value, error)

QueryRange performs a query for the given range.

func (*ServerGroup) Series

func (s *ServerGroup) Series(ctx context.Context, matches []string, startTime, endTime time.Time) ([]model.LabelSet, error)

Series finds series by label matchers.

func (*ServerGroup) State

func (s *ServerGroup) State() *ServerGroupState

State returns the current ServerGroupState

func (*ServerGroup) Sync

func (s *ServerGroup) Sync()

Sync updates the targets from our discovery manager

type ServerGroupState

type ServerGroupState struct {
	// Targets is the list of target URLs for this discovery round
	Targets []string
	// contains filtered or unexported fields
}

ServerGroupState encapsulates the state of a serverGroup from service discovery