diff --git a/.chloggen/46363-kubeletstats-reaggregation.yaml b/.chloggen/46363-kubeletstats-reaggregation.yaml new file mode 100644 index 0000000000000..d3c4882e7d7f2 --- /dev/null +++ b/.chloggen/46363-kubeletstats-reaggregation.yaml @@ -0,0 +1,22 @@ +# Use this changelog template to create an entry for release notes. + +# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix' +change_type: enhancement + +# The name of the component, or a single word describing the area of concern (e.g. receiver/filelog) +component: receiver/kubeletstats + +# A brief description of the change. +note: Enable re-aggregation support for kubeletstatsreceiver by adding metadata reaggregation configuration and attribute level classifications. + +# Mandatory: One or more tracking issues related to the change. +issues: [46363] + +# (Optional) Additional information for release notes. +# Not required for this change. +# subtext: | + +# Optional: Which changelog(s) this entry should appear in. +# Include 'user' for user-facing changes. +# Include 'api' for library/API changes. +change_logs: [user] \ No newline at end of file diff --git a/receiver/kubeletstatsreceiver/config_test.go b/receiver/kubeletstatsreceiver/config_test.go index 482fdc00da300..791319697bb4b 100644 --- a/receiver/kubeletstatsreceiver/config_test.go +++ b/receiver/kubeletstatsreceiver/config_test.go @@ -193,7 +193,7 @@ func TestLoadConfig(t *testing.T) { }, MetricsBuilderConfig: metadata.MetricsBuilderConfig{ Metrics: metadata.MetricsConfig{ - K8sContainerCPUNodeUtilization: metadata.MetricConfig{ + K8sContainerCPUNodeUtilization: metadata.K8sContainerCPUNodeUtilizationMetricConfig{ Enabled: true, }, }, @@ -221,7 +221,7 @@ func TestLoadConfig(t *testing.T) { }, MetricsBuilderConfig: metadata.MetricsBuilderConfig{ Metrics: metadata.MetricsConfig{ - K8sPodCPUNodeUtilization: metadata.MetricConfig{ + K8sPodCPUNodeUtilization: metadata.K8sPodCPUNodeUtilizationMetricConfig{ Enabled: true, }, }, @@ -249,7 +249,7 @@ func TestLoadConfig(t *testing.T) { }, MetricsBuilderConfig: metadata.MetricsBuilderConfig{ Metrics: metadata.MetricsConfig{ - K8sContainerMemoryNodeUtilization: metadata.MetricConfig{ + K8sContainerMemoryNodeUtilization: metadata.K8sContainerMemoryNodeUtilizationMetricConfig{ Enabled: true, }, }, @@ -277,7 +277,7 @@ func TestLoadConfig(t *testing.T) { }, MetricsBuilderConfig: metadata.MetricsBuilderConfig{ Metrics: metadata.MetricsConfig{ - K8sPodMemoryNodeUtilization: metadata.MetricConfig{ + K8sPodMemoryNodeUtilization: metadata.K8sPodMemoryNodeUtilizationMetricConfig{ Enabled: true, }, }, diff --git a/receiver/kubeletstatsreceiver/internal/metadata/config.schema.yaml b/receiver/kubeletstatsreceiver/internal/metadata/config.schema.yaml index e9f6e68c8cf45..9b1e2800177fd 100644 --- a/receiver/kubeletstatsreceiver/internal/metadata/config.schema.yaml +++ b/receiver/kubeletstatsreceiver/internal/metadata/config.schema.yaml @@ -214,6 +214,24 @@ $defs: enabled: type: boolean default: true + aggregation_strategy: + type: string + enum: + - "sum" + - "avg" + - "min" + - "max" + default: "sum" + attributes: + type: array + items: + type: string + enum: + - "interface" + - "direction" + default: + - "interface" + - "direction" k8s.node.network.io: description: "K8sNodeNetworkIoMetricConfig provides config for the k8s.node.network.io metric." type: object @@ -221,6 +239,24 @@ $defs: enabled: type: boolean default: true + aggregation_strategy: + type: string + enum: + - "sum" + - "avg" + - "min" + - "max" + default: "sum" + attributes: + type: array + items: + type: string + enum: + - "interface" + - "direction" + default: + - "interface" + - "direction" k8s.node.uptime: description: "K8sNodeUptimeMetricConfig provides config for the k8s.node.uptime metric." type: object @@ -354,6 +390,24 @@ $defs: enabled: type: boolean default: true + aggregation_strategy: + type: string + enum: + - "sum" + - "avg" + - "min" + - "max" + default: "sum" + attributes: + type: array + items: + type: string + enum: + - "interface" + - "direction" + default: + - "interface" + - "direction" k8s.pod.network.io: description: "K8sPodNetworkIoMetricConfig provides config for the k8s.pod.network.io metric." type: object @@ -361,6 +415,24 @@ $defs: enabled: type: boolean default: true + aggregation_strategy: + type: string + enum: + - "sum" + - "avg" + - "min" + - "max" + default: "sum" + attributes: + type: array + items: + type: string + enum: + - "interface" + - "direction" + default: + - "interface" + - "direction" k8s.pod.uptime: description: "K8sPodUptimeMetricConfig provides config for the k8s.pod.uptime metric." type: object diff --git a/receiver/kubeletstatsreceiver/internal/metadata/generated_config.go b/receiver/kubeletstatsreceiver/internal/metadata/generated_config.go index a8ca2e7a062cf..6c06d41c7671e 100644 --- a/receiver/kubeletstatsreceiver/internal/metadata/generated_config.go +++ b/receiver/kubeletstatsreceiver/internal/metadata/generated_config.go @@ -3,17 +3,1276 @@ package metadata import ( + "fmt" + "slices" + "go.opentelemetry.io/collector/confmap" "go.opentelemetry.io/collector/filter" ) -// MetricConfig provides common config for a particular metric. -type MetricConfig struct { +// ContainerCPUTimeMetricConfig provides config for the container.cpu.time metric. +type ContainerCPUTimeMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerCPUTimeMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// ContainerCPUUsageMetricConfig provides config for the container.cpu.usage metric. +type ContainerCPUUsageMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerCPUUsageMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// ContainerFilesystemAvailableMetricConfig provides config for the container.filesystem.available metric. +type ContainerFilesystemAvailableMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerFilesystemAvailableMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// ContainerFilesystemCapacityMetricConfig provides config for the container.filesystem.capacity metric. +type ContainerFilesystemCapacityMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerFilesystemCapacityMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// ContainerFilesystemUsageMetricConfig provides config for the container.filesystem.usage metric. +type ContainerFilesystemUsageMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerFilesystemUsageMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// ContainerMemoryAvailableMetricConfig provides config for the container.memory.available metric. +type ContainerMemoryAvailableMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerMemoryAvailableMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// ContainerMemoryMajorPageFaultsMetricConfig provides config for the container.memory.major_page_faults metric. +type ContainerMemoryMajorPageFaultsMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerMemoryMajorPageFaultsMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// ContainerMemoryPageFaultsMetricConfig provides config for the container.memory.page_faults metric. +type ContainerMemoryPageFaultsMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerMemoryPageFaultsMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// ContainerMemoryRssMetricConfig provides config for the container.memory.rss metric. +type ContainerMemoryRssMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerMemoryRssMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// ContainerMemoryUsageMetricConfig provides config for the container.memory.usage metric. +type ContainerMemoryUsageMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerMemoryUsageMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// ContainerMemoryWorkingSetMetricConfig provides config for the container.memory.working_set metric. +type ContainerMemoryWorkingSetMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerMemoryWorkingSetMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// ContainerUptimeMetricConfig provides config for the container.uptime metric. +type ContainerUptimeMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *ContainerUptimeMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sContainerCPUNodeUtilizationMetricConfig provides config for the k8s.container.cpu.node.utilization metric. +type K8sContainerCPUNodeUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sContainerCPUNodeUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sContainerCPULimitUtilizationMetricConfig provides config for the k8s.container.cpu_limit_utilization metric. +type K8sContainerCPULimitUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sContainerCPULimitUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sContainerCPURequestUtilizationMetricConfig provides config for the k8s.container.cpu_request_utilization metric. +type K8sContainerCPURequestUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sContainerCPURequestUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sContainerMemoryNodeUtilizationMetricConfig provides config for the k8s.container.memory.node.utilization metric. +type K8sContainerMemoryNodeUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sContainerMemoryNodeUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sContainerMemoryLimitUtilizationMetricConfig provides config for the k8s.container.memory_limit_utilization metric. +type K8sContainerMemoryLimitUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sContainerMemoryLimitUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sContainerMemoryRequestUtilizationMetricConfig provides config for the k8s.container.memory_request_utilization metric. +type K8sContainerMemoryRequestUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sContainerMemoryRequestUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeCPUTimeMetricConfig provides config for the k8s.node.cpu.time metric. +type K8sNodeCPUTimeMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeCPUTimeMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeCPUUsageMetricConfig provides config for the k8s.node.cpu.usage metric. +type K8sNodeCPUUsageMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeCPUUsageMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeFilesystemAvailableMetricConfig provides config for the k8s.node.filesystem.available metric. +type K8sNodeFilesystemAvailableMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeFilesystemAvailableMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeFilesystemCapacityMetricConfig provides config for the k8s.node.filesystem.capacity metric. +type K8sNodeFilesystemCapacityMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeFilesystemCapacityMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeFilesystemUsageMetricConfig provides config for the k8s.node.filesystem.usage metric. +type K8sNodeFilesystemUsageMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeFilesystemUsageMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeMemoryAvailableMetricConfig provides config for the k8s.node.memory.available metric. +type K8sNodeMemoryAvailableMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeMemoryAvailableMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeMemoryMajorPageFaultsMetricConfig provides config for the k8s.node.memory.major_page_faults metric. +type K8sNodeMemoryMajorPageFaultsMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeMemoryMajorPageFaultsMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeMemoryPageFaultsMetricConfig provides config for the k8s.node.memory.page_faults metric. +type K8sNodeMemoryPageFaultsMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeMemoryPageFaultsMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeMemoryRssMetricConfig provides config for the k8s.node.memory.rss metric. +type K8sNodeMemoryRssMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeMemoryRssMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeMemoryUsageMetricConfig provides config for the k8s.node.memory.usage metric. +type K8sNodeMemoryUsageMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeMemoryUsageMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeMemoryWorkingSetMetricConfig provides config for the k8s.node.memory.working_set metric. +type K8sNodeMemoryWorkingSetMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeMemoryWorkingSetMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sNodeNetworkErrorsMetricAttributeKey specifies the key of an attribute for the k8s.node.network.errors metric. +type K8sNodeNetworkErrorsMetricAttributeKey string + +const ( + K8sNodeNetworkErrorsMetricAttributeKeyInterface K8sNodeNetworkErrorsMetricAttributeKey = "interface" + K8sNodeNetworkErrorsMetricAttributeKeyDirection K8sNodeNetworkErrorsMetricAttributeKey = "direction" +) + +// K8sNodeNetworkErrorsMetricConfig provides config for the k8s.node.network.errors metric. +type K8sNodeNetworkErrorsMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool + + AggregationStrategy string `mapstructure:"aggregation_strategy"` + EnabledAttributes []K8sNodeNetworkErrorsMetricAttributeKey `mapstructure:"attributes"` +} + +func (ms *K8sNodeNetworkErrorsMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +func (ms *K8sNodeNetworkErrorsMetricConfig) Validate() error { + for _, val := range ms.EnabledAttributes { + switch val { + case K8sNodeNetworkErrorsMetricAttributeKeyInterface, K8sNodeNetworkErrorsMetricAttributeKeyDirection: + default: + return fmt.Errorf("metric k8s.node.network.errors doesn't have an attribute %v, valid attributes: [interface, direction]", val) + } + } + + switch ms.AggregationStrategy { + case AggregationStrategySum, AggregationStrategyAvg, AggregationStrategyMin, AggregationStrategyMax: + default: + return fmt.Errorf("invalid aggregation strategy %q, valid strategies: [%s, %s, %s, %s]", ms.AggregationStrategy, AggregationStrategySum, AggregationStrategyAvg, AggregationStrategyMin, AggregationStrategyMax) + } + + return nil +} + +// K8sNodeNetworkIoMetricAttributeKey specifies the key of an attribute for the k8s.node.network.io metric. +type K8sNodeNetworkIoMetricAttributeKey string + +const ( + K8sNodeNetworkIoMetricAttributeKeyInterface K8sNodeNetworkIoMetricAttributeKey = "interface" + K8sNodeNetworkIoMetricAttributeKeyDirection K8sNodeNetworkIoMetricAttributeKey = "direction" +) + +// K8sNodeNetworkIoMetricConfig provides config for the k8s.node.network.io metric. +type K8sNodeNetworkIoMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool + + AggregationStrategy string `mapstructure:"aggregation_strategy"` + EnabledAttributes []K8sNodeNetworkIoMetricAttributeKey `mapstructure:"attributes"` +} + +func (ms *K8sNodeNetworkIoMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +func (ms *K8sNodeNetworkIoMetricConfig) Validate() error { + for _, val := range ms.EnabledAttributes { + switch val { + case K8sNodeNetworkIoMetricAttributeKeyInterface, K8sNodeNetworkIoMetricAttributeKeyDirection: + default: + return fmt.Errorf("metric k8s.node.network.io doesn't have an attribute %v, valid attributes: [interface, direction]", val) + } + } + + switch ms.AggregationStrategy { + case AggregationStrategySum, AggregationStrategyAvg, AggregationStrategyMin, AggregationStrategyMax: + default: + return fmt.Errorf("invalid aggregation strategy %q, valid strategies: [%s, %s, %s, %s]", ms.AggregationStrategy, AggregationStrategySum, AggregationStrategyAvg, AggregationStrategyMin, AggregationStrategyMax) + } + + return nil +} + +// K8sNodeUptimeMetricConfig provides config for the k8s.node.uptime metric. +type K8sNodeUptimeMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sNodeUptimeMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodCPUNodeUtilizationMetricConfig provides config for the k8s.pod.cpu.node.utilization metric. +type K8sPodCPUNodeUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodCPUNodeUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodCPUTimeMetricConfig provides config for the k8s.pod.cpu.time metric. +type K8sPodCPUTimeMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodCPUTimeMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodCPUUsageMetricConfig provides config for the k8s.pod.cpu.usage metric. +type K8sPodCPUUsageMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodCPUUsageMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodCPULimitUtilizationMetricConfig provides config for the k8s.pod.cpu_limit_utilization metric. +type K8sPodCPULimitUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodCPULimitUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodCPURequestUtilizationMetricConfig provides config for the k8s.pod.cpu_request_utilization metric. +type K8sPodCPURequestUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodCPURequestUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodFilesystemAvailableMetricConfig provides config for the k8s.pod.filesystem.available metric. +type K8sPodFilesystemAvailableMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodFilesystemAvailableMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodFilesystemCapacityMetricConfig provides config for the k8s.pod.filesystem.capacity metric. +type K8sPodFilesystemCapacityMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodFilesystemCapacityMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodFilesystemUsageMetricConfig provides config for the k8s.pod.filesystem.usage metric. +type K8sPodFilesystemUsageMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodFilesystemUsageMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodMemoryAvailableMetricConfig provides config for the k8s.pod.memory.available metric. +type K8sPodMemoryAvailableMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodMemoryAvailableMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodMemoryMajorPageFaultsMetricConfig provides config for the k8s.pod.memory.major_page_faults metric. +type K8sPodMemoryMajorPageFaultsMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodMemoryMajorPageFaultsMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodMemoryNodeUtilizationMetricConfig provides config for the k8s.pod.memory.node.utilization metric. +type K8sPodMemoryNodeUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodMemoryNodeUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodMemoryPageFaultsMetricConfig provides config for the k8s.pod.memory.page_faults metric. +type K8sPodMemoryPageFaultsMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodMemoryPageFaultsMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodMemoryRssMetricConfig provides config for the k8s.pod.memory.rss metric. +type K8sPodMemoryRssMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodMemoryRssMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodMemoryUsageMetricConfig provides config for the k8s.pod.memory.usage metric. +type K8sPodMemoryUsageMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodMemoryUsageMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodMemoryWorkingSetMetricConfig provides config for the k8s.pod.memory.working_set metric. +type K8sPodMemoryWorkingSetMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodMemoryWorkingSetMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodMemoryLimitUtilizationMetricConfig provides config for the k8s.pod.memory_limit_utilization metric. +type K8sPodMemoryLimitUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodMemoryLimitUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodMemoryRequestUtilizationMetricConfig provides config for the k8s.pod.memory_request_utilization metric. +type K8sPodMemoryRequestUtilizationMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodMemoryRequestUtilizationMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodNetworkErrorsMetricAttributeKey specifies the key of an attribute for the k8s.pod.network.errors metric. +type K8sPodNetworkErrorsMetricAttributeKey string + +const ( + K8sPodNetworkErrorsMetricAttributeKeyInterface K8sPodNetworkErrorsMetricAttributeKey = "interface" + K8sPodNetworkErrorsMetricAttributeKeyDirection K8sPodNetworkErrorsMetricAttributeKey = "direction" +) + +// K8sPodNetworkErrorsMetricConfig provides config for the k8s.pod.network.errors metric. +type K8sPodNetworkErrorsMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool + + AggregationStrategy string `mapstructure:"aggregation_strategy"` + EnabledAttributes []K8sPodNetworkErrorsMetricAttributeKey `mapstructure:"attributes"` +} + +func (ms *K8sPodNetworkErrorsMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +func (ms *K8sPodNetworkErrorsMetricConfig) Validate() error { + for _, val := range ms.EnabledAttributes { + switch val { + case K8sPodNetworkErrorsMetricAttributeKeyInterface, K8sPodNetworkErrorsMetricAttributeKeyDirection: + default: + return fmt.Errorf("metric k8s.pod.network.errors doesn't have an attribute %v, valid attributes: [interface, direction]", val) + } + } + + switch ms.AggregationStrategy { + case AggregationStrategySum, AggregationStrategyAvg, AggregationStrategyMin, AggregationStrategyMax: + default: + return fmt.Errorf("invalid aggregation strategy %q, valid strategies: [%s, %s, %s, %s]", ms.AggregationStrategy, AggregationStrategySum, AggregationStrategyAvg, AggregationStrategyMin, AggregationStrategyMax) + } + + return nil +} + +// K8sPodNetworkIoMetricAttributeKey specifies the key of an attribute for the k8s.pod.network.io metric. +type K8sPodNetworkIoMetricAttributeKey string + +const ( + K8sPodNetworkIoMetricAttributeKeyInterface K8sPodNetworkIoMetricAttributeKey = "interface" + K8sPodNetworkIoMetricAttributeKeyDirection K8sPodNetworkIoMetricAttributeKey = "direction" +) + +// K8sPodNetworkIoMetricConfig provides config for the k8s.pod.network.io metric. +type K8sPodNetworkIoMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool + + AggregationStrategy string `mapstructure:"aggregation_strategy"` + EnabledAttributes []K8sPodNetworkIoMetricAttributeKey `mapstructure:"attributes"` +} + +func (ms *K8sPodNetworkIoMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +func (ms *K8sPodNetworkIoMetricConfig) Validate() error { + for _, val := range ms.EnabledAttributes { + switch val { + case K8sPodNetworkIoMetricAttributeKeyInterface, K8sPodNetworkIoMetricAttributeKeyDirection: + default: + return fmt.Errorf("metric k8s.pod.network.io doesn't have an attribute %v, valid attributes: [interface, direction]", val) + } + } + + switch ms.AggregationStrategy { + case AggregationStrategySum, AggregationStrategyAvg, AggregationStrategyMin, AggregationStrategyMax: + default: + return fmt.Errorf("invalid aggregation strategy %q, valid strategies: [%s, %s, %s, %s]", ms.AggregationStrategy, AggregationStrategySum, AggregationStrategyAvg, AggregationStrategyMin, AggregationStrategyMax) + } + + return nil +} + +// K8sPodUptimeMetricConfig provides config for the k8s.pod.uptime metric. +type K8sPodUptimeMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodUptimeMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sPodVolumeUsageMetricConfig provides config for the k8s.pod.volume.usage metric. +type K8sPodVolumeUsageMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sPodVolumeUsageMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sVolumeAvailableMetricConfig provides config for the k8s.volume.available metric. +type K8sVolumeAvailableMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sVolumeAvailableMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sVolumeCapacityMetricConfig provides config for the k8s.volume.capacity metric. +type K8sVolumeCapacityMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sVolumeCapacityMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sVolumeInodesMetricConfig provides config for the k8s.volume.inodes metric. +type K8sVolumeInodesMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sVolumeInodesMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sVolumeInodesFreeMetricConfig provides config for the k8s.volume.inodes.free metric. +type K8sVolumeInodesFreeMetricConfig struct { + Enabled bool `mapstructure:"enabled"` + enabledSetByUser bool +} + +func (ms *K8sVolumeInodesFreeMetricConfig) Unmarshal(parser *confmap.Conf) error { + if parser == nil { + return nil + } + + err := parser.Unmarshal(ms) + if err != nil { + return err + } + + ms.enabledSetByUser = parser.IsSet("enabled") + return nil +} + +// K8sVolumeInodesUsedMetricConfig provides config for the k8s.volume.inodes.used metric. +type K8sVolumeInodesUsedMetricConfig struct { Enabled bool `mapstructure:"enabled"` enabledSetByUser bool } -func (ms *MetricConfig) Unmarshal(parser *confmap.Conf) error { +func (ms *K8sVolumeInodesUsedMetricConfig) Unmarshal(parser *confmap.Conf) error { if parser == nil { return nil } @@ -29,240 +1288,248 @@ func (ms *MetricConfig) Unmarshal(parser *confmap.Conf) error { // MetricsConfig provides config for kubeletstats metrics. type MetricsConfig struct { - ContainerCPUTime MetricConfig `mapstructure:"container.cpu.time"` - ContainerCPUUsage MetricConfig `mapstructure:"container.cpu.usage"` - ContainerFilesystemAvailable MetricConfig `mapstructure:"container.filesystem.available"` - ContainerFilesystemCapacity MetricConfig `mapstructure:"container.filesystem.capacity"` - ContainerFilesystemUsage MetricConfig `mapstructure:"container.filesystem.usage"` - ContainerMemoryAvailable MetricConfig `mapstructure:"container.memory.available"` - ContainerMemoryMajorPageFaults MetricConfig `mapstructure:"container.memory.major_page_faults"` - ContainerMemoryPageFaults MetricConfig `mapstructure:"container.memory.page_faults"` - ContainerMemoryRss MetricConfig `mapstructure:"container.memory.rss"` - ContainerMemoryUsage MetricConfig `mapstructure:"container.memory.usage"` - ContainerMemoryWorkingSet MetricConfig `mapstructure:"container.memory.working_set"` - ContainerUptime MetricConfig `mapstructure:"container.uptime"` - K8sContainerCPUNodeUtilization MetricConfig `mapstructure:"k8s.container.cpu.node.utilization"` - K8sContainerCPULimitUtilization MetricConfig `mapstructure:"k8s.container.cpu_limit_utilization"` - K8sContainerCPURequestUtilization MetricConfig `mapstructure:"k8s.container.cpu_request_utilization"` - K8sContainerMemoryNodeUtilization MetricConfig `mapstructure:"k8s.container.memory.node.utilization"` - K8sContainerMemoryLimitUtilization MetricConfig `mapstructure:"k8s.container.memory_limit_utilization"` - K8sContainerMemoryRequestUtilization MetricConfig `mapstructure:"k8s.container.memory_request_utilization"` - K8sNodeCPUTime MetricConfig `mapstructure:"k8s.node.cpu.time"` - K8sNodeCPUUsage MetricConfig `mapstructure:"k8s.node.cpu.usage"` - K8sNodeFilesystemAvailable MetricConfig `mapstructure:"k8s.node.filesystem.available"` - K8sNodeFilesystemCapacity MetricConfig `mapstructure:"k8s.node.filesystem.capacity"` - K8sNodeFilesystemUsage MetricConfig `mapstructure:"k8s.node.filesystem.usage"` - K8sNodeMemoryAvailable MetricConfig `mapstructure:"k8s.node.memory.available"` - K8sNodeMemoryMajorPageFaults MetricConfig `mapstructure:"k8s.node.memory.major_page_faults"` - K8sNodeMemoryPageFaults MetricConfig `mapstructure:"k8s.node.memory.page_faults"` - K8sNodeMemoryRss MetricConfig `mapstructure:"k8s.node.memory.rss"` - K8sNodeMemoryUsage MetricConfig `mapstructure:"k8s.node.memory.usage"` - K8sNodeMemoryWorkingSet MetricConfig `mapstructure:"k8s.node.memory.working_set"` - K8sNodeNetworkErrors MetricConfig `mapstructure:"k8s.node.network.errors"` - K8sNodeNetworkIo MetricConfig `mapstructure:"k8s.node.network.io"` - K8sNodeUptime MetricConfig `mapstructure:"k8s.node.uptime"` - K8sPodCPUNodeUtilization MetricConfig `mapstructure:"k8s.pod.cpu.node.utilization"` - K8sPodCPUTime MetricConfig `mapstructure:"k8s.pod.cpu.time"` - K8sPodCPUUsage MetricConfig `mapstructure:"k8s.pod.cpu.usage"` - K8sPodCPULimitUtilization MetricConfig `mapstructure:"k8s.pod.cpu_limit_utilization"` - K8sPodCPURequestUtilization MetricConfig `mapstructure:"k8s.pod.cpu_request_utilization"` - K8sPodFilesystemAvailable MetricConfig `mapstructure:"k8s.pod.filesystem.available"` - K8sPodFilesystemCapacity MetricConfig `mapstructure:"k8s.pod.filesystem.capacity"` - K8sPodFilesystemUsage MetricConfig `mapstructure:"k8s.pod.filesystem.usage"` - K8sPodMemoryAvailable MetricConfig `mapstructure:"k8s.pod.memory.available"` - K8sPodMemoryMajorPageFaults MetricConfig `mapstructure:"k8s.pod.memory.major_page_faults"` - K8sPodMemoryNodeUtilization MetricConfig `mapstructure:"k8s.pod.memory.node.utilization"` - K8sPodMemoryPageFaults MetricConfig `mapstructure:"k8s.pod.memory.page_faults"` - K8sPodMemoryRss MetricConfig `mapstructure:"k8s.pod.memory.rss"` - K8sPodMemoryUsage MetricConfig `mapstructure:"k8s.pod.memory.usage"` - K8sPodMemoryWorkingSet MetricConfig `mapstructure:"k8s.pod.memory.working_set"` - K8sPodMemoryLimitUtilization MetricConfig `mapstructure:"k8s.pod.memory_limit_utilization"` - K8sPodMemoryRequestUtilization MetricConfig `mapstructure:"k8s.pod.memory_request_utilization"` - K8sPodNetworkErrors MetricConfig `mapstructure:"k8s.pod.network.errors"` - K8sPodNetworkIo MetricConfig `mapstructure:"k8s.pod.network.io"` - K8sPodUptime MetricConfig `mapstructure:"k8s.pod.uptime"` - K8sPodVolumeUsage MetricConfig `mapstructure:"k8s.pod.volume.usage"` - K8sVolumeAvailable MetricConfig `mapstructure:"k8s.volume.available"` - K8sVolumeCapacity MetricConfig `mapstructure:"k8s.volume.capacity"` - K8sVolumeInodes MetricConfig `mapstructure:"k8s.volume.inodes"` - K8sVolumeInodesFree MetricConfig `mapstructure:"k8s.volume.inodes.free"` - K8sVolumeInodesUsed MetricConfig `mapstructure:"k8s.volume.inodes.used"` + ContainerCPUTime ContainerCPUTimeMetricConfig `mapstructure:"container.cpu.time"` + ContainerCPUUsage ContainerCPUUsageMetricConfig `mapstructure:"container.cpu.usage"` + ContainerFilesystemAvailable ContainerFilesystemAvailableMetricConfig `mapstructure:"container.filesystem.available"` + ContainerFilesystemCapacity ContainerFilesystemCapacityMetricConfig `mapstructure:"container.filesystem.capacity"` + ContainerFilesystemUsage ContainerFilesystemUsageMetricConfig `mapstructure:"container.filesystem.usage"` + ContainerMemoryAvailable ContainerMemoryAvailableMetricConfig `mapstructure:"container.memory.available"` + ContainerMemoryMajorPageFaults ContainerMemoryMajorPageFaultsMetricConfig `mapstructure:"container.memory.major_page_faults"` + ContainerMemoryPageFaults ContainerMemoryPageFaultsMetricConfig `mapstructure:"container.memory.page_faults"` + ContainerMemoryRss ContainerMemoryRssMetricConfig `mapstructure:"container.memory.rss"` + ContainerMemoryUsage ContainerMemoryUsageMetricConfig `mapstructure:"container.memory.usage"` + ContainerMemoryWorkingSet ContainerMemoryWorkingSetMetricConfig `mapstructure:"container.memory.working_set"` + ContainerUptime ContainerUptimeMetricConfig `mapstructure:"container.uptime"` + K8sContainerCPUNodeUtilization K8sContainerCPUNodeUtilizationMetricConfig `mapstructure:"k8s.container.cpu.node.utilization"` + K8sContainerCPULimitUtilization K8sContainerCPULimitUtilizationMetricConfig `mapstructure:"k8s.container.cpu_limit_utilization"` + K8sContainerCPURequestUtilization K8sContainerCPURequestUtilizationMetricConfig `mapstructure:"k8s.container.cpu_request_utilization"` + K8sContainerMemoryNodeUtilization K8sContainerMemoryNodeUtilizationMetricConfig `mapstructure:"k8s.container.memory.node.utilization"` + K8sContainerMemoryLimitUtilization K8sContainerMemoryLimitUtilizationMetricConfig `mapstructure:"k8s.container.memory_limit_utilization"` + K8sContainerMemoryRequestUtilization K8sContainerMemoryRequestUtilizationMetricConfig `mapstructure:"k8s.container.memory_request_utilization"` + K8sNodeCPUTime K8sNodeCPUTimeMetricConfig `mapstructure:"k8s.node.cpu.time"` + K8sNodeCPUUsage K8sNodeCPUUsageMetricConfig `mapstructure:"k8s.node.cpu.usage"` + K8sNodeFilesystemAvailable K8sNodeFilesystemAvailableMetricConfig `mapstructure:"k8s.node.filesystem.available"` + K8sNodeFilesystemCapacity K8sNodeFilesystemCapacityMetricConfig `mapstructure:"k8s.node.filesystem.capacity"` + K8sNodeFilesystemUsage K8sNodeFilesystemUsageMetricConfig `mapstructure:"k8s.node.filesystem.usage"` + K8sNodeMemoryAvailable K8sNodeMemoryAvailableMetricConfig `mapstructure:"k8s.node.memory.available"` + K8sNodeMemoryMajorPageFaults K8sNodeMemoryMajorPageFaultsMetricConfig `mapstructure:"k8s.node.memory.major_page_faults"` + K8sNodeMemoryPageFaults K8sNodeMemoryPageFaultsMetricConfig `mapstructure:"k8s.node.memory.page_faults"` + K8sNodeMemoryRss K8sNodeMemoryRssMetricConfig `mapstructure:"k8s.node.memory.rss"` + K8sNodeMemoryUsage K8sNodeMemoryUsageMetricConfig `mapstructure:"k8s.node.memory.usage"` + K8sNodeMemoryWorkingSet K8sNodeMemoryWorkingSetMetricConfig `mapstructure:"k8s.node.memory.working_set"` + K8sNodeNetworkErrors K8sNodeNetworkErrorsMetricConfig `mapstructure:"k8s.node.network.errors"` + K8sNodeNetworkIo K8sNodeNetworkIoMetricConfig `mapstructure:"k8s.node.network.io"` + K8sNodeUptime K8sNodeUptimeMetricConfig `mapstructure:"k8s.node.uptime"` + K8sPodCPUNodeUtilization K8sPodCPUNodeUtilizationMetricConfig `mapstructure:"k8s.pod.cpu.node.utilization"` + K8sPodCPUTime K8sPodCPUTimeMetricConfig `mapstructure:"k8s.pod.cpu.time"` + K8sPodCPUUsage K8sPodCPUUsageMetricConfig `mapstructure:"k8s.pod.cpu.usage"` + K8sPodCPULimitUtilization K8sPodCPULimitUtilizationMetricConfig `mapstructure:"k8s.pod.cpu_limit_utilization"` + K8sPodCPURequestUtilization K8sPodCPURequestUtilizationMetricConfig `mapstructure:"k8s.pod.cpu_request_utilization"` + K8sPodFilesystemAvailable K8sPodFilesystemAvailableMetricConfig `mapstructure:"k8s.pod.filesystem.available"` + K8sPodFilesystemCapacity K8sPodFilesystemCapacityMetricConfig `mapstructure:"k8s.pod.filesystem.capacity"` + K8sPodFilesystemUsage K8sPodFilesystemUsageMetricConfig `mapstructure:"k8s.pod.filesystem.usage"` + K8sPodMemoryAvailable K8sPodMemoryAvailableMetricConfig `mapstructure:"k8s.pod.memory.available"` + K8sPodMemoryMajorPageFaults K8sPodMemoryMajorPageFaultsMetricConfig `mapstructure:"k8s.pod.memory.major_page_faults"` + K8sPodMemoryNodeUtilization K8sPodMemoryNodeUtilizationMetricConfig `mapstructure:"k8s.pod.memory.node.utilization"` + K8sPodMemoryPageFaults K8sPodMemoryPageFaultsMetricConfig `mapstructure:"k8s.pod.memory.page_faults"` + K8sPodMemoryRss K8sPodMemoryRssMetricConfig `mapstructure:"k8s.pod.memory.rss"` + K8sPodMemoryUsage K8sPodMemoryUsageMetricConfig `mapstructure:"k8s.pod.memory.usage"` + K8sPodMemoryWorkingSet K8sPodMemoryWorkingSetMetricConfig `mapstructure:"k8s.pod.memory.working_set"` + K8sPodMemoryLimitUtilization K8sPodMemoryLimitUtilizationMetricConfig `mapstructure:"k8s.pod.memory_limit_utilization"` + K8sPodMemoryRequestUtilization K8sPodMemoryRequestUtilizationMetricConfig `mapstructure:"k8s.pod.memory_request_utilization"` + K8sPodNetworkErrors K8sPodNetworkErrorsMetricConfig `mapstructure:"k8s.pod.network.errors"` + K8sPodNetworkIo K8sPodNetworkIoMetricConfig `mapstructure:"k8s.pod.network.io"` + K8sPodUptime K8sPodUptimeMetricConfig `mapstructure:"k8s.pod.uptime"` + K8sPodVolumeUsage K8sPodVolumeUsageMetricConfig `mapstructure:"k8s.pod.volume.usage"` + K8sVolumeAvailable K8sVolumeAvailableMetricConfig `mapstructure:"k8s.volume.available"` + K8sVolumeCapacity K8sVolumeCapacityMetricConfig `mapstructure:"k8s.volume.capacity"` + K8sVolumeInodes K8sVolumeInodesMetricConfig `mapstructure:"k8s.volume.inodes"` + K8sVolumeInodesFree K8sVolumeInodesFreeMetricConfig `mapstructure:"k8s.volume.inodes.free"` + K8sVolumeInodesUsed K8sVolumeInodesUsedMetricConfig `mapstructure:"k8s.volume.inodes.used"` } func DefaultMetricsConfig() MetricsConfig { return MetricsConfig{ - ContainerCPUTime: MetricConfig{ + ContainerCPUTime: ContainerCPUTimeMetricConfig{ Enabled: true, }, - ContainerCPUUsage: MetricConfig{ + ContainerCPUUsage: ContainerCPUUsageMetricConfig{ Enabled: true, }, - ContainerFilesystemAvailable: MetricConfig{ + ContainerFilesystemAvailable: ContainerFilesystemAvailableMetricConfig{ Enabled: true, }, - ContainerFilesystemCapacity: MetricConfig{ + ContainerFilesystemCapacity: ContainerFilesystemCapacityMetricConfig{ Enabled: true, }, - ContainerFilesystemUsage: MetricConfig{ + ContainerFilesystemUsage: ContainerFilesystemUsageMetricConfig{ Enabled: true, }, - ContainerMemoryAvailable: MetricConfig{ + ContainerMemoryAvailable: ContainerMemoryAvailableMetricConfig{ Enabled: true, }, - ContainerMemoryMajorPageFaults: MetricConfig{ + ContainerMemoryMajorPageFaults: ContainerMemoryMajorPageFaultsMetricConfig{ Enabled: true, }, - ContainerMemoryPageFaults: MetricConfig{ + ContainerMemoryPageFaults: ContainerMemoryPageFaultsMetricConfig{ Enabled: true, }, - ContainerMemoryRss: MetricConfig{ + ContainerMemoryRss: ContainerMemoryRssMetricConfig{ Enabled: true, }, - ContainerMemoryUsage: MetricConfig{ + ContainerMemoryUsage: ContainerMemoryUsageMetricConfig{ Enabled: true, }, - ContainerMemoryWorkingSet: MetricConfig{ + ContainerMemoryWorkingSet: ContainerMemoryWorkingSetMetricConfig{ Enabled: true, }, - ContainerUptime: MetricConfig{ + ContainerUptime: ContainerUptimeMetricConfig{ Enabled: false, }, - K8sContainerCPUNodeUtilization: MetricConfig{ + K8sContainerCPUNodeUtilization: K8sContainerCPUNodeUtilizationMetricConfig{ Enabled: false, }, - K8sContainerCPULimitUtilization: MetricConfig{ + K8sContainerCPULimitUtilization: K8sContainerCPULimitUtilizationMetricConfig{ Enabled: false, }, - K8sContainerCPURequestUtilization: MetricConfig{ + K8sContainerCPURequestUtilization: K8sContainerCPURequestUtilizationMetricConfig{ Enabled: false, }, - K8sContainerMemoryNodeUtilization: MetricConfig{ + K8sContainerMemoryNodeUtilization: K8sContainerMemoryNodeUtilizationMetricConfig{ Enabled: false, }, - K8sContainerMemoryLimitUtilization: MetricConfig{ + K8sContainerMemoryLimitUtilization: K8sContainerMemoryLimitUtilizationMetricConfig{ Enabled: false, }, - K8sContainerMemoryRequestUtilization: MetricConfig{ + K8sContainerMemoryRequestUtilization: K8sContainerMemoryRequestUtilizationMetricConfig{ Enabled: false, }, - K8sNodeCPUTime: MetricConfig{ + K8sNodeCPUTime: K8sNodeCPUTimeMetricConfig{ Enabled: true, }, - K8sNodeCPUUsage: MetricConfig{ + K8sNodeCPUUsage: K8sNodeCPUUsageMetricConfig{ Enabled: true, }, - K8sNodeFilesystemAvailable: MetricConfig{ + K8sNodeFilesystemAvailable: K8sNodeFilesystemAvailableMetricConfig{ Enabled: true, }, - K8sNodeFilesystemCapacity: MetricConfig{ + K8sNodeFilesystemCapacity: K8sNodeFilesystemCapacityMetricConfig{ Enabled: true, }, - K8sNodeFilesystemUsage: MetricConfig{ + K8sNodeFilesystemUsage: K8sNodeFilesystemUsageMetricConfig{ Enabled: true, }, - K8sNodeMemoryAvailable: MetricConfig{ + K8sNodeMemoryAvailable: K8sNodeMemoryAvailableMetricConfig{ Enabled: true, }, - K8sNodeMemoryMajorPageFaults: MetricConfig{ + K8sNodeMemoryMajorPageFaults: K8sNodeMemoryMajorPageFaultsMetricConfig{ Enabled: true, }, - K8sNodeMemoryPageFaults: MetricConfig{ + K8sNodeMemoryPageFaults: K8sNodeMemoryPageFaultsMetricConfig{ Enabled: true, }, - K8sNodeMemoryRss: MetricConfig{ + K8sNodeMemoryRss: K8sNodeMemoryRssMetricConfig{ Enabled: true, }, - K8sNodeMemoryUsage: MetricConfig{ + K8sNodeMemoryUsage: K8sNodeMemoryUsageMetricConfig{ Enabled: true, }, - K8sNodeMemoryWorkingSet: MetricConfig{ + K8sNodeMemoryWorkingSet: K8sNodeMemoryWorkingSetMetricConfig{ Enabled: true, }, - K8sNodeNetworkErrors: MetricConfig{ - Enabled: true, + K8sNodeNetworkErrors: K8sNodeNetworkErrorsMetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sNodeNetworkErrorsMetricAttributeKey{K8sNodeNetworkErrorsMetricAttributeKeyInterface, K8sNodeNetworkErrorsMetricAttributeKeyDirection}, }, - K8sNodeNetworkIo: MetricConfig{ - Enabled: true, + K8sNodeNetworkIo: K8sNodeNetworkIoMetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sNodeNetworkIoMetricAttributeKey{K8sNodeNetworkIoMetricAttributeKeyInterface, K8sNodeNetworkIoMetricAttributeKeyDirection}, }, - K8sNodeUptime: MetricConfig{ + K8sNodeUptime: K8sNodeUptimeMetricConfig{ Enabled: false, }, - K8sPodCPUNodeUtilization: MetricConfig{ + K8sPodCPUNodeUtilization: K8sPodCPUNodeUtilizationMetricConfig{ Enabled: false, }, - K8sPodCPUTime: MetricConfig{ + K8sPodCPUTime: K8sPodCPUTimeMetricConfig{ Enabled: true, }, - K8sPodCPUUsage: MetricConfig{ + K8sPodCPUUsage: K8sPodCPUUsageMetricConfig{ Enabled: true, }, - K8sPodCPULimitUtilization: MetricConfig{ + K8sPodCPULimitUtilization: K8sPodCPULimitUtilizationMetricConfig{ Enabled: false, }, - K8sPodCPURequestUtilization: MetricConfig{ + K8sPodCPURequestUtilization: K8sPodCPURequestUtilizationMetricConfig{ Enabled: false, }, - K8sPodFilesystemAvailable: MetricConfig{ + K8sPodFilesystemAvailable: K8sPodFilesystemAvailableMetricConfig{ Enabled: true, }, - K8sPodFilesystemCapacity: MetricConfig{ + K8sPodFilesystemCapacity: K8sPodFilesystemCapacityMetricConfig{ Enabled: true, }, - K8sPodFilesystemUsage: MetricConfig{ + K8sPodFilesystemUsage: K8sPodFilesystemUsageMetricConfig{ Enabled: true, }, - K8sPodMemoryAvailable: MetricConfig{ + K8sPodMemoryAvailable: K8sPodMemoryAvailableMetricConfig{ Enabled: true, }, - K8sPodMemoryMajorPageFaults: MetricConfig{ + K8sPodMemoryMajorPageFaults: K8sPodMemoryMajorPageFaultsMetricConfig{ Enabled: true, }, - K8sPodMemoryNodeUtilization: MetricConfig{ + K8sPodMemoryNodeUtilization: K8sPodMemoryNodeUtilizationMetricConfig{ Enabled: false, }, - K8sPodMemoryPageFaults: MetricConfig{ + K8sPodMemoryPageFaults: K8sPodMemoryPageFaultsMetricConfig{ Enabled: true, }, - K8sPodMemoryRss: MetricConfig{ + K8sPodMemoryRss: K8sPodMemoryRssMetricConfig{ Enabled: true, }, - K8sPodMemoryUsage: MetricConfig{ + K8sPodMemoryUsage: K8sPodMemoryUsageMetricConfig{ Enabled: true, }, - K8sPodMemoryWorkingSet: MetricConfig{ + K8sPodMemoryWorkingSet: K8sPodMemoryWorkingSetMetricConfig{ Enabled: true, }, - K8sPodMemoryLimitUtilization: MetricConfig{ + K8sPodMemoryLimitUtilization: K8sPodMemoryLimitUtilizationMetricConfig{ Enabled: false, }, - K8sPodMemoryRequestUtilization: MetricConfig{ + K8sPodMemoryRequestUtilization: K8sPodMemoryRequestUtilizationMetricConfig{ Enabled: false, }, - K8sPodNetworkErrors: MetricConfig{ - Enabled: true, + K8sPodNetworkErrors: K8sPodNetworkErrorsMetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sPodNetworkErrorsMetricAttributeKey{K8sPodNetworkErrorsMetricAttributeKeyInterface, K8sPodNetworkErrorsMetricAttributeKeyDirection}, }, - K8sPodNetworkIo: MetricConfig{ - Enabled: true, + K8sPodNetworkIo: K8sPodNetworkIoMetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sPodNetworkIoMetricAttributeKey{K8sPodNetworkIoMetricAttributeKeyInterface, K8sPodNetworkIoMetricAttributeKeyDirection}, }, - K8sPodUptime: MetricConfig{ + K8sPodUptime: K8sPodUptimeMetricConfig{ Enabled: false, }, - K8sPodVolumeUsage: MetricConfig{ + K8sPodVolumeUsage: K8sPodVolumeUsageMetricConfig{ Enabled: false, }, - K8sVolumeAvailable: MetricConfig{ + K8sVolumeAvailable: K8sVolumeAvailableMetricConfig{ Enabled: true, }, - K8sVolumeCapacity: MetricConfig{ + K8sVolumeCapacity: K8sVolumeCapacityMetricConfig{ Enabled: true, }, - K8sVolumeInodes: MetricConfig{ + K8sVolumeInodes: K8sVolumeInodesMetricConfig{ Enabled: true, }, - K8sVolumeInodesFree: MetricConfig{ + K8sVolumeInodesFree: K8sVolumeInodesFreeMetricConfig{ Enabled: true, }, - K8sVolumeInodesUsed: MetricConfig{ + K8sVolumeInodesUsed: K8sVolumeInodesUsedMetricConfig{ Enabled: true, }, } diff --git a/receiver/kubeletstatsreceiver/internal/metadata/generated_config_test.go b/receiver/kubeletstatsreceiver/internal/metadata/generated_config_test.go index a8708645fe464..e0791564f9200 100644 --- a/receiver/kubeletstatsreceiver/internal/metadata/generated_config_test.go +++ b/receiver/kubeletstatsreceiver/internal/metadata/generated_config_test.go @@ -9,6 +9,7 @@ import ( "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" "github.com/stretchr/testify/require" + "go.opentelemetry.io/collector/confmap" "go.opentelemetry.io/collector/confmap/confmaptest" ) @@ -26,178 +27,186 @@ func TestMetricsBuilderConfig(t *testing.T) { name: "all_set", want: MetricsBuilderConfig{ Metrics: MetricsConfig{ - ContainerCPUTime: MetricConfig{ + ContainerCPUTime: ContainerCPUTimeMetricConfig{ Enabled: true, }, - ContainerCPUUsage: MetricConfig{ + ContainerCPUUsage: ContainerCPUUsageMetricConfig{ Enabled: true, }, - ContainerFilesystemAvailable: MetricConfig{ + ContainerFilesystemAvailable: ContainerFilesystemAvailableMetricConfig{ Enabled: true, }, - ContainerFilesystemCapacity: MetricConfig{ + ContainerFilesystemCapacity: ContainerFilesystemCapacityMetricConfig{ Enabled: true, }, - ContainerFilesystemUsage: MetricConfig{ + ContainerFilesystemUsage: ContainerFilesystemUsageMetricConfig{ Enabled: true, }, - ContainerMemoryAvailable: MetricConfig{ + ContainerMemoryAvailable: ContainerMemoryAvailableMetricConfig{ Enabled: true, }, - ContainerMemoryMajorPageFaults: MetricConfig{ + ContainerMemoryMajorPageFaults: ContainerMemoryMajorPageFaultsMetricConfig{ Enabled: true, }, - ContainerMemoryPageFaults: MetricConfig{ + ContainerMemoryPageFaults: ContainerMemoryPageFaultsMetricConfig{ Enabled: true, }, - ContainerMemoryRss: MetricConfig{ + ContainerMemoryRss: ContainerMemoryRssMetricConfig{ Enabled: true, }, - ContainerMemoryUsage: MetricConfig{ + ContainerMemoryUsage: ContainerMemoryUsageMetricConfig{ Enabled: true, }, - ContainerMemoryWorkingSet: MetricConfig{ + ContainerMemoryWorkingSet: ContainerMemoryWorkingSetMetricConfig{ Enabled: true, }, - ContainerUptime: MetricConfig{ + ContainerUptime: ContainerUptimeMetricConfig{ Enabled: true, }, - K8sContainerCPUNodeUtilization: MetricConfig{ + K8sContainerCPUNodeUtilization: K8sContainerCPUNodeUtilizationMetricConfig{ Enabled: true, }, - K8sContainerCPULimitUtilization: MetricConfig{ + K8sContainerCPULimitUtilization: K8sContainerCPULimitUtilizationMetricConfig{ Enabled: true, }, - K8sContainerCPURequestUtilization: MetricConfig{ + K8sContainerCPURequestUtilization: K8sContainerCPURequestUtilizationMetricConfig{ Enabled: true, }, - K8sContainerMemoryNodeUtilization: MetricConfig{ + K8sContainerMemoryNodeUtilization: K8sContainerMemoryNodeUtilizationMetricConfig{ Enabled: true, }, - K8sContainerMemoryLimitUtilization: MetricConfig{ + K8sContainerMemoryLimitUtilization: K8sContainerMemoryLimitUtilizationMetricConfig{ Enabled: true, }, - K8sContainerMemoryRequestUtilization: MetricConfig{ + K8sContainerMemoryRequestUtilization: K8sContainerMemoryRequestUtilizationMetricConfig{ Enabled: true, }, - K8sNodeCPUTime: MetricConfig{ + K8sNodeCPUTime: K8sNodeCPUTimeMetricConfig{ Enabled: true, }, - K8sNodeCPUUsage: MetricConfig{ + K8sNodeCPUUsage: K8sNodeCPUUsageMetricConfig{ Enabled: true, }, - K8sNodeFilesystemAvailable: MetricConfig{ + K8sNodeFilesystemAvailable: K8sNodeFilesystemAvailableMetricConfig{ Enabled: true, }, - K8sNodeFilesystemCapacity: MetricConfig{ + K8sNodeFilesystemCapacity: K8sNodeFilesystemCapacityMetricConfig{ Enabled: true, }, - K8sNodeFilesystemUsage: MetricConfig{ + K8sNodeFilesystemUsage: K8sNodeFilesystemUsageMetricConfig{ Enabled: true, }, - K8sNodeMemoryAvailable: MetricConfig{ + K8sNodeMemoryAvailable: K8sNodeMemoryAvailableMetricConfig{ Enabled: true, }, - K8sNodeMemoryMajorPageFaults: MetricConfig{ + K8sNodeMemoryMajorPageFaults: K8sNodeMemoryMajorPageFaultsMetricConfig{ Enabled: true, }, - K8sNodeMemoryPageFaults: MetricConfig{ + K8sNodeMemoryPageFaults: K8sNodeMemoryPageFaultsMetricConfig{ Enabled: true, }, - K8sNodeMemoryRss: MetricConfig{ + K8sNodeMemoryRss: K8sNodeMemoryRssMetricConfig{ Enabled: true, }, - K8sNodeMemoryUsage: MetricConfig{ + K8sNodeMemoryUsage: K8sNodeMemoryUsageMetricConfig{ Enabled: true, }, - K8sNodeMemoryWorkingSet: MetricConfig{ + K8sNodeMemoryWorkingSet: K8sNodeMemoryWorkingSetMetricConfig{ Enabled: true, }, - K8sNodeNetworkErrors: MetricConfig{ - Enabled: true, + K8sNodeNetworkErrors: K8sNodeNetworkErrorsMetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sNodeNetworkErrorsMetricAttributeKey{K8sNodeNetworkErrorsMetricAttributeKeyInterface, K8sNodeNetworkErrorsMetricAttributeKeyDirection}, }, - K8sNodeNetworkIo: MetricConfig{ - Enabled: true, + K8sNodeNetworkIo: K8sNodeNetworkIoMetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sNodeNetworkIoMetricAttributeKey{K8sNodeNetworkIoMetricAttributeKeyInterface, K8sNodeNetworkIoMetricAttributeKeyDirection}, }, - K8sNodeUptime: MetricConfig{ + K8sNodeUptime: K8sNodeUptimeMetricConfig{ Enabled: true, }, - K8sPodCPUNodeUtilization: MetricConfig{ + K8sPodCPUNodeUtilization: K8sPodCPUNodeUtilizationMetricConfig{ Enabled: true, }, - K8sPodCPUTime: MetricConfig{ + K8sPodCPUTime: K8sPodCPUTimeMetricConfig{ Enabled: true, }, - K8sPodCPUUsage: MetricConfig{ + K8sPodCPUUsage: K8sPodCPUUsageMetricConfig{ Enabled: true, }, - K8sPodCPULimitUtilization: MetricConfig{ + K8sPodCPULimitUtilization: K8sPodCPULimitUtilizationMetricConfig{ Enabled: true, }, - K8sPodCPURequestUtilization: MetricConfig{ + K8sPodCPURequestUtilization: K8sPodCPURequestUtilizationMetricConfig{ Enabled: true, }, - K8sPodFilesystemAvailable: MetricConfig{ + K8sPodFilesystemAvailable: K8sPodFilesystemAvailableMetricConfig{ Enabled: true, }, - K8sPodFilesystemCapacity: MetricConfig{ + K8sPodFilesystemCapacity: K8sPodFilesystemCapacityMetricConfig{ Enabled: true, }, - K8sPodFilesystemUsage: MetricConfig{ + K8sPodFilesystemUsage: K8sPodFilesystemUsageMetricConfig{ Enabled: true, }, - K8sPodMemoryAvailable: MetricConfig{ + K8sPodMemoryAvailable: K8sPodMemoryAvailableMetricConfig{ Enabled: true, }, - K8sPodMemoryMajorPageFaults: MetricConfig{ + K8sPodMemoryMajorPageFaults: K8sPodMemoryMajorPageFaultsMetricConfig{ Enabled: true, }, - K8sPodMemoryNodeUtilization: MetricConfig{ + K8sPodMemoryNodeUtilization: K8sPodMemoryNodeUtilizationMetricConfig{ Enabled: true, }, - K8sPodMemoryPageFaults: MetricConfig{ + K8sPodMemoryPageFaults: K8sPodMemoryPageFaultsMetricConfig{ Enabled: true, }, - K8sPodMemoryRss: MetricConfig{ + K8sPodMemoryRss: K8sPodMemoryRssMetricConfig{ Enabled: true, }, - K8sPodMemoryUsage: MetricConfig{ + K8sPodMemoryUsage: K8sPodMemoryUsageMetricConfig{ Enabled: true, }, - K8sPodMemoryWorkingSet: MetricConfig{ + K8sPodMemoryWorkingSet: K8sPodMemoryWorkingSetMetricConfig{ Enabled: true, }, - K8sPodMemoryLimitUtilization: MetricConfig{ + K8sPodMemoryLimitUtilization: K8sPodMemoryLimitUtilizationMetricConfig{ Enabled: true, }, - K8sPodMemoryRequestUtilization: MetricConfig{ + K8sPodMemoryRequestUtilization: K8sPodMemoryRequestUtilizationMetricConfig{ Enabled: true, }, - K8sPodNetworkErrors: MetricConfig{ - Enabled: true, + K8sPodNetworkErrors: K8sPodNetworkErrorsMetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sPodNetworkErrorsMetricAttributeKey{K8sPodNetworkErrorsMetricAttributeKeyInterface, K8sPodNetworkErrorsMetricAttributeKeyDirection}, }, - K8sPodNetworkIo: MetricConfig{ - Enabled: true, + K8sPodNetworkIo: K8sPodNetworkIoMetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sPodNetworkIoMetricAttributeKey{K8sPodNetworkIoMetricAttributeKeyInterface, K8sPodNetworkIoMetricAttributeKeyDirection}, }, - K8sPodUptime: MetricConfig{ + K8sPodUptime: K8sPodUptimeMetricConfig{ Enabled: true, }, - K8sPodVolumeUsage: MetricConfig{ + K8sPodVolumeUsage: K8sPodVolumeUsageMetricConfig{ Enabled: true, }, - K8sVolumeAvailable: MetricConfig{ + K8sVolumeAvailable: K8sVolumeAvailableMetricConfig{ Enabled: true, }, - K8sVolumeCapacity: MetricConfig{ + K8sVolumeCapacity: K8sVolumeCapacityMetricConfig{ Enabled: true, }, - K8sVolumeInodes: MetricConfig{ + K8sVolumeInodes: K8sVolumeInodesMetricConfig{ Enabled: true, }, - K8sVolumeInodesFree: MetricConfig{ + K8sVolumeInodesFree: K8sVolumeInodesFreeMetricConfig{ Enabled: true, }, - K8sVolumeInodesUsed: MetricConfig{ + K8sVolumeInodesUsed: K8sVolumeInodesUsedMetricConfig{ Enabled: true, }, }, @@ -224,178 +233,186 @@ func TestMetricsBuilderConfig(t *testing.T) { name: "none_set", want: MetricsBuilderConfig{ Metrics: MetricsConfig{ - ContainerCPUTime: MetricConfig{ + ContainerCPUTime: ContainerCPUTimeMetricConfig{ Enabled: false, }, - ContainerCPUUsage: MetricConfig{ + ContainerCPUUsage: ContainerCPUUsageMetricConfig{ Enabled: false, }, - ContainerFilesystemAvailable: MetricConfig{ + ContainerFilesystemAvailable: ContainerFilesystemAvailableMetricConfig{ Enabled: false, }, - ContainerFilesystemCapacity: MetricConfig{ + ContainerFilesystemCapacity: ContainerFilesystemCapacityMetricConfig{ Enabled: false, }, - ContainerFilesystemUsage: MetricConfig{ + ContainerFilesystemUsage: ContainerFilesystemUsageMetricConfig{ Enabled: false, }, - ContainerMemoryAvailable: MetricConfig{ + ContainerMemoryAvailable: ContainerMemoryAvailableMetricConfig{ Enabled: false, }, - ContainerMemoryMajorPageFaults: MetricConfig{ + ContainerMemoryMajorPageFaults: ContainerMemoryMajorPageFaultsMetricConfig{ Enabled: false, }, - ContainerMemoryPageFaults: MetricConfig{ + ContainerMemoryPageFaults: ContainerMemoryPageFaultsMetricConfig{ Enabled: false, }, - ContainerMemoryRss: MetricConfig{ + ContainerMemoryRss: ContainerMemoryRssMetricConfig{ Enabled: false, }, - ContainerMemoryUsage: MetricConfig{ + ContainerMemoryUsage: ContainerMemoryUsageMetricConfig{ Enabled: false, }, - ContainerMemoryWorkingSet: MetricConfig{ + ContainerMemoryWorkingSet: ContainerMemoryWorkingSetMetricConfig{ Enabled: false, }, - ContainerUptime: MetricConfig{ + ContainerUptime: ContainerUptimeMetricConfig{ Enabled: false, }, - K8sContainerCPUNodeUtilization: MetricConfig{ + K8sContainerCPUNodeUtilization: K8sContainerCPUNodeUtilizationMetricConfig{ Enabled: false, }, - K8sContainerCPULimitUtilization: MetricConfig{ + K8sContainerCPULimitUtilization: K8sContainerCPULimitUtilizationMetricConfig{ Enabled: false, }, - K8sContainerCPURequestUtilization: MetricConfig{ + K8sContainerCPURequestUtilization: K8sContainerCPURequestUtilizationMetricConfig{ Enabled: false, }, - K8sContainerMemoryNodeUtilization: MetricConfig{ + K8sContainerMemoryNodeUtilization: K8sContainerMemoryNodeUtilizationMetricConfig{ Enabled: false, }, - K8sContainerMemoryLimitUtilization: MetricConfig{ + K8sContainerMemoryLimitUtilization: K8sContainerMemoryLimitUtilizationMetricConfig{ Enabled: false, }, - K8sContainerMemoryRequestUtilization: MetricConfig{ + K8sContainerMemoryRequestUtilization: K8sContainerMemoryRequestUtilizationMetricConfig{ Enabled: false, }, - K8sNodeCPUTime: MetricConfig{ + K8sNodeCPUTime: K8sNodeCPUTimeMetricConfig{ Enabled: false, }, - K8sNodeCPUUsage: MetricConfig{ + K8sNodeCPUUsage: K8sNodeCPUUsageMetricConfig{ Enabled: false, }, - K8sNodeFilesystemAvailable: MetricConfig{ + K8sNodeFilesystemAvailable: K8sNodeFilesystemAvailableMetricConfig{ Enabled: false, }, - K8sNodeFilesystemCapacity: MetricConfig{ + K8sNodeFilesystemCapacity: K8sNodeFilesystemCapacityMetricConfig{ Enabled: false, }, - K8sNodeFilesystemUsage: MetricConfig{ + K8sNodeFilesystemUsage: K8sNodeFilesystemUsageMetricConfig{ Enabled: false, }, - K8sNodeMemoryAvailable: MetricConfig{ + K8sNodeMemoryAvailable: K8sNodeMemoryAvailableMetricConfig{ Enabled: false, }, - K8sNodeMemoryMajorPageFaults: MetricConfig{ + K8sNodeMemoryMajorPageFaults: K8sNodeMemoryMajorPageFaultsMetricConfig{ Enabled: false, }, - K8sNodeMemoryPageFaults: MetricConfig{ + K8sNodeMemoryPageFaults: K8sNodeMemoryPageFaultsMetricConfig{ Enabled: false, }, - K8sNodeMemoryRss: MetricConfig{ + K8sNodeMemoryRss: K8sNodeMemoryRssMetricConfig{ Enabled: false, }, - K8sNodeMemoryUsage: MetricConfig{ + K8sNodeMemoryUsage: K8sNodeMemoryUsageMetricConfig{ Enabled: false, }, - K8sNodeMemoryWorkingSet: MetricConfig{ + K8sNodeMemoryWorkingSet: K8sNodeMemoryWorkingSetMetricConfig{ Enabled: false, }, - K8sNodeNetworkErrors: MetricConfig{ - Enabled: false, + K8sNodeNetworkErrors: K8sNodeNetworkErrorsMetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sNodeNetworkErrorsMetricAttributeKey{K8sNodeNetworkErrorsMetricAttributeKeyInterface, K8sNodeNetworkErrorsMetricAttributeKeyDirection}, }, - K8sNodeNetworkIo: MetricConfig{ - Enabled: false, + K8sNodeNetworkIo: K8sNodeNetworkIoMetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sNodeNetworkIoMetricAttributeKey{K8sNodeNetworkIoMetricAttributeKeyInterface, K8sNodeNetworkIoMetricAttributeKeyDirection}, }, - K8sNodeUptime: MetricConfig{ + K8sNodeUptime: K8sNodeUptimeMetricConfig{ Enabled: false, }, - K8sPodCPUNodeUtilization: MetricConfig{ + K8sPodCPUNodeUtilization: K8sPodCPUNodeUtilizationMetricConfig{ Enabled: false, }, - K8sPodCPUTime: MetricConfig{ + K8sPodCPUTime: K8sPodCPUTimeMetricConfig{ Enabled: false, }, - K8sPodCPUUsage: MetricConfig{ + K8sPodCPUUsage: K8sPodCPUUsageMetricConfig{ Enabled: false, }, - K8sPodCPULimitUtilization: MetricConfig{ + K8sPodCPULimitUtilization: K8sPodCPULimitUtilizationMetricConfig{ Enabled: false, }, - K8sPodCPURequestUtilization: MetricConfig{ + K8sPodCPURequestUtilization: K8sPodCPURequestUtilizationMetricConfig{ Enabled: false, }, - K8sPodFilesystemAvailable: MetricConfig{ + K8sPodFilesystemAvailable: K8sPodFilesystemAvailableMetricConfig{ Enabled: false, }, - K8sPodFilesystemCapacity: MetricConfig{ + K8sPodFilesystemCapacity: K8sPodFilesystemCapacityMetricConfig{ Enabled: false, }, - K8sPodFilesystemUsage: MetricConfig{ + K8sPodFilesystemUsage: K8sPodFilesystemUsageMetricConfig{ Enabled: false, }, - K8sPodMemoryAvailable: MetricConfig{ + K8sPodMemoryAvailable: K8sPodMemoryAvailableMetricConfig{ Enabled: false, }, - K8sPodMemoryMajorPageFaults: MetricConfig{ + K8sPodMemoryMajorPageFaults: K8sPodMemoryMajorPageFaultsMetricConfig{ Enabled: false, }, - K8sPodMemoryNodeUtilization: MetricConfig{ + K8sPodMemoryNodeUtilization: K8sPodMemoryNodeUtilizationMetricConfig{ Enabled: false, }, - K8sPodMemoryPageFaults: MetricConfig{ + K8sPodMemoryPageFaults: K8sPodMemoryPageFaultsMetricConfig{ Enabled: false, }, - K8sPodMemoryRss: MetricConfig{ + K8sPodMemoryRss: K8sPodMemoryRssMetricConfig{ Enabled: false, }, - K8sPodMemoryUsage: MetricConfig{ + K8sPodMemoryUsage: K8sPodMemoryUsageMetricConfig{ Enabled: false, }, - K8sPodMemoryWorkingSet: MetricConfig{ + K8sPodMemoryWorkingSet: K8sPodMemoryWorkingSetMetricConfig{ Enabled: false, }, - K8sPodMemoryLimitUtilization: MetricConfig{ + K8sPodMemoryLimitUtilization: K8sPodMemoryLimitUtilizationMetricConfig{ Enabled: false, }, - K8sPodMemoryRequestUtilization: MetricConfig{ + K8sPodMemoryRequestUtilization: K8sPodMemoryRequestUtilizationMetricConfig{ Enabled: false, }, - K8sPodNetworkErrors: MetricConfig{ - Enabled: false, + K8sPodNetworkErrors: K8sPodNetworkErrorsMetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sPodNetworkErrorsMetricAttributeKey{K8sPodNetworkErrorsMetricAttributeKeyInterface, K8sPodNetworkErrorsMetricAttributeKeyDirection}, }, - K8sPodNetworkIo: MetricConfig{ - Enabled: false, + K8sPodNetworkIo: K8sPodNetworkIoMetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategySum, + EnabledAttributes: []K8sPodNetworkIoMetricAttributeKey{K8sPodNetworkIoMetricAttributeKeyInterface, K8sPodNetworkIoMetricAttributeKeyDirection}, }, - K8sPodUptime: MetricConfig{ + K8sPodUptime: K8sPodUptimeMetricConfig{ Enabled: false, }, - K8sPodVolumeUsage: MetricConfig{ + K8sPodVolumeUsage: K8sPodVolumeUsageMetricConfig{ Enabled: false, }, - K8sVolumeAvailable: MetricConfig{ + K8sVolumeAvailable: K8sVolumeAvailableMetricConfig{ Enabled: false, }, - K8sVolumeCapacity: MetricConfig{ + K8sVolumeCapacity: K8sVolumeCapacityMetricConfig{ Enabled: false, }, - K8sVolumeInodes: MetricConfig{ + K8sVolumeInodes: K8sVolumeInodesMetricConfig{ Enabled: false, }, - K8sVolumeInodesFree: MetricConfig{ + K8sVolumeInodesFree: K8sVolumeInodesFreeMetricConfig{ Enabled: false, }, - K8sVolumeInodesUsed: MetricConfig{ + K8sVolumeInodesUsed: K8sVolumeInodesUsedMetricConfig{ Enabled: false, }, }, @@ -422,7 +439,7 @@ func TestMetricsBuilderConfig(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { cfg := loadMetricsBuilderConfig(t, tt.name) - diff := cmp.Diff(tt.want, cfg, cmpopts.IgnoreUnexported(MetricConfig{}, ResourceAttributeConfig{})) + diff := cmp.Diff(tt.want, cfg, cmpopts.IgnoreUnexported(ContainerCPUTimeMetricConfig{}, ContainerCPUUsageMetricConfig{}, ContainerFilesystemAvailableMetricConfig{}, ContainerFilesystemCapacityMetricConfig{}, ContainerFilesystemUsageMetricConfig{}, ContainerMemoryAvailableMetricConfig{}, ContainerMemoryMajorPageFaultsMetricConfig{}, ContainerMemoryPageFaultsMetricConfig{}, ContainerMemoryRssMetricConfig{}, ContainerMemoryUsageMetricConfig{}, ContainerMemoryWorkingSetMetricConfig{}, ContainerUptimeMetricConfig{}, K8sContainerCPUNodeUtilizationMetricConfig{}, K8sContainerCPULimitUtilizationMetricConfig{}, K8sContainerCPURequestUtilizationMetricConfig{}, K8sContainerMemoryNodeUtilizationMetricConfig{}, K8sContainerMemoryLimitUtilizationMetricConfig{}, K8sContainerMemoryRequestUtilizationMetricConfig{}, K8sNodeCPUTimeMetricConfig{}, K8sNodeCPUUsageMetricConfig{}, K8sNodeFilesystemAvailableMetricConfig{}, K8sNodeFilesystemCapacityMetricConfig{}, K8sNodeFilesystemUsageMetricConfig{}, K8sNodeMemoryAvailableMetricConfig{}, K8sNodeMemoryMajorPageFaultsMetricConfig{}, K8sNodeMemoryPageFaultsMetricConfig{}, K8sNodeMemoryRssMetricConfig{}, K8sNodeMemoryUsageMetricConfig{}, K8sNodeMemoryWorkingSetMetricConfig{}, K8sNodeNetworkErrorsMetricConfig{}, K8sNodeNetworkIoMetricConfig{}, K8sNodeUptimeMetricConfig{}, K8sPodCPUNodeUtilizationMetricConfig{}, K8sPodCPUTimeMetricConfig{}, K8sPodCPUUsageMetricConfig{}, K8sPodCPULimitUtilizationMetricConfig{}, K8sPodCPURequestUtilizationMetricConfig{}, K8sPodFilesystemAvailableMetricConfig{}, K8sPodFilesystemCapacityMetricConfig{}, K8sPodFilesystemUsageMetricConfig{}, K8sPodMemoryAvailableMetricConfig{}, K8sPodMemoryMajorPageFaultsMetricConfig{}, K8sPodMemoryNodeUtilizationMetricConfig{}, K8sPodMemoryPageFaultsMetricConfig{}, K8sPodMemoryRssMetricConfig{}, K8sPodMemoryUsageMetricConfig{}, K8sPodMemoryWorkingSetMetricConfig{}, K8sPodMemoryLimitUtilizationMetricConfig{}, K8sPodMemoryRequestUtilizationMetricConfig{}, K8sPodNetworkErrorsMetricConfig{}, K8sPodNetworkIoMetricConfig{}, K8sPodUptimeMetricConfig{}, K8sPodVolumeUsageMetricConfig{}, K8sVolumeAvailableMetricConfig{}, K8sVolumeCapacityMetricConfig{}, K8sVolumeInodesMetricConfig{}, K8sVolumeInodesFreeMetricConfig{}, K8sVolumeInodesUsedMetricConfig{}, ResourceAttributeConfig{})) require.Emptyf(t, diff, "Config mismatch (-expected +actual):\n%s", diff) }) } diff --git a/receiver/kubeletstatsreceiver/internal/metadata/generated_metrics.go b/receiver/kubeletstatsreceiver/internal/metadata/generated_metrics.go index dc5cfd91d353c..92e7ac0ff8227 100644 --- a/receiver/kubeletstatsreceiver/internal/metadata/generated_metrics.go +++ b/receiver/kubeletstatsreceiver/internal/metadata/generated_metrics.go @@ -3,6 +3,7 @@ package metadata import ( + "slices" "time" "go.opentelemetry.io/collector/component" @@ -12,6 +13,13 @@ import ( "go.opentelemetry.io/collector/receiver" ) +const ( + AggregationStrategySum = "sum" + AggregationStrategyAvg = "avg" + AggregationStrategyMin = "min" + AggregationStrategyMax = "max" +) + // AttributeDirection specifies the value direction attribute. type AttributeDirection int @@ -281,9 +289,9 @@ type metricInfo struct { } type metricContainerCPUTime struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerCPUTimeMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.cpu.time metric with initial data. @@ -322,7 +330,7 @@ func (m *metricContainerCPUTime) emit(metrics pmetric.MetricSlice) { } } -func newMetricContainerCPUTime(cfg MetricConfig) metricContainerCPUTime { +func newMetricContainerCPUTime(cfg ContainerCPUTimeMetricConfig) metricContainerCPUTime { m := metricContainerCPUTime{config: cfg} if cfg.Enabled { @@ -333,9 +341,9 @@ func newMetricContainerCPUTime(cfg MetricConfig) metricContainerCPUTime { } type metricContainerCPUUsage struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerCPUUsageMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.cpu.usage metric with initial data. @@ -372,7 +380,7 @@ func (m *metricContainerCPUUsage) emit(metrics pmetric.MetricSlice) { } } -func newMetricContainerCPUUsage(cfg MetricConfig) metricContainerCPUUsage { +func newMetricContainerCPUUsage(cfg ContainerCPUUsageMetricConfig) metricContainerCPUUsage { m := metricContainerCPUUsage{config: cfg} if cfg.Enabled { @@ -383,9 +391,9 @@ func newMetricContainerCPUUsage(cfg MetricConfig) metricContainerCPUUsage { } type metricContainerFilesystemAvailable struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerFilesystemAvailableMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.filesystem.available metric with initial data. @@ -422,7 +430,7 @@ func (m *metricContainerFilesystemAvailable) emit(metrics pmetric.MetricSlice) { } } -func newMetricContainerFilesystemAvailable(cfg MetricConfig) metricContainerFilesystemAvailable { +func newMetricContainerFilesystemAvailable(cfg ContainerFilesystemAvailableMetricConfig) metricContainerFilesystemAvailable { m := metricContainerFilesystemAvailable{config: cfg} if cfg.Enabled { @@ -433,9 +441,9 @@ func newMetricContainerFilesystemAvailable(cfg MetricConfig) metricContainerFile } type metricContainerFilesystemCapacity struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerFilesystemCapacityMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.filesystem.capacity metric with initial data. @@ -472,7 +480,7 @@ func (m *metricContainerFilesystemCapacity) emit(metrics pmetric.MetricSlice) { } } -func newMetricContainerFilesystemCapacity(cfg MetricConfig) metricContainerFilesystemCapacity { +func newMetricContainerFilesystemCapacity(cfg ContainerFilesystemCapacityMetricConfig) metricContainerFilesystemCapacity { m := metricContainerFilesystemCapacity{config: cfg} if cfg.Enabled { @@ -483,9 +491,9 @@ func newMetricContainerFilesystemCapacity(cfg MetricConfig) metricContainerFiles } type metricContainerFilesystemUsage struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerFilesystemUsageMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.filesystem.usage metric with initial data. @@ -522,7 +530,7 @@ func (m *metricContainerFilesystemUsage) emit(metrics pmetric.MetricSlice) { } } -func newMetricContainerFilesystemUsage(cfg MetricConfig) metricContainerFilesystemUsage { +func newMetricContainerFilesystemUsage(cfg ContainerFilesystemUsageMetricConfig) metricContainerFilesystemUsage { m := metricContainerFilesystemUsage{config: cfg} if cfg.Enabled { @@ -533,9 +541,9 @@ func newMetricContainerFilesystemUsage(cfg MetricConfig) metricContainerFilesyst } type metricContainerMemoryAvailable struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerMemoryAvailableMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.memory.available metric with initial data. @@ -572,7 +580,7 @@ func (m *metricContainerMemoryAvailable) emit(metrics pmetric.MetricSlice) { } } -func newMetricContainerMemoryAvailable(cfg MetricConfig) metricContainerMemoryAvailable { +func newMetricContainerMemoryAvailable(cfg ContainerMemoryAvailableMetricConfig) metricContainerMemoryAvailable { m := metricContainerMemoryAvailable{config: cfg} if cfg.Enabled { @@ -583,9 +591,9 @@ func newMetricContainerMemoryAvailable(cfg MetricConfig) metricContainerMemoryAv } type metricContainerMemoryMajorPageFaults struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerMemoryMajorPageFaultsMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.memory.major_page_faults metric with initial data. @@ -622,7 +630,7 @@ func (m *metricContainerMemoryMajorPageFaults) emit(metrics pmetric.MetricSlice) } } -func newMetricContainerMemoryMajorPageFaults(cfg MetricConfig) metricContainerMemoryMajorPageFaults { +func newMetricContainerMemoryMajorPageFaults(cfg ContainerMemoryMajorPageFaultsMetricConfig) metricContainerMemoryMajorPageFaults { m := metricContainerMemoryMajorPageFaults{config: cfg} if cfg.Enabled { @@ -633,9 +641,9 @@ func newMetricContainerMemoryMajorPageFaults(cfg MetricConfig) metricContainerMe } type metricContainerMemoryPageFaults struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerMemoryPageFaultsMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.memory.page_faults metric with initial data. @@ -672,7 +680,7 @@ func (m *metricContainerMemoryPageFaults) emit(metrics pmetric.MetricSlice) { } } -func newMetricContainerMemoryPageFaults(cfg MetricConfig) metricContainerMemoryPageFaults { +func newMetricContainerMemoryPageFaults(cfg ContainerMemoryPageFaultsMetricConfig) metricContainerMemoryPageFaults { m := metricContainerMemoryPageFaults{config: cfg} if cfg.Enabled { @@ -683,9 +691,9 @@ func newMetricContainerMemoryPageFaults(cfg MetricConfig) metricContainerMemoryP } type metricContainerMemoryRss struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerMemoryRssMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.memory.rss metric with initial data. @@ -722,7 +730,7 @@ func (m *metricContainerMemoryRss) emit(metrics pmetric.MetricSlice) { } } -func newMetricContainerMemoryRss(cfg MetricConfig) metricContainerMemoryRss { +func newMetricContainerMemoryRss(cfg ContainerMemoryRssMetricConfig) metricContainerMemoryRss { m := metricContainerMemoryRss{config: cfg} if cfg.Enabled { @@ -733,9 +741,9 @@ func newMetricContainerMemoryRss(cfg MetricConfig) metricContainerMemoryRss { } type metricContainerMemoryUsage struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerMemoryUsageMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.memory.usage metric with initial data. @@ -772,7 +780,7 @@ func (m *metricContainerMemoryUsage) emit(metrics pmetric.MetricSlice) { } } -func newMetricContainerMemoryUsage(cfg MetricConfig) metricContainerMemoryUsage { +func newMetricContainerMemoryUsage(cfg ContainerMemoryUsageMetricConfig) metricContainerMemoryUsage { m := metricContainerMemoryUsage{config: cfg} if cfg.Enabled { @@ -783,9 +791,9 @@ func newMetricContainerMemoryUsage(cfg MetricConfig) metricContainerMemoryUsage } type metricContainerMemoryWorkingSet struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerMemoryWorkingSetMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.memory.working_set metric with initial data. @@ -822,7 +830,7 @@ func (m *metricContainerMemoryWorkingSet) emit(metrics pmetric.MetricSlice) { } } -func newMetricContainerMemoryWorkingSet(cfg MetricConfig) metricContainerMemoryWorkingSet { +func newMetricContainerMemoryWorkingSet(cfg ContainerMemoryWorkingSetMetricConfig) metricContainerMemoryWorkingSet { m := metricContainerMemoryWorkingSet{config: cfg} if cfg.Enabled { @@ -833,9 +841,9 @@ func newMetricContainerMemoryWorkingSet(cfg MetricConfig) metricContainerMemoryW } type metricContainerUptime struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config ContainerUptimeMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills container.uptime metric with initial data. @@ -874,7 +882,7 @@ func (m *metricContainerUptime) emit(metrics pmetric.MetricSlice) { } } -func newMetricContainerUptime(cfg MetricConfig) metricContainerUptime { +func newMetricContainerUptime(cfg ContainerUptimeMetricConfig) metricContainerUptime { m := metricContainerUptime{config: cfg} if cfg.Enabled { @@ -885,9 +893,9 @@ func newMetricContainerUptime(cfg MetricConfig) metricContainerUptime { } type metricK8sContainerCPUNodeUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sContainerCPUNodeUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.container.cpu.node.utilization metric with initial data. @@ -924,7 +932,7 @@ func (m *metricK8sContainerCPUNodeUtilization) emit(metrics pmetric.MetricSlice) } } -func newMetricK8sContainerCPUNodeUtilization(cfg MetricConfig) metricK8sContainerCPUNodeUtilization { +func newMetricK8sContainerCPUNodeUtilization(cfg K8sContainerCPUNodeUtilizationMetricConfig) metricK8sContainerCPUNodeUtilization { m := metricK8sContainerCPUNodeUtilization{config: cfg} if cfg.Enabled { @@ -935,9 +943,9 @@ func newMetricK8sContainerCPUNodeUtilization(cfg MetricConfig) metricK8sContaine } type metricK8sContainerCPULimitUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sContainerCPULimitUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.container.cpu_limit_utilization metric with initial data. @@ -974,7 +982,7 @@ func (m *metricK8sContainerCPULimitUtilization) emit(metrics pmetric.MetricSlice } } -func newMetricK8sContainerCPULimitUtilization(cfg MetricConfig) metricK8sContainerCPULimitUtilization { +func newMetricK8sContainerCPULimitUtilization(cfg K8sContainerCPULimitUtilizationMetricConfig) metricK8sContainerCPULimitUtilization { m := metricK8sContainerCPULimitUtilization{config: cfg} if cfg.Enabled { @@ -985,9 +993,9 @@ func newMetricK8sContainerCPULimitUtilization(cfg MetricConfig) metricK8sContain } type metricK8sContainerCPURequestUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sContainerCPURequestUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.container.cpu_request_utilization metric with initial data. @@ -1024,7 +1032,7 @@ func (m *metricK8sContainerCPURequestUtilization) emit(metrics pmetric.MetricSli } } -func newMetricK8sContainerCPURequestUtilization(cfg MetricConfig) metricK8sContainerCPURequestUtilization { +func newMetricK8sContainerCPURequestUtilization(cfg K8sContainerCPURequestUtilizationMetricConfig) metricK8sContainerCPURequestUtilization { m := metricK8sContainerCPURequestUtilization{config: cfg} if cfg.Enabled { @@ -1035,9 +1043,9 @@ func newMetricK8sContainerCPURequestUtilization(cfg MetricConfig) metricK8sConta } type metricK8sContainerMemoryNodeUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sContainerMemoryNodeUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.container.memory.node.utilization metric with initial data. @@ -1074,7 +1082,7 @@ func (m *metricK8sContainerMemoryNodeUtilization) emit(metrics pmetric.MetricSli } } -func newMetricK8sContainerMemoryNodeUtilization(cfg MetricConfig) metricK8sContainerMemoryNodeUtilization { +func newMetricK8sContainerMemoryNodeUtilization(cfg K8sContainerMemoryNodeUtilizationMetricConfig) metricK8sContainerMemoryNodeUtilization { m := metricK8sContainerMemoryNodeUtilization{config: cfg} if cfg.Enabled { @@ -1085,9 +1093,9 @@ func newMetricK8sContainerMemoryNodeUtilization(cfg MetricConfig) metricK8sConta } type metricK8sContainerMemoryLimitUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sContainerMemoryLimitUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.container.memory_limit_utilization metric with initial data. @@ -1124,7 +1132,7 @@ func (m *metricK8sContainerMemoryLimitUtilization) emit(metrics pmetric.MetricSl } } -func newMetricK8sContainerMemoryLimitUtilization(cfg MetricConfig) metricK8sContainerMemoryLimitUtilization { +func newMetricK8sContainerMemoryLimitUtilization(cfg K8sContainerMemoryLimitUtilizationMetricConfig) metricK8sContainerMemoryLimitUtilization { m := metricK8sContainerMemoryLimitUtilization{config: cfg} if cfg.Enabled { @@ -1135,9 +1143,9 @@ func newMetricK8sContainerMemoryLimitUtilization(cfg MetricConfig) metricK8sCont } type metricK8sContainerMemoryRequestUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sContainerMemoryRequestUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.container.memory_request_utilization metric with initial data. @@ -1174,7 +1182,7 @@ func (m *metricK8sContainerMemoryRequestUtilization) emit(metrics pmetric.Metric } } -func newMetricK8sContainerMemoryRequestUtilization(cfg MetricConfig) metricK8sContainerMemoryRequestUtilization { +func newMetricK8sContainerMemoryRequestUtilization(cfg K8sContainerMemoryRequestUtilizationMetricConfig) metricK8sContainerMemoryRequestUtilization { m := metricK8sContainerMemoryRequestUtilization{config: cfg} if cfg.Enabled { @@ -1185,9 +1193,9 @@ func newMetricK8sContainerMemoryRequestUtilization(cfg MetricConfig) metricK8sCo } type metricK8sNodeCPUTime struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeCPUTimeMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.cpu.time metric with initial data. @@ -1226,7 +1234,7 @@ func (m *metricK8sNodeCPUTime) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeCPUTime(cfg MetricConfig) metricK8sNodeCPUTime { +func newMetricK8sNodeCPUTime(cfg K8sNodeCPUTimeMetricConfig) metricK8sNodeCPUTime { m := metricK8sNodeCPUTime{config: cfg} if cfg.Enabled { @@ -1237,9 +1245,9 @@ func newMetricK8sNodeCPUTime(cfg MetricConfig) metricK8sNodeCPUTime { } type metricK8sNodeCPUUsage struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeCPUUsageMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.cpu.usage metric with initial data. @@ -1276,7 +1284,7 @@ func (m *metricK8sNodeCPUUsage) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeCPUUsage(cfg MetricConfig) metricK8sNodeCPUUsage { +func newMetricK8sNodeCPUUsage(cfg K8sNodeCPUUsageMetricConfig) metricK8sNodeCPUUsage { m := metricK8sNodeCPUUsage{config: cfg} if cfg.Enabled { @@ -1287,9 +1295,9 @@ func newMetricK8sNodeCPUUsage(cfg MetricConfig) metricK8sNodeCPUUsage { } type metricK8sNodeFilesystemAvailable struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeFilesystemAvailableMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.filesystem.available metric with initial data. @@ -1326,7 +1334,7 @@ func (m *metricK8sNodeFilesystemAvailable) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeFilesystemAvailable(cfg MetricConfig) metricK8sNodeFilesystemAvailable { +func newMetricK8sNodeFilesystemAvailable(cfg K8sNodeFilesystemAvailableMetricConfig) metricK8sNodeFilesystemAvailable { m := metricK8sNodeFilesystemAvailable{config: cfg} if cfg.Enabled { @@ -1337,9 +1345,9 @@ func newMetricK8sNodeFilesystemAvailable(cfg MetricConfig) metricK8sNodeFilesyst } type metricK8sNodeFilesystemCapacity struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeFilesystemCapacityMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.filesystem.capacity metric with initial data. @@ -1376,7 +1384,7 @@ func (m *metricK8sNodeFilesystemCapacity) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeFilesystemCapacity(cfg MetricConfig) metricK8sNodeFilesystemCapacity { +func newMetricK8sNodeFilesystemCapacity(cfg K8sNodeFilesystemCapacityMetricConfig) metricK8sNodeFilesystemCapacity { m := metricK8sNodeFilesystemCapacity{config: cfg} if cfg.Enabled { @@ -1387,9 +1395,9 @@ func newMetricK8sNodeFilesystemCapacity(cfg MetricConfig) metricK8sNodeFilesyste } type metricK8sNodeFilesystemUsage struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeFilesystemUsageMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.filesystem.usage metric with initial data. @@ -1426,7 +1434,7 @@ func (m *metricK8sNodeFilesystemUsage) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeFilesystemUsage(cfg MetricConfig) metricK8sNodeFilesystemUsage { +func newMetricK8sNodeFilesystemUsage(cfg K8sNodeFilesystemUsageMetricConfig) metricK8sNodeFilesystemUsage { m := metricK8sNodeFilesystemUsage{config: cfg} if cfg.Enabled { @@ -1437,9 +1445,9 @@ func newMetricK8sNodeFilesystemUsage(cfg MetricConfig) metricK8sNodeFilesystemUs } type metricK8sNodeMemoryAvailable struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeMemoryAvailableMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.memory.available metric with initial data. @@ -1476,7 +1484,7 @@ func (m *metricK8sNodeMemoryAvailable) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeMemoryAvailable(cfg MetricConfig) metricK8sNodeMemoryAvailable { +func newMetricK8sNodeMemoryAvailable(cfg K8sNodeMemoryAvailableMetricConfig) metricK8sNodeMemoryAvailable { m := metricK8sNodeMemoryAvailable{config: cfg} if cfg.Enabled { @@ -1487,9 +1495,9 @@ func newMetricK8sNodeMemoryAvailable(cfg MetricConfig) metricK8sNodeMemoryAvaila } type metricK8sNodeMemoryMajorPageFaults struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeMemoryMajorPageFaultsMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.memory.major_page_faults metric with initial data. @@ -1526,7 +1534,7 @@ func (m *metricK8sNodeMemoryMajorPageFaults) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeMemoryMajorPageFaults(cfg MetricConfig) metricK8sNodeMemoryMajorPageFaults { +func newMetricK8sNodeMemoryMajorPageFaults(cfg K8sNodeMemoryMajorPageFaultsMetricConfig) metricK8sNodeMemoryMajorPageFaults { m := metricK8sNodeMemoryMajorPageFaults{config: cfg} if cfg.Enabled { @@ -1537,9 +1545,9 @@ func newMetricK8sNodeMemoryMajorPageFaults(cfg MetricConfig) metricK8sNodeMemory } type metricK8sNodeMemoryPageFaults struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeMemoryPageFaultsMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.memory.page_faults metric with initial data. @@ -1576,7 +1584,7 @@ func (m *metricK8sNodeMemoryPageFaults) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeMemoryPageFaults(cfg MetricConfig) metricK8sNodeMemoryPageFaults { +func newMetricK8sNodeMemoryPageFaults(cfg K8sNodeMemoryPageFaultsMetricConfig) metricK8sNodeMemoryPageFaults { m := metricK8sNodeMemoryPageFaults{config: cfg} if cfg.Enabled { @@ -1587,9 +1595,9 @@ func newMetricK8sNodeMemoryPageFaults(cfg MetricConfig) metricK8sNodeMemoryPageF } type metricK8sNodeMemoryRss struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeMemoryRssMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.memory.rss metric with initial data. @@ -1626,7 +1634,7 @@ func (m *metricK8sNodeMemoryRss) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeMemoryRss(cfg MetricConfig) metricK8sNodeMemoryRss { +func newMetricK8sNodeMemoryRss(cfg K8sNodeMemoryRssMetricConfig) metricK8sNodeMemoryRss { m := metricK8sNodeMemoryRss{config: cfg} if cfg.Enabled { @@ -1637,9 +1645,9 @@ func newMetricK8sNodeMemoryRss(cfg MetricConfig) metricK8sNodeMemoryRss { } type metricK8sNodeMemoryUsage struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeMemoryUsageMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.memory.usage metric with initial data. @@ -1676,7 +1684,7 @@ func (m *metricK8sNodeMemoryUsage) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeMemoryUsage(cfg MetricConfig) metricK8sNodeMemoryUsage { +func newMetricK8sNodeMemoryUsage(cfg K8sNodeMemoryUsageMetricConfig) metricK8sNodeMemoryUsage { m := metricK8sNodeMemoryUsage{config: cfg} if cfg.Enabled { @@ -1687,9 +1695,9 @@ func newMetricK8sNodeMemoryUsage(cfg MetricConfig) metricK8sNodeMemoryUsage { } type metricK8sNodeMemoryWorkingSet struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeMemoryWorkingSetMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.memory.working_set metric with initial data. @@ -1726,7 +1734,7 @@ func (m *metricK8sNodeMemoryWorkingSet) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeMemoryWorkingSet(cfg MetricConfig) metricK8sNodeMemoryWorkingSet { +func newMetricK8sNodeMemoryWorkingSet(cfg K8sNodeMemoryWorkingSetMetricConfig) metricK8sNodeMemoryWorkingSet { m := metricK8sNodeMemoryWorkingSet{config: cfg} if cfg.Enabled { @@ -1737,9 +1745,10 @@ func newMetricK8sNodeMemoryWorkingSet(cfg MetricConfig) metricK8sNodeMemoryWorki } type metricK8sNodeNetworkErrors struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeNetworkErrorsMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []int64 // slice containing number of aggregated datapoints at each index } // init fills k8s.node.network.errors metric with initial data. @@ -1751,18 +1760,51 @@ func (m *metricK8sNodeNetworkErrors) init() { m.data.Sum().SetIsMonotonic(true) m.data.Sum().SetAggregationTemporality(pmetric.AggregationTemporalityCumulative) m.data.Sum().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricK8sNodeNetworkErrors) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, interfaceAttributeValue string, directionAttributeValue string) { if !m.config.Enabled { return } - dp := m.data.Sum().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, K8sNodeNetworkErrorsMetricAttributeKeyInterface) { + dp.Attributes().PutStr("interface", interfaceAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, K8sNodeNetworkErrorsMetricAttributeKeyDirection) { + dp.Attributes().PutStr("direction", directionAttributeValue) + } + + var s string + dps := m.data.Sum().DataPoints() + for i := 0; i < dps.Len(); i++ { + dpi := dps.At(i) + if dp.Attributes().Equal(dpi.Attributes()) && dp.StartTimestamp() == dpi.StartTimestamp() && dp.Timestamp() == dpi.Timestamp() { + switch s = m.config.AggregationStrategy; s { + case AggregationStrategySum, AggregationStrategyAvg: + dpi.SetIntValue(dpi.IntValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.IntValue() > val { + dpi.SetIntValue(val) + } + return + case AggregationStrategyMax: + if dpi.IntValue() < val { + dpi.SetIntValue(val) + } + return + } + } + } + dp.SetIntValue(val) - dp.Attributes().PutStr("interface", interfaceAttributeValue) - dp.Attributes().PutStr("direction", directionAttributeValue) + m.aggDataPoints = append(m.aggDataPoints, 1) + dp.MoveTo(dps.AppendEmpty()) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. @@ -1775,13 +1817,18 @@ func (m *metricK8sNodeNetworkErrors) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricK8sNodeNetworkErrors) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Sum().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Sum().DataPoints().At(i).SetIntValue(m.data.Sum().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() } } -func newMetricK8sNodeNetworkErrors(cfg MetricConfig) metricK8sNodeNetworkErrors { +func newMetricK8sNodeNetworkErrors(cfg K8sNodeNetworkErrorsMetricConfig) metricK8sNodeNetworkErrors { m := metricK8sNodeNetworkErrors{config: cfg} if cfg.Enabled { @@ -1792,9 +1839,10 @@ func newMetricK8sNodeNetworkErrors(cfg MetricConfig) metricK8sNodeNetworkErrors } type metricK8sNodeNetworkIo struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeNetworkIoMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []int64 // slice containing number of aggregated datapoints at each index } // init fills k8s.node.network.io metric with initial data. @@ -1806,18 +1854,51 @@ func (m *metricK8sNodeNetworkIo) init() { m.data.Sum().SetIsMonotonic(true) m.data.Sum().SetAggregationTemporality(pmetric.AggregationTemporalityCumulative) m.data.Sum().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricK8sNodeNetworkIo) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, interfaceAttributeValue string, directionAttributeValue string) { if !m.config.Enabled { return } - dp := m.data.Sum().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, K8sNodeNetworkIoMetricAttributeKeyInterface) { + dp.Attributes().PutStr("interface", interfaceAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, K8sNodeNetworkIoMetricAttributeKeyDirection) { + dp.Attributes().PutStr("direction", directionAttributeValue) + } + + var s string + dps := m.data.Sum().DataPoints() + for i := 0; i < dps.Len(); i++ { + dpi := dps.At(i) + if dp.Attributes().Equal(dpi.Attributes()) && dp.StartTimestamp() == dpi.StartTimestamp() && dp.Timestamp() == dpi.Timestamp() { + switch s = m.config.AggregationStrategy; s { + case AggregationStrategySum, AggregationStrategyAvg: + dpi.SetIntValue(dpi.IntValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.IntValue() > val { + dpi.SetIntValue(val) + } + return + case AggregationStrategyMax: + if dpi.IntValue() < val { + dpi.SetIntValue(val) + } + return + } + } + } + dp.SetIntValue(val) - dp.Attributes().PutStr("interface", interfaceAttributeValue) - dp.Attributes().PutStr("direction", directionAttributeValue) + m.aggDataPoints = append(m.aggDataPoints, 1) + dp.MoveTo(dps.AppendEmpty()) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. @@ -1830,13 +1911,18 @@ func (m *metricK8sNodeNetworkIo) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricK8sNodeNetworkIo) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Sum().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Sum().DataPoints().At(i).SetIntValue(m.data.Sum().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() } } -func newMetricK8sNodeNetworkIo(cfg MetricConfig) metricK8sNodeNetworkIo { +func newMetricK8sNodeNetworkIo(cfg K8sNodeNetworkIoMetricConfig) metricK8sNodeNetworkIo { m := metricK8sNodeNetworkIo{config: cfg} if cfg.Enabled { @@ -1847,9 +1933,9 @@ func newMetricK8sNodeNetworkIo(cfg MetricConfig) metricK8sNodeNetworkIo { } type metricK8sNodeUptime struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sNodeUptimeMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.node.uptime metric with initial data. @@ -1888,7 +1974,7 @@ func (m *metricK8sNodeUptime) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sNodeUptime(cfg MetricConfig) metricK8sNodeUptime { +func newMetricK8sNodeUptime(cfg K8sNodeUptimeMetricConfig) metricK8sNodeUptime { m := metricK8sNodeUptime{config: cfg} if cfg.Enabled { @@ -1899,9 +1985,9 @@ func newMetricK8sNodeUptime(cfg MetricConfig) metricK8sNodeUptime { } type metricK8sPodCPUNodeUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodCPUNodeUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.cpu.node.utilization metric with initial data. @@ -1938,7 +2024,7 @@ func (m *metricK8sPodCPUNodeUtilization) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodCPUNodeUtilization(cfg MetricConfig) metricK8sPodCPUNodeUtilization { +func newMetricK8sPodCPUNodeUtilization(cfg K8sPodCPUNodeUtilizationMetricConfig) metricK8sPodCPUNodeUtilization { m := metricK8sPodCPUNodeUtilization{config: cfg} if cfg.Enabled { @@ -1949,9 +2035,9 @@ func newMetricK8sPodCPUNodeUtilization(cfg MetricConfig) metricK8sPodCPUNodeUtil } type metricK8sPodCPUTime struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodCPUTimeMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.cpu.time metric with initial data. @@ -1990,7 +2076,7 @@ func (m *metricK8sPodCPUTime) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodCPUTime(cfg MetricConfig) metricK8sPodCPUTime { +func newMetricK8sPodCPUTime(cfg K8sPodCPUTimeMetricConfig) metricK8sPodCPUTime { m := metricK8sPodCPUTime{config: cfg} if cfg.Enabled { @@ -2001,9 +2087,9 @@ func newMetricK8sPodCPUTime(cfg MetricConfig) metricK8sPodCPUTime { } type metricK8sPodCPUUsage struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodCPUUsageMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.cpu.usage metric with initial data. @@ -2040,7 +2126,7 @@ func (m *metricK8sPodCPUUsage) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodCPUUsage(cfg MetricConfig) metricK8sPodCPUUsage { +func newMetricK8sPodCPUUsage(cfg K8sPodCPUUsageMetricConfig) metricK8sPodCPUUsage { m := metricK8sPodCPUUsage{config: cfg} if cfg.Enabled { @@ -2051,9 +2137,9 @@ func newMetricK8sPodCPUUsage(cfg MetricConfig) metricK8sPodCPUUsage { } type metricK8sPodCPULimitUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodCPULimitUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.cpu_limit_utilization metric with initial data. @@ -2090,7 +2176,7 @@ func (m *metricK8sPodCPULimitUtilization) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodCPULimitUtilization(cfg MetricConfig) metricK8sPodCPULimitUtilization { +func newMetricK8sPodCPULimitUtilization(cfg K8sPodCPULimitUtilizationMetricConfig) metricK8sPodCPULimitUtilization { m := metricK8sPodCPULimitUtilization{config: cfg} if cfg.Enabled { @@ -2101,9 +2187,9 @@ func newMetricK8sPodCPULimitUtilization(cfg MetricConfig) metricK8sPodCPULimitUt } type metricK8sPodCPURequestUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodCPURequestUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.cpu_request_utilization metric with initial data. @@ -2140,7 +2226,7 @@ func (m *metricK8sPodCPURequestUtilization) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodCPURequestUtilization(cfg MetricConfig) metricK8sPodCPURequestUtilization { +func newMetricK8sPodCPURequestUtilization(cfg K8sPodCPURequestUtilizationMetricConfig) metricK8sPodCPURequestUtilization { m := metricK8sPodCPURequestUtilization{config: cfg} if cfg.Enabled { @@ -2151,9 +2237,9 @@ func newMetricK8sPodCPURequestUtilization(cfg MetricConfig) metricK8sPodCPUReque } type metricK8sPodFilesystemAvailable struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodFilesystemAvailableMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.filesystem.available metric with initial data. @@ -2190,7 +2276,7 @@ func (m *metricK8sPodFilesystemAvailable) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodFilesystemAvailable(cfg MetricConfig) metricK8sPodFilesystemAvailable { +func newMetricK8sPodFilesystemAvailable(cfg K8sPodFilesystemAvailableMetricConfig) metricK8sPodFilesystemAvailable { m := metricK8sPodFilesystemAvailable{config: cfg} if cfg.Enabled { @@ -2201,9 +2287,9 @@ func newMetricK8sPodFilesystemAvailable(cfg MetricConfig) metricK8sPodFilesystem } type metricK8sPodFilesystemCapacity struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodFilesystemCapacityMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.filesystem.capacity metric with initial data. @@ -2240,7 +2326,7 @@ func (m *metricK8sPodFilesystemCapacity) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodFilesystemCapacity(cfg MetricConfig) metricK8sPodFilesystemCapacity { +func newMetricK8sPodFilesystemCapacity(cfg K8sPodFilesystemCapacityMetricConfig) metricK8sPodFilesystemCapacity { m := metricK8sPodFilesystemCapacity{config: cfg} if cfg.Enabled { @@ -2251,9 +2337,9 @@ func newMetricK8sPodFilesystemCapacity(cfg MetricConfig) metricK8sPodFilesystemC } type metricK8sPodFilesystemUsage struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodFilesystemUsageMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.filesystem.usage metric with initial data. @@ -2290,7 +2376,7 @@ func (m *metricK8sPodFilesystemUsage) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodFilesystemUsage(cfg MetricConfig) metricK8sPodFilesystemUsage { +func newMetricK8sPodFilesystemUsage(cfg K8sPodFilesystemUsageMetricConfig) metricK8sPodFilesystemUsage { m := metricK8sPodFilesystemUsage{config: cfg} if cfg.Enabled { @@ -2301,9 +2387,9 @@ func newMetricK8sPodFilesystemUsage(cfg MetricConfig) metricK8sPodFilesystemUsag } type metricK8sPodMemoryAvailable struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodMemoryAvailableMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.memory.available metric with initial data. @@ -2340,7 +2426,7 @@ func (m *metricK8sPodMemoryAvailable) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodMemoryAvailable(cfg MetricConfig) metricK8sPodMemoryAvailable { +func newMetricK8sPodMemoryAvailable(cfg K8sPodMemoryAvailableMetricConfig) metricK8sPodMemoryAvailable { m := metricK8sPodMemoryAvailable{config: cfg} if cfg.Enabled { @@ -2351,9 +2437,9 @@ func newMetricK8sPodMemoryAvailable(cfg MetricConfig) metricK8sPodMemoryAvailabl } type metricK8sPodMemoryMajorPageFaults struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodMemoryMajorPageFaultsMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.memory.major_page_faults metric with initial data. @@ -2390,7 +2476,7 @@ func (m *metricK8sPodMemoryMajorPageFaults) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodMemoryMajorPageFaults(cfg MetricConfig) metricK8sPodMemoryMajorPageFaults { +func newMetricK8sPodMemoryMajorPageFaults(cfg K8sPodMemoryMajorPageFaultsMetricConfig) metricK8sPodMemoryMajorPageFaults { m := metricK8sPodMemoryMajorPageFaults{config: cfg} if cfg.Enabled { @@ -2401,9 +2487,9 @@ func newMetricK8sPodMemoryMajorPageFaults(cfg MetricConfig) metricK8sPodMemoryMa } type metricK8sPodMemoryNodeUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodMemoryNodeUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.memory.node.utilization metric with initial data. @@ -2440,7 +2526,7 @@ func (m *metricK8sPodMemoryNodeUtilization) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodMemoryNodeUtilization(cfg MetricConfig) metricK8sPodMemoryNodeUtilization { +func newMetricK8sPodMemoryNodeUtilization(cfg K8sPodMemoryNodeUtilizationMetricConfig) metricK8sPodMemoryNodeUtilization { m := metricK8sPodMemoryNodeUtilization{config: cfg} if cfg.Enabled { @@ -2451,9 +2537,9 @@ func newMetricK8sPodMemoryNodeUtilization(cfg MetricConfig) metricK8sPodMemoryNo } type metricK8sPodMemoryPageFaults struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodMemoryPageFaultsMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.memory.page_faults metric with initial data. @@ -2490,7 +2576,7 @@ func (m *metricK8sPodMemoryPageFaults) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodMemoryPageFaults(cfg MetricConfig) metricK8sPodMemoryPageFaults { +func newMetricK8sPodMemoryPageFaults(cfg K8sPodMemoryPageFaultsMetricConfig) metricK8sPodMemoryPageFaults { m := metricK8sPodMemoryPageFaults{config: cfg} if cfg.Enabled { @@ -2501,9 +2587,9 @@ func newMetricK8sPodMemoryPageFaults(cfg MetricConfig) metricK8sPodMemoryPageFau } type metricK8sPodMemoryRss struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodMemoryRssMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.memory.rss metric with initial data. @@ -2540,7 +2626,7 @@ func (m *metricK8sPodMemoryRss) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodMemoryRss(cfg MetricConfig) metricK8sPodMemoryRss { +func newMetricK8sPodMemoryRss(cfg K8sPodMemoryRssMetricConfig) metricK8sPodMemoryRss { m := metricK8sPodMemoryRss{config: cfg} if cfg.Enabled { @@ -2551,9 +2637,9 @@ func newMetricK8sPodMemoryRss(cfg MetricConfig) metricK8sPodMemoryRss { } type metricK8sPodMemoryUsage struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodMemoryUsageMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.memory.usage metric with initial data. @@ -2590,7 +2676,7 @@ func (m *metricK8sPodMemoryUsage) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodMemoryUsage(cfg MetricConfig) metricK8sPodMemoryUsage { +func newMetricK8sPodMemoryUsage(cfg K8sPodMemoryUsageMetricConfig) metricK8sPodMemoryUsage { m := metricK8sPodMemoryUsage{config: cfg} if cfg.Enabled { @@ -2601,9 +2687,9 @@ func newMetricK8sPodMemoryUsage(cfg MetricConfig) metricK8sPodMemoryUsage { } type metricK8sPodMemoryWorkingSet struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodMemoryWorkingSetMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.memory.working_set metric with initial data. @@ -2640,7 +2726,7 @@ func (m *metricK8sPodMemoryWorkingSet) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodMemoryWorkingSet(cfg MetricConfig) metricK8sPodMemoryWorkingSet { +func newMetricK8sPodMemoryWorkingSet(cfg K8sPodMemoryWorkingSetMetricConfig) metricK8sPodMemoryWorkingSet { m := metricK8sPodMemoryWorkingSet{config: cfg} if cfg.Enabled { @@ -2651,9 +2737,9 @@ func newMetricK8sPodMemoryWorkingSet(cfg MetricConfig) metricK8sPodMemoryWorking } type metricK8sPodMemoryLimitUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodMemoryLimitUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.memory_limit_utilization metric with initial data. @@ -2690,7 +2776,7 @@ func (m *metricK8sPodMemoryLimitUtilization) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodMemoryLimitUtilization(cfg MetricConfig) metricK8sPodMemoryLimitUtilization { +func newMetricK8sPodMemoryLimitUtilization(cfg K8sPodMemoryLimitUtilizationMetricConfig) metricK8sPodMemoryLimitUtilization { m := metricK8sPodMemoryLimitUtilization{config: cfg} if cfg.Enabled { @@ -2701,9 +2787,9 @@ func newMetricK8sPodMemoryLimitUtilization(cfg MetricConfig) metricK8sPodMemoryL } type metricK8sPodMemoryRequestUtilization struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodMemoryRequestUtilizationMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.memory_request_utilization metric with initial data. @@ -2740,7 +2826,7 @@ func (m *metricK8sPodMemoryRequestUtilization) emit(metrics pmetric.MetricSlice) } } -func newMetricK8sPodMemoryRequestUtilization(cfg MetricConfig) metricK8sPodMemoryRequestUtilization { +func newMetricK8sPodMemoryRequestUtilization(cfg K8sPodMemoryRequestUtilizationMetricConfig) metricK8sPodMemoryRequestUtilization { m := metricK8sPodMemoryRequestUtilization{config: cfg} if cfg.Enabled { @@ -2751,9 +2837,10 @@ func newMetricK8sPodMemoryRequestUtilization(cfg MetricConfig) metricK8sPodMemor } type metricK8sPodNetworkErrors struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodNetworkErrorsMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []int64 // slice containing number of aggregated datapoints at each index } // init fills k8s.pod.network.errors metric with initial data. @@ -2765,18 +2852,51 @@ func (m *metricK8sPodNetworkErrors) init() { m.data.Sum().SetIsMonotonic(true) m.data.Sum().SetAggregationTemporality(pmetric.AggregationTemporalityCumulative) m.data.Sum().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricK8sPodNetworkErrors) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, interfaceAttributeValue string, directionAttributeValue string) { if !m.config.Enabled { return } - dp := m.data.Sum().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, K8sPodNetworkErrorsMetricAttributeKeyInterface) { + dp.Attributes().PutStr("interface", interfaceAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, K8sPodNetworkErrorsMetricAttributeKeyDirection) { + dp.Attributes().PutStr("direction", directionAttributeValue) + } + + var s string + dps := m.data.Sum().DataPoints() + for i := 0; i < dps.Len(); i++ { + dpi := dps.At(i) + if dp.Attributes().Equal(dpi.Attributes()) && dp.StartTimestamp() == dpi.StartTimestamp() && dp.Timestamp() == dpi.Timestamp() { + switch s = m.config.AggregationStrategy; s { + case AggregationStrategySum, AggregationStrategyAvg: + dpi.SetIntValue(dpi.IntValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.IntValue() > val { + dpi.SetIntValue(val) + } + return + case AggregationStrategyMax: + if dpi.IntValue() < val { + dpi.SetIntValue(val) + } + return + } + } + } + dp.SetIntValue(val) - dp.Attributes().PutStr("interface", interfaceAttributeValue) - dp.Attributes().PutStr("direction", directionAttributeValue) + m.aggDataPoints = append(m.aggDataPoints, 1) + dp.MoveTo(dps.AppendEmpty()) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. @@ -2789,13 +2909,18 @@ func (m *metricK8sPodNetworkErrors) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricK8sPodNetworkErrors) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Sum().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Sum().DataPoints().At(i).SetIntValue(m.data.Sum().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() } } -func newMetricK8sPodNetworkErrors(cfg MetricConfig) metricK8sPodNetworkErrors { +func newMetricK8sPodNetworkErrors(cfg K8sPodNetworkErrorsMetricConfig) metricK8sPodNetworkErrors { m := metricK8sPodNetworkErrors{config: cfg} if cfg.Enabled { @@ -2806,9 +2931,10 @@ func newMetricK8sPodNetworkErrors(cfg MetricConfig) metricK8sPodNetworkErrors { } type metricK8sPodNetworkIo struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodNetworkIoMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []int64 // slice containing number of aggregated datapoints at each index } // init fills k8s.pod.network.io metric with initial data. @@ -2820,18 +2946,51 @@ func (m *metricK8sPodNetworkIo) init() { m.data.Sum().SetIsMonotonic(true) m.data.Sum().SetAggregationTemporality(pmetric.AggregationTemporalityCumulative) m.data.Sum().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricK8sPodNetworkIo) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, interfaceAttributeValue string, directionAttributeValue string) { if !m.config.Enabled { return } - dp := m.data.Sum().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, K8sPodNetworkIoMetricAttributeKeyInterface) { + dp.Attributes().PutStr("interface", interfaceAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, K8sPodNetworkIoMetricAttributeKeyDirection) { + dp.Attributes().PutStr("direction", directionAttributeValue) + } + + var s string + dps := m.data.Sum().DataPoints() + for i := 0; i < dps.Len(); i++ { + dpi := dps.At(i) + if dp.Attributes().Equal(dpi.Attributes()) && dp.StartTimestamp() == dpi.StartTimestamp() && dp.Timestamp() == dpi.Timestamp() { + switch s = m.config.AggregationStrategy; s { + case AggregationStrategySum, AggregationStrategyAvg: + dpi.SetIntValue(dpi.IntValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.IntValue() > val { + dpi.SetIntValue(val) + } + return + case AggregationStrategyMax: + if dpi.IntValue() < val { + dpi.SetIntValue(val) + } + return + } + } + } + dp.SetIntValue(val) - dp.Attributes().PutStr("interface", interfaceAttributeValue) - dp.Attributes().PutStr("direction", directionAttributeValue) + m.aggDataPoints = append(m.aggDataPoints, 1) + dp.MoveTo(dps.AppendEmpty()) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. @@ -2844,13 +3003,18 @@ func (m *metricK8sPodNetworkIo) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricK8sPodNetworkIo) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Sum().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Sum().DataPoints().At(i).SetIntValue(m.data.Sum().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() } } -func newMetricK8sPodNetworkIo(cfg MetricConfig) metricK8sPodNetworkIo { +func newMetricK8sPodNetworkIo(cfg K8sPodNetworkIoMetricConfig) metricK8sPodNetworkIo { m := metricK8sPodNetworkIo{config: cfg} if cfg.Enabled { @@ -2861,9 +3025,9 @@ func newMetricK8sPodNetworkIo(cfg MetricConfig) metricK8sPodNetworkIo { } type metricK8sPodUptime struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodUptimeMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.uptime metric with initial data. @@ -2902,7 +3066,7 @@ func (m *metricK8sPodUptime) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodUptime(cfg MetricConfig) metricK8sPodUptime { +func newMetricK8sPodUptime(cfg K8sPodUptimeMetricConfig) metricK8sPodUptime { m := metricK8sPodUptime{config: cfg} if cfg.Enabled { @@ -2913,9 +3077,9 @@ func newMetricK8sPodUptime(cfg MetricConfig) metricK8sPodUptime { } type metricK8sPodVolumeUsage struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sPodVolumeUsageMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.pod.volume.usage metric with initial data. @@ -2954,7 +3118,7 @@ func (m *metricK8sPodVolumeUsage) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sPodVolumeUsage(cfg MetricConfig) metricK8sPodVolumeUsage { +func newMetricK8sPodVolumeUsage(cfg K8sPodVolumeUsageMetricConfig) metricK8sPodVolumeUsage { m := metricK8sPodVolumeUsage{config: cfg} if cfg.Enabled { @@ -2965,9 +3129,9 @@ func newMetricK8sPodVolumeUsage(cfg MetricConfig) metricK8sPodVolumeUsage { } type metricK8sVolumeAvailable struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sVolumeAvailableMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.volume.available metric with initial data. @@ -3004,7 +3168,7 @@ func (m *metricK8sVolumeAvailable) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sVolumeAvailable(cfg MetricConfig) metricK8sVolumeAvailable { +func newMetricK8sVolumeAvailable(cfg K8sVolumeAvailableMetricConfig) metricK8sVolumeAvailable { m := metricK8sVolumeAvailable{config: cfg} if cfg.Enabled { @@ -3015,9 +3179,9 @@ func newMetricK8sVolumeAvailable(cfg MetricConfig) metricK8sVolumeAvailable { } type metricK8sVolumeCapacity struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sVolumeCapacityMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.volume.capacity metric with initial data. @@ -3054,7 +3218,7 @@ func (m *metricK8sVolumeCapacity) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sVolumeCapacity(cfg MetricConfig) metricK8sVolumeCapacity { +func newMetricK8sVolumeCapacity(cfg K8sVolumeCapacityMetricConfig) metricK8sVolumeCapacity { m := metricK8sVolumeCapacity{config: cfg} if cfg.Enabled { @@ -3065,9 +3229,9 @@ func newMetricK8sVolumeCapacity(cfg MetricConfig) metricK8sVolumeCapacity { } type metricK8sVolumeInodes struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sVolumeInodesMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.volume.inodes metric with initial data. @@ -3104,7 +3268,7 @@ func (m *metricK8sVolumeInodes) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sVolumeInodes(cfg MetricConfig) metricK8sVolumeInodes { +func newMetricK8sVolumeInodes(cfg K8sVolumeInodesMetricConfig) metricK8sVolumeInodes { m := metricK8sVolumeInodes{config: cfg} if cfg.Enabled { @@ -3115,9 +3279,9 @@ func newMetricK8sVolumeInodes(cfg MetricConfig) metricK8sVolumeInodes { } type metricK8sVolumeInodesFree struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sVolumeInodesFreeMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.volume.inodes.free metric with initial data. @@ -3154,7 +3318,7 @@ func (m *metricK8sVolumeInodesFree) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sVolumeInodesFree(cfg MetricConfig) metricK8sVolumeInodesFree { +func newMetricK8sVolumeInodesFree(cfg K8sVolumeInodesFreeMetricConfig) metricK8sVolumeInodesFree { m := metricK8sVolumeInodesFree{config: cfg} if cfg.Enabled { @@ -3165,9 +3329,9 @@ func newMetricK8sVolumeInodesFree(cfg MetricConfig) metricK8sVolumeInodesFree { } type metricK8sVolumeInodesUsed struct { - data pmetric.Metric // data buffer for generated metric. - config MetricConfig // metric config provided by user. - capacity int // max observed number of data points added to the metric. + data pmetric.Metric // data buffer for generated metric. + config K8sVolumeInodesUsedMetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. } // init fills k8s.volume.inodes.used metric with initial data. @@ -3204,7 +3368,7 @@ func (m *metricK8sVolumeInodesUsed) emit(metrics pmetric.MetricSlice) { } } -func newMetricK8sVolumeInodesUsed(cfg MetricConfig) metricK8sVolumeInodesUsed { +func newMetricK8sVolumeInodesUsed(cfg K8sVolumeInodesUsedMetricConfig) metricK8sVolumeInodesUsed { m := metricK8sVolumeInodesUsed{config: cfg} if cfg.Enabled { diff --git a/receiver/kubeletstatsreceiver/internal/metadata/generated_metrics_test.go b/receiver/kubeletstatsreceiver/internal/metadata/generated_metrics_test.go index d18022d120ce9..2498a094e94c1 100644 --- a/receiver/kubeletstatsreceiver/internal/metadata/generated_metrics_test.go +++ b/receiver/kubeletstatsreceiver/internal/metadata/generated_metrics_test.go @@ -19,6 +19,7 @@ const ( testDataSetDefault testDataSet = iota testDataSetAll testDataSetNone + testDataSetReag ) func TestMetricsBuilder(t *testing.T) { @@ -36,6 +37,11 @@ func TestMetricsBuilder(t *testing.T) { metricsSet: testDataSetAll, resAttrsSet: testDataSetAll, }, + { + name: "reaggregate_set", + metricsSet: testDataSetReag, + resAttrsSet: testDataSetReag, + }, { name: "none_set", metricsSet: testDataSetNone, @@ -60,6 +66,11 @@ func TestMetricsBuilder(t *testing.T) { settings := receivertest.NewNopSettings(receivertest.NopType) settings.Logger = zap.New(observedZapCore) mb := NewMetricsBuilder(loadMetricsBuilderConfig(t, tt.name), settings, WithStartTime(start)) + aggMap := make(map[string]string) // contains the aggregation strategies for each metric name + aggMap["K8sNodeNetworkErrors"] = mb.metricK8sNodeNetworkErrors.config.AggregationStrategy + aggMap["K8sNodeNetworkIo"] = mb.metricK8sNodeNetworkIo.config.AggregationStrategy + aggMap["K8sPodNetworkErrors"] = mb.metricK8sPodNetworkErrors.config.AggregationStrategy + aggMap["K8sPodNetworkIo"] = mb.metricK8sPodNetworkIo.config.AggregationStrategy expectedWarnings := 0 if tt.resAttrsSet == testDataSetDefault || tt.resAttrsSet == testDataSetAll { @@ -86,7 +97,9 @@ func TestMetricsBuilder(t *testing.T) { assert.Equal(t, "[WARNING] `partition` should not be enabled: This resource_attribute is deprecated and will be removed soon", observedLogs.All()[expectedWarnings].Message) expectedWarnings++ } - assert.Equal(t, expectedWarnings, observedLogs.Len()) + if tt.metricsSet != testDataSetReag { + assert.Equal(t, expectedWarnings, observedLogs.Len()) + } defaultMetricsCount := 0 allMetricsCount := 0 @@ -203,10 +216,16 @@ func TestMetricsBuilder(t *testing.T) { defaultMetricsCount++ allMetricsCount++ mb.RecordK8sNodeNetworkErrorsDataPoint(ts, 1, "interface-val", AttributeDirectionReceive) + if tt.name == "reaggregate_set" { + mb.RecordK8sNodeNetworkErrorsDataPoint(ts, 3, "interface-val-2", AttributeDirectionTransmit) + } defaultMetricsCount++ allMetricsCount++ mb.RecordK8sNodeNetworkIoDataPoint(ts, 1, "interface-val", AttributeDirectionReceive) + if tt.name == "reaggregate_set" { + mb.RecordK8sNodeNetworkIoDataPoint(ts, 3, "interface-val-2", AttributeDirectionTransmit) + } allMetricsCount++ mb.RecordK8sNodeUptimeDataPoint(ts, 1) @@ -276,10 +295,16 @@ func TestMetricsBuilder(t *testing.T) { defaultMetricsCount++ allMetricsCount++ mb.RecordK8sPodNetworkErrorsDataPoint(ts, 1, "interface-val", AttributeDirectionReceive) + if tt.name == "reaggregate_set" { + mb.RecordK8sPodNetworkErrorsDataPoint(ts, 3, "interface-val-2", AttributeDirectionTransmit) + } defaultMetricsCount++ allMetricsCount++ mb.RecordK8sPodNetworkIoDataPoint(ts, 1, "interface-val", AttributeDirectionReceive) + if tt.name == "reaggregate_set" { + mb.RecordK8sPodNetworkIoDataPoint(ts, 3, "interface-val-2", AttributeDirectionTransmit) + } allMetricsCount++ mb.RecordK8sPodUptimeDataPoint(ts, 1) @@ -325,6 +350,12 @@ func TestMetricsBuilder(t *testing.T) { rb.SetPartition("partition-val") res := rb.Emit() metrics := mb.Emit(WithResource(res)) + if tt.name == "reaggregate_set" { + assert.Empty(t, mb.metricK8sNodeNetworkErrors.aggDataPoints) + assert.Empty(t, mb.metricK8sNodeNetworkIo.aggDataPoints) + assert.Empty(t, mb.metricK8sPodNetworkErrors.aggDataPoints) + assert.Empty(t, mb.metricK8sPodNetworkIo.aggDataPoints) + } if tt.expectEmpty { assert.Equal(t, 0, metrics.ResourceMetrics().Len()) @@ -706,45 +737,103 @@ func TestMetricsBuilder(t *testing.T) { assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) assert.Equal(t, int64(1), dp.IntValue()) case "k8s.node.network.errors": - assert.False(t, validatedMetrics["k8s.node.network.errors"], "Found a duplicate in the metrics slice: k8s.node.network.errors") - validatedMetrics["k8s.node.network.errors"] = true - assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) - assert.Equal(t, 1, mi.Sum().DataPoints().Len()) - assert.Equal(t, "Node network errors", mi.Description()) - assert.Equal(t, "1", mi.Unit()) - assert.True(t, mi.Sum().IsMonotonic()) - assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) - dp := mi.Sum().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) - assert.Equal(t, int64(1), dp.IntValue()) - interfaceAttrVal, ok := dp.Attributes().Get("interface") - assert.True(t, ok) - assert.Equal(t, "interface-val", interfaceAttrVal.Str()) - directionAttrVal, ok := dp.Attributes().Get("direction") - assert.True(t, ok) - assert.Equal(t, "receive", directionAttrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["k8s.node.network.errors"], "Found a duplicate in the metrics slice: k8s.node.network.errors") + validatedMetrics["k8s.node.network.errors"] = true + assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) + assert.Equal(t, 1, mi.Sum().DataPoints().Len()) + assert.Equal(t, "Node network errors", mi.Description()) + assert.Equal(t, "1", mi.Unit()) + assert.True(t, mi.Sum().IsMonotonic()) + assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) + dp := mi.Sum().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + assert.Equal(t, int64(1), dp.IntValue()) + interfaceAttrVal, ok := dp.Attributes().Get("interface") + assert.True(t, ok) + assert.Equal(t, "interface-val", interfaceAttrVal.Str()) + directionAttrVal, ok := dp.Attributes().Get("direction") + assert.True(t, ok) + assert.Equal(t, "receive", directionAttrVal.Str()) + } else { + assert.False(t, validatedMetrics["k8s.node.network.errors"], "Found a duplicate in the metrics slice: k8s.node.network.errors") + validatedMetrics["k8s.node.network.errors"] = true + assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) + assert.Equal(t, 1, mi.Sum().DataPoints().Len()) + assert.Equal(t, "Node network errors", mi.Description()) + assert.Equal(t, "1", mi.Unit()) + assert.True(t, mi.Sum().IsMonotonic()) + assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) + dp := mi.Sum().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["k8s.node.network.errors"] { + case "sum": + assert.Equal(t, int64(4), dp.IntValue()) + case "avg": + assert.Equal(t, int64(2), dp.IntValue()) + case "min": + assert.Equal(t, int64(1), dp.IntValue()) + case "max": + assert.Equal(t, int64(3), dp.IntValue()) + } + _, ok := dp.Attributes().Get("interface") + assert.False(t, ok) + _, ok = dp.Attributes().Get("direction") + assert.False(t, ok) + } case "k8s.node.network.io": - assert.False(t, validatedMetrics["k8s.node.network.io"], "Found a duplicate in the metrics slice: k8s.node.network.io") - validatedMetrics["k8s.node.network.io"] = true - assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) - assert.Equal(t, 1, mi.Sum().DataPoints().Len()) - assert.Equal(t, "Node network IO", mi.Description()) - assert.Equal(t, "By", mi.Unit()) - assert.True(t, mi.Sum().IsMonotonic()) - assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) - dp := mi.Sum().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) - assert.Equal(t, int64(1), dp.IntValue()) - interfaceAttrVal, ok := dp.Attributes().Get("interface") - assert.True(t, ok) - assert.Equal(t, "interface-val", interfaceAttrVal.Str()) - directionAttrVal, ok := dp.Attributes().Get("direction") - assert.True(t, ok) - assert.Equal(t, "receive", directionAttrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["k8s.node.network.io"], "Found a duplicate in the metrics slice: k8s.node.network.io") + validatedMetrics["k8s.node.network.io"] = true + assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) + assert.Equal(t, 1, mi.Sum().DataPoints().Len()) + assert.Equal(t, "Node network IO", mi.Description()) + assert.Equal(t, "By", mi.Unit()) + assert.True(t, mi.Sum().IsMonotonic()) + assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) + dp := mi.Sum().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + assert.Equal(t, int64(1), dp.IntValue()) + interfaceAttrVal, ok := dp.Attributes().Get("interface") + assert.True(t, ok) + assert.Equal(t, "interface-val", interfaceAttrVal.Str()) + directionAttrVal, ok := dp.Attributes().Get("direction") + assert.True(t, ok) + assert.Equal(t, "receive", directionAttrVal.Str()) + } else { + assert.False(t, validatedMetrics["k8s.node.network.io"], "Found a duplicate in the metrics slice: k8s.node.network.io") + validatedMetrics["k8s.node.network.io"] = true + assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) + assert.Equal(t, 1, mi.Sum().DataPoints().Len()) + assert.Equal(t, "Node network IO", mi.Description()) + assert.Equal(t, "By", mi.Unit()) + assert.True(t, mi.Sum().IsMonotonic()) + assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) + dp := mi.Sum().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["k8s.node.network.io"] { + case "sum": + assert.Equal(t, int64(4), dp.IntValue()) + case "avg": + assert.Equal(t, int64(2), dp.IntValue()) + case "min": + assert.Equal(t, int64(1), dp.IntValue()) + case "max": + assert.Equal(t, int64(3), dp.IntValue()) + } + _, ok := dp.Attributes().Get("interface") + assert.False(t, ok) + _, ok = dp.Attributes().Get("direction") + assert.False(t, ok) + } case "k8s.node.uptime": assert.False(t, validatedMetrics["k8s.node.uptime"], "Found a duplicate in the metrics slice: k8s.node.uptime") validatedMetrics["k8s.node.uptime"] = true @@ -966,45 +1055,103 @@ func TestMetricsBuilder(t *testing.T) { assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) case "k8s.pod.network.errors": - assert.False(t, validatedMetrics["k8s.pod.network.errors"], "Found a duplicate in the metrics slice: k8s.pod.network.errors") - validatedMetrics["k8s.pod.network.errors"] = true - assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) - assert.Equal(t, 1, mi.Sum().DataPoints().Len()) - assert.Equal(t, "Pod network errors", mi.Description()) - assert.Equal(t, "1", mi.Unit()) - assert.True(t, mi.Sum().IsMonotonic()) - assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) - dp := mi.Sum().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) - assert.Equal(t, int64(1), dp.IntValue()) - interfaceAttrVal, ok := dp.Attributes().Get("interface") - assert.True(t, ok) - assert.Equal(t, "interface-val", interfaceAttrVal.Str()) - directionAttrVal, ok := dp.Attributes().Get("direction") - assert.True(t, ok) - assert.Equal(t, "receive", directionAttrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["k8s.pod.network.errors"], "Found a duplicate in the metrics slice: k8s.pod.network.errors") + validatedMetrics["k8s.pod.network.errors"] = true + assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) + assert.Equal(t, 1, mi.Sum().DataPoints().Len()) + assert.Equal(t, "Pod network errors", mi.Description()) + assert.Equal(t, "1", mi.Unit()) + assert.True(t, mi.Sum().IsMonotonic()) + assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) + dp := mi.Sum().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + assert.Equal(t, int64(1), dp.IntValue()) + interfaceAttrVal, ok := dp.Attributes().Get("interface") + assert.True(t, ok) + assert.Equal(t, "interface-val", interfaceAttrVal.Str()) + directionAttrVal, ok := dp.Attributes().Get("direction") + assert.True(t, ok) + assert.Equal(t, "receive", directionAttrVal.Str()) + } else { + assert.False(t, validatedMetrics["k8s.pod.network.errors"], "Found a duplicate in the metrics slice: k8s.pod.network.errors") + validatedMetrics["k8s.pod.network.errors"] = true + assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) + assert.Equal(t, 1, mi.Sum().DataPoints().Len()) + assert.Equal(t, "Pod network errors", mi.Description()) + assert.Equal(t, "1", mi.Unit()) + assert.True(t, mi.Sum().IsMonotonic()) + assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) + dp := mi.Sum().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["k8s.pod.network.errors"] { + case "sum": + assert.Equal(t, int64(4), dp.IntValue()) + case "avg": + assert.Equal(t, int64(2), dp.IntValue()) + case "min": + assert.Equal(t, int64(1), dp.IntValue()) + case "max": + assert.Equal(t, int64(3), dp.IntValue()) + } + _, ok := dp.Attributes().Get("interface") + assert.False(t, ok) + _, ok = dp.Attributes().Get("direction") + assert.False(t, ok) + } case "k8s.pod.network.io": - assert.False(t, validatedMetrics["k8s.pod.network.io"], "Found a duplicate in the metrics slice: k8s.pod.network.io") - validatedMetrics["k8s.pod.network.io"] = true - assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) - assert.Equal(t, 1, mi.Sum().DataPoints().Len()) - assert.Equal(t, "Pod network IO", mi.Description()) - assert.Equal(t, "By", mi.Unit()) - assert.True(t, mi.Sum().IsMonotonic()) - assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) - dp := mi.Sum().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) - assert.Equal(t, int64(1), dp.IntValue()) - interfaceAttrVal, ok := dp.Attributes().Get("interface") - assert.True(t, ok) - assert.Equal(t, "interface-val", interfaceAttrVal.Str()) - directionAttrVal, ok := dp.Attributes().Get("direction") - assert.True(t, ok) - assert.Equal(t, "receive", directionAttrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["k8s.pod.network.io"], "Found a duplicate in the metrics slice: k8s.pod.network.io") + validatedMetrics["k8s.pod.network.io"] = true + assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) + assert.Equal(t, 1, mi.Sum().DataPoints().Len()) + assert.Equal(t, "Pod network IO", mi.Description()) + assert.Equal(t, "By", mi.Unit()) + assert.True(t, mi.Sum().IsMonotonic()) + assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) + dp := mi.Sum().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + assert.Equal(t, int64(1), dp.IntValue()) + interfaceAttrVal, ok := dp.Attributes().Get("interface") + assert.True(t, ok) + assert.Equal(t, "interface-val", interfaceAttrVal.Str()) + directionAttrVal, ok := dp.Attributes().Get("direction") + assert.True(t, ok) + assert.Equal(t, "receive", directionAttrVal.Str()) + } else { + assert.False(t, validatedMetrics["k8s.pod.network.io"], "Found a duplicate in the metrics slice: k8s.pod.network.io") + validatedMetrics["k8s.pod.network.io"] = true + assert.Equal(t, pmetric.MetricTypeSum, mi.Type()) + assert.Equal(t, 1, mi.Sum().DataPoints().Len()) + assert.Equal(t, "Pod network IO", mi.Description()) + assert.Equal(t, "By", mi.Unit()) + assert.True(t, mi.Sum().IsMonotonic()) + assert.Equal(t, pmetric.AggregationTemporalityCumulative, mi.Sum().AggregationTemporality()) + dp := mi.Sum().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["k8s.pod.network.io"] { + case "sum": + assert.Equal(t, int64(4), dp.IntValue()) + case "avg": + assert.Equal(t, int64(2), dp.IntValue()) + case "min": + assert.Equal(t, int64(1), dp.IntValue()) + case "max": + assert.Equal(t, int64(3), dp.IntValue()) + } + _, ok := dp.Attributes().Get("interface") + assert.False(t, ok) + _, ok = dp.Attributes().Get("direction") + assert.False(t, ok) + } case "k8s.pod.uptime": assert.False(t, validatedMetrics["k8s.pod.uptime"], "Found a duplicate in the metrics slice: k8s.pod.uptime") validatedMetrics["k8s.pod.uptime"] = true diff --git a/receiver/kubeletstatsreceiver/internal/metadata/testdata/config.yaml b/receiver/kubeletstatsreceiver/internal/metadata/testdata/config.yaml index d43052cd4e630..a31f05c4c11ae 100644 --- a/receiver/kubeletstatsreceiver/internal/metadata/testdata/config.yaml +++ b/receiver/kubeletstatsreceiver/internal/metadata/testdata/config.yaml @@ -61,8 +61,10 @@ all_set: enabled: true k8s.node.network.errors: enabled: true + attributes: ["interface","direction"] k8s.node.network.io: enabled: true + attributes: ["interface","direction"] k8s.node.uptime: enabled: true k8s.pod.cpu.node.utilization: @@ -101,8 +103,163 @@ all_set: enabled: true k8s.pod.network.errors: enabled: true + attributes: ["interface","direction"] k8s.pod.network.io: enabled: true + attributes: ["interface","direction"] + k8s.pod.uptime: + enabled: true + k8s.pod.volume.usage: + enabled: true + k8s.volume.available: + enabled: true + k8s.volume.capacity: + enabled: true + k8s.volume.inodes: + enabled: true + k8s.volume.inodes.free: + enabled: true + k8s.volume.inodes.used: + enabled: true + resource_attributes: + aws.volume.id: + enabled: true + container.id: + enabled: true + fs.type: + enabled: true + gce.pd.name: + enabled: true + glusterfs.endpoints.name: + enabled: true + glusterfs.path: + enabled: true + k8s.container.name: + enabled: true + k8s.namespace.name: + enabled: true + k8s.node.name: + enabled: true + k8s.persistentvolumeclaim.name: + enabled: true + k8s.pod.name: + enabled: true + k8s.pod.uid: + enabled: true + k8s.volume.name: + enabled: true + k8s.volume.type: + enabled: true + partition: + enabled: true +reaggregate_set: + metrics: + container.cpu.time: + enabled: true + container.cpu.usage: + enabled: true + container.filesystem.available: + enabled: true + container.filesystem.capacity: + enabled: true + container.filesystem.usage: + enabled: true + container.memory.available: + enabled: true + container.memory.major_page_faults: + enabled: true + container.memory.page_faults: + enabled: true + container.memory.rss: + enabled: true + container.memory.usage: + enabled: true + container.memory.working_set: + enabled: true + container.uptime: + enabled: true + k8s.container.cpu.node.utilization: + enabled: true + k8s.container.cpu_limit_utilization: + enabled: true + k8s.container.cpu_request_utilization: + enabled: true + k8s.container.memory.node.utilization: + enabled: true + k8s.container.memory_limit_utilization: + enabled: true + k8s.container.memory_request_utilization: + enabled: true + k8s.node.cpu.time: + enabled: true + k8s.node.cpu.usage: + enabled: true + k8s.node.filesystem.available: + enabled: true + k8s.node.filesystem.capacity: + enabled: true + k8s.node.filesystem.usage: + enabled: true + k8s.node.memory.available: + enabled: true + k8s.node.memory.major_page_faults: + enabled: true + k8s.node.memory.page_faults: + enabled: true + k8s.node.memory.rss: + enabled: true + k8s.node.memory.usage: + enabled: true + k8s.node.memory.working_set: + enabled: true + k8s.node.network.errors: + enabled: true + attributes: [] + k8s.node.network.io: + enabled: true + attributes: [] + k8s.node.uptime: + enabled: true + k8s.pod.cpu.node.utilization: + enabled: true + k8s.pod.cpu.time: + enabled: true + k8s.pod.cpu.usage: + enabled: true + k8s.pod.cpu_limit_utilization: + enabled: true + k8s.pod.cpu_request_utilization: + enabled: true + k8s.pod.filesystem.available: + enabled: true + k8s.pod.filesystem.capacity: + enabled: true + k8s.pod.filesystem.usage: + enabled: true + k8s.pod.memory.available: + enabled: true + k8s.pod.memory.major_page_faults: + enabled: true + k8s.pod.memory.node.utilization: + enabled: true + k8s.pod.memory.page_faults: + enabled: true + k8s.pod.memory.rss: + enabled: true + k8s.pod.memory.usage: + enabled: true + k8s.pod.memory.working_set: + enabled: true + k8s.pod.memory_limit_utilization: + enabled: true + k8s.pod.memory_request_utilization: + enabled: true + k8s.pod.network.errors: + enabled: true + attributes: [] + k8s.pod.network.io: + enabled: true + attributes: [] k8s.pod.uptime: enabled: true k8s.pod.volume.usage: @@ -210,8 +367,10 @@ none_set: enabled: false k8s.node.network.errors: enabled: false + attributes: ["interface","direction"] k8s.node.network.io: enabled: false + attributes: ["interface","direction"] k8s.node.uptime: enabled: false k8s.pod.cpu.node.utilization: @@ -250,8 +409,10 @@ none_set: enabled: false k8s.pod.network.errors: enabled: false + attributes: ["interface","direction"] k8s.pod.network.io: enabled: false + attributes: ["interface","direction"] k8s.pod.uptime: enabled: false k8s.pod.volume.usage: diff --git a/receiver/kubeletstatsreceiver/metadata.yaml b/receiver/kubeletstatsreceiver/metadata.yaml index 051f64564ab20..7f3cdc0c740e2 100644 --- a/receiver/kubeletstatsreceiver/metadata.yaml +++ b/receiver/kubeletstatsreceiver/metadata.yaml @@ -5,6 +5,8 @@ description: | The Kubelet Stats Receiver pulls node, pod, container, and volume metrics from the API server on a kubelet and sends it down the metric pipeline for further processing. +reaggregation_enabled: true + status: class: receiver stability: @@ -84,6 +86,7 @@ resource_attributes: partition: description: "[DEPRECATED] The partition in the Volume" enabled: true + requirement_level: recommended type: string warnings: if_enabled: "This resource_attribute is deprecated and will be removed soon" @@ -92,9 +95,11 @@ attributes: description: Direction of flow of bytes/operations (receive or transmit). type: string enum: [receive, transmit] + requirement_level: recommended interface: description: Name of the network interface. type: string + requirement_level: recommended metrics: container.cpu.time: diff --git a/receiver/kubeletstatsreceiver/scraper_test.go b/receiver/kubeletstatsreceiver/scraper_test.go index ac85ac62f2a28..f3497a9e59ca7 100644 --- a/receiver/kubeletstatsreceiver/scraper_test.go +++ b/receiver/kubeletstatsreceiver/scraper_test.go @@ -153,10 +153,10 @@ func TestScraperWithCPUNodeUtilization(t *testing.T) { options, metadata.MetricsBuilderConfig{ Metrics: metadata.MetricsConfig{ - K8sContainerCPUNodeUtilization: metadata.MetricConfig{ + K8sContainerCPUNodeUtilization: metadata.K8sContainerCPUNodeUtilizationMetricConfig{ Enabled: true, }, - K8sPodCPUNodeUtilization: metadata.MetricConfig{ + K8sPodCPUNodeUtilization: metadata.K8sPodCPUNodeUtilizationMetricConfig{ Enabled: true, }, }, @@ -233,9 +233,9 @@ func TestScraperWithMemoryNodeUtilization(t *testing.T) { options, metadata.MetricsBuilderConfig{ Metrics: metadata.MetricsConfig{ - K8sContainerMemoryNodeUtilization: metadata.MetricConfig{ + K8sContainerMemoryNodeUtilization: metadata.K8sContainerMemoryNodeUtilizationMetricConfig{ Enabled: true, - }, K8sPodMemoryNodeUtilization: metadata.MetricConfig{ + }, K8sPodMemoryNodeUtilization: metadata.K8sPodMemoryNodeUtilizationMetricConfig{ Enabled: true, }, }, @@ -358,148 +358,148 @@ func TestScraperWithPercentMetrics(t *testing.T) { } metricsConfig := metadata.MetricsBuilderConfig{ Metrics: metadata.MetricsConfig{ - ContainerCPUTime: metadata.MetricConfig{ + ContainerCPUTime: metadata.ContainerCPUTimeMetricConfig{ Enabled: false, }, - ContainerFilesystemAvailable: metadata.MetricConfig{ + ContainerFilesystemAvailable: metadata.ContainerFilesystemAvailableMetricConfig{ Enabled: false, }, - ContainerFilesystemCapacity: metadata.MetricConfig{ + ContainerFilesystemCapacity: metadata.ContainerFilesystemCapacityMetricConfig{ Enabled: false, }, - ContainerFilesystemUsage: metadata.MetricConfig{ + ContainerFilesystemUsage: metadata.ContainerFilesystemUsageMetricConfig{ Enabled: false, }, - ContainerMemoryAvailable: metadata.MetricConfig{ + ContainerMemoryAvailable: metadata.ContainerMemoryAvailableMetricConfig{ Enabled: false, }, - ContainerMemoryMajorPageFaults: metadata.MetricConfig{ + ContainerMemoryMajorPageFaults: metadata.ContainerMemoryMajorPageFaultsMetricConfig{ Enabled: false, }, - ContainerMemoryPageFaults: metadata.MetricConfig{ + ContainerMemoryPageFaults: metadata.ContainerMemoryPageFaultsMetricConfig{ Enabled: false, }, - ContainerMemoryRss: metadata.MetricConfig{ + ContainerMemoryRss: metadata.ContainerMemoryRssMetricConfig{ Enabled: false, }, - ContainerMemoryUsage: metadata.MetricConfig{ + ContainerMemoryUsage: metadata.ContainerMemoryUsageMetricConfig{ Enabled: false, }, - K8sContainerCPULimitUtilization: metadata.MetricConfig{ + K8sContainerCPULimitUtilization: metadata.K8sContainerCPULimitUtilizationMetricConfig{ Enabled: true, }, - K8sContainerCPURequestUtilization: metadata.MetricConfig{ + K8sContainerCPURequestUtilization: metadata.K8sContainerCPURequestUtilizationMetricConfig{ Enabled: true, }, - K8sContainerMemoryLimitUtilization: metadata.MetricConfig{ + K8sContainerMemoryLimitUtilization: metadata.K8sContainerMemoryLimitUtilizationMetricConfig{ Enabled: true, }, - K8sContainerMemoryRequestUtilization: metadata.MetricConfig{ + K8sContainerMemoryRequestUtilization: metadata.K8sContainerMemoryRequestUtilizationMetricConfig{ Enabled: true, }, - ContainerMemoryWorkingSet: metadata.MetricConfig{ + ContainerMemoryWorkingSet: metadata.ContainerMemoryWorkingSetMetricConfig{ Enabled: false, }, - K8sNodeCPUTime: metadata.MetricConfig{ + K8sNodeCPUTime: metadata.K8sNodeCPUTimeMetricConfig{ Enabled: false, }, - K8sNodeFilesystemAvailable: metadata.MetricConfig{ + K8sNodeFilesystemAvailable: metadata.K8sNodeFilesystemAvailableMetricConfig{ Enabled: false, }, - K8sNodeFilesystemCapacity: metadata.MetricConfig{ + K8sNodeFilesystemCapacity: metadata.K8sNodeFilesystemCapacityMetricConfig{ Enabled: false, }, - K8sNodeFilesystemUsage: metadata.MetricConfig{ + K8sNodeFilesystemUsage: metadata.K8sNodeFilesystemUsageMetricConfig{ Enabled: false, }, - K8sNodeMemoryAvailable: metadata.MetricConfig{ + K8sNodeMemoryAvailable: metadata.K8sNodeMemoryAvailableMetricConfig{ Enabled: false, }, - K8sNodeMemoryMajorPageFaults: metadata.MetricConfig{ + K8sNodeMemoryMajorPageFaults: metadata.K8sNodeMemoryMajorPageFaultsMetricConfig{ Enabled: false, }, - K8sNodeMemoryPageFaults: metadata.MetricConfig{ + K8sNodeMemoryPageFaults: metadata.K8sNodeMemoryPageFaultsMetricConfig{ Enabled: false, }, - K8sNodeMemoryRss: metadata.MetricConfig{ + K8sNodeMemoryRss: metadata.K8sNodeMemoryRssMetricConfig{ Enabled: false, }, - K8sNodeMemoryUsage: metadata.MetricConfig{ + K8sNodeMemoryUsage: metadata.K8sNodeMemoryUsageMetricConfig{ Enabled: false, }, - K8sNodeMemoryWorkingSet: metadata.MetricConfig{ + K8sNodeMemoryWorkingSet: metadata.K8sNodeMemoryWorkingSetMetricConfig{ Enabled: false, }, - K8sNodeNetworkErrors: metadata.MetricConfig{ + K8sNodeNetworkErrors: metadata.K8sNodeNetworkErrorsMetricConfig{ Enabled: false, }, - K8sNodeNetworkIo: metadata.MetricConfig{ + K8sNodeNetworkIo: metadata.K8sNodeNetworkIoMetricConfig{ Enabled: false, }, - K8sPodCPUTime: metadata.MetricConfig{ + K8sPodCPUTime: metadata.K8sPodCPUTimeMetricConfig{ Enabled: false, }, - K8sPodFilesystemAvailable: metadata.MetricConfig{ + K8sPodFilesystemAvailable: metadata.K8sPodFilesystemAvailableMetricConfig{ Enabled: false, }, - K8sPodFilesystemCapacity: metadata.MetricConfig{ + K8sPodFilesystemCapacity: metadata.K8sPodFilesystemCapacityMetricConfig{ Enabled: false, }, - K8sPodFilesystemUsage: metadata.MetricConfig{ + K8sPodFilesystemUsage: metadata.K8sPodFilesystemUsageMetricConfig{ Enabled: false, }, - K8sPodMemoryAvailable: metadata.MetricConfig{ + K8sPodMemoryAvailable: metadata.K8sPodMemoryAvailableMetricConfig{ Enabled: false, }, - K8sPodMemoryMajorPageFaults: metadata.MetricConfig{ + K8sPodMemoryMajorPageFaults: metadata.K8sPodMemoryMajorPageFaultsMetricConfig{ Enabled: false, }, - K8sPodMemoryPageFaults: metadata.MetricConfig{ + K8sPodMemoryPageFaults: metadata.K8sPodMemoryPageFaultsMetricConfig{ Enabled: false, }, - K8sPodMemoryRss: metadata.MetricConfig{ + K8sPodMemoryRss: metadata.K8sPodMemoryRssMetricConfig{ Enabled: false, }, - K8sPodMemoryUsage: metadata.MetricConfig{ + K8sPodMemoryUsage: metadata.K8sPodMemoryUsageMetricConfig{ Enabled: false, }, - K8sPodCPULimitUtilization: metadata.MetricConfig{ + K8sPodCPULimitUtilization: metadata.K8sPodCPULimitUtilizationMetricConfig{ Enabled: true, }, - K8sPodCPURequestUtilization: metadata.MetricConfig{ + K8sPodCPURequestUtilization: metadata.K8sPodCPURequestUtilizationMetricConfig{ Enabled: true, }, - K8sPodMemoryLimitUtilization: metadata.MetricConfig{ + K8sPodMemoryLimitUtilization: metadata.K8sPodMemoryLimitUtilizationMetricConfig{ Enabled: true, }, - K8sPodMemoryRequestUtilization: metadata.MetricConfig{ + K8sPodMemoryRequestUtilization: metadata.K8sPodMemoryRequestUtilizationMetricConfig{ Enabled: true, }, - K8sPodMemoryWorkingSet: metadata.MetricConfig{ + K8sPodMemoryWorkingSet: metadata.K8sPodMemoryWorkingSetMetricConfig{ Enabled: false, }, - K8sPodNetworkErrors: metadata.MetricConfig{ + K8sPodNetworkErrors: metadata.K8sPodNetworkErrorsMetricConfig{ Enabled: false, }, - K8sPodNetworkIo: metadata.MetricConfig{ + K8sPodNetworkIo: metadata.K8sPodNetworkIoMetricConfig{ Enabled: false, }, - K8sVolumeAvailable: metadata.MetricConfig{ + K8sVolumeAvailable: metadata.K8sVolumeAvailableMetricConfig{ Enabled: false, }, - K8sVolumeCapacity: metadata.MetricConfig{ + K8sVolumeCapacity: metadata.K8sVolumeCapacityMetricConfig{ Enabled: false, }, - K8sPodVolumeUsage: metadata.MetricConfig{ + K8sPodVolumeUsage: metadata.K8sPodVolumeUsageMetricConfig{ Enabled: false, }, - K8sVolumeInodes: metadata.MetricConfig{ + K8sVolumeInodes: metadata.K8sVolumeInodesMetricConfig{ Enabled: false, }, - K8sVolumeInodesFree: metadata.MetricConfig{ + K8sVolumeInodesFree: metadata.K8sVolumeInodesFreeMetricConfig{ Enabled: false, }, - K8sVolumeInodesUsed: metadata.MetricConfig{ + K8sVolumeInodesUsed: metadata.K8sVolumeInodesUsedMetricConfig{ Enabled: false, }, },