ctrstats

Documentation

Index

• Variables
• func GetContainerStats(ctx context.Context, c Container) (*v1.Metrics, error)
• func NewContainerdClient(address, namespace string) (*containerd.Client, error)
• type Container
  • func GetContainers(client *containerd.Client) ([]Container, error)
• type Metric
  • func (m *Metric) Desc() *prometheus.Desc

Variables

var CpuMetrics = []*Metric{
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.CPU == nil {
				return value{}
			}
			return value{
				V: float64(stats.CPU.Usage.Total),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.CPU == nil {
				return value{}
			}
			return value{
				V: float64(stats.CPU.Usage.Kernel),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.CPU == nil {
				return value{}
			}
			return value{
				V: float64(stats.CPU.Usage.User),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.CPU == nil {
				return value{}
			}
			return value{
				V: float64(stats.CPU.Throttling.Periods),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.CounterValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.CPU == nil {
				return value{}
			}
			return value{
				V: float64(stats.CPU.Throttling.ThrottledPeriods),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.CPU == nil {
				return value{}
			}
			return value{
				V: float64(stats.CPU.Throttling.ThrottledTime),
			}
		},
		// contains filtered or unexported fields
	},
}

var MemoryMetrics = []*Metric{
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.Cache),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.RSS),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.RSSHuge),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.MappedFile),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.PgMajFault),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.InactiveAnon),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.ActiveAnon),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.InactiveFile),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.ActiveFile),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.TotalCache),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.TotalRSS),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.TotalMappedFile),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.Usage.Failcnt),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.Usage.Limit),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.Usage.Max),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.Usage.Usage),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.Kernel.Failcnt),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.Kernel.Limit),
			}
		},
		// contains filtered or unexported fields
	},
	{

		Vt: prometheus.GaugeValue,
		GetValues: func(stats *v1.Metrics) value {
			if stats.Memory == nil {
				return value{}
			}
			return value{
				V: float64(stats.Memory.Kernel.Usage),
			}
		},
		// contains filtered or unexported fields
	},
}

Functions

func GetContainerStats

func GetContainerStats(ctx context.Context, c Container) (*v1.Metrics, error)

func NewContainerdClient

func NewContainerdClient(address, namespace string) (*containerd.Client, error)

Types

type Container

type Container struct {
	SandboxID        string
	ContainerID      string
	PodID            string
	PodName          string
	SandboxNamespace string
	ContainerName    string
	Container        containerd.Container
}

func GetContainers

func GetContainers(client *containerd.Client) ([]Container, error)

type Metric

type Metric struct {
	Vt prometheus.ValueType

	// getvalues returns the value and labels for the data
	GetValues func(stats *v1.Metrics) value
	// contains filtered or unexported fields
}

func (*Metric) Desc

func (m *Metric) Desc() *prometheus.Desc