servergroup

Documentation

Index

• type Config
  • func (c *Config) GetAntiAffinity() model.Time
  • func (c *Config) GetScheme() string
• type ServerGroup
  • func New() *ServerGroup
  • func (s *ServerGroup) ApplyConfig(cfg *Config) error
  • func (s *ServerGroup) Cancel()
  • func (s *ServerGroup) GetData(ctx context.Context, path string, values url.Values) (model.Value, error)
  • func (s *ServerGroup) GetValue(ctx context.Context, start, end time.Time, matchers []*labels.Matcher) (model.Value, error)
  • func (s *ServerGroup) GetValuesForLabelName(ctx context.Context, path string) (*promclient.LabelResult, error)
  • func (s *ServerGroup) RemoteRead(ctx context.Context, start, end time.Time, matchers []*labels.Matcher) (model.Value, error)
  • func (s *ServerGroup) Sync()
  • func (s *ServerGroup) Targets() []string
• type ServerGroups
  • func (s ServerGroups) GetData(ctx context.Context, path string, values url.Values) (model.Value, error)
  • func (s ServerGroups) GetValue(ctx context.Context, start, end time.Time, matchers []*labels.Matcher) (model.Value, error)
  • func (s ServerGroups) GetValuesForLabelName(ctx context.Context, path string) (*promclient.LabelResult, error)

Types

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 config_util.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 is identical in function and configuration as prometheus'
	// relabel config for scrape jobs
	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"`
	// 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"`
}

func (*Config) GetAntiAffinity

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

func (*Config) GetScheme

func (c *Config) GetScheme() string

type ServerGroup

type ServerGroup struct {
	Ready chan struct{}

	Cfg    *Config
	Client *http.Client

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

func New

func New() *ServerGroup

TODO: pass in parent context

func (*ServerGroup) ApplyConfig

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

TODO: move config + client into state object to be swapped with atomics

func (*ServerGroup) Cancel

func (s *ServerGroup) Cancel()

func (*ServerGroup) GetData

func (s *ServerGroup) GetData(ctx context.Context, path string, values url.Values) (model.Value, error)

func (*ServerGroup) GetValue

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

func (*ServerGroup) GetValuesForLabelName

func (s *ServerGroup) GetValuesForLabelName(ctx context.Context, path string) (*promclient.LabelResult, error)

func (*ServerGroup) RemoteRead

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

func (*ServerGroup) Sync

func (s *ServerGroup) Sync()

func (*ServerGroup) Targets

func (s *ServerGroup) Targets() []string

type ServerGroups

type ServerGroups []*ServerGroup

func (ServerGroups) GetData

func (s ServerGroups) GetData(ctx context.Context, path string, values url.Values) (model.Value, error)

func (ServerGroups) GetValue

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

GetValue fetches a `model.Value` from the servergroups

func (ServerGroups) GetValuesForLabelName

func (s ServerGroups) GetValuesForLabelName(ctx context.Context, path string) (*promclient.LabelResult, error)