metricsgenerationprocessor

README

Metrics Generation Processor

Status: under development; Not recommended for production usage.

Supported pipeline types: metrics

Description

The metrics generation processor (experimental_metricsgenerationprocessor) can be used to create new metrics using existing metrics following a given rule. Currently it supports following two approaches for creating a new metric.

1. It can create a new metric from two existing metrics by applying one of the folliwing arithmetic operations: add, subtract, multiply, divide and percent. One use case is to calculate the pod.memory.utilization metric like the following equation- pod.memory.utilization = (pod.memory.usage.bytes / node.memory.limit)
2. It can create a new metric by scaling the value of an existing metric with a given constant number. One use case is to convert pod.memory.usage metric values from Megabytes to Bytes (multiply the existing metric's value by 1,048,576)

Configuration

Configuration is specified through a list of generation rules. Generation rules find the metrics which match the given metric names and apply the specified operation to those metrics.

processors:
    # processor name: experimental_metricsgeneration
    experimental_metricsgeneration:

        # specify the metric generation rules
        rules:
              # Name of the new metric. This is a required field.
            - name: <new_metric_name>

              # Unit for the new metric being generated.
              unit: <new_metric_unit>

              # type describes how the new metric will be generated. It can be one of `calculate` or `scale`.  calculate generates a metric applying the given operation on two operand metrics. scale operates only on operand1 metric to generate the new metric.
              type: {calculate, scale}

              # This is a required field.
              metric1: <first_operand_metric>

              # This field is required only if the type is "calculate".
              metric2: <second_operand_metric>

              # Operation specifies which arithmetic operation to apply. It must be one of the five supported operations.
              operation: {add, subtract, multiply, divide, percent}

Example Configurations

Create a new metric using two existing metrics

# create pod.cpu.utilized following (pod.cpu.usage / node.cpu.limit)
rules:
    - name: pod.cpu.utilized
      type: calculate
      metric1: pod.cpu.usage
      metric2: node.cpu.limit
      operation: divide

Create a new metric scaling the value of an existing metric

# create pod.memory.usage.bytes from pod.memory.usage.megabytes
rules:
    - name: pod.memory.usage.bytes
      unit: Bytes
      type: scale
      metric1: pod.memory.usage.megabytes
      operation: multiply
      scale_by: 1048576

Documentation

Overview

package metricsgenerationprocessor implements a processor which calculates a new metric from existing metrics.

Index

• func NewFactory() component.ProcessorFactory
• type Config
  • func (config *Config) Validate() error
• type GenerationType
• type OperationType
• type Rule

Functions

func NewFactory

func NewFactory() component.ProcessorFactory

NewFactory returns a new factory for the Metrics Generation processor.

Types

type Config

type Config struct {
	config.ProcessorSettings `mapstructure:",squash"` // squash ensures fields are correctly decoded in embedded struct

	// Set of rules for generating new metrics
	Rules []Rule `mapstructure:"rules"`
}

Config defines the configuration for the processor.

func (*Config) Validate

func (config *Config) Validate() error

Validate checks whether the input configuration has all of the required fields for the processor. An error is returned if there are any invalid inputs.

type GenerationType

type GenerationType string

type OperationType

type OperationType string

type Rule

type Rule struct {
	// Name of the new metric being generated. This is a required field.
	Name string `mapstructure:"name"`

	// Unit for the new metric being generated.
	Unit string `mapstructure:"unit"`

	// The rule type following which the new metric will be generated. This is a required field.
	Type GenerationType `mapstructure:"type"`

	// First operand metric to use in the calculation. This is a required field.
	Metric1 string `mapstructure:"metric1"`

	// Second operand metric to use in the calculation. A required field if the type is calculate.
	Metric2 string `mapstructure:"metric2"`

	// The arithmetic operation to apply for the calculation. This is a required field.
	Operation OperationType `mapstructure:"operation"`

	// A constant number by which the first operand will be scaled. A required field if the type is scale.
	ScaleBy float64 `mapstructure:"scale_by"`
}