collectors

Documentation

Index

• Constants
• Variables
• func TagCardinalityToString(c TagCardinality) string
• type Catalog
• type CollectionMode
• type Collector
• type CollectorFactory
• type CollectorPriority
• type Fetcher
• type GardenCollector
  • func (c *GardenCollector) Detect(out chan<- []*TagInfo) (CollectionMode, error)
  • func (c *GardenCollector) Fetch(entity string) ([]string, []string, []string, error)
  • func (c *GardenCollector) Pull() error
• type Puller
• type StaticCollector
  • func (c *StaticCollector) Detect(out chan<- []*TagInfo) (CollectionMode, error)
  • func (c *StaticCollector) Fetch(entity string) ([]string, []string, []string, error)
• type Streamer
• type TagCardinality
  • func StringToTagCardinality(c string) (TagCardinality, error)
• type TagInfo

Constants

const (
	// OrchestratorScopeEntityID defines the orchestrator scope entity ID
	OrchestratorScopeEntityID = "internal:orchestrator-scope-entity-id"
)

Variables

var CollectorPriorities = make(map[string]CollectorPriority)

CollectorPriorities holds collector priorities

var DefaultCatalog = make(Catalog)

DefaultCatalog holds every compiled-in collector

Functions

func TagCardinalityToString

func TagCardinalityToString(c TagCardinality) string

TagCardinalityToString returns a string representation of a TagCardinality value.

Types

type Catalog

type Catalog map[string]CollectorFactory

Catalog holds available collectors for detection and usage

type CollectionMode

type CollectionMode int

CollectionMode informs the Tagger of how to schedule a Collector

const (
	NoCollection        CollectionMode = iota // Not available
	PullCollection                            // Call regularly via the Pull method
	StreamCollection                          // Will continuously feed updates on the channel from Steam() to Stop()
	FetchOnlyCollection                       // Only call Fetch() on cache misses
)

Return values for Collector.Init to inform the Tagger of the scheduling needed

type Collector

type Collector interface {
	Detect(chan<- []*TagInfo) (CollectionMode, error)
}

Collector retrieve entity tags from a given source and feeds updates via the TagInfo channel

type CollectorFactory

type CollectorFactory func() Collector

CollectorFactory is functions that return a Collector

type CollectorPriority

type CollectorPriority int

CollectorPriority helps resolving dupe tags from collectors

const (
	NodeRuntime CollectorPriority = iota
	NodeOrchestrator
	ClusterOrchestrator
)

List of collector priorities

type Fetcher

type Fetcher interface {
	Fetch(string) ([]string, []string, []string, error)
}

Fetcher allows to fetch tags on-demand in case of cache miss

type GardenCollector

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

GardenCollector collects tags for CF application containers

func (*GardenCollector) Detect

func (c *GardenCollector) Detect(out chan<- []*TagInfo) (CollectionMode, error)

Detect tries to connect to the Garden API and the cluster agent

func (*GardenCollector) Fetch

func (c *GardenCollector) Fetch(entity string) ([]string, []string, []string, error)

Fetch gets the tags for a specific entity

func (*GardenCollector) Pull

func (c *GardenCollector) Pull() error

Pull gets the list of containers

type Puller

type Puller interface {
	Fetcher
	Pull() error
}

Puller has to be triggered regularly

type StaticCollector

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

StaticCollector fetches "static" tags, e.g. those from an env var It is not intended to run as a stand alone. This is currently only used for Fargate instances where host tags are not collected

func (*StaticCollector) Detect

func (c *StaticCollector) Detect(out chan<- []*TagInfo) (CollectionMode, error)

Detect detects static tags

func (*StaticCollector) Fetch

func (c *StaticCollector) Fetch(entity string) ([]string, []string, []string, error)

Fetch fetches static tags

type Streamer

type Streamer interface {
	Fetcher
	Stream() error
	Stop() error
}

Streamer feeds back TagInfo when detecting changes

type TagCardinality

type TagCardinality int

TagCardinality indicates the cardinality-level of a tag. It can be low cardinality (in the host count order of magnitude) orchestrator cardinality (tags that change value for each pod, task, etc.) high cardinality (typically tags that change value for each web request, each container, etc.)

const (
	LowCardinality TagCardinality = iota
	OrchestratorCardinality
	HighCardinality
)

List of possible container cardinality

func StringToTagCardinality

func StringToTagCardinality(c string) (TagCardinality, error)

StringToTagCardinality extracts a TagCardinality from a string. In case of failure to parse, returns an error and defaults to Low.

type TagInfo

type TagInfo struct {
	Source               string   // source collector's name
	Entity               string   // entity name ready for lookup
	HighCardTags         []string // high cardinality tags that can create a lot of different timeseries (typically one per container, user request, etc.)
	OrchestratorCardTags []string // orchestrator cardinality tags that have as many combination as pods/tasks
	LowCardTags          []string // low cardinality tags safe for every pipeline
	StandardTags         []string // the discovered standard tags (env, version, service) for the entity
	DeleteEntity         bool     // true if the entity is to be deleted from the store
	CacheMiss            bool     // true if the TagInfo is generated by a tag miss
}

TagInfo holds the tag information for a given entity and source. It's meant to be created from collectors and read by the store.