From bb77515084992ca32426926653247bd4cb534414 Mon Sep 17 00:00:00 2001 From: shalper2 Date: Tue, 13 Jan 2026 14:28:59 -0600 Subject: [PATCH 1/5] enabled reagg, fixed golden --- .../internal/metadata/generated_config.go | 286 ++ .../metadata/generated_config_test.go | 612 ++- .../internal/metadata/generated_metrics.go | 2794 ++++++++++-- .../metadata/generated_metrics_test.go | 3798 ++++++++++++----- .../internal/metadata/testdata/config.yaml | 257 ++ .../splunkenterprisereceiver/metadata.yaml | 22 +- .../testdata/scraper/expected.yaml | 152 - 7 files changed, 6256 insertions(+), 1665 deletions(-) diff --git a/receiver/splunkenterprisereceiver/internal/metadata/generated_config.go b/receiver/splunkenterprisereceiver/internal/metadata/generated_config.go index 724d4aa79983e..904a23a2ee794 100644 --- a/receiver/splunkenterprisereceiver/internal/metadata/generated_config.go +++ b/receiver/splunkenterprisereceiver/internal/metadata/generated_config.go @@ -3,6 +3,9 @@ package metadata import ( + "fmt" + "slices" + "go.opentelemetry.io/collector/confmap" ) @@ -10,6 +13,11 @@ import ( type MetricConfig struct { Enabled bool `mapstructure:"enabled"` enabledSetByUser bool + + AggregationStrategy string `mapstructure:"aggregation_strategy"` + EnabledAttributes []string `mapstructure:"attributes"` + definedAttributes []string + requiredAttributes []string } func (ms *MetricConfig) Unmarshal(parser *confmap.Conf) error { @@ -21,11 +29,34 @@ func (ms *MetricConfig) Unmarshal(parser *confmap.Conf) error { if err != nil { return err } + for _, val := range ms.EnabledAttributes { + if !slices.Contains(ms.definedAttributes, val) { + return fmt.Errorf("%v is not defined in metadata.yaml", val) + } + } + + for _, val := range ms.requiredAttributes { + if !slices.Contains(ms.EnabledAttributes, val) { + return fmt.Errorf("`attributes` field must contain required attribute: %v", val) + } + } + + if ms.AggregationStrategy != AggregationStrategySum && + ms.AggregationStrategy != AggregationStrategyAvg && + ms.AggregationStrategy != AggregationStrategyMin && + ms.AggregationStrategy != AggregationStrategyMax { + return fmt.Errorf("invalid aggregation strategy set: '%v'", ms.AggregationStrategy) + } ms.enabledSetByUser = parser.IsSet("enabled") return nil } +// AttributeConfig holds configuration information for a particular metric. +type AttributeConfig struct { + Enabled bool `mapstructure:"enabled"` +} + // MetricsConfig provides config for splunkenterprise metrics. type MetricsConfig struct { SplunkAggregationQueueRatio MetricConfig `mapstructure:"splunk.aggregation.queue.ratio"` @@ -85,156 +116,411 @@ func DefaultMetricsConfig() MetricsConfig { return MetricsConfig{ SplunkAggregationQueueRatio: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkBucketsSearchableStatus: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.indexer.searchable", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.indexer.searchable", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkDataIndexesExtendedBucketCount: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkDataIndexesExtendedBucketEventCount: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkDataIndexesExtendedBucketHotCount: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkDataIndexesExtendedBucketWarmCount: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkDataIndexesExtendedEventCount: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkDataIndexesExtendedRawSize: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkDataIndexesExtendedTotalSize: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkHealth: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.feature", "splunk.feature.health", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.feature", "splunk.feature.health", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIndexerAvgRate: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIndexerCPUTime: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIndexerQueueRatio: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIndexerRawWriteTime: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIndexerRollingrestartStatus: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.searchable.restart", "splunk.rollingorrestart", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.searchable.restart", "splunk.rollingorrestart", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIndexerThroughput: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.indexer.status", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.indexer.status", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIndexesAvgSize: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIndexesAvgUsage: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIndexesBucketCount: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIndexesMedianDataAge: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIndexesSize: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkIoAvgIops: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkKvstoreBackupStatus: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkKvstoreReplicationStatus: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkKvstoreStatus: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.kvstore.storage.engine", "splunk.kvstore.external", "splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.kvstore.storage.engine", "splunk.kvstore.external", "splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkLicenseExpirationSecondsRemaining: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.license.status", "splunk.license.label", "splunk.license.type", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.license.status", "splunk.license.label", "splunk.license.type", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkLicenseIndexUsage: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkParseQueueRatio: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkPipelineSetCount: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkSchedulerAvgExecutionLatency: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkSchedulerAvgRunTime: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkSchedulerCompletionRatio: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkSearchDuration: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkSearchInitiation: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkSearchStatus: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.search.state", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.search.state", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkSearchSuccess: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerIntrospectionQueuesCurrent: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.queue.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.queue.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerIntrospectionQueuesCurrentBytes: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.queue.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.queue.name", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsAdhoc: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsAdhocSize: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsCompleted: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsCompletedSize: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsIncomplete: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsIncompleteSize: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsInvalid: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsJobCacheCount: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsJobCacheSize: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.searchartifacts.cache.type", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.searchartifacts.cache.type", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsSavedsearches: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsScheduled: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkServerSearchartifactsScheduledSize: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, SplunkTypingQueueRatio: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, }, } } diff --git a/receiver/splunkenterprisereceiver/internal/metadata/generated_config_test.go b/receiver/splunkenterprisereceiver/internal/metadata/generated_config_test.go index 2ebe38dd575b5..b3cefb931fc49 100644 --- a/receiver/splunkenterprisereceiver/internal/metadata/generated_config_test.go +++ b/receiver/splunkenterprisereceiver/internal/metadata/generated_config_test.go @@ -26,57 +26,261 @@ func TestMetricsBuilderConfig(t *testing.T) { name: "all_set", want: MetricsBuilderConfig{ Metrics: MetricsConfig{ - SplunkAggregationQueueRatio: MetricConfig{Enabled: true}, - SplunkBucketsSearchableStatus: MetricConfig{Enabled: true}, - SplunkDataIndexesExtendedBucketCount: MetricConfig{Enabled: true}, - SplunkDataIndexesExtendedBucketEventCount: MetricConfig{Enabled: true}, - SplunkDataIndexesExtendedBucketHotCount: MetricConfig{Enabled: true}, - SplunkDataIndexesExtendedBucketWarmCount: MetricConfig{Enabled: true}, - SplunkDataIndexesExtendedEventCount: MetricConfig{Enabled: true}, - SplunkDataIndexesExtendedRawSize: MetricConfig{Enabled: true}, - SplunkDataIndexesExtendedTotalSize: MetricConfig{Enabled: true}, - SplunkHealth: MetricConfig{Enabled: true}, - SplunkIndexerAvgRate: MetricConfig{Enabled: true}, - SplunkIndexerCPUTime: MetricConfig{Enabled: true}, - SplunkIndexerQueueRatio: MetricConfig{Enabled: true}, - SplunkIndexerRawWriteTime: MetricConfig{Enabled: true}, - SplunkIndexerRollingrestartStatus: MetricConfig{Enabled: true}, - SplunkIndexerThroughput: MetricConfig{Enabled: true}, - SplunkIndexesAvgSize: MetricConfig{Enabled: true}, - SplunkIndexesAvgUsage: MetricConfig{Enabled: true}, - SplunkIndexesBucketCount: MetricConfig{Enabled: true}, - SplunkIndexesMedianDataAge: MetricConfig{Enabled: true}, - SplunkIndexesSize: MetricConfig{Enabled: true}, - SplunkIoAvgIops: MetricConfig{Enabled: true}, - SplunkKvstoreBackupStatus: MetricConfig{Enabled: true}, - SplunkKvstoreReplicationStatus: MetricConfig{Enabled: true}, - SplunkKvstoreStatus: MetricConfig{Enabled: true}, - SplunkLicenseExpirationSecondsRemaining: MetricConfig{Enabled: true}, - SplunkLicenseIndexUsage: MetricConfig{Enabled: true}, - SplunkParseQueueRatio: MetricConfig{Enabled: true}, - SplunkPipelineSetCount: MetricConfig{Enabled: true}, - SplunkSchedulerAvgExecutionLatency: MetricConfig{Enabled: true}, - SplunkSchedulerAvgRunTime: MetricConfig{Enabled: true}, - SplunkSchedulerCompletionRatio: MetricConfig{Enabled: true}, - SplunkSearchDuration: MetricConfig{Enabled: true}, - SplunkSearchInitiation: MetricConfig{Enabled: true}, - SplunkSearchStatus: MetricConfig{Enabled: true}, - SplunkSearchSuccess: MetricConfig{Enabled: true}, - SplunkServerIntrospectionQueuesCurrent: MetricConfig{Enabled: true}, - SplunkServerIntrospectionQueuesCurrentBytes: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsAdhoc: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsAdhocSize: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsCompleted: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsCompletedSize: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsIncomplete: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsIncompleteSize: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsInvalid: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsJobCacheCount: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsJobCacheSize: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsSavedsearches: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsScheduled: MetricConfig{Enabled: true}, - SplunkServerSearchartifactsScheduledSize: MetricConfig{Enabled: true}, - SplunkTypingQueueRatio: MetricConfig{Enabled: true}, + SplunkAggregationQueueRatio: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkBucketsSearchableStatus: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.indexer.searchable", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedBucketCount: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedBucketEventCount: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedBucketHotCount: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedBucketWarmCount: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedEventCount: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedRawSize: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedTotalSize: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkHealth: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.feature", "splunk.feature.health", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerAvgRate: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerCPUTime: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerQueueRatio: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerRawWriteTime: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerRollingrestartStatus: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.searchable.restart", "splunk.rollingorrestart", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerThroughput: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.indexer.status", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexesAvgSize: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexesAvgUsage: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexesBucketCount: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexesMedianDataAge: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexesSize: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIoAvgIops: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkKvstoreBackupStatus: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkKvstoreReplicationStatus: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkKvstoreStatus: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.kvstore.storage.engine", "splunk.kvstore.external", "splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkLicenseExpirationSecondsRemaining: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.license.status", "splunk.license.label", "splunk.license.type", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkLicenseIndexUsage: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkParseQueueRatio: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkPipelineSetCount: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSchedulerAvgExecutionLatency: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSchedulerAvgRunTime: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSchedulerCompletionRatio: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSearchDuration: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSearchInitiation: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSearchStatus: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.search.state", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSearchSuccess: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerIntrospectionQueuesCurrent: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.queue.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerIntrospectionQueuesCurrentBytes: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.queue.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsAdhoc: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsAdhocSize: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsCompleted: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsCompletedSize: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsIncomplete: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsIncompleteSize: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsInvalid: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsJobCacheCount: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsJobCacheSize: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.searchartifacts.cache.type", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsSavedsearches: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsScheduled: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsScheduledSize: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkTypingQueueRatio: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, }, }, }, @@ -84,57 +288,261 @@ func TestMetricsBuilderConfig(t *testing.T) { name: "none_set", want: MetricsBuilderConfig{ Metrics: MetricsConfig{ - SplunkAggregationQueueRatio: MetricConfig{Enabled: false}, - SplunkBucketsSearchableStatus: MetricConfig{Enabled: false}, - SplunkDataIndexesExtendedBucketCount: MetricConfig{Enabled: false}, - SplunkDataIndexesExtendedBucketEventCount: MetricConfig{Enabled: false}, - SplunkDataIndexesExtendedBucketHotCount: MetricConfig{Enabled: false}, - SplunkDataIndexesExtendedBucketWarmCount: MetricConfig{Enabled: false}, - SplunkDataIndexesExtendedEventCount: MetricConfig{Enabled: false}, - SplunkDataIndexesExtendedRawSize: MetricConfig{Enabled: false}, - SplunkDataIndexesExtendedTotalSize: MetricConfig{Enabled: false}, - SplunkHealth: MetricConfig{Enabled: false}, - SplunkIndexerAvgRate: MetricConfig{Enabled: false}, - SplunkIndexerCPUTime: MetricConfig{Enabled: false}, - SplunkIndexerQueueRatio: MetricConfig{Enabled: false}, - SplunkIndexerRawWriteTime: MetricConfig{Enabled: false}, - SplunkIndexerRollingrestartStatus: MetricConfig{Enabled: false}, - SplunkIndexerThroughput: MetricConfig{Enabled: false}, - SplunkIndexesAvgSize: MetricConfig{Enabled: false}, - SplunkIndexesAvgUsage: MetricConfig{Enabled: false}, - SplunkIndexesBucketCount: MetricConfig{Enabled: false}, - SplunkIndexesMedianDataAge: MetricConfig{Enabled: false}, - SplunkIndexesSize: MetricConfig{Enabled: false}, - SplunkIoAvgIops: MetricConfig{Enabled: false}, - SplunkKvstoreBackupStatus: MetricConfig{Enabled: false}, - SplunkKvstoreReplicationStatus: MetricConfig{Enabled: false}, - SplunkKvstoreStatus: MetricConfig{Enabled: false}, - SplunkLicenseExpirationSecondsRemaining: MetricConfig{Enabled: false}, - SplunkLicenseIndexUsage: MetricConfig{Enabled: false}, - SplunkParseQueueRatio: MetricConfig{Enabled: false}, - SplunkPipelineSetCount: MetricConfig{Enabled: false}, - SplunkSchedulerAvgExecutionLatency: MetricConfig{Enabled: false}, - SplunkSchedulerAvgRunTime: MetricConfig{Enabled: false}, - SplunkSchedulerCompletionRatio: MetricConfig{Enabled: false}, - SplunkSearchDuration: MetricConfig{Enabled: false}, - SplunkSearchInitiation: MetricConfig{Enabled: false}, - SplunkSearchStatus: MetricConfig{Enabled: false}, - SplunkSearchSuccess: MetricConfig{Enabled: false}, - SplunkServerIntrospectionQueuesCurrent: MetricConfig{Enabled: false}, - SplunkServerIntrospectionQueuesCurrentBytes: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsAdhoc: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsAdhocSize: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsCompleted: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsCompletedSize: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsIncomplete: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsIncompleteSize: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsInvalid: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsJobCacheCount: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsJobCacheSize: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsSavedsearches: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsScheduled: MetricConfig{Enabled: false}, - SplunkServerSearchartifactsScheduledSize: MetricConfig{Enabled: false}, - SplunkTypingQueueRatio: MetricConfig{Enabled: false}, + SplunkAggregationQueueRatio: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkBucketsSearchableStatus: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.indexer.searchable", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedBucketCount: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedBucketEventCount: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedBucketHotCount: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedBucketWarmCount: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.bucket.dir", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedEventCount: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedRawSize: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkDataIndexesExtendedTotalSize: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkHealth: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.feature", "splunk.feature.health", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerAvgRate: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerCPUTime: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerQueueRatio: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerRawWriteTime: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerRollingrestartStatus: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.searchable.restart", "splunk.rollingorrestart", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexerThroughput: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.indexer.status", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexesAvgSize: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexesAvgUsage: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexesBucketCount: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexesMedianDataAge: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIndexesSize: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkIoAvgIops: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkKvstoreBackupStatus: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkKvstoreReplicationStatus: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkKvstoreStatus: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.kvstore.storage.engine", "splunk.kvstore.external", "splunk.kvstore.status.value", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkLicenseExpirationSecondsRemaining: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.license.status", "splunk.license.label", "splunk.license.type", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkLicenseIndexUsage: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.index.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkParseQueueRatio: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkPipelineSetCount: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSchedulerAvgExecutionLatency: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSchedulerAvgRunTime: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSchedulerCompletionRatio: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSearchDuration: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSearchInitiation: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSearchStatus: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.search.state", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkSearchSuccess: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerIntrospectionQueuesCurrent: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.queue.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerIntrospectionQueuesCurrentBytes: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.queue.name", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsAdhoc: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsAdhocSize: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsCompleted: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsCompletedSize: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsIncomplete: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsIncompleteSize: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsInvalid: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsJobCacheCount: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsJobCacheSize: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.searchartifacts.cache.type", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsSavedsearches: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsScheduled: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkServerSearchartifactsScheduledSize: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, + SplunkTypingQueueRatio: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"splunk.host", "splunk.splunkd.build", "splunk.splunkd.version"}, + }, }, }, }, diff --git a/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics.go b/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics.go index 6713ca4cb958a..47beab0dda9d0 100644 --- a/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics.go +++ b/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics.go @@ -3,6 +3,7 @@ package metadata import ( + "slices" "time" "go.opentelemetry.io/collector/component" @@ -11,6 +12,13 @@ import ( "go.opentelemetry.io/collector/receiver" ) +const ( + AggregationStrategySum = "sum" + AggregationStrategyAvg = "avg" + AggregationStrategyMin = "min" + AggregationStrategyMax = "max" +) + var MetricsInfo = metricsInfo{ SplunkAggregationQueueRatio: metricInfo{ Name: "splunk.aggregation.queue.ratio", @@ -226,9 +234,10 @@ type metricInfo struct { } type metricSplunkAggregationQueueRatio 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.aggregation.queue.ratio metric with initial data. @@ -244,13 +253,47 @@ func (m *metricSplunkAggregationQueueRatio) recordDataPoint(start pcommon.Timest if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -263,6 +306,11 @@ func (m *metricSplunkAggregationQueueRatio) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkAggregationQueueRatio) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -280,9 +328,10 @@ func newMetricSplunkAggregationQueueRatio(cfg MetricConfig) metricSplunkAggregat } type metricSplunkBucketsSearchableStatus 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 MetricConfig // 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 splunk.buckets.searchable.status metric with initial data. @@ -298,14 +347,50 @@ func (m *metricSplunkBucketsSearchableStatus) recordDataPoint(start pcommon.Time if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.indexer.searchable") { + dp.Attributes().PutStr("splunk.indexer.searchable", splunkIndexerSearchableAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.indexer.searchable", splunkIndexerSearchableAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -318,6 +403,11 @@ func (m *metricSplunkBucketsSearchableStatus) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkBucketsSearchableStatus) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -335,9 +425,10 @@ func newMetricSplunkBucketsSearchableStatus(cfg MetricConfig) metricSplunkBucket } type metricSplunkDataIndexesExtendedBucketCount 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 MetricConfig // 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 splunk.data.indexes.extended.bucket.count metric with initial data. @@ -353,13 +444,47 @@ func (m *metricSplunkDataIndexesExtendedBucketCount) recordDataPoint(start pcomm if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -372,6 +497,11 @@ func (m *metricSplunkDataIndexesExtendedBucketCount) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkDataIndexesExtendedBucketCount) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -389,9 +519,10 @@ func newMetricSplunkDataIndexesExtendedBucketCount(cfg MetricConfig) metricSplun } type metricSplunkDataIndexesExtendedBucketEventCount 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 MetricConfig // 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 splunk.data.indexes.extended.bucket.event.count metric with initial data. @@ -407,14 +538,50 @@ func (m *metricSplunkDataIndexesExtendedBucketEventCount) recordDataPoint(start if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.bucket.dir") { + dp.Attributes().PutStr("splunk.bucket.dir", splunkBucketDirAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.bucket.dir", splunkBucketDirAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -427,6 +594,11 @@ func (m *metricSplunkDataIndexesExtendedBucketEventCount) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkDataIndexesExtendedBucketEventCount) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -444,9 +616,10 @@ func newMetricSplunkDataIndexesExtendedBucketEventCount(cfg MetricConfig) metric } type metricSplunkDataIndexesExtendedBucketHotCount 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 MetricConfig // 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 splunk.data.indexes.extended.bucket.hot.count metric with initial data. @@ -462,14 +635,50 @@ func (m *metricSplunkDataIndexesExtendedBucketHotCount) recordDataPoint(start pc if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.bucket.dir") { + dp.Attributes().PutStr("splunk.bucket.dir", splunkBucketDirAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.bucket.dir", splunkBucketDirAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -482,6 +691,11 @@ func (m *metricSplunkDataIndexesExtendedBucketHotCount) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkDataIndexesExtendedBucketHotCount) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -499,9 +713,10 @@ func newMetricSplunkDataIndexesExtendedBucketHotCount(cfg MetricConfig) metricSp } type metricSplunkDataIndexesExtendedBucketWarmCount 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 MetricConfig // 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 splunk.data.indexes.extended.bucket.warm.count metric with initial data. @@ -517,14 +732,50 @@ func (m *metricSplunkDataIndexesExtendedBucketWarmCount) recordDataPoint(start p if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.bucket.dir") { + dp.Attributes().PutStr("splunk.bucket.dir", splunkBucketDirAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.bucket.dir", splunkBucketDirAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -537,6 +788,11 @@ func (m *metricSplunkDataIndexesExtendedBucketWarmCount) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkDataIndexesExtendedBucketWarmCount) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -554,9 +810,10 @@ func newMetricSplunkDataIndexesExtendedBucketWarmCount(cfg MetricConfig) metricS } type metricSplunkDataIndexesExtendedEventCount 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 MetricConfig // 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 splunk.data.indexes.extended.event.count metric with initial data. @@ -572,13 +829,47 @@ func (m *metricSplunkDataIndexesExtendedEventCount) recordDataPoint(start pcommo if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -591,6 +882,11 @@ func (m *metricSplunkDataIndexesExtendedEventCount) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkDataIndexesExtendedEventCount) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -608,9 +904,10 @@ func newMetricSplunkDataIndexesExtendedEventCount(cfg MetricConfig) metricSplunk } type metricSplunkDataIndexesExtendedRawSize 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 MetricConfig // 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 splunk.data.indexes.extended.raw.size metric with initial data. @@ -626,13 +923,47 @@ func (m *metricSplunkDataIndexesExtendedRawSize) recordDataPoint(start pcommon.T if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -645,6 +976,11 @@ func (m *metricSplunkDataIndexesExtendedRawSize) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkDataIndexesExtendedRawSize) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -662,9 +998,10 @@ func newMetricSplunkDataIndexesExtendedRawSize(cfg MetricConfig) metricSplunkDat } type metricSplunkDataIndexesExtendedTotalSize 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 MetricConfig // 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 splunk.data.indexes.extended.total.size metric with initial data. @@ -680,13 +1017,47 @@ func (m *metricSplunkDataIndexesExtendedTotalSize) recordDataPoint(start pcommon if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -699,6 +1070,11 @@ func (m *metricSplunkDataIndexesExtendedTotalSize) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkDataIndexesExtendedTotalSize) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -716,9 +1092,10 @@ func newMetricSplunkDataIndexesExtendedTotalSize(cfg MetricConfig) metricSplunkD } type metricSplunkHealth 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 MetricConfig // 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 splunk.health metric with initial data. @@ -734,14 +1111,50 @@ func (m *metricSplunkHealth) recordDataPoint(start pcommon.Timestamp, ts pcommon if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.feature") { + dp.Attributes().PutStr("splunk.feature", splunkFeatureAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.feature.health") { + dp.Attributes().PutStr("splunk.feature.health", splunkFeatureHealthAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.feature", splunkFeatureAttributeValue) - dp.Attributes().PutStr("splunk.feature.health", splunkFeatureHealthAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -754,6 +1167,11 @@ func (m *metricSplunkHealth) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkHealth) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -771,9 +1189,10 @@ func newMetricSplunkHealth(cfg MetricConfig) metricSplunkHealth { } type metricSplunkIndexerAvgRate 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.indexer.avg.rate metric with initial data. @@ -789,13 +1208,47 @@ func (m *metricSplunkIndexerAvgRate) recordDataPoint(start pcommon.Timestamp, ts if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -808,6 +1261,11 @@ func (m *metricSplunkIndexerAvgRate) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIndexerAvgRate) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -825,9 +1283,10 @@ func newMetricSplunkIndexerAvgRate(cfg MetricConfig) metricSplunkIndexerAvgRate } type metricSplunkIndexerCPUTime 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.indexer.cpu.time metric with initial data. @@ -843,13 +1302,47 @@ func (m *metricSplunkIndexerCPUTime) recordDataPoint(start pcommon.Timestamp, ts if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -862,6 +1355,11 @@ func (m *metricSplunkIndexerCPUTime) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIndexerCPUTime) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -879,9 +1377,10 @@ func newMetricSplunkIndexerCPUTime(cfg MetricConfig) metricSplunkIndexerCPUTime } type metricSplunkIndexerQueueRatio 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.indexer.queue.ratio metric with initial data. @@ -897,13 +1396,47 @@ func (m *metricSplunkIndexerQueueRatio) recordDataPoint(start pcommon.Timestamp, if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -916,6 +1449,11 @@ func (m *metricSplunkIndexerQueueRatio) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIndexerQueueRatio) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -933,9 +1471,10 @@ func newMetricSplunkIndexerQueueRatio(cfg MetricConfig) metricSplunkIndexerQueue } type metricSplunkIndexerRawWriteTime 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.indexer.raw.write.time metric with initial data. @@ -951,13 +1490,47 @@ func (m *metricSplunkIndexerRawWriteTime) recordDataPoint(start pcommon.Timestam if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -970,6 +1543,11 @@ func (m *metricSplunkIndexerRawWriteTime) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIndexerRawWriteTime) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -987,9 +1565,10 @@ func newMetricSplunkIndexerRawWriteTime(cfg MetricConfig) metricSplunkIndexerRaw } type metricSplunkIndexerRollingrestartStatus 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 MetricConfig // 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 splunk.indexer.rollingrestart.status metric with initial data. @@ -1005,14 +1584,50 @@ func (m *metricSplunkIndexerRollingrestartStatus) recordDataPoint(start pcommon. if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.searchable.restart") { + dp.Attributes().PutBool("splunk.searchable.restart", splunkSearchableRestartAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.rollingorrestart") { + dp.Attributes().PutBool("splunk.rollingorrestart", splunkRollingorrestartAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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().PutBool("splunk.searchable.restart", splunkSearchableRestartAttributeValue) - dp.Attributes().PutBool("splunk.rollingorrestart", splunkRollingorrestartAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1025,6 +1640,11 @@ func (m *metricSplunkIndexerRollingrestartStatus) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIndexerRollingrestartStatus) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1042,9 +1662,10 @@ func newMetricSplunkIndexerRollingrestartStatus(cfg MetricConfig) metricSplunkIn } type metricSplunkIndexerThroughput 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.indexer.throughput metric with initial data. @@ -1060,13 +1681,47 @@ func (m *metricSplunkIndexerThroughput) recordDataPoint(start pcommon.Timestamp, if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.indexer.status") { + dp.Attributes().PutStr("splunk.indexer.status", splunkIndexerStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.indexer.status", splunkIndexerStatusAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1079,6 +1734,11 @@ func (m *metricSplunkIndexerThroughput) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIndexerThroughput) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1096,9 +1756,10 @@ func newMetricSplunkIndexerThroughput(cfg MetricConfig) metricSplunkIndexerThrou } type metricSplunkIndexesAvgSize 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.indexes.avg.size metric with initial data. @@ -1114,13 +1775,47 @@ func (m *metricSplunkIndexesAvgSize) recordDataPoint(start pcommon.Timestamp, ts if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1133,6 +1828,11 @@ func (m *metricSplunkIndexesAvgSize) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIndexesAvgSize) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1150,9 +1850,10 @@ func newMetricSplunkIndexesAvgSize(cfg MetricConfig) metricSplunkIndexesAvgSize } type metricSplunkIndexesAvgUsage 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.indexes.avg.usage metric with initial data. @@ -1168,13 +1869,47 @@ func (m *metricSplunkIndexesAvgUsage) recordDataPoint(start pcommon.Timestamp, t if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1187,6 +1922,11 @@ func (m *metricSplunkIndexesAvgUsage) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIndexesAvgUsage) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1204,9 +1944,10 @@ func newMetricSplunkIndexesAvgUsage(cfg MetricConfig) metricSplunkIndexesAvgUsag } type metricSplunkIndexesBucketCount 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 MetricConfig // 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 splunk.indexes.bucket.count metric with initial data. @@ -1222,13 +1963,47 @@ func (m *metricSplunkIndexesBucketCount) recordDataPoint(start pcommon.Timestamp if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1241,6 +2016,11 @@ func (m *metricSplunkIndexesBucketCount) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIndexesBucketCount) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1258,9 +2038,10 @@ func newMetricSplunkIndexesBucketCount(cfg MetricConfig) metricSplunkIndexesBuck } type metricSplunkIndexesMedianDataAge 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 MetricConfig // 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 splunk.indexes.median.data.age metric with initial data. @@ -1276,13 +2057,47 @@ func (m *metricSplunkIndexesMedianDataAge) recordDataPoint(start pcommon.Timesta if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1295,6 +2110,11 @@ func (m *metricSplunkIndexesMedianDataAge) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIndexesMedianDataAge) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1312,9 +2132,10 @@ func newMetricSplunkIndexesMedianDataAge(cfg MetricConfig) metricSplunkIndexesMe } type metricSplunkIndexesSize 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.indexes.size metric with initial data. @@ -1330,13 +2151,47 @@ func (m *metricSplunkIndexesSize) recordDataPoint(start pcommon.Timestamp, ts pc if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1349,6 +2204,11 @@ func (m *metricSplunkIndexesSize) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIndexesSize) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1366,9 +2226,10 @@ func newMetricSplunkIndexesSize(cfg MetricConfig) metricSplunkIndexesSize { } type metricSplunkIoAvgIops 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 MetricConfig // 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 splunk.io.avg.iops metric with initial data. @@ -1384,13 +2245,47 @@ func (m *metricSplunkIoAvgIops) recordDataPoint(start pcommon.Timestamp, ts pcom if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1403,6 +2298,11 @@ func (m *metricSplunkIoAvgIops) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkIoAvgIops) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1420,9 +2320,10 @@ func newMetricSplunkIoAvgIops(cfg MetricConfig) metricSplunkIoAvgIops { } type metricSplunkKvstoreBackupStatus 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 MetricConfig // 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 splunk.kvstore.backup.status metric with initial data. @@ -1438,13 +2339,47 @@ func (m *metricSplunkKvstoreBackupStatus) recordDataPoint(start pcommon.Timestam if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.kvstore.status.value") { + dp.Attributes().PutStr("splunk.kvstore.status.value", splunkKvstoreStatusValueAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.kvstore.status.value", splunkKvstoreStatusValueAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1457,6 +2392,11 @@ func (m *metricSplunkKvstoreBackupStatus) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkKvstoreBackupStatus) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1474,9 +2414,10 @@ func newMetricSplunkKvstoreBackupStatus(cfg MetricConfig) metricSplunkKvstoreBac } type metricSplunkKvstoreReplicationStatus 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 MetricConfig // 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 splunk.kvstore.replication.status metric with initial data. @@ -1492,13 +2433,47 @@ func (m *metricSplunkKvstoreReplicationStatus) recordDataPoint(start pcommon.Tim if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.kvstore.status.value") { + dp.Attributes().PutStr("splunk.kvstore.status.value", splunkKvstoreStatusValueAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.kvstore.status.value", splunkKvstoreStatusValueAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1511,6 +2486,11 @@ func (m *metricSplunkKvstoreReplicationStatus) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkKvstoreReplicationStatus) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1528,9 +2508,10 @@ func newMetricSplunkKvstoreReplicationStatus(cfg MetricConfig) metricSplunkKvsto } type metricSplunkKvstoreStatus 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 MetricConfig // 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 splunk.kvstore.status metric with initial data. @@ -1546,15 +2527,53 @@ func (m *metricSplunkKvstoreStatus) recordDataPoint(start pcommon.Timestamp, ts if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.kvstore.storage.engine") { + dp.Attributes().PutStr("splunk.kvstore.storage.engine", splunkKvstoreStorageEngineAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.kvstore.external") { + dp.Attributes().PutStr("splunk.kvstore.external", splunkKvstoreExternalAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.kvstore.status.value") { + dp.Attributes().PutStr("splunk.kvstore.status.value", splunkKvstoreStatusValueAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.kvstore.storage.engine", splunkKvstoreStorageEngineAttributeValue) - dp.Attributes().PutStr("splunk.kvstore.external", splunkKvstoreExternalAttributeValue) - dp.Attributes().PutStr("splunk.kvstore.status.value", splunkKvstoreStatusValueAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1567,6 +2586,11 @@ func (m *metricSplunkKvstoreStatus) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkKvstoreStatus) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1584,9 +2608,10 @@ func newMetricSplunkKvstoreStatus(cfg MetricConfig) metricSplunkKvstoreStatus { } type metricSplunkLicenseExpirationSecondsRemaining 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 MetricConfig // 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 splunk.license.expiration.seconds_remaining metric with initial data. @@ -1602,15 +2627,53 @@ func (m *metricSplunkLicenseExpirationSecondsRemaining) recordDataPoint(start pc if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.license.status") { + dp.Attributes().PutStr("splunk.license.status", splunkLicenseStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.license.label") { + dp.Attributes().PutStr("splunk.license.label", splunkLicenseLabelAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.license.type") { + dp.Attributes().PutStr("splunk.license.type", splunkLicenseTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.license.status", splunkLicenseStatusAttributeValue) - dp.Attributes().PutStr("splunk.license.label", splunkLicenseLabelAttributeValue) - dp.Attributes().PutStr("splunk.license.type", splunkLicenseTypeAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1623,6 +2686,11 @@ func (m *metricSplunkLicenseExpirationSecondsRemaining) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkLicenseExpirationSecondsRemaining) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1640,9 +2708,10 @@ func newMetricSplunkLicenseExpirationSecondsRemaining(cfg MetricConfig) metricSp } type metricSplunkLicenseIndexUsage 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 MetricConfig // 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 splunk.license.index.usage metric with initial data. @@ -1658,13 +2727,47 @@ func (m *metricSplunkLicenseIndexUsage) recordDataPoint(start pcommon.Timestamp, if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.index.name") { + dp.Attributes().PutStr("splunk.index.name", splunkIndexNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.index.name", splunkIndexNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1677,6 +2780,11 @@ func (m *metricSplunkLicenseIndexUsage) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkLicenseIndexUsage) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1694,9 +2802,10 @@ func newMetricSplunkLicenseIndexUsage(cfg MetricConfig) metricSplunkLicenseIndex } type metricSplunkParseQueueRatio 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.parse.queue.ratio metric with initial data. @@ -1712,13 +2821,47 @@ func (m *metricSplunkParseQueueRatio) recordDataPoint(start pcommon.Timestamp, t if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1731,6 +2874,11 @@ func (m *metricSplunkParseQueueRatio) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkParseQueueRatio) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1748,9 +2896,10 @@ func newMetricSplunkParseQueueRatio(cfg MetricConfig) metricSplunkParseQueueRati } type metricSplunkPipelineSetCount 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 MetricConfig // 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 splunk.pipeline.set.count metric with initial data. @@ -1766,13 +2915,47 @@ func (m *metricSplunkPipelineSetCount) recordDataPoint(start pcommon.Timestamp, if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1785,6 +2968,11 @@ func (m *metricSplunkPipelineSetCount) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkPipelineSetCount) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1802,9 +2990,10 @@ func newMetricSplunkPipelineSetCount(cfg MetricConfig) metricSplunkPipelineSetCo } type metricSplunkSchedulerAvgExecutionLatency 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.scheduler.avg.execution.latency metric with initial data. @@ -1820,13 +3009,47 @@ func (m *metricSplunkSchedulerAvgExecutionLatency) recordDataPoint(start pcommon if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1839,6 +3062,11 @@ func (m *metricSplunkSchedulerAvgExecutionLatency) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkSchedulerAvgExecutionLatency) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1856,9 +3084,10 @@ func newMetricSplunkSchedulerAvgExecutionLatency(cfg MetricConfig) metricSplunkS } type metricSplunkSchedulerAvgRunTime 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.scheduler.avg.run.time metric with initial data. @@ -1874,13 +3103,47 @@ func (m *metricSplunkSchedulerAvgRunTime) recordDataPoint(start pcommon.Timestam if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1893,6 +3156,11 @@ func (m *metricSplunkSchedulerAvgRunTime) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkSchedulerAvgRunTime) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1910,9 +3178,10 @@ func newMetricSplunkSchedulerAvgRunTime(cfg MetricConfig) metricSplunkSchedulerA } type metricSplunkSchedulerCompletionRatio 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.scheduler.completion.ratio metric with initial data. @@ -1928,13 +3197,47 @@ func (m *metricSplunkSchedulerCompletionRatio) recordDataPoint(start pcommon.Tim if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -1947,6 +3250,11 @@ func (m *metricSplunkSchedulerCompletionRatio) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkSchedulerCompletionRatio) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -1964,9 +3272,10 @@ func newMetricSplunkSchedulerCompletionRatio(cfg MetricConfig) metricSplunkSched } type metricSplunkSearchDuration 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.search.duration metric with initial data. @@ -1982,12 +3291,44 @@ func (m *metricSplunkSearchDuration) recordDataPoint(start pcommon.Timestamp, ts if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2000,6 +3341,11 @@ func (m *metricSplunkSearchDuration) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkSearchDuration) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2017,9 +3363,10 @@ func newMetricSplunkSearchDuration(cfg MetricConfig) metricSplunkSearchDuration } type metricSplunkSearchInitiation 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 MetricConfig // 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 splunk.search.initiation metric with initial data. @@ -2035,12 +3382,44 @@ func (m *metricSplunkSearchInitiation) recordDataPoint(start pcommon.Timestamp, if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2053,6 +3432,11 @@ func (m *metricSplunkSearchInitiation) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkSearchInitiation) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2070,9 +3454,10 @@ func newMetricSplunkSearchInitiation(cfg MetricConfig) metricSplunkSearchInitiat } type metricSplunkSearchStatus 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 MetricConfig // 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 splunk.search.status metric with initial data. @@ -2088,13 +3473,47 @@ func (m *metricSplunkSearchStatus) recordDataPoint(start pcommon.Timestamp, ts p if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.search.state") { + dp.Attributes().PutStr("splunk.search.state", splunkSearchStateAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.search.state", splunkSearchStateAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2107,6 +3526,11 @@ func (m *metricSplunkSearchStatus) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkSearchStatus) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2124,9 +3548,10 @@ func newMetricSplunkSearchStatus(cfg MetricConfig) metricSplunkSearchStatus { } type metricSplunkSearchSuccess 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 MetricConfig // 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 splunk.search.success metric with initial data. @@ -2142,12 +3567,44 @@ func (m *metricSplunkSearchSuccess) recordDataPoint(start pcommon.Timestamp, ts if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2160,6 +3617,11 @@ func (m *metricSplunkSearchSuccess) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkSearchSuccess) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2177,9 +3639,10 @@ func newMetricSplunkSearchSuccess(cfg MetricConfig) metricSplunkSearchSuccess { } type metricSplunkServerIntrospectionQueuesCurrent 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 MetricConfig // 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 splunk.server.introspection.queues.current metric with initial data. @@ -2195,13 +3658,47 @@ func (m *metricSplunkServerIntrospectionQueuesCurrent) recordDataPoint(start pco if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.queue.name") { + dp.Attributes().PutStr("splunk.queue.name", splunkQueueNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.queue.name", splunkQueueNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2214,6 +3711,11 @@ func (m *metricSplunkServerIntrospectionQueuesCurrent) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerIntrospectionQueuesCurrent) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2231,9 +3733,10 @@ func newMetricSplunkServerIntrospectionQueuesCurrent(cfg MetricConfig) metricSpl } type metricSplunkServerIntrospectionQueuesCurrentBytes 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 MetricConfig // 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 splunk.server.introspection.queues.current.bytes metric with initial data. @@ -2249,13 +3752,47 @@ func (m *metricSplunkServerIntrospectionQueuesCurrentBytes) recordDataPoint(star if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.queue.name") { + dp.Attributes().PutStr("splunk.queue.name", splunkQueueNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.queue.name", splunkQueueNameAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2268,6 +3805,11 @@ func (m *metricSplunkServerIntrospectionQueuesCurrentBytes) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerIntrospectionQueuesCurrentBytes) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2285,9 +3827,10 @@ func newMetricSplunkServerIntrospectionQueuesCurrentBytes(cfg MetricConfig) metr } type metricSplunkServerSearchartifactsAdhoc 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 MetricConfig // 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 splunk.server.searchartifacts.adhoc metric with initial data. @@ -2303,13 +3846,47 @@ func (m *metricSplunkServerSearchartifactsAdhoc) recordDataPoint(start pcommon.T if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2322,6 +3899,11 @@ func (m *metricSplunkServerSearchartifactsAdhoc) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsAdhoc) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2339,9 +3921,10 @@ func newMetricSplunkServerSearchartifactsAdhoc(cfg MetricConfig) metricSplunkSer } type metricSplunkServerSearchartifactsAdhocSize 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 MetricConfig // 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 splunk.server.searchartifacts.adhoc.size metric with initial data. @@ -2357,13 +3940,47 @@ func (m *metricSplunkServerSearchartifactsAdhocSize) recordDataPoint(start pcomm if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2376,6 +3993,11 @@ func (m *metricSplunkServerSearchartifactsAdhocSize) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsAdhocSize) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2393,9 +4015,10 @@ func newMetricSplunkServerSearchartifactsAdhocSize(cfg MetricConfig) metricSplun } type metricSplunkServerSearchartifactsCompleted 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 MetricConfig // 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 splunk.server.searchartifacts.completed metric with initial data. @@ -2411,13 +4034,47 @@ func (m *metricSplunkServerSearchartifactsCompleted) recordDataPoint(start pcomm if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2430,6 +4087,11 @@ func (m *metricSplunkServerSearchartifactsCompleted) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsCompleted) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2447,9 +4109,10 @@ func newMetricSplunkServerSearchartifactsCompleted(cfg MetricConfig) metricSplun } type metricSplunkServerSearchartifactsCompletedSize 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 MetricConfig // 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 splunk.server.searchartifacts.completed.size metric with initial data. @@ -2465,13 +4128,47 @@ func (m *metricSplunkServerSearchartifactsCompletedSize) recordDataPoint(start p if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2484,6 +4181,11 @@ func (m *metricSplunkServerSearchartifactsCompletedSize) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsCompletedSize) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2501,9 +4203,10 @@ func newMetricSplunkServerSearchartifactsCompletedSize(cfg MetricConfig) metricS } type metricSplunkServerSearchartifactsIncomplete 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 MetricConfig // 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 splunk.server.searchartifacts.incomplete metric with initial data. @@ -2519,13 +4222,47 @@ func (m *metricSplunkServerSearchartifactsIncomplete) recordDataPoint(start pcom if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2538,6 +4275,11 @@ func (m *metricSplunkServerSearchartifactsIncomplete) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsIncomplete) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2555,9 +4297,10 @@ func newMetricSplunkServerSearchartifactsIncomplete(cfg MetricConfig) metricSplu } type metricSplunkServerSearchartifactsIncompleteSize 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 MetricConfig // 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 splunk.server.searchartifacts.incomplete.size metric with initial data. @@ -2573,13 +4316,47 @@ func (m *metricSplunkServerSearchartifactsIncompleteSize) recordDataPoint(start if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2592,6 +4369,11 @@ func (m *metricSplunkServerSearchartifactsIncompleteSize) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsIncompleteSize) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2609,9 +4391,10 @@ func newMetricSplunkServerSearchartifactsIncompleteSize(cfg MetricConfig) metric } type metricSplunkServerSearchartifactsInvalid 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 MetricConfig // 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 splunk.server.searchartifacts.invalid metric with initial data. @@ -2627,13 +4410,47 @@ func (m *metricSplunkServerSearchartifactsInvalid) recordDataPoint(start pcommon if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2646,6 +4463,11 @@ func (m *metricSplunkServerSearchartifactsInvalid) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsInvalid) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2663,9 +4485,10 @@ func newMetricSplunkServerSearchartifactsInvalid(cfg MetricConfig) metricSplunkS } type metricSplunkServerSearchartifactsJobCacheCount 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 MetricConfig // 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 splunk.server.searchartifacts.job.cache.count metric with initial data. @@ -2681,13 +4504,47 @@ func (m *metricSplunkServerSearchartifactsJobCacheCount) recordDataPoint(start p if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2700,6 +4557,11 @@ func (m *metricSplunkServerSearchartifactsJobCacheCount) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsJobCacheCount) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2717,9 +4579,10 @@ func newMetricSplunkServerSearchartifactsJobCacheCount(cfg MetricConfig) metricS } type metricSplunkServerSearchartifactsJobCacheSize 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 MetricConfig // 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 splunk.server.searchartifacts.job.cache.size metric with initial data. @@ -2735,14 +4598,50 @@ func (m *metricSplunkServerSearchartifactsJobCacheSize) recordDataPoint(start pc if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.searchartifacts.cache.type") { + dp.Attributes().PutStr("splunk.searchartifacts.cache.type", splunkSearchartifactsCacheTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.searchartifacts.cache.type", splunkSearchartifactsCacheTypeAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2755,6 +4654,11 @@ func (m *metricSplunkServerSearchartifactsJobCacheSize) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsJobCacheSize) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2772,9 +4676,10 @@ func newMetricSplunkServerSearchartifactsJobCacheSize(cfg MetricConfig) metricSp } type metricSplunkServerSearchartifactsSavedsearches 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 MetricConfig // 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 splunk.server.searchartifacts.savedsearches metric with initial data. @@ -2790,13 +4695,47 @@ func (m *metricSplunkServerSearchartifactsSavedsearches) recordDataPoint(start p if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2809,6 +4748,11 @@ func (m *metricSplunkServerSearchartifactsSavedsearches) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsSavedsearches) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2826,9 +4770,10 @@ func newMetricSplunkServerSearchartifactsSavedsearches(cfg MetricConfig) metricS } type metricSplunkServerSearchartifactsScheduled 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 MetricConfig // 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 splunk.server.searchartifacts.scheduled metric with initial data. @@ -2844,13 +4789,47 @@ func (m *metricSplunkServerSearchartifactsScheduled) recordDataPoint(start pcomm if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2863,6 +4842,11 @@ func (m *metricSplunkServerSearchartifactsScheduled) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsScheduled) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2880,9 +4864,10 @@ func newMetricSplunkServerSearchartifactsScheduled(cfg MetricConfig) metricSplun } type metricSplunkServerSearchartifactsScheduledSize 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 MetricConfig // 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 splunk.server.searchartifacts.scheduled.size metric with initial data. @@ -2898,13 +4883,47 @@ func (m *metricSplunkServerSearchartifactsScheduledSize) recordDataPoint(start p if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2917,6 +4936,11 @@ func (m *metricSplunkServerSearchartifactsScheduledSize) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkServerSearchartifactsScheduledSize) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetIntValue(m.data.Gauge().DataPoints().At(i).IntValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() @@ -2934,9 +4958,10 @@ func newMetricSplunkServerSearchartifactsScheduledSize(cfg MetricConfig) metricS } type metricSplunkTypingQueueRatio 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 MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index } // init fills splunk.typing.queue.ratio metric with initial data. @@ -2952,13 +4977,47 @@ func (m *metricSplunkTypingQueueRatio) recordDataPoint(start pcommon.Timestamp, if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "splunk.host") { + dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.build") { + dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "splunk.splunkd.version") { + dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + } + + var s string + dps := m.data.Gauge().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.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + dp.SetDoubleValue(val) - dp.Attributes().PutStr("splunk.host", splunkHostAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.build", splunkSplunkdBuildAttributeValue) - dp.Attributes().PutStr("splunk.splunkd.version", splunkSplunkdVersionAttributeValue) + 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. @@ -2971,6 +5030,11 @@ func (m *metricSplunkTypingQueueRatio) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSplunkTypingQueueRatio) emit(metrics pmetric.MetricSlice) { if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) m.init() diff --git a/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics_test.go b/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics_test.go index c584a91f5c891..347a4070fa0bf 100644 --- a/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics_test.go +++ b/receiver/splunkenterprisereceiver/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, @@ -51,166 +57,373 @@ 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["SplunkAggregationQueueRatio"] = mb.metricSplunkAggregationQueueRatio.config.AggregationStrategy + aggMap["SplunkBucketsSearchableStatus"] = mb.metricSplunkBucketsSearchableStatus.config.AggregationStrategy + aggMap["SplunkDataIndexesExtendedBucketCount"] = mb.metricSplunkDataIndexesExtendedBucketCount.config.AggregationStrategy + aggMap["SplunkDataIndexesExtendedBucketEventCount"] = mb.metricSplunkDataIndexesExtendedBucketEventCount.config.AggregationStrategy + aggMap["SplunkDataIndexesExtendedBucketHotCount"] = mb.metricSplunkDataIndexesExtendedBucketHotCount.config.AggregationStrategy + aggMap["SplunkDataIndexesExtendedBucketWarmCount"] = mb.metricSplunkDataIndexesExtendedBucketWarmCount.config.AggregationStrategy + aggMap["SplunkDataIndexesExtendedEventCount"] = mb.metricSplunkDataIndexesExtendedEventCount.config.AggregationStrategy + aggMap["SplunkDataIndexesExtendedRawSize"] = mb.metricSplunkDataIndexesExtendedRawSize.config.AggregationStrategy + aggMap["SplunkDataIndexesExtendedTotalSize"] = mb.metricSplunkDataIndexesExtendedTotalSize.config.AggregationStrategy + aggMap["SplunkHealth"] = mb.metricSplunkHealth.config.AggregationStrategy + aggMap["SplunkIndexerAvgRate"] = mb.metricSplunkIndexerAvgRate.config.AggregationStrategy + aggMap["SplunkIndexerCPUTime"] = mb.metricSplunkIndexerCPUTime.config.AggregationStrategy + aggMap["SplunkIndexerQueueRatio"] = mb.metricSplunkIndexerQueueRatio.config.AggregationStrategy + aggMap["SplunkIndexerRawWriteTime"] = mb.metricSplunkIndexerRawWriteTime.config.AggregationStrategy + aggMap["SplunkIndexerRollingrestartStatus"] = mb.metricSplunkIndexerRollingrestartStatus.config.AggregationStrategy + aggMap["SplunkIndexerThroughput"] = mb.metricSplunkIndexerThroughput.config.AggregationStrategy + aggMap["SplunkIndexesAvgSize"] = mb.metricSplunkIndexesAvgSize.config.AggregationStrategy + aggMap["SplunkIndexesAvgUsage"] = mb.metricSplunkIndexesAvgUsage.config.AggregationStrategy + aggMap["SplunkIndexesBucketCount"] = mb.metricSplunkIndexesBucketCount.config.AggregationStrategy + aggMap["SplunkIndexesMedianDataAge"] = mb.metricSplunkIndexesMedianDataAge.config.AggregationStrategy + aggMap["SplunkIndexesSize"] = mb.metricSplunkIndexesSize.config.AggregationStrategy + aggMap["SplunkIoAvgIops"] = mb.metricSplunkIoAvgIops.config.AggregationStrategy + aggMap["SplunkKvstoreBackupStatus"] = mb.metricSplunkKvstoreBackupStatus.config.AggregationStrategy + aggMap["SplunkKvstoreReplicationStatus"] = mb.metricSplunkKvstoreReplicationStatus.config.AggregationStrategy + aggMap["SplunkKvstoreStatus"] = mb.metricSplunkKvstoreStatus.config.AggregationStrategy + aggMap["SplunkLicenseExpirationSecondsRemaining"] = mb.metricSplunkLicenseExpirationSecondsRemaining.config.AggregationStrategy + aggMap["SplunkLicenseIndexUsage"] = mb.metricSplunkLicenseIndexUsage.config.AggregationStrategy + aggMap["SplunkParseQueueRatio"] = mb.metricSplunkParseQueueRatio.config.AggregationStrategy + aggMap["SplunkPipelineSetCount"] = mb.metricSplunkPipelineSetCount.config.AggregationStrategy + aggMap["SplunkSchedulerAvgExecutionLatency"] = mb.metricSplunkSchedulerAvgExecutionLatency.config.AggregationStrategy + aggMap["SplunkSchedulerAvgRunTime"] = mb.metricSplunkSchedulerAvgRunTime.config.AggregationStrategy + aggMap["SplunkSchedulerCompletionRatio"] = mb.metricSplunkSchedulerCompletionRatio.config.AggregationStrategy + aggMap["SplunkSearchDuration"] = mb.metricSplunkSearchDuration.config.AggregationStrategy + aggMap["SplunkSearchInitiation"] = mb.metricSplunkSearchInitiation.config.AggregationStrategy + aggMap["SplunkSearchStatus"] = mb.metricSplunkSearchStatus.config.AggregationStrategy + aggMap["SplunkSearchSuccess"] = mb.metricSplunkSearchSuccess.config.AggregationStrategy + aggMap["SplunkServerIntrospectionQueuesCurrent"] = mb.metricSplunkServerIntrospectionQueuesCurrent.config.AggregationStrategy + aggMap["SplunkServerIntrospectionQueuesCurrentBytes"] = mb.metricSplunkServerIntrospectionQueuesCurrentBytes.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsAdhoc"] = mb.metricSplunkServerSearchartifactsAdhoc.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsAdhocSize"] = mb.metricSplunkServerSearchartifactsAdhocSize.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsCompleted"] = mb.metricSplunkServerSearchartifactsCompleted.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsCompletedSize"] = mb.metricSplunkServerSearchartifactsCompletedSize.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsIncomplete"] = mb.metricSplunkServerSearchartifactsIncomplete.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsIncompleteSize"] = mb.metricSplunkServerSearchartifactsIncompleteSize.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsInvalid"] = mb.metricSplunkServerSearchartifactsInvalid.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsJobCacheCount"] = mb.metricSplunkServerSearchartifactsJobCacheCount.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsJobCacheSize"] = mb.metricSplunkServerSearchartifactsJobCacheSize.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsSavedsearches"] = mb.metricSplunkServerSearchartifactsSavedsearches.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsScheduled"] = mb.metricSplunkServerSearchartifactsScheduled.config.AggregationStrategy + aggMap["SplunkServerSearchartifactsScheduledSize"] = mb.metricSplunkServerSearchartifactsScheduledSize.config.AggregationStrategy + aggMap["SplunkTypingQueueRatio"] = mb.metricSplunkTypingQueueRatio.config.AggregationStrategy expectedWarnings := 0 - assert.Equal(t, expectedWarnings, observedLogs.Len()) + if tt.metricsSet != testDataSetReag { + assert.Equal(t, expectedWarnings, observedLogs.Len()) + } defaultMetricsCount := 0 allMetricsCount := 0 allMetricsCount++ mb.RecordSplunkAggregationQueueRatioDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkAggregationQueueRatioDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkBucketsSearchableStatusDataPoint(ts, 1, "splunk.host-val", "splunk.indexer.searchable-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkBucketsSearchableStatusDataPoint(ts, 3, "splunk.host-val-2", "splunk.indexer.searchable-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkDataIndexesExtendedBucketCountDataPoint(ts, 1, "splunk.index.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkDataIndexesExtendedBucketCountDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkDataIndexesExtendedBucketEventCountDataPoint(ts, 1, "splunk.index.name-val", "splunk.bucket.dir-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkDataIndexesExtendedBucketEventCountDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.bucket.dir-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkDataIndexesExtendedBucketHotCountDataPoint(ts, 1, "splunk.index.name-val", "splunk.bucket.dir-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkDataIndexesExtendedBucketHotCountDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.bucket.dir-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkDataIndexesExtendedBucketWarmCountDataPoint(ts, 1, "splunk.index.name-val", "splunk.bucket.dir-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkDataIndexesExtendedBucketWarmCountDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.bucket.dir-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkDataIndexesExtendedEventCountDataPoint(ts, 1, "splunk.index.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkDataIndexesExtendedEventCountDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkDataIndexesExtendedRawSizeDataPoint(ts, 1, "splunk.index.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkDataIndexesExtendedRawSizeDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkDataIndexesExtendedTotalSizeDataPoint(ts, 1, "splunk.index.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkDataIndexesExtendedTotalSizeDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSplunkHealthDataPoint(ts, 1, "splunk.feature-val", "splunk.feature.health-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkHealthDataPoint(ts, 3, "splunk.feature-val-2", "splunk.feature.health-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIndexerAvgRateDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIndexerAvgRateDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIndexerCPUTimeDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIndexerCPUTimeDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIndexerQueueRatioDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIndexerQueueRatioDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIndexerRawWriteTimeDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIndexerRawWriteTimeDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIndexerRollingrestartStatusDataPoint(ts, 1, false, false, "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIndexerRollingrestartStatusDataPoint(ts, 3, true, true, "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIndexerThroughputDataPoint(ts, 1, "splunk.indexer.status-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIndexerThroughputDataPoint(ts, 3, "splunk.indexer.status-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIndexesAvgSizeDataPoint(ts, 1, "splunk.index.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIndexesAvgSizeDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIndexesAvgUsageDataPoint(ts, 1, "splunk.index.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIndexesAvgUsageDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIndexesBucketCountDataPoint(ts, 1, "splunk.index.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIndexesBucketCountDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIndexesMedianDataAgeDataPoint(ts, 1, "splunk.index.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIndexesMedianDataAgeDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIndexesSizeDataPoint(ts, 1, "splunk.index.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIndexesSizeDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkIoAvgIopsDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkIoAvgIopsDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkKvstoreBackupStatusDataPoint(ts, 1, "splunk.kvstore.status.value-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkKvstoreBackupStatusDataPoint(ts, 3, "splunk.kvstore.status.value-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkKvstoreReplicationStatusDataPoint(ts, 1, "splunk.kvstore.status.value-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkKvstoreReplicationStatusDataPoint(ts, 3, "splunk.kvstore.status.value-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkKvstoreStatusDataPoint(ts, 1, "splunk.kvstore.storage.engine-val", "splunk.kvstore.external-val", "splunk.kvstore.status.value-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkKvstoreStatusDataPoint(ts, 3, "splunk.kvstore.storage.engine-val-2", "splunk.kvstore.external-val-2", "splunk.kvstore.status.value-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkLicenseExpirationSecondsRemainingDataPoint(ts, 1, "splunk.license.status-val", "splunk.license.label-val", "splunk.license.type-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkLicenseExpirationSecondsRemainingDataPoint(ts, 3, "splunk.license.status-val-2", "splunk.license.label-val-2", "splunk.license.type-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkLicenseIndexUsageDataPoint(ts, 1, "splunk.index.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkLicenseIndexUsageDataPoint(ts, 3, "splunk.index.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkParseQueueRatioDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkParseQueueRatioDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkPipelineSetCountDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkPipelineSetCountDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkSchedulerAvgExecutionLatencyDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkSchedulerAvgExecutionLatencyDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkSchedulerAvgRunTimeDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkSchedulerAvgRunTimeDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkSchedulerCompletionRatioDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkSchedulerCompletionRatioDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkSearchDurationDataPoint(ts, 1, "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkSearchDurationDataPoint(ts, 3, "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkSearchInitiationDataPoint(ts, 1, "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkSearchInitiationDataPoint(ts, 3, "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkSearchStatusDataPoint(ts, 1, "splunk.search.state-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkSearchStatusDataPoint(ts, 3, "splunk.search.state-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkSearchSuccessDataPoint(ts, 1, "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkSearchSuccessDataPoint(ts, 3, "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerIntrospectionQueuesCurrentDataPoint(ts, 1, "splunk.queue.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerIntrospectionQueuesCurrentDataPoint(ts, 3, "splunk.queue.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerIntrospectionQueuesCurrentBytesDataPoint(ts, 1, "splunk.queue.name-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerIntrospectionQueuesCurrentBytesDataPoint(ts, 3, "splunk.queue.name-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsAdhocDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsAdhocDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsAdhocSizeDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsAdhocSizeDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsCompletedDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsCompletedDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsCompletedSizeDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsCompletedSizeDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsIncompleteDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsIncompleteDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsIncompleteSizeDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsIncompleteSizeDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsInvalidDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsInvalidDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsJobCacheCountDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsJobCacheCountDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsJobCacheSizeDataPoint(ts, 1, "splunk.host-val", "splunk.searchartifacts.cache.type-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsJobCacheSizeDataPoint(ts, 3, "splunk.host-val-2", "splunk.searchartifacts.cache.type-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsSavedsearchesDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsSavedsearchesDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsScheduledDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsScheduledDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkServerSearchartifactsScheduledSizeDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkServerSearchartifactsScheduledSizeDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } allMetricsCount++ mb.RecordSplunkTypingQueueRatioDataPoint(ts, 1, "splunk.host-val", "splunk.splunkd.build-val", "splunk.splunkd.version-val") + if tt.name == "reaggregate_set" { + mb.RecordSplunkTypingQueueRatioDataPoint(ts, 3, "splunk.host-val-2", "splunk.splunkd.build-val-2", "splunk.splunkd.version-val-2") + } res := pcommon.NewResource() metrics := mb.Emit(WithResource(res)) @@ -235,1100 +448,2595 @@ func TestMetricsBuilder(t *testing.T) { for i := 0; i < ms.Len(); i++ { switch ms.At(i).Name() { case "splunk.aggregation.queue.ratio": - assert.False(t, validatedMetrics["splunk.aggregation.queue.ratio"], "Found a duplicate in the metrics slice: splunk.aggregation.queue.ratio") - validatedMetrics["splunk.aggregation.queue.ratio"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the average indexer aggregation queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "{%}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.aggregation.queue.ratio"], "Found a duplicate in the metrics slice: splunk.aggregation.queue.ratio") + validatedMetrics["splunk.aggregation.queue.ratio"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average indexer aggregation queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.aggregation.queue.ratio"], "Found a duplicate in the metrics slice: splunk.aggregation.queue.ratio") + validatedMetrics["splunk.aggregation.queue.ratio"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average indexer aggregation queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.aggregation.queue.ratio"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.buckets.searchable.status": - assert.False(t, validatedMetrics["splunk.buckets.searchable.status"], "Found a duplicate in the metrics slice: splunk.buckets.searchable.status") - validatedMetrics["splunk.buckets.searchable.status"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the number of buckets and their searchable status. *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "{count}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.indexer.searchable") - assert.True(t, ok) - assert.Equal(t, "splunk.indexer.searchable-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.buckets.searchable.status"], "Found a duplicate in the metrics slice: splunk.buckets.searchable.status") + validatedMetrics["splunk.buckets.searchable.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the number of buckets and their searchable status. *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{count}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.indexer.searchable") + assert.True(t, ok) + assert.Equal(t, "splunk.indexer.searchable-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.buckets.searchable.status"], "Found a duplicate in the metrics slice: splunk.buckets.searchable.status") + validatedMetrics["splunk.buckets.searchable.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the number of buckets and their searchable status. *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{count}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.buckets.searchable.status"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.indexer.searchable") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.data.indexes.extended.bucket.count": - assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.count") - validatedMetrics["splunk.data.indexes.extended.bucket.count"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Count of buckets per index", ms.At(i).Description()) - assert.Equal(t, "{buckets}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.count") + validatedMetrics["splunk.data.indexes.extended.bucket.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Count of buckets per index", ms.At(i).Description()) + assert.Equal(t, "{buckets}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.count") + validatedMetrics["splunk.data.indexes.extended.bucket.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Count of buckets per index", ms.At(i).Description()) + assert.Equal(t, "{buckets}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.data.indexes.extended.bucket.count"] { + 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("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.data.indexes.extended.bucket.event.count": - assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.event.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.event.count") - validatedMetrics["splunk.data.indexes.extended.bucket.event.count"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Count of events in this bucket super-directory. *Note:** Must be pointed at specific indexer `endpoint`.", ms.At(i).Description()) - assert.Equal(t, "{events}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.bucket.dir") - assert.True(t, ok) - assert.Equal(t, "splunk.bucket.dir-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.event.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.event.count") + validatedMetrics["splunk.data.indexes.extended.bucket.event.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Count of events in this bucket super-directory. *Note:** Must be pointed at specific indexer `endpoint`.", ms.At(i).Description()) + assert.Equal(t, "{events}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.bucket.dir") + assert.True(t, ok) + assert.Equal(t, "splunk.bucket.dir-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.event.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.event.count") + validatedMetrics["splunk.data.indexes.extended.bucket.event.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Count of events in this bucket super-directory. *Note:** Must be pointed at specific indexer `endpoint`.", ms.At(i).Description()) + assert.Equal(t, "{events}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.data.indexes.extended.bucket.event.count"] { + 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("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.bucket.dir") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.data.indexes.extended.bucket.hot.count": - assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.hot.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.hot.count") - validatedMetrics["splunk.data.indexes.extended.bucket.hot.count"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "(If size > 0) Number of hot buckets. *Note:** Must be pointed at specific indexer `endpoint`.", ms.At(i).Description()) - assert.Equal(t, "{buckets}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.bucket.dir") - assert.True(t, ok) - assert.Equal(t, "splunk.bucket.dir-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.hot.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.hot.count") + validatedMetrics["splunk.data.indexes.extended.bucket.hot.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "(If size > 0) Number of hot buckets. *Note:** Must be pointed at specific indexer `endpoint`.", ms.At(i).Description()) + assert.Equal(t, "{buckets}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.bucket.dir") + assert.True(t, ok) + assert.Equal(t, "splunk.bucket.dir-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.hot.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.hot.count") + validatedMetrics["splunk.data.indexes.extended.bucket.hot.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "(If size > 0) Number of hot buckets. *Note:** Must be pointed at specific indexer `endpoint`.", ms.At(i).Description()) + assert.Equal(t, "{buckets}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.data.indexes.extended.bucket.hot.count"] { + 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("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.bucket.dir") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.data.indexes.extended.bucket.warm.count": - assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.warm.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.warm.count") - validatedMetrics["splunk.data.indexes.extended.bucket.warm.count"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "(If size > 0) Number of warm buckets. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) - assert.Equal(t, "{buckets}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.bucket.dir") - assert.True(t, ok) - assert.Equal(t, "splunk.bucket.dir-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.warm.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.warm.count") + validatedMetrics["splunk.data.indexes.extended.bucket.warm.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "(If size > 0) Number of warm buckets. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "{buckets}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.bucket.dir") + assert.True(t, ok) + assert.Equal(t, "splunk.bucket.dir-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.bucket.warm.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.bucket.warm.count") + validatedMetrics["splunk.data.indexes.extended.bucket.warm.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "(If size > 0) Number of warm buckets. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "{buckets}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.data.indexes.extended.bucket.warm.count"] { + 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("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.bucket.dir") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.data.indexes.extended.event.count": - assert.False(t, validatedMetrics["splunk.data.indexes.extended.event.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.event.count") - validatedMetrics["splunk.data.indexes.extended.event.count"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Count of events for index, excluding frozen events. Approximately equal to the event_count sum of all buckets. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) - assert.Equal(t, "{events}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.event.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.event.count") + validatedMetrics["splunk.data.indexes.extended.event.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Count of events for index, excluding frozen events. Approximately equal to the event_count sum of all buckets. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "{events}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.event.count"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.event.count") + validatedMetrics["splunk.data.indexes.extended.event.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Count of events for index, excluding frozen events. Approximately equal to the event_count sum of all buckets. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "{events}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.data.indexes.extended.event.count"] { + 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("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.data.indexes.extended.raw.size": - assert.False(t, validatedMetrics["splunk.data.indexes.extended.raw.size"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.raw.size") - validatedMetrics["splunk.data.indexes.extended.raw.size"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Size in bytes on disk of the /rawdata/ directories of all buckets in this index, excluding frozen *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) - assert.Equal(t, "By", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.raw.size"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.raw.size") + validatedMetrics["splunk.data.indexes.extended.raw.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Size in bytes on disk of the /rawdata/ directories of all buckets in this index, excluding frozen *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "By", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.raw.size"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.raw.size") + validatedMetrics["splunk.data.indexes.extended.raw.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Size in bytes on disk of the /rawdata/ directories of all buckets in this index, excluding frozen *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "By", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.data.indexes.extended.raw.size"] { + 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("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.data.indexes.extended.total.size": - assert.False(t, validatedMetrics["splunk.data.indexes.extended.total.size"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.total.size") - validatedMetrics["splunk.data.indexes.extended.total.size"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Size in bytes on disk of this index *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) - assert.Equal(t, "By", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.total.size"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.total.size") + validatedMetrics["splunk.data.indexes.extended.total.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Size in bytes on disk of this index *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "By", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.data.indexes.extended.total.size"], "Found a duplicate in the metrics slice: splunk.data.indexes.extended.total.size") + validatedMetrics["splunk.data.indexes.extended.total.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Size in bytes on disk of this index *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "By", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.data.indexes.extended.total.size"] { + 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("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.health": - assert.False(t, validatedMetrics["splunk.health"], "Found a duplicate in the metrics slice: splunk.health") - validatedMetrics["splunk.health"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "The status ('red', 'yellow', or 'green') of the Splunk server. Health of 'red' produces a 0 while all other colors produce a 1.", ms.At(i).Description()) - assert.Equal(t, "{status}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.feature") - assert.True(t, ok) - assert.Equal(t, "splunk.feature-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.feature.health") - assert.True(t, ok) - assert.Equal(t, "splunk.feature.health-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.health"], "Found a duplicate in the metrics slice: splunk.health") + validatedMetrics["splunk.health"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "The status ('red', 'yellow', or 'green') of the Splunk server. Health of 'red' produces a 0 while all other colors produce a 1.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.feature") + assert.True(t, ok) + assert.Equal(t, "splunk.feature-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.feature.health") + assert.True(t, ok) + assert.Equal(t, "splunk.feature.health-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.health"], "Found a duplicate in the metrics slice: splunk.health") + validatedMetrics["splunk.health"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "The status ('red', 'yellow', or 'green') of the Splunk server. Health of 'red' produces a 0 while all other colors produce a 1.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.health"] { + 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("splunk.feature") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.feature.health") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.indexer.avg.rate": - assert.False(t, validatedMetrics["splunk.indexer.avg.rate"], "Found a duplicate in the metrics slice: splunk.indexer.avg.rate") - validatedMetrics["splunk.indexer.avg.rate"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the average rate of indexed data. **Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "KBy", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.indexer.avg.rate"], "Found a duplicate in the metrics slice: splunk.indexer.avg.rate") + validatedMetrics["splunk.indexer.avg.rate"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average rate of indexed data. **Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "KBy", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.indexer.avg.rate"], "Found a duplicate in the metrics slice: splunk.indexer.avg.rate") + validatedMetrics["splunk.indexer.avg.rate"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average rate of indexed data. **Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "KBy", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.indexer.avg.rate"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.indexer.cpu.time": - assert.False(t, validatedMetrics["splunk.indexer.cpu.time"], "Found a duplicate in the metrics slice: splunk.indexer.cpu.time") - validatedMetrics["splunk.indexer.cpu.time"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the number of indexing process cpu seconds per instance", ms.At(i).Description()) - assert.Equal(t, "{s}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.indexer.cpu.time"], "Found a duplicate in the metrics slice: splunk.indexer.cpu.time") + validatedMetrics["splunk.indexer.cpu.time"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the number of indexing process cpu seconds per instance", ms.At(i).Description()) + assert.Equal(t, "{s}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.indexer.cpu.time"], "Found a duplicate in the metrics slice: splunk.indexer.cpu.time") + validatedMetrics["splunk.indexer.cpu.time"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the number of indexing process cpu seconds per instance", ms.At(i).Description()) + assert.Equal(t, "{s}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.indexer.cpu.time"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.indexer.queue.ratio": - assert.False(t, validatedMetrics["splunk.indexer.queue.ratio"], "Found a duplicate in the metrics slice: splunk.indexer.queue.ratio") - validatedMetrics["splunk.indexer.queue.ratio"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the average indexer index queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "{%}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.indexer.queue.ratio"], "Found a duplicate in the metrics slice: splunk.indexer.queue.ratio") + validatedMetrics["splunk.indexer.queue.ratio"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average indexer index queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.indexer.queue.ratio"], "Found a duplicate in the metrics slice: splunk.indexer.queue.ratio") + validatedMetrics["splunk.indexer.queue.ratio"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average indexer index queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.indexer.queue.ratio"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.indexer.raw.write.time": - assert.False(t, validatedMetrics["splunk.indexer.raw.write.time"], "Found a duplicate in the metrics slice: splunk.indexer.raw.write.time") - validatedMetrics["splunk.indexer.raw.write.time"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the number of raw write seconds per instance", ms.At(i).Description()) - assert.Equal(t, "{s}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.indexer.raw.write.time"], "Found a duplicate in the metrics slice: splunk.indexer.raw.write.time") + validatedMetrics["splunk.indexer.raw.write.time"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the number of raw write seconds per instance", ms.At(i).Description()) + assert.Equal(t, "{s}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.indexer.raw.write.time"], "Found a duplicate in the metrics slice: splunk.indexer.raw.write.time") + validatedMetrics["splunk.indexer.raw.write.time"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the number of raw write seconds per instance", ms.At(i).Description()) + assert.Equal(t, "{s}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.indexer.raw.write.time"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.indexer.rollingrestart.status": - assert.False(t, validatedMetrics["splunk.indexer.rollingrestart.status"], "Found a duplicate in the metrics slice: splunk.indexer.rollingrestart.status") - validatedMetrics["splunk.indexer.rollingrestart.status"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "The status of a rolling restart.", ms.At(i).Description()) - assert.Equal(t, "{status}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.searchable.restart") - assert.True(t, ok) - assert.False(t, attrVal.Bool()) - attrVal, ok = dp.Attributes().Get("splunk.rollingorrestart") - assert.True(t, ok) - assert.False(t, attrVal.Bool()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.indexer.rollingrestart.status"], "Found a duplicate in the metrics slice: splunk.indexer.rollingrestart.status") + validatedMetrics["splunk.indexer.rollingrestart.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "The status of a rolling restart.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.searchable.restart") + assert.True(t, ok) + assert.False(t, attrVal.Bool()) + attrVal, ok = dp.Attributes().Get("splunk.rollingorrestart") + assert.True(t, ok) + assert.False(t, attrVal.Bool()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.indexer.rollingrestart.status"], "Found a duplicate in the metrics slice: splunk.indexer.rollingrestart.status") + validatedMetrics["splunk.indexer.rollingrestart.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "The status of a rolling restart.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.indexer.rollingrestart.status"] { + 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("splunk.searchable.restart") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.rollingorrestart") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.indexer.throughput": - assert.False(t, validatedMetrics["splunk.indexer.throughput"], "Found a duplicate in the metrics slice: splunk.indexer.throughput") - validatedMetrics["splunk.indexer.throughput"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking average bytes per second throughput of indexer. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) - assert.Equal(t, "By/s", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.indexer.status") - assert.True(t, ok) - assert.Equal(t, "splunk.indexer.status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.indexer.throughput"], "Found a duplicate in the metrics slice: splunk.indexer.throughput") + validatedMetrics["splunk.indexer.throughput"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking average bytes per second throughput of indexer. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "By/s", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.indexer.status") + assert.True(t, ok) + assert.Equal(t, "splunk.indexer.status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.indexer.throughput"], "Found a duplicate in the metrics slice: splunk.indexer.throughput") + validatedMetrics["splunk.indexer.throughput"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking average bytes per second throughput of indexer. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "By/s", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.indexer.throughput"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.indexer.status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.indexes.avg.size": - assert.False(t, validatedMetrics["splunk.indexes.avg.size"], "Found a duplicate in the metrics slice: splunk.indexes.avg.size") - validatedMetrics["splunk.indexes.avg.size"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the indexes and their average size (gb). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "Gb", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.indexes.avg.size"], "Found a duplicate in the metrics slice: splunk.indexes.avg.size") + validatedMetrics["splunk.indexes.avg.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexes and their average size (gb). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "Gb", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.indexes.avg.size"], "Found a duplicate in the metrics slice: splunk.indexes.avg.size") + validatedMetrics["splunk.indexes.avg.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexes and their average size (gb). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "Gb", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.indexes.avg.size"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.indexes.avg.usage": - assert.False(t, validatedMetrics["splunk.indexes.avg.usage"], "Found a duplicate in the metrics slice: splunk.indexes.avg.usage") - validatedMetrics["splunk.indexes.avg.usage"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the indexes and their average usage (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "{%}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.indexes.avg.usage"], "Found a duplicate in the metrics slice: splunk.indexes.avg.usage") + validatedMetrics["splunk.indexes.avg.usage"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexes and their average usage (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.indexes.avg.usage"], "Found a duplicate in the metrics slice: splunk.indexes.avg.usage") + validatedMetrics["splunk.indexes.avg.usage"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexes and their average usage (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.indexes.avg.usage"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.indexes.bucket.count": - assert.False(t, validatedMetrics["splunk.indexes.bucket.count"], "Found a duplicate in the metrics slice: splunk.indexes.bucket.count") - validatedMetrics["splunk.indexes.bucket.count"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the indexes and their bucket counts. *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "{count}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.indexes.bucket.count"], "Found a duplicate in the metrics slice: splunk.indexes.bucket.count") + validatedMetrics["splunk.indexes.bucket.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexes and their bucket counts. *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{count}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.indexes.bucket.count"], "Found a duplicate in the metrics slice: splunk.indexes.bucket.count") + validatedMetrics["splunk.indexes.bucket.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexes and their bucket counts. *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{count}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.indexes.bucket.count"] { + 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("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.indexes.median.data.age": - assert.False(t, validatedMetrics["splunk.indexes.median.data.age"], "Found a duplicate in the metrics slice: splunk.indexes.median.data.age") - validatedMetrics["splunk.indexes.median.data.age"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the indexes and their median data age (days). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "{days}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.indexes.median.data.age"], "Found a duplicate in the metrics slice: splunk.indexes.median.data.age") + validatedMetrics["splunk.indexes.median.data.age"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexes and their median data age (days). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{days}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.indexes.median.data.age"], "Found a duplicate in the metrics slice: splunk.indexes.median.data.age") + validatedMetrics["splunk.indexes.median.data.age"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexes and their median data age (days). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{days}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.indexes.median.data.age"] { + 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("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.indexes.size": - assert.False(t, validatedMetrics["splunk.indexes.size"], "Found a duplicate in the metrics slice: splunk.indexes.size") - validatedMetrics["splunk.indexes.size"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the indexes and their total size (gb). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "Gb", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.indexes.size"], "Found a duplicate in the metrics slice: splunk.indexes.size") + validatedMetrics["splunk.indexes.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexes and their total size (gb). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "Gb", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.indexes.size"], "Found a duplicate in the metrics slice: splunk.indexes.size") + validatedMetrics["splunk.indexes.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexes and their total size (gb). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "Gb", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.indexes.size"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.io.avg.iops": - assert.False(t, validatedMetrics["splunk.io.avg.iops"], "Found a duplicate in the metrics slice: splunk.io.avg.iops") - validatedMetrics["splunk.io.avg.iops"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the average IOPs used per instance", ms.At(i).Description()) - assert.Equal(t, "{iops}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.io.avg.iops"], "Found a duplicate in the metrics slice: splunk.io.avg.iops") + validatedMetrics["splunk.io.avg.iops"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average IOPs used per instance", ms.At(i).Description()) + assert.Equal(t, "{iops}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.io.avg.iops"], "Found a duplicate in the metrics slice: splunk.io.avg.iops") + validatedMetrics["splunk.io.avg.iops"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average IOPs used per instance", ms.At(i).Description()) + assert.Equal(t, "{iops}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.io.avg.iops"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.kvstore.backup.status": - assert.False(t, validatedMetrics["splunk.kvstore.backup.status"], "Found a duplicate in the metrics slice: splunk.kvstore.backup.status") - validatedMetrics["splunk.kvstore.backup.status"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Backup and restore status of the KV store.", ms.At(i).Description()) - assert.Equal(t, "{status}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.kvstore.status.value") - assert.True(t, ok) - assert.Equal(t, "splunk.kvstore.status.value-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.kvstore.backup.status"], "Found a duplicate in the metrics slice: splunk.kvstore.backup.status") + validatedMetrics["splunk.kvstore.backup.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Backup and restore status of the KV store.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.kvstore.status.value") + assert.True(t, ok) + assert.Equal(t, "splunk.kvstore.status.value-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.kvstore.backup.status"], "Found a duplicate in the metrics slice: splunk.kvstore.backup.status") + validatedMetrics["splunk.kvstore.backup.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Backup and restore status of the KV store.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.kvstore.backup.status"] { + 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("splunk.kvstore.status.value") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.kvstore.replication.status": - assert.False(t, validatedMetrics["splunk.kvstore.replication.status"], "Found a duplicate in the metrics slice: splunk.kvstore.replication.status") - validatedMetrics["splunk.kvstore.replication.status"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Replication status of the KV store.", ms.At(i).Description()) - assert.Equal(t, "{status}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.kvstore.status.value") - assert.True(t, ok) - assert.Equal(t, "splunk.kvstore.status.value-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.kvstore.replication.status"], "Found a duplicate in the metrics slice: splunk.kvstore.replication.status") + validatedMetrics["splunk.kvstore.replication.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Replication status of the KV store.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.kvstore.status.value") + assert.True(t, ok) + assert.Equal(t, "splunk.kvstore.status.value-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.kvstore.replication.status"], "Found a duplicate in the metrics slice: splunk.kvstore.replication.status") + validatedMetrics["splunk.kvstore.replication.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Replication status of the KV store.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.kvstore.replication.status"] { + 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("splunk.kvstore.status.value") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.kvstore.status": - assert.False(t, validatedMetrics["splunk.kvstore.status"], "Found a duplicate in the metrics slice: splunk.kvstore.status") - validatedMetrics["splunk.kvstore.status"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "This is the overall status of the kvstore for the given deployment.", ms.At(i).Description()) - assert.Equal(t, "{status}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.kvstore.storage.engine") - assert.True(t, ok) - assert.Equal(t, "splunk.kvstore.storage.engine-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.kvstore.external") - assert.True(t, ok) - assert.Equal(t, "splunk.kvstore.external-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.kvstore.status.value") - assert.True(t, ok) - assert.Equal(t, "splunk.kvstore.status.value-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.kvstore.status"], "Found a duplicate in the metrics slice: splunk.kvstore.status") + validatedMetrics["splunk.kvstore.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "This is the overall status of the kvstore for the given deployment.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.kvstore.storage.engine") + assert.True(t, ok) + assert.Equal(t, "splunk.kvstore.storage.engine-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.kvstore.external") + assert.True(t, ok) + assert.Equal(t, "splunk.kvstore.external-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.kvstore.status.value") + assert.True(t, ok) + assert.Equal(t, "splunk.kvstore.status.value-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.kvstore.status"], "Found a duplicate in the metrics slice: splunk.kvstore.status") + validatedMetrics["splunk.kvstore.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "This is the overall status of the kvstore for the given deployment.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.kvstore.status"] { + 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("splunk.kvstore.storage.engine") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.kvstore.external") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.kvstore.status.value") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.license.expiration.seconds_remaining": - assert.False(t, validatedMetrics["splunk.license.expiration.seconds_remaining"], "Found a duplicate in the metrics slice: splunk.license.expiration.seconds_remaining") - validatedMetrics["splunk.license.expiration.seconds_remaining"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the seconds remaining on any given Splunk License found via Splunk API. **Note:** This will only work on a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "{seconds}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.license.status") - assert.True(t, ok) - assert.Equal(t, "splunk.license.status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.license.label") - assert.True(t, ok) - assert.Equal(t, "splunk.license.label-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.license.type") - assert.True(t, ok) - assert.Equal(t, "splunk.license.type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.license.expiration.seconds_remaining"], "Found a duplicate in the metrics slice: splunk.license.expiration.seconds_remaining") + validatedMetrics["splunk.license.expiration.seconds_remaining"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the seconds remaining on any given Splunk License found via Splunk API. **Note:** This will only work on a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{seconds}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.license.status") + assert.True(t, ok) + assert.Equal(t, "splunk.license.status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.license.label") + assert.True(t, ok) + assert.Equal(t, "splunk.license.label-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.license.type") + assert.True(t, ok) + assert.Equal(t, "splunk.license.type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.license.expiration.seconds_remaining"], "Found a duplicate in the metrics slice: splunk.license.expiration.seconds_remaining") + validatedMetrics["splunk.license.expiration.seconds_remaining"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the seconds remaining on any given Splunk License found via Splunk API. **Note:** This will only work on a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{seconds}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.license.expiration.seconds_remaining"] { + 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("splunk.license.status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.license.label") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.license.type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.license.index.usage": - assert.False(t, validatedMetrics["splunk.license.index.usage"], "Found a duplicate in the metrics slice: splunk.license.index.usage") - validatedMetrics["splunk.license.index.usage"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the indexed license usage per index", ms.At(i).Description()) - assert.Equal(t, "By", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.index.name") - assert.True(t, ok) - assert.Equal(t, "splunk.index.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.license.index.usage"], "Found a duplicate in the metrics slice: splunk.license.index.usage") + validatedMetrics["splunk.license.index.usage"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexed license usage per index", ms.At(i).Description()) + assert.Equal(t, "By", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.index.name") + assert.True(t, ok) + assert.Equal(t, "splunk.index.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.license.index.usage"], "Found a duplicate in the metrics slice: splunk.license.index.usage") + validatedMetrics["splunk.license.index.usage"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the indexed license usage per index", ms.At(i).Description()) + assert.Equal(t, "By", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.license.index.usage"] { + 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("splunk.index.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.parse.queue.ratio": - assert.False(t, validatedMetrics["splunk.parse.queue.ratio"], "Found a duplicate in the metrics slice: splunk.parse.queue.ratio") - validatedMetrics["splunk.parse.queue.ratio"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the average indexer parser queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "{%}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.parse.queue.ratio"], "Found a duplicate in the metrics slice: splunk.parse.queue.ratio") + validatedMetrics["splunk.parse.queue.ratio"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average indexer parser queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.parse.queue.ratio"], "Found a duplicate in the metrics slice: splunk.parse.queue.ratio") + validatedMetrics["splunk.parse.queue.ratio"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average indexer parser queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.parse.queue.ratio"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.pipeline.set.count": - assert.False(t, validatedMetrics["splunk.pipeline.set.count"], "Found a duplicate in the metrics slice: splunk.pipeline.set.count") - validatedMetrics["splunk.pipeline.set.count"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the number of pipeline sets per indexer. **Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "KBy", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.pipeline.set.count"], "Found a duplicate in the metrics slice: splunk.pipeline.set.count") + validatedMetrics["splunk.pipeline.set.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the number of pipeline sets per indexer. **Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "KBy", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.pipeline.set.count"], "Found a duplicate in the metrics slice: splunk.pipeline.set.count") + validatedMetrics["splunk.pipeline.set.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the number of pipeline sets per indexer. **Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "KBy", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.pipeline.set.count"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.scheduler.avg.execution.latency": - assert.False(t, validatedMetrics["splunk.scheduler.avg.execution.latency"], "Found a duplicate in the metrics slice: splunk.scheduler.avg.execution.latency") - validatedMetrics["splunk.scheduler.avg.execution.latency"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the average execution latency of scheduled searches", ms.At(i).Description()) - assert.Equal(t, "{ms}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.scheduler.avg.execution.latency"], "Found a duplicate in the metrics slice: splunk.scheduler.avg.execution.latency") + validatedMetrics["splunk.scheduler.avg.execution.latency"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average execution latency of scheduled searches", ms.At(i).Description()) + assert.Equal(t, "{ms}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.scheduler.avg.execution.latency"], "Found a duplicate in the metrics slice: splunk.scheduler.avg.execution.latency") + validatedMetrics["splunk.scheduler.avg.execution.latency"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average execution latency of scheduled searches", ms.At(i).Description()) + assert.Equal(t, "{ms}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.scheduler.avg.execution.latency"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.scheduler.avg.run.time": - assert.False(t, validatedMetrics["splunk.scheduler.avg.run.time"], "Found a duplicate in the metrics slice: splunk.scheduler.avg.run.time") - validatedMetrics["splunk.scheduler.avg.run.time"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the average runtime of scheduled searches", ms.At(i).Description()) - assert.Equal(t, "{ms}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.scheduler.avg.run.time"], "Found a duplicate in the metrics slice: splunk.scheduler.avg.run.time") + validatedMetrics["splunk.scheduler.avg.run.time"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average runtime of scheduled searches", ms.At(i).Description()) + assert.Equal(t, "{ms}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.scheduler.avg.run.time"], "Found a duplicate in the metrics slice: splunk.scheduler.avg.run.time") + validatedMetrics["splunk.scheduler.avg.run.time"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average runtime of scheduled searches", ms.At(i).Description()) + assert.Equal(t, "{ms}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.scheduler.avg.run.time"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.scheduler.completion.ratio": - assert.False(t, validatedMetrics["splunk.scheduler.completion.ratio"], "Found a duplicate in the metrics slice: splunk.scheduler.completion.ratio") - validatedMetrics["splunk.scheduler.completion.ratio"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the ratio of completed to skipped scheduled searches", ms.At(i).Description()) - assert.Equal(t, "{%}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.scheduler.completion.ratio"], "Found a duplicate in the metrics slice: splunk.scheduler.completion.ratio") + validatedMetrics["splunk.scheduler.completion.ratio"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the ratio of completed to skipped scheduled searches", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.scheduler.completion.ratio"], "Found a duplicate in the metrics slice: splunk.scheduler.completion.ratio") + validatedMetrics["splunk.scheduler.completion.ratio"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the ratio of completed to skipped scheduled searches", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.scheduler.completion.ratio"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.search.duration": - assert.False(t, validatedMetrics["splunk.search.duration"], "Found a duplicate in the metrics slice: splunk.search.duration") - validatedMetrics["splunk.search.duration"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the duration in seconds of the last search probe call.", ms.At(i).Description()) - assert.Equal(t, "{status}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.search.duration"], "Found a duplicate in the metrics slice: splunk.search.duration") + validatedMetrics["splunk.search.duration"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the duration in seconds of the last search probe call.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.search.duration"], "Found a duplicate in the metrics slice: splunk.search.duration") + validatedMetrics["splunk.search.duration"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the duration in seconds of the last search probe call.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.search.duration"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.search.initiation": - assert.False(t, validatedMetrics["splunk.search.initiation"], "Found a duplicate in the metrics slice: splunk.search.initiation") - validatedMetrics["splunk.search.initiation"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking whether the last search probe successfully initiated a search.", ms.At(i).Description()) - assert.Equal(t, "{status}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.search.initiation"], "Found a duplicate in the metrics slice: splunk.search.initiation") + validatedMetrics["splunk.search.initiation"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking whether the last search probe successfully initiated a search.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.search.initiation"], "Found a duplicate in the metrics slice: splunk.search.initiation") + validatedMetrics["splunk.search.initiation"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking whether the last search probe successfully initiated a search.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.search.initiation"] { + 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("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.search.status": - assert.False(t, validatedMetrics["splunk.search.status"], "Found a duplicate in the metrics slice: splunk.search.status") - validatedMetrics["splunk.search.status"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the dispatch status of the last search probe.", ms.At(i).Description()) - assert.Equal(t, "{status}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.search.state") - assert.True(t, ok) - assert.Equal(t, "splunk.search.state-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.search.status"], "Found a duplicate in the metrics slice: splunk.search.status") + validatedMetrics["splunk.search.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the dispatch status of the last search probe.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.search.state") + assert.True(t, ok) + assert.Equal(t, "splunk.search.state-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.search.status"], "Found a duplicate in the metrics slice: splunk.search.status") + validatedMetrics["splunk.search.status"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the dispatch status of the last search probe.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.search.status"] { + 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("splunk.search.state") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.search.success": - assert.False(t, validatedMetrics["splunk.search.success"], "Found a duplicate in the metrics slice: splunk.search.success") - validatedMetrics["splunk.search.success"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking whether the last search probe call was successful with the dispatch state 'DONE'.", ms.At(i).Description()) - assert.Equal(t, "{status}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.search.success"], "Found a duplicate in the metrics slice: splunk.search.success") + validatedMetrics["splunk.search.success"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking whether the last search probe call was successful with the dispatch state 'DONE'.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.search.success"], "Found a duplicate in the metrics slice: splunk.search.success") + validatedMetrics["splunk.search.success"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking whether the last search probe call was successful with the dispatch state 'DONE'.", ms.At(i).Description()) + assert.Equal(t, "{status}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.search.success"] { + 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("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.introspection.queues.current": - assert.False(t, validatedMetrics["splunk.server.introspection.queues.current"], "Found a duplicate in the metrics slice: splunk.server.introspection.queues.current") - validatedMetrics["splunk.server.introspection.queues.current"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking current length of queue. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) - assert.Equal(t, "{queues}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.queue.name") - assert.True(t, ok) - assert.Equal(t, "splunk.queue.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.introspection.queues.current"], "Found a duplicate in the metrics slice: splunk.server.introspection.queues.current") + validatedMetrics["splunk.server.introspection.queues.current"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking current length of queue. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "{queues}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.queue.name") + assert.True(t, ok) + assert.Equal(t, "splunk.queue.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.introspection.queues.current"], "Found a duplicate in the metrics slice: splunk.server.introspection.queues.current") + validatedMetrics["splunk.server.introspection.queues.current"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking current length of queue. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "{queues}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.introspection.queues.current"] { + 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("splunk.queue.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.introspection.queues.current.bytes": - assert.False(t, validatedMetrics["splunk.server.introspection.queues.current.bytes"], "Found a duplicate in the metrics slice: splunk.server.introspection.queues.current.bytes") - validatedMetrics["splunk.server.introspection.queues.current.bytes"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking current bytes waiting in queue. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) - assert.Equal(t, "By", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.queue.name") - assert.True(t, ok) - assert.Equal(t, "splunk.queue.name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.introspection.queues.current.bytes"], "Found a duplicate in the metrics slice: splunk.server.introspection.queues.current.bytes") + validatedMetrics["splunk.server.introspection.queues.current.bytes"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking current bytes waiting in queue. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "By", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.queue.name") + assert.True(t, ok) + assert.Equal(t, "splunk.queue.name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.introspection.queues.current.bytes"], "Found a duplicate in the metrics slice: splunk.server.introspection.queues.current.bytes") + validatedMetrics["splunk.server.introspection.queues.current.bytes"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking current bytes waiting in queue. *Note:** Must be pointed at specific indexer `endpoint` and gathers metrics from only that indexer.", ms.At(i).Description()) + assert.Equal(t, "By", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.introspection.queues.current.bytes"] { + 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("splunk.queue.name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.adhoc": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.adhoc"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.adhoc") - validatedMetrics["splunk.server.searchartifacts.adhoc"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking number of ad hoc search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.adhoc"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.adhoc") + validatedMetrics["splunk.server.searchartifacts.adhoc"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number of ad hoc search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.adhoc"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.adhoc") + validatedMetrics["splunk.server.searchartifacts.adhoc"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number of ad hoc search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.adhoc"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.adhoc.size": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.adhoc.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.adhoc.size") - validatedMetrics["splunk.server.searchartifacts.adhoc.size"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge total size (MB) of ad hoc search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.adhoc.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.adhoc.size") + validatedMetrics["splunk.server.searchartifacts.adhoc.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge total size (MB) of ad hoc search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.adhoc.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.adhoc.size") + validatedMetrics["splunk.server.searchartifacts.adhoc.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge total size (MB) of ad hoc search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.adhoc.size"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.completed": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.completed"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.completed") - validatedMetrics["splunk.server.searchartifacts.completed"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking number of artifacts currently on disk that belong to finished searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.completed"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.completed") + validatedMetrics["splunk.server.searchartifacts.completed"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number of artifacts currently on disk that belong to finished searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.completed"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.completed") + validatedMetrics["splunk.server.searchartifacts.completed"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number of artifacts currently on disk that belong to finished searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.completed"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.completed.size": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.completed.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.completed.size") - validatedMetrics["splunk.server.searchartifacts.completed.size"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge total size (MB) of artifacts currently on disk that belong to finished searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.completed.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.completed.size") + validatedMetrics["splunk.server.searchartifacts.completed.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge total size (MB) of artifacts currently on disk that belong to finished searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.completed.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.completed.size") + validatedMetrics["splunk.server.searchartifacts.completed.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge total size (MB) of artifacts currently on disk that belong to finished searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.completed.size"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.incomplete": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.incomplete"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.incomplete") - validatedMetrics["splunk.server.searchartifacts.incomplete"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking number of artifacts currently on disk that belong to unfinished/running searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.incomplete"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.incomplete") + validatedMetrics["splunk.server.searchartifacts.incomplete"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number of artifacts currently on disk that belong to unfinished/running searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.incomplete"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.incomplete") + validatedMetrics["splunk.server.searchartifacts.incomplete"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number of artifacts currently on disk that belong to unfinished/running searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.incomplete"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.incomplete.size": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.incomplete.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.incomplete.size") - validatedMetrics["splunk.server.searchartifacts.incomplete.size"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge total size (MB) of artifacts currently on disk that belong to unfinished/running searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.incomplete.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.incomplete.size") + validatedMetrics["splunk.server.searchartifacts.incomplete.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge total size (MB) of artifacts currently on disk that belong to unfinished/running searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.incomplete.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.incomplete.size") + validatedMetrics["splunk.server.searchartifacts.incomplete.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge total size (MB) of artifacts currently on disk that belong to unfinished/running searches. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.incomplete.size"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.invalid": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.invalid"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.invalid") - validatedMetrics["splunk.server.searchartifacts.invalid"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking number of artifacts currently on disk that are not in a valid state, such as missing info.csv file, etc. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.invalid"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.invalid") + validatedMetrics["splunk.server.searchartifacts.invalid"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number of artifacts currently on disk that are not in a valid state, such as missing info.csv file, etc. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.invalid"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.invalid") + validatedMetrics["splunk.server.searchartifacts.invalid"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number of artifacts currently on disk that are not in a valid state, such as missing info.csv file, etc. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.invalid"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.job.cache.count": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.job.cache.count"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.job.cache.count") - validatedMetrics["splunk.server.searchartifacts.job.cache.count"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking number search artifacts metadata stored in memory, available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.job.cache.count"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.job.cache.count") + validatedMetrics["splunk.server.searchartifacts.job.cache.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number search artifacts metadata stored in memory, available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.job.cache.count"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.job.cache.count") + validatedMetrics["splunk.server.searchartifacts.job.cache.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number search artifacts metadata stored in memory, available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.job.cache.count"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.job.cache.size": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.job.cache.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.job.cache.size") - validatedMetrics["splunk.server.searchartifacts.job.cache.size"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking, in megabytes, memory used to cache job status and job info of all search artifacts, available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{mb}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.searchartifacts.cache.type") - assert.True(t, ok) - assert.Equal(t, "splunk.searchartifacts.cache.type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.job.cache.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.job.cache.size") + validatedMetrics["splunk.server.searchartifacts.job.cache.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking, in megabytes, memory used to cache job status and job info of all search artifacts, available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{mb}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.searchartifacts.cache.type") + assert.True(t, ok) + assert.Equal(t, "splunk.searchartifacts.cache.type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.job.cache.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.job.cache.size") + validatedMetrics["splunk.server.searchartifacts.job.cache.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking, in megabytes, memory used to cache job status and job info of all search artifacts, available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{mb}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.job.cache.size"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.searchartifacts.cache.type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.savedsearches": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.savedsearches"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.savedsearches") - validatedMetrics["splunk.server.searchartifacts.savedsearches"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking, for the `splunk.server.searchartifacts.scheduled` number of scheduled search artifacts, how many different saved-searches they belong to. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.savedsearches"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.savedsearches") + validatedMetrics["splunk.server.searchartifacts.savedsearches"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking, for the `splunk.server.searchartifacts.scheduled` number of scheduled search artifacts, how many different saved-searches they belong to. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.savedsearches"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.savedsearches") + validatedMetrics["splunk.server.searchartifacts.savedsearches"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking, for the `splunk.server.searchartifacts.scheduled` number of scheduled search artifacts, how many different saved-searches they belong to. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.savedsearches"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.scheduled": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.scheduled"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.scheduled") - validatedMetrics["splunk.server.searchartifacts.scheduled"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking number of scheduled search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.scheduled"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.scheduled") + validatedMetrics["splunk.server.searchartifacts.scheduled"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number of scheduled search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.scheduled"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.scheduled") + validatedMetrics["splunk.server.searchartifacts.scheduled"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking number of scheduled search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.scheduled"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.server.searchartifacts.scheduled.size": - assert.False(t, validatedMetrics["splunk.server.searchartifacts.scheduled.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.scheduled.size") - validatedMetrics["splunk.server.searchartifacts.scheduled.size"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge total size (MB) of scheduled search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) - assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().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()) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.scheduled.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.scheduled.size") + validatedMetrics["splunk.server.searchartifacts.scheduled.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge total size (MB) of scheduled search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().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()) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.server.searchartifacts.scheduled.size"], "Found a duplicate in the metrics slice: splunk.server.searchartifacts.scheduled.size") + validatedMetrics["splunk.server.searchartifacts.scheduled.size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge total size (MB) of scheduled search artifacts currently on disk. Note:* Must be pointed at specific Search Head endpoint and gathers metrics from only that Search Head. Available in builds 9.1.2312.207+ and 9.3.x+.", ms.At(i).Description()) + assert.Equal(t, "{search_artifacts}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + switch aggMap["splunk.server.searchartifacts.scheduled.size"] { + 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("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } case "splunk.typing.queue.ratio": - assert.False(t, validatedMetrics["splunk.typing.queue.ratio"], "Found a duplicate in the metrics slice: splunk.typing.queue.ratio") - validatedMetrics["splunk.typing.queue.ratio"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Gauge tracking the average indexer typing queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) - assert.Equal(t, "{%}", ms.At(i).Unit()) - dp := ms.At(i).Gauge().DataPoints().At(0) - assert.Equal(t, start, dp.StartTimestamp()) - assert.Equal(t, ts, dp.Timestamp()) - assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("splunk.host") - assert.True(t, ok) - assert.Equal(t, "splunk.host-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") - assert.True(t, ok) - assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["splunk.typing.queue.ratio"], "Found a duplicate in the metrics slice: splunk.typing.queue.ratio") + validatedMetrics["splunk.typing.queue.ratio"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average indexer typing queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("splunk.host") + assert.True(t, ok) + assert.Equal(t, "splunk.host-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.build-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.True(t, ok) + assert.Equal(t, "splunk.splunkd.version-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["splunk.typing.queue.ratio"], "Found a duplicate in the metrics slice: splunk.typing.queue.ratio") + validatedMetrics["splunk.typing.queue.ratio"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Gauge tracking the average indexer typing queue ration (%). *Note:** Search is best run against a Cluster Manager.", ms.At(i).Description()) + assert.Equal(t, "{%}", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["splunk.typing.queue.ratio"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("splunk.host") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.build") + assert.False(t, ok) + _, ok = dp.Attributes().Get("splunk.splunkd.version") + assert.False(t, ok) + } } } }) diff --git a/receiver/splunkenterprisereceiver/internal/metadata/testdata/config.yaml b/receiver/splunkenterprisereceiver/internal/metadata/testdata/config.yaml index 09e1ed53d8893..ec8fb3e153a7c 100644 --- a/receiver/splunkenterprisereceiver/internal/metadata/testdata/config.yaml +++ b/receiver/splunkenterprisereceiver/internal/metadata/testdata/config.yaml @@ -3,207 +3,464 @@ all_set: metrics: splunk.aggregation.queue.ratio: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.buckets.searchable.status: enabled: true + attributes: ["splunk.host","splunk.indexer.searchable","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.bucket.count: enabled: true + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.bucket.event.count: enabled: true + attributes: ["splunk.index.name","splunk.bucket.dir","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.bucket.hot.count: enabled: true + attributes: ["splunk.index.name","splunk.bucket.dir","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.bucket.warm.count: enabled: true + attributes: ["splunk.index.name","splunk.bucket.dir","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.event.count: enabled: true + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.raw.size: enabled: true + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.total.size: enabled: true + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.health: enabled: true + attributes: ["splunk.feature","splunk.feature.health","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.avg.rate: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.cpu.time: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.queue.ratio: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.raw.write.time: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.rollingrestart.status: enabled: true + attributes: ["splunk.searchable.restart","splunk.rollingorrestart","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.throughput: enabled: true + attributes: ["splunk.indexer.status","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexes.avg.size: enabled: true + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexes.avg.usage: enabled: true + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexes.bucket.count: enabled: true + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexes.median.data.age: enabled: true + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexes.size: enabled: true + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.io.avg.iops: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.kvstore.backup.status: enabled: true + attributes: ["splunk.kvstore.status.value","splunk.splunkd.build","splunk.splunkd.version"] splunk.kvstore.replication.status: enabled: true + attributes: ["splunk.kvstore.status.value","splunk.splunkd.build","splunk.splunkd.version"] splunk.kvstore.status: enabled: true + attributes: ["splunk.kvstore.storage.engine","splunk.kvstore.external","splunk.kvstore.status.value","splunk.splunkd.build","splunk.splunkd.version"] splunk.license.expiration.seconds_remaining: enabled: true + attributes: ["splunk.license.status","splunk.license.label","splunk.license.type","splunk.splunkd.build","splunk.splunkd.version"] splunk.license.index.usage: enabled: true + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.parse.queue.ratio: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.pipeline.set.count: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.scheduler.avg.execution.latency: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.scheduler.avg.run.time: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.scheduler.completion.ratio: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.search.duration: enabled: true + attributes: ["splunk.splunkd.build","splunk.splunkd.version"] splunk.search.initiation: enabled: true + attributes: ["splunk.splunkd.build","splunk.splunkd.version"] splunk.search.status: enabled: true + attributes: ["splunk.search.state","splunk.splunkd.build","splunk.splunkd.version"] splunk.search.success: enabled: true + attributes: ["splunk.splunkd.build","splunk.splunkd.version"] splunk.server.introspection.queues.current: enabled: true + attributes: ["splunk.queue.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.introspection.queues.current.bytes: enabled: true + attributes: ["splunk.queue.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.adhoc: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.adhoc.size: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.completed: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.completed.size: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.incomplete: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.incomplete.size: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.invalid: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.job.cache.count: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.job.cache.size: enabled: true + attributes: ["splunk.host","splunk.searchartifacts.cache.type","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.savedsearches: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.scheduled: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.scheduled.size: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.typing.queue.ratio: enabled: true + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] +reaggregate_set: + metrics: + splunk.aggregation.queue.ratio: + enabled: true + attributes: [] + splunk.buckets.searchable.status: + enabled: true + attributes: [] + splunk.data.indexes.extended.bucket.count: + enabled: true + attributes: [] + splunk.data.indexes.extended.bucket.event.count: + enabled: true + attributes: [] + splunk.data.indexes.extended.bucket.hot.count: + enabled: true + attributes: [] + splunk.data.indexes.extended.bucket.warm.count: + enabled: true + attributes: [] + splunk.data.indexes.extended.event.count: + enabled: true + attributes: [] + splunk.data.indexes.extended.raw.size: + enabled: true + attributes: [] + splunk.data.indexes.extended.total.size: + enabled: true + attributes: [] + splunk.health: + enabled: true + attributes: [] + splunk.indexer.avg.rate: + enabled: true + attributes: [] + splunk.indexer.cpu.time: + enabled: true + attributes: [] + splunk.indexer.queue.ratio: + enabled: true + attributes: [] + splunk.indexer.raw.write.time: + enabled: true + attributes: [] + splunk.indexer.rollingrestart.status: + enabled: true + attributes: [] + splunk.indexer.throughput: + enabled: true + attributes: [] + splunk.indexes.avg.size: + enabled: true + attributes: [] + splunk.indexes.avg.usage: + enabled: true + attributes: [] + splunk.indexes.bucket.count: + enabled: true + attributes: [] + splunk.indexes.median.data.age: + enabled: true + attributes: [] + splunk.indexes.size: + enabled: true + attributes: [] + splunk.io.avg.iops: + enabled: true + attributes: [] + splunk.kvstore.backup.status: + enabled: true + attributes: [] + splunk.kvstore.replication.status: + enabled: true + attributes: [] + splunk.kvstore.status: + enabled: true + attributes: [] + splunk.license.expiration.seconds_remaining: + enabled: true + attributes: [] + splunk.license.index.usage: + enabled: true + attributes: [] + splunk.parse.queue.ratio: + enabled: true + attributes: [] + splunk.pipeline.set.count: + enabled: true + attributes: [] + splunk.scheduler.avg.execution.latency: + enabled: true + attributes: [] + splunk.scheduler.avg.run.time: + enabled: true + attributes: [] + splunk.scheduler.completion.ratio: + enabled: true + attributes: [] + splunk.search.duration: + enabled: true + attributes: [] + splunk.search.initiation: + enabled: true + attributes: [] + splunk.search.status: + enabled: true + attributes: [] + splunk.search.success: + enabled: true + attributes: [] + splunk.server.introspection.queues.current: + enabled: true + attributes: [] + splunk.server.introspection.queues.current.bytes: + enabled: true + attributes: [] + splunk.server.searchartifacts.adhoc: + enabled: true + attributes: [] + splunk.server.searchartifacts.adhoc.size: + enabled: true + attributes: [] + splunk.server.searchartifacts.completed: + enabled: true + attributes: [] + splunk.server.searchartifacts.completed.size: + enabled: true + attributes: [] + splunk.server.searchartifacts.incomplete: + enabled: true + attributes: [] + splunk.server.searchartifacts.incomplete.size: + enabled: true + attributes: [] + splunk.server.searchartifacts.invalid: + enabled: true + attributes: [] + splunk.server.searchartifacts.job.cache.count: + enabled: true + attributes: [] + splunk.server.searchartifacts.job.cache.size: + enabled: true + attributes: [] + splunk.server.searchartifacts.savedsearches: + enabled: true + attributes: [] + splunk.server.searchartifacts.scheduled: + enabled: true + attributes: [] + splunk.server.searchartifacts.scheduled.size: + enabled: true + attributes: [] + splunk.typing.queue.ratio: + enabled: true + attributes: [] none_set: metrics: splunk.aggregation.queue.ratio: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.buckets.searchable.status: enabled: false + attributes: ["splunk.host","splunk.indexer.searchable","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.bucket.count: enabled: false + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.bucket.event.count: enabled: false + attributes: ["splunk.index.name","splunk.bucket.dir","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.bucket.hot.count: enabled: false + attributes: ["splunk.index.name","splunk.bucket.dir","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.bucket.warm.count: enabled: false + attributes: ["splunk.index.name","splunk.bucket.dir","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.event.count: enabled: false + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.raw.size: enabled: false + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.data.indexes.extended.total.size: enabled: false + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.health: enabled: false + attributes: ["splunk.feature","splunk.feature.health","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.avg.rate: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.cpu.time: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.queue.ratio: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.raw.write.time: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.rollingrestart.status: enabled: false + attributes: ["splunk.searchable.restart","splunk.rollingorrestart","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexer.throughput: enabled: false + attributes: ["splunk.indexer.status","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexes.avg.size: enabled: false + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexes.avg.usage: enabled: false + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexes.bucket.count: enabled: false + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexes.median.data.age: enabled: false + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.indexes.size: enabled: false + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.io.avg.iops: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.kvstore.backup.status: enabled: false + attributes: ["splunk.kvstore.status.value","splunk.splunkd.build","splunk.splunkd.version"] splunk.kvstore.replication.status: enabled: false + attributes: ["splunk.kvstore.status.value","splunk.splunkd.build","splunk.splunkd.version"] splunk.kvstore.status: enabled: false + attributes: ["splunk.kvstore.storage.engine","splunk.kvstore.external","splunk.kvstore.status.value","splunk.splunkd.build","splunk.splunkd.version"] splunk.license.expiration.seconds_remaining: enabled: false + attributes: ["splunk.license.status","splunk.license.label","splunk.license.type","splunk.splunkd.build","splunk.splunkd.version"] splunk.license.index.usage: enabled: false + attributes: ["splunk.index.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.parse.queue.ratio: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.pipeline.set.count: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.scheduler.avg.execution.latency: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.scheduler.avg.run.time: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.scheduler.completion.ratio: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.search.duration: enabled: false + attributes: ["splunk.splunkd.build","splunk.splunkd.version"] splunk.search.initiation: enabled: false + attributes: ["splunk.splunkd.build","splunk.splunkd.version"] splunk.search.status: enabled: false + attributes: ["splunk.search.state","splunk.splunkd.build","splunk.splunkd.version"] splunk.search.success: enabled: false + attributes: ["splunk.splunkd.build","splunk.splunkd.version"] splunk.server.introspection.queues.current: enabled: false + attributes: ["splunk.queue.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.introspection.queues.current.bytes: enabled: false + attributes: ["splunk.queue.name","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.adhoc: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.adhoc.size: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.completed: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.completed.size: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.incomplete: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.incomplete.size: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.invalid: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.job.cache.count: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.job.cache.size: enabled: false + attributes: ["splunk.host","splunk.searchartifacts.cache.type","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.savedsearches: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.scheduled: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.server.searchartifacts.scheduled.size: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] splunk.typing.queue.ratio: enabled: false + attributes: ["splunk.host","splunk.splunkd.build","splunk.splunkd.version"] diff --git a/receiver/splunkenterprisereceiver/metadata.yaml b/receiver/splunkenterprisereceiver/metadata.yaml index c4651eaf24b22..f157d359edb6d 100644 --- a/receiver/splunkenterprisereceiver/metadata.yaml +++ b/receiver/splunkenterprisereceiver/metadata.yaml @@ -8,68 +8,88 @@ status: codeowners: active: [shalper2, MovieStoreGuy, greatestusername] +reaggregation_enabled: true attributes: splunk.bucket.dir: description: The bucket super-directory (home, cold, thawed) for each index type: string + requirement_level: recommended splunk.feature: description: The Feature name from the Splunk Health Introspection Endpoint type: string + requirement_level: recommended splunk.feature.health: description: The Health (in color form) of a Splunk Feature from the Splunk Health Introspection Endpoint type: string + requirement_level: recommended splunk.host: description: The name of the splunk host type: string + requirement_level: recommended splunk.index.name: description: The name of the index reporting a specific KPI type: string + requirement_level: recommended splunk.indexer.searchable: description: The searchability status reported for a specific object type: string + requirement_level: recommended splunk.indexer.status: description: The status message reported for a specific object type: string + requirement_level: recommended splunk.kvstore.external: description: Value denoting if the KV store is using an external service type: string + requirement_level: recommended splunk.kvstore.status.value: description: The string value of the status returned when reporting on KV store using the introspection endpoint type: string + requirement_level: recommended splunk.kvstore.storage.engine: description: The backend storage used by the KV store type: string + requirement_level: recommended splunk.license.label: description: The label of the license. type: string + requirement_level: recommended splunk.license.status: description: The status of the license. type: string + requirement_level: recommended splunk.license.type: description: The type of license. type: string - + requirement_level: recommended splunk.queue.name: description: The name of the queue reporting a specific KPI type: string + requirement_level: recommended splunk.rollingorrestart: description: Boolean that indicates if there is a rolling restart or rolling upgrade in progress. type: bool + requirement_level: recommended splunk.search.state: description: The dispatch state of the search type: string + requirement_level: recommended splunk.searchable.restart: description: Boolean that indicates if a searchable rolling restart/upgrade in progress.t type: bool + requirement_level: recommended splunk.searchartifacts.cache.type: description: The search artifacts cache type type: string + requirement_level: recommended splunk.splunkd.build: description: The build number for this Splunk instance version type: string + requirement_level: recommended splunk.splunkd.version: description: The splunkd version number type: string + requirement_level: recommended metrics: splunk.aggregation.queue.ratio: diff --git a/receiver/splunkenterprisereceiver/testdata/scraper/expected.yaml b/receiver/splunkenterprisereceiver/testdata/scraper/expected.yaml index 0031134a63f1e..a1629cec92eaf 100644 --- a/receiver/splunkenterprisereceiver/testdata/scraper/expected.yaml +++ b/receiver/splunkenterprisereceiver/testdata/scraper/expected.yaml @@ -6,16 +6,6 @@ resourceMetrics: gauge: dataPoints: - asInt: "51" - attributes: - - key: splunk.index.name - value: - stringValue: _audit - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.bucket.count @@ -24,19 +14,6 @@ resourceMetrics: gauge: dataPoints: - asInt: "107267027" - attributes: - - key: splunk.bucket.dir - value: - stringValue: home - - key: splunk.index.name - value: - stringValue: _audit - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.bucket.event.count @@ -45,19 +22,6 @@ resourceMetrics: gauge: dataPoints: - asInt: "1" - attributes: - - key: splunk.bucket.dir - value: - stringValue: hot - - key: splunk.index.name - value: - stringValue: _audit - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.bucket.hot.count @@ -66,19 +30,6 @@ resourceMetrics: gauge: dataPoints: - asInt: "50" - attributes: - - key: splunk.bucket.dir - value: - stringValue: warm - - key: splunk.index.name - value: - stringValue: _audit - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.bucket.warm.count @@ -87,16 +38,6 @@ resourceMetrics: gauge: dataPoints: - asInt: "108411855" - attributes: - - key: splunk.index.name - value: - stringValue: _audit - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.event.count @@ -105,16 +46,6 @@ resourceMetrics: gauge: dataPoints: - asInt: "70825079209" - attributes: - - key: splunk.index.name - value: - stringValue: _audit - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.raw.size @@ -123,16 +54,6 @@ resourceMetrics: gauge: dataPoints: - asInt: "20818468798" - attributes: - - key: splunk.index.name - value: - stringValue: _audit - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.total.size @@ -141,16 +62,6 @@ resourceMetrics: gauge: dataPoints: - asDouble: 69.2 - attributes: - - key: splunk.host - value: - stringValue: some-host - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.indexer.cpu.time @@ -159,19 +70,6 @@ resourceMetrics: gauge: dataPoints: - asInt: "0" - attributes: - - key: splunk.rollingorrestart - value: - boolValue: false - - key: splunk.searchable.restart - value: - boolValue: false - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.indexer.rollingrestart.status @@ -180,16 +78,6 @@ resourceMetrics: gauge: dataPoints: - asDouble: 25579.690815904476 - attributes: - - key: splunk.indexer.status - value: - stringValue: normal - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.indexer.throughput @@ -198,16 +86,6 @@ resourceMetrics: gauge: dataPoints: - asInt: "200400" - attributes: - - key: splunk.host - value: - stringValue: some-host - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.io.avg.iops @@ -260,16 +138,6 @@ resourceMetrics: gauge: dataPoints: - asDouble: 200.4 - attributes: - - key: splunk.host - value: - stringValue: some-host - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.scheduler.avg.run.time @@ -278,16 +146,6 @@ resourceMetrics: gauge: dataPoints: - asInt: "1" - attributes: - - key: splunk.queue.name - value: - stringValue: AEQ - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.server.introspection.queues.current @@ -296,16 +154,6 @@ resourceMetrics: gauge: dataPoints: - asInt: "100" - attributes: - - key: splunk.queue.name - value: - stringValue: AEQ - - key: splunk.splunkd.build - value: - stringValue: "" - - key: splunk.splunkd.version - value: - stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.server.introspection.queues.current.bytes From 62783022609290c71d33310d9f09621757d3ee98 Mon Sep 17 00:00:00 2001 From: shalper2 Date: Tue, 13 Jan 2026 14:32:43 -0600 Subject: [PATCH 2/5] chlog --- .chloggen/45396-enable-reaggregation.yaml | 27 +++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 .chloggen/45396-enable-reaggregation.yaml diff --git a/.chloggen/45396-enable-reaggregation.yaml b/.chloggen/45396-enable-reaggregation.yaml new file mode 100644 index 0000000000000..3d0a82f3b6da3 --- /dev/null +++ b/.chloggen/45396-enable-reaggregation.yaml @@ -0,0 +1,27 @@ +# 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/splunkenterprise + +# A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`). +note: Enables dynamic metric reaggregation in the Splunk Enterprise receiver. This does not break existing configuration files. + +# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists. +issues: [45396] + +# (Optional) One or more lines of additional information to render under the primary note. +# These lines will be padded with 2 spaces and then inserted directly into the document. +# Use pipe (|) for multiline entries. +subtext: + +# If your change doesn't affect end users or the exported elements of any package, +# you should instead start your pull request title with [chore] or use the "Skip Changelog" label. +# Optional: The change log or logs in which this entry should be included. +# e.g. '[user]' or '[user, api]' +# Include 'user' if the change is relevant to end users. +# Include 'api' if there is a change to a library API. +# Default: '[user]' +change_logs: [user, api] From 12bd30e7ae89cb3718566e6169723a2d130a12cf Mon Sep 17 00:00:00 2001 From: shalper2 Date: Wed, 14 Jan 2026 10:00:21 -0600 Subject: [PATCH 3/5] fixed tests --- .../splunkenterprisereceiver/metadata.yaml | 2 +- .../splunkenterprisereceiver/scraper_test.go | 37 ++--- .../testdata/scraper/expected.yaml | 152 ++++++++++++++++++ 3 files changed, 172 insertions(+), 19 deletions(-) diff --git a/receiver/splunkenterprisereceiver/metadata.yaml b/receiver/splunkenterprisereceiver/metadata.yaml index f157d359edb6d..6c12315f0dc17 100644 --- a/receiver/splunkenterprisereceiver/metadata.yaml +++ b/receiver/splunkenterprisereceiver/metadata.yaml @@ -8,7 +8,7 @@ status: codeowners: active: [shalper2, MovieStoreGuy, greatestusername] -reaggregation_enabled: true +reaggregation_enabled: true attributes: splunk.bucket.dir: description: The bucket super-directory (home, cold, thawed) for each index diff --git a/receiver/splunkenterprisereceiver/scraper_test.go b/receiver/splunkenterprisereceiver/scraper_test.go index 1a20bfe2c9542..f4ab202ffc846 100644 --- a/receiver/splunkenterprisereceiver/scraper_test.go +++ b/receiver/splunkenterprisereceiver/scraper_test.go @@ -166,24 +166,25 @@ func createConfig(ts *httptest.Server, badConfig bool) *Config { } else { endpoint = ts.URL } - metricsettings := metadata.MetricsBuilderConfig{} + metricsCfg := metadata.DefaultMetricsBuilderConfig() // in the future add more metrics - metricsettings.Metrics.SplunkIndexerThroughput.Enabled = true - metricsettings.Metrics.SplunkDataIndexesExtendedTotalSize.Enabled = true - metricsettings.Metrics.SplunkDataIndexesExtendedEventCount.Enabled = true - metricsettings.Metrics.SplunkDataIndexesExtendedBucketCount.Enabled = true - metricsettings.Metrics.SplunkDataIndexesExtendedRawSize.Enabled = true - metricsettings.Metrics.SplunkDataIndexesExtendedBucketEventCount.Enabled = true - metricsettings.Metrics.SplunkDataIndexesExtendedBucketHotCount.Enabled = true - metricsettings.Metrics.SplunkDataIndexesExtendedBucketWarmCount.Enabled = true - metricsettings.Metrics.SplunkServerIntrospectionQueuesCurrent.Enabled = true - metricsettings.Metrics.SplunkServerIntrospectionQueuesCurrentBytes.Enabled = true - metricsettings.Metrics.SplunkIndexerRollingrestartStatus.Enabled = true - metricsettings.Metrics.SplunkIndexerCPUTime.Enabled = true - metricsettings.Metrics.SplunkIoAvgIops.Enabled = true - metricsettings.Metrics.SplunkSchedulerAvgRunTime.Enabled = true - metricsettings.Metrics.SplunkServerSearchartifactsAdhoc.Enabled = true - metricsettings.Metrics.SplunkLicenseIndexUsage.Enabled = true + metricsCfg.Metrics.SplunkHealth.Enabled = false + metricsCfg.Metrics.SplunkIndexerThroughput.Enabled = true + metricsCfg.Metrics.SplunkDataIndexesExtendedTotalSize.Enabled = true + metricsCfg.Metrics.SplunkDataIndexesExtendedEventCount.Enabled = true + metricsCfg.Metrics.SplunkDataIndexesExtendedBucketCount.Enabled = true + metricsCfg.Metrics.SplunkDataIndexesExtendedRawSize.Enabled = true + metricsCfg.Metrics.SplunkDataIndexesExtendedBucketEventCount.Enabled = true + metricsCfg.Metrics.SplunkDataIndexesExtendedBucketHotCount.Enabled = true + metricsCfg.Metrics.SplunkDataIndexesExtendedBucketWarmCount.Enabled = true + metricsCfg.Metrics.SplunkServerIntrospectionQueuesCurrent.Enabled = true + metricsCfg.Metrics.SplunkServerIntrospectionQueuesCurrentBytes.Enabled = true + metricsCfg.Metrics.SplunkIndexerRollingrestartStatus.Enabled = true + metricsCfg.Metrics.SplunkIndexerCPUTime.Enabled = true + metricsCfg.Metrics.SplunkIoAvgIops.Enabled = true + metricsCfg.Metrics.SplunkSchedulerAvgRunTime.Enabled = true + metricsCfg.Metrics.SplunkServerSearchartifactsAdhoc.Enabled = true + metricsCfg.Metrics.SplunkLicenseIndexUsage.Enabled = true return &Config{ IdxEndpoint: confighttp.ClientConfig{ Endpoint: endpoint, @@ -202,7 +203,7 @@ func createConfig(ts *httptest.Server, badConfig bool) *Config { InitialDelay: 1 * time.Second, Timeout: 11 * time.Second, }, - MetricsBuilderConfig: metricsettings, + MetricsBuilderConfig: metricsCfg, VersionInfo: false, } } diff --git a/receiver/splunkenterprisereceiver/testdata/scraper/expected.yaml b/receiver/splunkenterprisereceiver/testdata/scraper/expected.yaml index a1629cec92eaf..0031134a63f1e 100644 --- a/receiver/splunkenterprisereceiver/testdata/scraper/expected.yaml +++ b/receiver/splunkenterprisereceiver/testdata/scraper/expected.yaml @@ -6,6 +6,16 @@ resourceMetrics: gauge: dataPoints: - asInt: "51" + attributes: + - key: splunk.index.name + value: + stringValue: _audit + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.bucket.count @@ -14,6 +24,19 @@ resourceMetrics: gauge: dataPoints: - asInt: "107267027" + attributes: + - key: splunk.bucket.dir + value: + stringValue: home + - key: splunk.index.name + value: + stringValue: _audit + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.bucket.event.count @@ -22,6 +45,19 @@ resourceMetrics: gauge: dataPoints: - asInt: "1" + attributes: + - key: splunk.bucket.dir + value: + stringValue: hot + - key: splunk.index.name + value: + stringValue: _audit + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.bucket.hot.count @@ -30,6 +66,19 @@ resourceMetrics: gauge: dataPoints: - asInt: "50" + attributes: + - key: splunk.bucket.dir + value: + stringValue: warm + - key: splunk.index.name + value: + stringValue: _audit + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.bucket.warm.count @@ -38,6 +87,16 @@ resourceMetrics: gauge: dataPoints: - asInt: "108411855" + attributes: + - key: splunk.index.name + value: + stringValue: _audit + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.event.count @@ -46,6 +105,16 @@ resourceMetrics: gauge: dataPoints: - asInt: "70825079209" + attributes: + - key: splunk.index.name + value: + stringValue: _audit + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.raw.size @@ -54,6 +123,16 @@ resourceMetrics: gauge: dataPoints: - asInt: "20818468798" + attributes: + - key: splunk.index.name + value: + stringValue: _audit + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.data.indexes.extended.total.size @@ -62,6 +141,16 @@ resourceMetrics: gauge: dataPoints: - asDouble: 69.2 + attributes: + - key: splunk.host + value: + stringValue: some-host + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.indexer.cpu.time @@ -70,6 +159,19 @@ resourceMetrics: gauge: dataPoints: - asInt: "0" + attributes: + - key: splunk.rollingorrestart + value: + boolValue: false + - key: splunk.searchable.restart + value: + boolValue: false + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.indexer.rollingrestart.status @@ -78,6 +180,16 @@ resourceMetrics: gauge: dataPoints: - asDouble: 25579.690815904476 + attributes: + - key: splunk.indexer.status + value: + stringValue: normal + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.indexer.throughput @@ -86,6 +198,16 @@ resourceMetrics: gauge: dataPoints: - asInt: "200400" + attributes: + - key: splunk.host + value: + stringValue: some-host + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.io.avg.iops @@ -138,6 +260,16 @@ resourceMetrics: gauge: dataPoints: - asDouble: 200.4 + attributes: + - key: splunk.host + value: + stringValue: some-host + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.scheduler.avg.run.time @@ -146,6 +278,16 @@ resourceMetrics: gauge: dataPoints: - asInt: "1" + attributes: + - key: splunk.queue.name + value: + stringValue: AEQ + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.server.introspection.queues.current @@ -154,6 +296,16 @@ resourceMetrics: gauge: dataPoints: - asInt: "100" + attributes: + - key: splunk.queue.name + value: + stringValue: AEQ + - key: splunk.splunkd.build + value: + stringValue: "" + - key: splunk.splunkd.version + value: + stringValue: "" startTimeUnixNano: "1000000" timeUnixNano: "2000000" name: splunk.server.introspection.queues.current.bytes From 6a628fd33313998b2321644fc46a29798b504953 Mon Sep 17 00:00:00 2001 From: shalper2 Date: Thu, 19 Feb 2026 10:04:51 -0600 Subject: [PATCH 4/5] make generate --- .../internal/metadata/generated_metrics.go | 51 ++++++++++++++++++ .../metadata/generated_metrics_test.go | 53 +++++++++++++++++++ 2 files changed, 104 insertions(+) diff --git a/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics.go b/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics.go index 47beab0dda9d0..f635f536566d7 100644 --- a/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics.go +++ b/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics.go @@ -247,6 +247,7 @@ func (m *metricSplunkAggregationQueueRatio) init() { m.data.SetUnit("{%}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkAggregationQueueRatio) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -341,6 +342,7 @@ func (m *metricSplunkBucketsSearchableStatus) init() { m.data.SetUnit("{count}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkBucketsSearchableStatus) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkIndexerSearchableAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -438,6 +440,7 @@ func (m *metricSplunkDataIndexesExtendedBucketCount) init() { m.data.SetUnit("{buckets}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkDataIndexesExtendedBucketCount) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkIndexNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -532,6 +535,7 @@ func (m *metricSplunkDataIndexesExtendedBucketEventCount) init() { m.data.SetUnit("{events}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkDataIndexesExtendedBucketEventCount) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkIndexNameAttributeValue string, splunkBucketDirAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -629,6 +633,7 @@ func (m *metricSplunkDataIndexesExtendedBucketHotCount) init() { m.data.SetUnit("{buckets}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkDataIndexesExtendedBucketHotCount) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkIndexNameAttributeValue string, splunkBucketDirAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -726,6 +731,7 @@ func (m *metricSplunkDataIndexesExtendedBucketWarmCount) init() { m.data.SetUnit("{buckets}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkDataIndexesExtendedBucketWarmCount) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkIndexNameAttributeValue string, splunkBucketDirAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -823,6 +829,7 @@ func (m *metricSplunkDataIndexesExtendedEventCount) init() { m.data.SetUnit("{events}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkDataIndexesExtendedEventCount) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkIndexNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -917,6 +924,7 @@ func (m *metricSplunkDataIndexesExtendedRawSize) init() { m.data.SetUnit("By") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkDataIndexesExtendedRawSize) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkIndexNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -1011,6 +1019,7 @@ func (m *metricSplunkDataIndexesExtendedTotalSize) init() { m.data.SetUnit("By") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkDataIndexesExtendedTotalSize) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkIndexNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -1105,6 +1114,7 @@ func (m *metricSplunkHealth) init() { m.data.SetUnit("{status}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkHealth) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkFeatureAttributeValue string, splunkFeatureHealthAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -1202,6 +1212,7 @@ func (m *metricSplunkIndexerAvgRate) init() { m.data.SetUnit("KBy") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIndexerAvgRate) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -1296,6 +1307,7 @@ func (m *metricSplunkIndexerCPUTime) init() { m.data.SetUnit("{s}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIndexerCPUTime) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -1390,6 +1402,7 @@ func (m *metricSplunkIndexerQueueRatio) init() { m.data.SetUnit("{%}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIndexerQueueRatio) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -1484,6 +1497,7 @@ func (m *metricSplunkIndexerRawWriteTime) init() { m.data.SetUnit("{s}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIndexerRawWriteTime) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -1578,6 +1592,7 @@ func (m *metricSplunkIndexerRollingrestartStatus) init() { m.data.SetUnit("{status}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIndexerRollingrestartStatus) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkSearchableRestartAttributeValue bool, splunkRollingorrestartAttributeValue bool, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -1675,6 +1690,7 @@ func (m *metricSplunkIndexerThroughput) init() { m.data.SetUnit("By/s") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIndexerThroughput) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkIndexerStatusAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -1769,6 +1785,7 @@ func (m *metricSplunkIndexesAvgSize) init() { m.data.SetUnit("Gb") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIndexesAvgSize) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkIndexNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -1863,6 +1880,7 @@ func (m *metricSplunkIndexesAvgUsage) init() { m.data.SetUnit("{%}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIndexesAvgUsage) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkIndexNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -1957,6 +1975,7 @@ func (m *metricSplunkIndexesBucketCount) init() { m.data.SetUnit("{count}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIndexesBucketCount) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkIndexNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -2051,6 +2070,7 @@ func (m *metricSplunkIndexesMedianDataAge) init() { m.data.SetUnit("{days}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIndexesMedianDataAge) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkIndexNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -2145,6 +2165,7 @@ func (m *metricSplunkIndexesSize) init() { m.data.SetUnit("Gb") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIndexesSize) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkIndexNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -2239,6 +2260,7 @@ func (m *metricSplunkIoAvgIops) init() { m.data.SetUnit("{iops}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkIoAvgIops) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -2333,6 +2355,7 @@ func (m *metricSplunkKvstoreBackupStatus) init() { m.data.SetUnit("{status}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkKvstoreBackupStatus) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkKvstoreStatusValueAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -2427,6 +2450,7 @@ func (m *metricSplunkKvstoreReplicationStatus) init() { m.data.SetUnit("{status}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkKvstoreReplicationStatus) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkKvstoreStatusValueAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -2521,6 +2545,7 @@ func (m *metricSplunkKvstoreStatus) init() { m.data.SetUnit("{status}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkKvstoreStatus) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkKvstoreStorageEngineAttributeValue string, splunkKvstoreExternalAttributeValue string, splunkKvstoreStatusValueAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -2621,6 +2646,7 @@ func (m *metricSplunkLicenseExpirationSecondsRemaining) init() { m.data.SetUnit("{seconds}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkLicenseExpirationSecondsRemaining) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkLicenseStatusAttributeValue string, splunkLicenseLabelAttributeValue string, splunkLicenseTypeAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -2721,6 +2747,7 @@ func (m *metricSplunkLicenseIndexUsage) init() { m.data.SetUnit("By") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkLicenseIndexUsage) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkIndexNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -2815,6 +2842,7 @@ func (m *metricSplunkParseQueueRatio) init() { m.data.SetUnit("{%}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkParseQueueRatio) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -2909,6 +2937,7 @@ func (m *metricSplunkPipelineSetCount) init() { m.data.SetUnit("KBy") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkPipelineSetCount) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -3003,6 +3032,7 @@ func (m *metricSplunkSchedulerAvgExecutionLatency) init() { m.data.SetUnit("{ms}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkSchedulerAvgExecutionLatency) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -3097,6 +3127,7 @@ func (m *metricSplunkSchedulerAvgRunTime) init() { m.data.SetUnit("{ms}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkSchedulerAvgRunTime) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -3191,6 +3222,7 @@ func (m *metricSplunkSchedulerCompletionRatio) init() { m.data.SetUnit("{%}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkSchedulerCompletionRatio) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -3285,6 +3317,7 @@ func (m *metricSplunkSearchDuration) init() { m.data.SetUnit("{status}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkSearchDuration) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -3376,6 +3409,7 @@ func (m *metricSplunkSearchInitiation) init() { m.data.SetUnit("{status}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkSearchInitiation) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -3467,6 +3501,7 @@ func (m *metricSplunkSearchStatus) init() { m.data.SetUnit("{status}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkSearchStatus) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkSearchStateAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -3561,6 +3596,7 @@ func (m *metricSplunkSearchSuccess) init() { m.data.SetUnit("{status}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkSearchSuccess) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -3652,6 +3688,7 @@ func (m *metricSplunkServerIntrospectionQueuesCurrent) init() { m.data.SetUnit("{queues}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerIntrospectionQueuesCurrent) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkQueueNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -3746,6 +3783,7 @@ func (m *metricSplunkServerIntrospectionQueuesCurrentBytes) init() { m.data.SetUnit("By") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerIntrospectionQueuesCurrentBytes) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkQueueNameAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -3840,6 +3878,7 @@ func (m *metricSplunkServerSearchartifactsAdhoc) init() { m.data.SetUnit("{search_artifacts}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsAdhoc) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -3934,6 +3973,7 @@ func (m *metricSplunkServerSearchartifactsAdhocSize) init() { m.data.SetUnit("{search_artifacts}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsAdhocSize) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -4028,6 +4068,7 @@ func (m *metricSplunkServerSearchartifactsCompleted) init() { m.data.SetUnit("{search_artifacts}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsCompleted) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -4122,6 +4163,7 @@ func (m *metricSplunkServerSearchartifactsCompletedSize) init() { m.data.SetUnit("{search_artifacts}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsCompletedSize) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -4216,6 +4258,7 @@ func (m *metricSplunkServerSearchartifactsIncomplete) init() { m.data.SetUnit("{search_artifacts}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsIncomplete) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -4310,6 +4353,7 @@ func (m *metricSplunkServerSearchartifactsIncompleteSize) init() { m.data.SetUnit("{search_artifacts}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsIncompleteSize) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -4404,6 +4448,7 @@ func (m *metricSplunkServerSearchartifactsInvalid) init() { m.data.SetUnit("{search_artifacts}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsInvalid) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -4498,6 +4543,7 @@ func (m *metricSplunkServerSearchartifactsJobCacheCount) init() { m.data.SetUnit("{search_artifacts}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsJobCacheCount) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -4592,6 +4638,7 @@ func (m *metricSplunkServerSearchartifactsJobCacheSize) init() { m.data.SetUnit("{mb}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsJobCacheSize) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSearchartifactsCacheTypeAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -4689,6 +4736,7 @@ func (m *metricSplunkServerSearchartifactsSavedsearches) init() { m.data.SetUnit("{search_artifacts}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsSavedsearches) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -4783,6 +4831,7 @@ func (m *metricSplunkServerSearchartifactsScheduled) init() { m.data.SetUnit("{search_artifacts}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsScheduled) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -4877,6 +4926,7 @@ func (m *metricSplunkServerSearchartifactsScheduledSize) init() { m.data.SetUnit("{search_artifacts}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkServerSearchartifactsScheduledSize) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { @@ -4971,6 +5021,7 @@ func (m *metricSplunkTypingQueueRatio) init() { m.data.SetUnit("{%}") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) + m.aggDataPoints = m.aggDataPoints[:0] } func (m *metricSplunkTypingQueueRatio) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, splunkHostAttributeValue string, splunkSplunkdBuildAttributeValue string, splunkSplunkdVersionAttributeValue string) { diff --git a/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics_test.go b/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics_test.go index 347a4070fa0bf..44fa38d170870 100644 --- a/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics_test.go +++ b/receiver/splunkenterprisereceiver/internal/metadata/generated_metrics_test.go @@ -427,6 +427,59 @@ func TestMetricsBuilder(t *testing.T) { res := pcommon.NewResource() metrics := mb.Emit(WithResource(res)) + if tt.name == "reaggregate_set" { + assert.Empty(t, mb.metricSplunkAggregationQueueRatio.aggDataPoints) + assert.Empty(t, mb.metricSplunkBucketsSearchableStatus.aggDataPoints) + assert.Empty(t, mb.metricSplunkDataIndexesExtendedBucketCount.aggDataPoints) + assert.Empty(t, mb.metricSplunkDataIndexesExtendedBucketEventCount.aggDataPoints) + assert.Empty(t, mb.metricSplunkDataIndexesExtendedBucketHotCount.aggDataPoints) + assert.Empty(t, mb.metricSplunkDataIndexesExtendedBucketWarmCount.aggDataPoints) + assert.Empty(t, mb.metricSplunkDataIndexesExtendedEventCount.aggDataPoints) + assert.Empty(t, mb.metricSplunkDataIndexesExtendedRawSize.aggDataPoints) + assert.Empty(t, mb.metricSplunkDataIndexesExtendedTotalSize.aggDataPoints) + assert.Empty(t, mb.metricSplunkHealth.aggDataPoints) + assert.Empty(t, mb.metricSplunkIndexerAvgRate.aggDataPoints) + assert.Empty(t, mb.metricSplunkIndexerCPUTime.aggDataPoints) + assert.Empty(t, mb.metricSplunkIndexerQueueRatio.aggDataPoints) + assert.Empty(t, mb.metricSplunkIndexerRawWriteTime.aggDataPoints) + assert.Empty(t, mb.metricSplunkIndexerRollingrestartStatus.aggDataPoints) + assert.Empty(t, mb.metricSplunkIndexerThroughput.aggDataPoints) + assert.Empty(t, mb.metricSplunkIndexesAvgSize.aggDataPoints) + assert.Empty(t, mb.metricSplunkIndexesAvgUsage.aggDataPoints) + assert.Empty(t, mb.metricSplunkIndexesBucketCount.aggDataPoints) + assert.Empty(t, mb.metricSplunkIndexesMedianDataAge.aggDataPoints) + assert.Empty(t, mb.metricSplunkIndexesSize.aggDataPoints) + assert.Empty(t, mb.metricSplunkIoAvgIops.aggDataPoints) + assert.Empty(t, mb.metricSplunkKvstoreBackupStatus.aggDataPoints) + assert.Empty(t, mb.metricSplunkKvstoreReplicationStatus.aggDataPoints) + assert.Empty(t, mb.metricSplunkKvstoreStatus.aggDataPoints) + assert.Empty(t, mb.metricSplunkLicenseExpirationSecondsRemaining.aggDataPoints) + assert.Empty(t, mb.metricSplunkLicenseIndexUsage.aggDataPoints) + assert.Empty(t, mb.metricSplunkParseQueueRatio.aggDataPoints) + assert.Empty(t, mb.metricSplunkPipelineSetCount.aggDataPoints) + assert.Empty(t, mb.metricSplunkSchedulerAvgExecutionLatency.aggDataPoints) + assert.Empty(t, mb.metricSplunkSchedulerAvgRunTime.aggDataPoints) + assert.Empty(t, mb.metricSplunkSchedulerCompletionRatio.aggDataPoints) + assert.Empty(t, mb.metricSplunkSearchDuration.aggDataPoints) + assert.Empty(t, mb.metricSplunkSearchInitiation.aggDataPoints) + assert.Empty(t, mb.metricSplunkSearchStatus.aggDataPoints) + assert.Empty(t, mb.metricSplunkSearchSuccess.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerIntrospectionQueuesCurrent.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerIntrospectionQueuesCurrentBytes.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsAdhoc.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsAdhocSize.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsCompleted.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsCompletedSize.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsIncomplete.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsIncompleteSize.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsInvalid.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsJobCacheCount.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsJobCacheSize.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsSavedsearches.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsScheduled.aggDataPoints) + assert.Empty(t, mb.metricSplunkServerSearchartifactsScheduledSize.aggDataPoints) + assert.Empty(t, mb.metricSplunkTypingQueueRatio.aggDataPoints) + } if tt.expectEmpty { assert.Equal(t, 0, metrics.ResourceMetrics().Len()) From 1a4a1e0ca33944f71f632bb6555727468cccd1b7 Mon Sep 17 00:00:00 2001 From: shalper2 Date: Thu, 19 Feb 2026 10:27:25 -0600 Subject: [PATCH 5/5] schema gen --- .../internal/metadata/config.schema.yaml | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/receiver/splunkenterprisereceiver/internal/metadata/config.schema.yaml b/receiver/splunkenterprisereceiver/internal/metadata/config.schema.yaml index c5be1fbbbd86d..2ea3576bd0377 100644 --- a/receiver/splunkenterprisereceiver/internal/metadata/config.schema.yaml +++ b/receiver/splunkenterprisereceiver/internal/metadata/config.schema.yaml @@ -1,8 +1,20 @@ $defs: + attribute_config: + description: AttributeConfig holds configuration information for a particular metric. + type: object + properties: + enabled: + type: boolean metric_config: description: MetricConfig provides common config for a particular metric. type: object properties: + aggregation_strategy: + type: string + attributes: + type: array + items: + type: string enabled: type: boolean metrics_builder_config: