framework

Documentation

Index

• Constants
• func CollectorsHasStarted(collectors map[string]Collector) bool
• func DeviceCollectorsStarted(devices map[string]DeviceCollector) bool
• type AndPodFilter
  • func (a *AndPodFilter) FilterPod(podMeta *statesinformer.PodMeta) (bool, string)
• type CPUStat
• type Collector
• type CollectorFactory
• type Config
  • func NewDefaultConfig() *Config
  • func (c *Config) InitFlags(fs *flag.FlagSet)
• type Context
• type DeviceCollector
• type DeviceFactory
• type LatestMetric
• type NothingPodFilter
  • func (n *NothingPodFilter) FilterPod(podMeta *statesinformer.PodMeta) (bool, string)
• type Options
• type PodCollector
• type PodFilter
  • func NewAndPodFilter(filters ...PodFilter) PodFilter
• type SharedState
  • func NewSharedState() *SharedState
  • func (r *SharedState) GetHostAppUsage() (cpu, memory *metriccache.Point)
  • func (r *SharedState) GetNodeUsage() (cpu, memory *metriccache.Point)
  • func (r *SharedState) GetPodsUsageByCollector() (cpu, memory map[string]metriccache.Point)
  • func (r *SharedState) UpdateHostAppUsage(cpu, memory metriccache.Point)
  • func (r *SharedState) UpdateNodeUsage(cpu, memory metriccache.Point)
  • func (r *SharedState) UpdatePodUsage(collectorName string, cpu, memory metriccache.Point)
• type TerminatedPodFilter
  • func (t *TerminatedPodFilter) FilterPod(podMeta *statesinformer.PodMeta) (bool, string)

Constants

const (
	CleanupInterval     = 600 * time.Second
	ContextExpiredRatio = 20
)

Functions

func CollectorsHasStarted

func CollectorsHasStarted(collectors map[string]Collector) bool

func DeviceCollectorsStarted

func DeviceCollectorsStarted(devices map[string]DeviceCollector) bool

Types

type AndPodFilter

type AndPodFilter struct {
	Filters []PodFilter
}

func (*AndPodFilter) FilterPod

func (a *AndPodFilter) FilterPod(podMeta *statesinformer.PodMeta) (bool, string)

type CPUStat

type CPUStat struct {
	// TODO check CPUTick or CPUUsage can be abandoned
	CPUTick   uint64
	CPUUsage  uint64
	Timestamp time.Time
}

type Collector

type Collector interface {
	Enabled() bool
	Setup(s *Context)
	Run(stopCh <-chan struct{})
	Started() bool
}

type CollectorFactory

type CollectorFactory = func(opt *Options) Collector

type Config

type Config struct {
	CollectResUsedInterval           time.Duration
	CollectSysMetricOutdatedInterval time.Duration
	CollectNodeCPUInfoInterval       time.Duration
	CollectNodeStorageInfoInterval   time.Duration
	CPICollectorInterval             time.Duration
	PSICollectorInterval             time.Duration
	CPICollectorTimeWindow           time.Duration
	ColdPageCollectorInterval        time.Duration
	EnablePageCacheCollector         bool
}

func NewDefaultConfig

func NewDefaultConfig() *Config

func (*Config) InitFlags

func (c *Config) InitFlags(fs *flag.FlagSet)

type Context

type Context struct {
	DeviceCollectors map[string]DeviceCollector
	Collectors       map[string]Collector
	State            *SharedState
}

type DeviceCollector

type DeviceCollector interface {
	Collector
	Shutdown()
	Started() bool
	Infos() metriccache.Devices
	GetNodeMetric() ([]metriccache.MetricSample, error)
	GetPodMetric(uid, podParentDir string, cs []corev1.ContainerStatus) ([]metriccache.MetricSample, error)
	GetContainerMetric(containerID, podParentDir string, c *corev1.ContainerStatus) ([]metriccache.MetricSample, error)
}

type DeviceFactory

type DeviceFactory = func(opt *Options) DeviceCollector

type LatestMetric

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

type NothingPodFilter

type NothingPodFilter struct{}

func (*NothingPodFilter) FilterPod

func (n *NothingPodFilter) FilterPod(podMeta *statesinformer.PodMeta) (bool, string)

type Options

type Options struct {
	Config         *Config
	StatesInformer statesinformer.StatesInformer
	MetricCache    metriccache.MetricCache
	CgroupReader   resourceexecutor.CgroupReader
	PodFilters     map[string]PodFilter
}

type PodCollector

type PodCollector interface {
	Collector
	PodFilter
}

type PodFilter

type PodFilter interface {
	// FilterPod returns true if the collector should skip collecting the pod.
	FilterPod(podMeta *statesinformer.PodMeta) (shouldSkip bool, msg string)
}

var DefaultPodFilter PodFilter = &NothingPodFilter{}

DefaultPodFilter filters nothing and allows collection for all pods.

func NewAndPodFilter

func NewAndPodFilter(filters ...PodFilter) PodFilter

type SharedState

type SharedState struct {
	LatestMetric
}

SharedState is for sharing infos across collectors, for example the system resource collector use the result of pod and node resource collector for calculating system usage

func NewSharedState

func NewSharedState() *SharedState

func (*SharedState) GetHostAppUsage

func (r *SharedState) GetHostAppUsage() (cpu, memory *metriccache.Point)

func (*SharedState) GetNodeUsage

func (r *SharedState) GetNodeUsage() (cpu, memory *metriccache.Point)

func (*SharedState) GetPodsUsageByCollector

func (r *SharedState) GetPodsUsageByCollector() (cpu, memory map[string]metriccache.Point)

func (*SharedState) UpdateHostAppUsage

func (r *SharedState) UpdateHostAppUsage(cpu, memory metriccache.Point)

func (*SharedState) UpdateNodeUsage

func (r *SharedState) UpdateNodeUsage(cpu, memory metriccache.Point)

func (*SharedState) UpdatePodUsage

func (r *SharedState) UpdatePodUsage(collectorName string, cpu, memory metriccache.Point)

type TerminatedPodFilter

type TerminatedPodFilter struct{}

func (*TerminatedPodFilter) FilterPod

func (t *TerminatedPodFilter) FilterPod(podMeta *statesinformer.PodMeta) (bool, string)