From eac6ecffd64bf543711d8d0ecbafbe7ccf0a0f9d Mon Sep 17 00:00:00 2001 From: shalper2 Date: Thu, 15 Jan 2026 09:46:14 -0600 Subject: [PATCH 1/2] enabled reagg --- .../internal/metadata/generated_config.go | 206 ++ .../metadata/generated_config_test.go | 420 ++- .../internal/metadata/generated_metrics.go | 2070 ++++++++++-- .../metadata/generated_metrics_test.go | 2910 ++++++++++++----- .../internal/metadata/testdata/config.yaml | 180 + receiver/snowflakereceiver/metadata.yaml | 14 + 6 files changed, 4612 insertions(+), 1188 deletions(-) diff --git a/receiver/snowflakereceiver/internal/metadata/generated_config.go b/receiver/snowflakereceiver/internal/metadata/generated_config.go index 6383f7061d2cb..303dddaa489bd 100644 --- a/receiver/snowflakereceiver/internal/metadata/generated_config.go +++ b/receiver/snowflakereceiver/internal/metadata/generated_config.go @@ -3,6 +3,9 @@ package metadata import ( + "fmt" + "slices" + "go.opentelemetry.io/collector/confmap" "go.opentelemetry.io/collector/filter" ) @@ -11,6 +14,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 { @@ -22,11 +30,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 snowflake metrics. type MetricsConfig struct { SnowflakeBillingCloudServiceTotal MetricConfig `mapstructure:"snowflake.billing.cloud_service.total"` @@ -70,108 +101,283 @@ func DefaultMetricsConfig() MetricsConfig { return MetricsConfig{ SnowflakeBillingCloudServiceTotal: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"service_type"}, + EnabledAttributes: []string{"service_type"}, }, SnowflakeBillingTotalCreditTotal: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"service_type"}, + EnabledAttributes: []string{"service_type"}, }, SnowflakeBillingVirtualWarehouseTotal: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"service_type"}, + EnabledAttributes: []string{"service_type"}, }, SnowflakeBillingWarehouseCloudServiceTotal: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"warehouse_name"}, + EnabledAttributes: []string{"warehouse_name"}, }, SnowflakeBillingWarehouseTotalCreditTotal: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"warehouse_name"}, + EnabledAttributes: []string{"warehouse_name"}, }, SnowflakeBillingWarehouseVirtualWarehouseTotal: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"warehouse_name"}, + EnabledAttributes: []string{"warehouse_name"}, }, SnowflakeDatabaseBytesScannedAvg: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeDatabaseQueryCount: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeLoginsTotal: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"error_message", "reported_client_type", "is_success"}, + EnabledAttributes: []string{"error_message", "reported_client_type", "is_success"}, }, SnowflakePipeCreditsUsedTotal: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"pipe_name"}, + EnabledAttributes: []string{"pipe_name"}, }, SnowflakeQueryBlocked: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"warehouse_name"}, + EnabledAttributes: []string{"warehouse_name"}, }, SnowflakeQueryBytesDeletedAvg: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeQueryBytesSpilledLocalAvg: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeQueryBytesSpilledRemoteAvg: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeQueryBytesWrittenAvg: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeQueryCompilationTimeAvg: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeQueryDataScannedCacheAvg: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeQueryExecuted: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"warehouse_name"}, + EnabledAttributes: []string{"warehouse_name"}, }, SnowflakeQueryExecutionTimeAvg: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeQueryPartitionsScannedAvg: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeQueryQueuedOverload: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"warehouse_name"}, + EnabledAttributes: []string{"warehouse_name"}, }, SnowflakeQueryQueuedProvision: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"warehouse_name"}, + EnabledAttributes: []string{"warehouse_name"}, }, SnowflakeQueuedOverloadTimeAvg: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeQueuedProvisioningTimeAvg: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeQueuedRepairTimeAvg: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeRowsDeletedAvg: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeRowsInsertedAvg: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeRowsProducedAvg: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeRowsUnloadedAvg: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeRowsUpdatedAvg: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, SnowflakeSessionIDCount: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"user_name"}, + EnabledAttributes: []string{"user_name"}, }, SnowflakeStorageFailsafeBytesTotal: MetricConfig{ Enabled: false, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{}, + EnabledAttributes: []string{}, }, SnowflakeStorageStageBytesTotal: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{}, + EnabledAttributes: []string{}, }, SnowflakeStorageStorageBytesTotal: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{}, + EnabledAttributes: []string{}, }, SnowflakeTotalElapsedTimeAvg: MetricConfig{ Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{}, + definedAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, }, } } diff --git a/receiver/snowflakereceiver/internal/metadata/generated_config_test.go b/receiver/snowflakereceiver/internal/metadata/generated_config_test.go index a7cedc342661d..9b07d364ea0ae 100644 --- a/receiver/snowflakereceiver/internal/metadata/generated_config_test.go +++ b/receiver/snowflakereceiver/internal/metadata/generated_config_test.go @@ -26,41 +26,181 @@ func TestMetricsBuilderConfig(t *testing.T) { name: "all_set", want: MetricsBuilderConfig{ Metrics: MetricsConfig{ - SnowflakeBillingCloudServiceTotal: MetricConfig{Enabled: true}, - SnowflakeBillingTotalCreditTotal: MetricConfig{Enabled: true}, - SnowflakeBillingVirtualWarehouseTotal: MetricConfig{Enabled: true}, - SnowflakeBillingWarehouseCloudServiceTotal: MetricConfig{Enabled: true}, - SnowflakeBillingWarehouseTotalCreditTotal: MetricConfig{Enabled: true}, - SnowflakeBillingWarehouseVirtualWarehouseTotal: MetricConfig{Enabled: true}, - SnowflakeDatabaseBytesScannedAvg: MetricConfig{Enabled: true}, - SnowflakeDatabaseQueryCount: MetricConfig{Enabled: true}, - SnowflakeLoginsTotal: MetricConfig{Enabled: true}, - SnowflakePipeCreditsUsedTotal: MetricConfig{Enabled: true}, - SnowflakeQueryBlocked: MetricConfig{Enabled: true}, - SnowflakeQueryBytesDeletedAvg: MetricConfig{Enabled: true}, - SnowflakeQueryBytesSpilledLocalAvg: MetricConfig{Enabled: true}, - SnowflakeQueryBytesSpilledRemoteAvg: MetricConfig{Enabled: true}, - SnowflakeQueryBytesWrittenAvg: MetricConfig{Enabled: true}, - SnowflakeQueryCompilationTimeAvg: MetricConfig{Enabled: true}, - SnowflakeQueryDataScannedCacheAvg: MetricConfig{Enabled: true}, - SnowflakeQueryExecuted: MetricConfig{Enabled: true}, - SnowflakeQueryExecutionTimeAvg: MetricConfig{Enabled: true}, - SnowflakeQueryPartitionsScannedAvg: MetricConfig{Enabled: true}, - SnowflakeQueryQueuedOverload: MetricConfig{Enabled: true}, - SnowflakeQueryQueuedProvision: MetricConfig{Enabled: true}, - SnowflakeQueuedOverloadTimeAvg: MetricConfig{Enabled: true}, - SnowflakeQueuedProvisioningTimeAvg: MetricConfig{Enabled: true}, - SnowflakeQueuedRepairTimeAvg: MetricConfig{Enabled: true}, - SnowflakeRowsDeletedAvg: MetricConfig{Enabled: true}, - SnowflakeRowsInsertedAvg: MetricConfig{Enabled: true}, - SnowflakeRowsProducedAvg: MetricConfig{Enabled: true}, - SnowflakeRowsUnloadedAvg: MetricConfig{Enabled: true}, - SnowflakeRowsUpdatedAvg: MetricConfig{Enabled: true}, - SnowflakeSessionIDCount: MetricConfig{Enabled: true}, - SnowflakeStorageFailsafeBytesTotal: MetricConfig{Enabled: true}, - SnowflakeStorageStageBytesTotal: MetricConfig{Enabled: true}, - SnowflakeStorageStorageBytesTotal: MetricConfig{Enabled: true}, - SnowflakeTotalElapsedTimeAvg: MetricConfig{Enabled: true}, + SnowflakeBillingCloudServiceTotal: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"service_type"}, + }, + SnowflakeBillingTotalCreditTotal: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"service_type"}, + }, + SnowflakeBillingVirtualWarehouseTotal: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"service_type"}, + }, + SnowflakeBillingWarehouseCloudServiceTotal: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeBillingWarehouseTotalCreditTotal: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeBillingWarehouseVirtualWarehouseTotal: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeDatabaseBytesScannedAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeDatabaseQueryCount: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeLoginsTotal: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"error_message", "reported_client_type", "is_success"}, + }, + SnowflakePipeCreditsUsedTotal: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"pipe_name"}, + }, + SnowflakeQueryBlocked: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeQueryBytesDeletedAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryBytesSpilledLocalAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryBytesSpilledRemoteAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryBytesWrittenAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryCompilationTimeAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryDataScannedCacheAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryExecuted: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeQueryExecutionTimeAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryPartitionsScannedAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryQueuedOverload: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeQueryQueuedProvision: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeQueuedOverloadTimeAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueuedProvisioningTimeAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueuedRepairTimeAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeRowsDeletedAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeRowsInsertedAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeRowsProducedAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeRowsUnloadedAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeRowsUpdatedAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeSessionIDCount: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"user_name"}, + }, + SnowflakeStorageFailsafeBytesTotal: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{}, + }, + SnowflakeStorageStageBytesTotal: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{}, + }, + SnowflakeStorageStorageBytesTotal: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{}, + }, + SnowflakeTotalElapsedTimeAvg: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, }, ResourceAttributes: ResourceAttributesConfig{ SnowflakeAccountName: ResourceAttributeConfig{Enabled: true}, @@ -71,41 +211,181 @@ func TestMetricsBuilderConfig(t *testing.T) { name: "none_set", want: MetricsBuilderConfig{ Metrics: MetricsConfig{ - SnowflakeBillingCloudServiceTotal: MetricConfig{Enabled: false}, - SnowflakeBillingTotalCreditTotal: MetricConfig{Enabled: false}, - SnowflakeBillingVirtualWarehouseTotal: MetricConfig{Enabled: false}, - SnowflakeBillingWarehouseCloudServiceTotal: MetricConfig{Enabled: false}, - SnowflakeBillingWarehouseTotalCreditTotal: MetricConfig{Enabled: false}, - SnowflakeBillingWarehouseVirtualWarehouseTotal: MetricConfig{Enabled: false}, - SnowflakeDatabaseBytesScannedAvg: MetricConfig{Enabled: false}, - SnowflakeDatabaseQueryCount: MetricConfig{Enabled: false}, - SnowflakeLoginsTotal: MetricConfig{Enabled: false}, - SnowflakePipeCreditsUsedTotal: MetricConfig{Enabled: false}, - SnowflakeQueryBlocked: MetricConfig{Enabled: false}, - SnowflakeQueryBytesDeletedAvg: MetricConfig{Enabled: false}, - SnowflakeQueryBytesSpilledLocalAvg: MetricConfig{Enabled: false}, - SnowflakeQueryBytesSpilledRemoteAvg: MetricConfig{Enabled: false}, - SnowflakeQueryBytesWrittenAvg: MetricConfig{Enabled: false}, - SnowflakeQueryCompilationTimeAvg: MetricConfig{Enabled: false}, - SnowflakeQueryDataScannedCacheAvg: MetricConfig{Enabled: false}, - SnowflakeQueryExecuted: MetricConfig{Enabled: false}, - SnowflakeQueryExecutionTimeAvg: MetricConfig{Enabled: false}, - SnowflakeQueryPartitionsScannedAvg: MetricConfig{Enabled: false}, - SnowflakeQueryQueuedOverload: MetricConfig{Enabled: false}, - SnowflakeQueryQueuedProvision: MetricConfig{Enabled: false}, - SnowflakeQueuedOverloadTimeAvg: MetricConfig{Enabled: false}, - SnowflakeQueuedProvisioningTimeAvg: MetricConfig{Enabled: false}, - SnowflakeQueuedRepairTimeAvg: MetricConfig{Enabled: false}, - SnowflakeRowsDeletedAvg: MetricConfig{Enabled: false}, - SnowflakeRowsInsertedAvg: MetricConfig{Enabled: false}, - SnowflakeRowsProducedAvg: MetricConfig{Enabled: false}, - SnowflakeRowsUnloadedAvg: MetricConfig{Enabled: false}, - SnowflakeRowsUpdatedAvg: MetricConfig{Enabled: false}, - SnowflakeSessionIDCount: MetricConfig{Enabled: false}, - SnowflakeStorageFailsafeBytesTotal: MetricConfig{Enabled: false}, - SnowflakeStorageStageBytesTotal: MetricConfig{Enabled: false}, - SnowflakeStorageStorageBytesTotal: MetricConfig{Enabled: false}, - SnowflakeTotalElapsedTimeAvg: MetricConfig{Enabled: false}, + SnowflakeBillingCloudServiceTotal: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"service_type"}, + }, + SnowflakeBillingTotalCreditTotal: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"service_type"}, + }, + SnowflakeBillingVirtualWarehouseTotal: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"service_type"}, + }, + SnowflakeBillingWarehouseCloudServiceTotal: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeBillingWarehouseTotalCreditTotal: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeBillingWarehouseVirtualWarehouseTotal: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeDatabaseBytesScannedAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeDatabaseQueryCount: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeLoginsTotal: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"error_message", "reported_client_type", "is_success"}, + }, + SnowflakePipeCreditsUsedTotal: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"pipe_name"}, + }, + SnowflakeQueryBlocked: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeQueryBytesDeletedAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryBytesSpilledLocalAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryBytesSpilledRemoteAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryBytesWrittenAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryCompilationTimeAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryDataScannedCacheAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryExecuted: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeQueryExecutionTimeAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryPartitionsScannedAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueryQueuedOverload: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeQueryQueuedProvision: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"warehouse_name"}, + }, + SnowflakeQueuedOverloadTimeAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueuedProvisioningTimeAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeQueuedRepairTimeAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeRowsDeletedAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeRowsInsertedAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeRowsProducedAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeRowsUnloadedAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeRowsUpdatedAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, + SnowflakeSessionIDCount: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"user_name"}, + }, + SnowflakeStorageFailsafeBytesTotal: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{}, + }, + SnowflakeStorageStageBytesTotal: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{}, + }, + SnowflakeStorageStorageBytesTotal: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{}, + }, + SnowflakeTotalElapsedTimeAvg: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"schema_name", "execution_status", "error_message", "query_type", "warehouse_name", "database_name", "warehouse_size"}, + }, }, ResourceAttributes: ResourceAttributesConfig{ SnowflakeAccountName: ResourceAttributeConfig{Enabled: false}, diff --git a/receiver/snowflakereceiver/internal/metadata/generated_metrics.go b/receiver/snowflakereceiver/internal/metadata/generated_metrics.go index f11ff21347e7f..076a8c6d3e4ec 100644 --- a/receiver/snowflakereceiver/internal/metadata/generated_metrics.go +++ b/receiver/snowflakereceiver/internal/metadata/generated_metrics.go @@ -3,6 +3,7 @@ package metadata import ( + "slices" "time" "go.opentelemetry.io/collector/component" @@ -12,6 +13,13 @@ import ( "go.opentelemetry.io/collector/receiver" ) +const ( + AggregationStrategySum = "sum" + AggregationStrategyAvg = "avg" + AggregationStrategyMin = "min" + AggregationStrategyMax = "max" +) + var MetricsInfo = metricsInfo{ SnowflakeBillingCloudServiceTotal: metricInfo{ Name: "snowflake.billing.cloud_service.total", @@ -163,9 +171,10 @@ type metricInfo struct { } type metricSnowflakeBillingCloudServiceTotal 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 snowflake.billing.cloud_service.total metric with initial data. @@ -181,11 +190,41 @@ func (m *metricSnowflakeBillingCloudServiceTotal) 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, "service_type") { + dp.Attributes().PutStr("service_type", serviceTypeAttributeValue) + } + + 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("service_type", serviceTypeAttributeValue) + 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. @@ -198,6 +237,11 @@ func (m *metricSnowflakeBillingCloudServiceTotal) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeBillingCloudServiceTotal) 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() @@ -215,9 +259,10 @@ func newMetricSnowflakeBillingCloudServiceTotal(cfg MetricConfig) metricSnowflak } type metricSnowflakeBillingTotalCreditTotal 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 snowflake.billing.total_credit.total metric with initial data. @@ -233,11 +278,41 @@ func (m *metricSnowflakeBillingTotalCreditTotal) 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, "service_type") { + dp.Attributes().PutStr("service_type", serviceTypeAttributeValue) + } + + 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("service_type", serviceTypeAttributeValue) + 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. @@ -250,6 +325,11 @@ func (m *metricSnowflakeBillingTotalCreditTotal) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeBillingTotalCreditTotal) 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() @@ -267,9 +347,10 @@ func newMetricSnowflakeBillingTotalCreditTotal(cfg MetricConfig) metricSnowflake } type metricSnowflakeBillingVirtualWarehouseTotal 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 snowflake.billing.virtual_warehouse.total metric with initial data. @@ -285,11 +366,41 @@ func (m *metricSnowflakeBillingVirtualWarehouseTotal) 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, "service_type") { + dp.Attributes().PutStr("service_type", serviceTypeAttributeValue) + } + + 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("service_type", serviceTypeAttributeValue) + 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. @@ -302,6 +413,11 @@ func (m *metricSnowflakeBillingVirtualWarehouseTotal) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeBillingVirtualWarehouseTotal) 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() @@ -319,9 +435,10 @@ func newMetricSnowflakeBillingVirtualWarehouseTotal(cfg MetricConfig) metricSnow } type metricSnowflakeBillingWarehouseCloudServiceTotal 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 snowflake.billing.warehouse.cloud_service.total metric with initial data. @@ -337,11 +454,41 @@ func (m *metricSnowflakeBillingWarehouseCloudServiceTotal) 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, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + + 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("warehouse_name", warehouseNameAttributeValue) + 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. @@ -354,6 +501,11 @@ func (m *metricSnowflakeBillingWarehouseCloudServiceTotal) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeBillingWarehouseCloudServiceTotal) 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() @@ -371,9 +523,10 @@ func newMetricSnowflakeBillingWarehouseCloudServiceTotal(cfg MetricConfig) metri } type metricSnowflakeBillingWarehouseTotalCreditTotal 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 snowflake.billing.warehouse.total_credit.total metric with initial data. @@ -389,11 +542,41 @@ func (m *metricSnowflakeBillingWarehouseTotalCreditTotal) 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, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + + 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("warehouse_name", warehouseNameAttributeValue) + 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. @@ -406,6 +589,11 @@ func (m *metricSnowflakeBillingWarehouseTotalCreditTotal) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeBillingWarehouseTotalCreditTotal) 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() @@ -423,9 +611,10 @@ func newMetricSnowflakeBillingWarehouseTotalCreditTotal(cfg MetricConfig) metric } type metricSnowflakeBillingWarehouseVirtualWarehouseTotal 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 snowflake.billing.warehouse.virtual_warehouse.total metric with initial data. @@ -441,11 +630,41 @@ func (m *metricSnowflakeBillingWarehouseVirtualWarehouseTotal) recordDataPoint(s 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, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + + 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("warehouse_name", warehouseNameAttributeValue) + 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. @@ -458,6 +677,11 @@ func (m *metricSnowflakeBillingWarehouseVirtualWarehouseTotal) updateCapacity() // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeBillingWarehouseVirtualWarehouseTotal) 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() @@ -475,9 +699,10 @@ func newMetricSnowflakeBillingWarehouseVirtualWarehouseTotal(cfg MetricConfig) m } type metricSnowflakeDatabaseBytesScannedAvg 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 snowflake.database.bytes_scanned.avg metric with initial data. @@ -493,17 +718,59 @@ func (m *metricSnowflakeDatabaseBytesScannedAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -516,6 +783,11 @@ func (m *metricSnowflakeDatabaseBytesScannedAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeDatabaseBytesScannedAvg) 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() @@ -533,9 +805,10 @@ func newMetricSnowflakeDatabaseBytesScannedAvg(cfg MetricConfig) metricSnowflake } type metricSnowflakeDatabaseQueryCount 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 snowflake.database.query.count metric with initial data. @@ -551,17 +824,59 @@ func (m *metricSnowflakeDatabaseQueryCount) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -574,6 +889,11 @@ func (m *metricSnowflakeDatabaseQueryCount) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeDatabaseQueryCount) 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() @@ -591,9 +911,10 @@ func newMetricSnowflakeDatabaseQueryCount(cfg MetricConfig) metricSnowflakeDatab } type metricSnowflakeLoginsTotal 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 snowflake.logins.total metric with initial data. @@ -609,13 +930,47 @@ func (m *metricSnowflakeLoginsTotal) 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, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "reported_client_type") { + dp.Attributes().PutStr("reported_client_type", reportedClientTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "is_success") { + dp.Attributes().PutStr("is_success", isSuccessAttributeValue) + } + + 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("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("reported_client_type", reportedClientTypeAttributeValue) - dp.Attributes().PutStr("is_success", isSuccessAttributeValue) + 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. @@ -628,6 +983,11 @@ func (m *metricSnowflakeLoginsTotal) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeLoginsTotal) 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() @@ -645,9 +1005,10 @@ func newMetricSnowflakeLoginsTotal(cfg MetricConfig) metricSnowflakeLoginsTotal } type metricSnowflakePipeCreditsUsedTotal 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 snowflake.pipe.credits_used.total metric with initial data. @@ -663,11 +1024,41 @@ func (m *metricSnowflakePipeCreditsUsedTotal) 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, "pipe_name") { + dp.Attributes().PutStr("pipe_name", pipeNameAttributeValue) + } + + 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("pipe_name", pipeNameAttributeValue) + 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. @@ -680,6 +1071,11 @@ func (m *metricSnowflakePipeCreditsUsedTotal) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakePipeCreditsUsedTotal) 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() @@ -697,9 +1093,10 @@ func newMetricSnowflakePipeCreditsUsedTotal(cfg MetricConfig) metricSnowflakePip } type metricSnowflakeQueryBlocked 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 snowflake.query.blocked metric with initial data. @@ -715,11 +1112,41 @@ func (m *metricSnowflakeQueryBlocked) 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, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + + 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("warehouse_name", warehouseNameAttributeValue) + 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. @@ -732,6 +1159,11 @@ func (m *metricSnowflakeQueryBlocked) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryBlocked) 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() @@ -749,9 +1181,10 @@ func newMetricSnowflakeQueryBlocked(cfg MetricConfig) metricSnowflakeQueryBlocke } type metricSnowflakeQueryBytesDeletedAvg 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 snowflake.query.bytes_deleted.avg metric with initial data. @@ -767,17 +1200,59 @@ func (m *metricSnowflakeQueryBytesDeletedAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -790,6 +1265,11 @@ func (m *metricSnowflakeQueryBytesDeletedAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryBytesDeletedAvg) 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() @@ -807,9 +1287,10 @@ func newMetricSnowflakeQueryBytesDeletedAvg(cfg MetricConfig) metricSnowflakeQue } type metricSnowflakeQueryBytesSpilledLocalAvg 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 snowflake.query.bytes_spilled.local.avg metric with initial data. @@ -825,17 +1306,59 @@ func (m *metricSnowflakeQueryBytesSpilledLocalAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -848,6 +1371,11 @@ func (m *metricSnowflakeQueryBytesSpilledLocalAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryBytesSpilledLocalAvg) 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() @@ -865,9 +1393,10 @@ func newMetricSnowflakeQueryBytesSpilledLocalAvg(cfg MetricConfig) metricSnowfla } type metricSnowflakeQueryBytesSpilledRemoteAvg 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 snowflake.query.bytes_spilled.remote.avg metric with initial data. @@ -883,17 +1412,59 @@ func (m *metricSnowflakeQueryBytesSpilledRemoteAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -906,6 +1477,11 @@ func (m *metricSnowflakeQueryBytesSpilledRemoteAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryBytesSpilledRemoteAvg) 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() @@ -923,9 +1499,10 @@ func newMetricSnowflakeQueryBytesSpilledRemoteAvg(cfg MetricConfig) metricSnowfl } type metricSnowflakeQueryBytesWrittenAvg 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 snowflake.query.bytes_written.avg metric with initial data. @@ -941,17 +1518,59 @@ func (m *metricSnowflakeQueryBytesWrittenAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -964,6 +1583,11 @@ func (m *metricSnowflakeQueryBytesWrittenAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryBytesWrittenAvg) 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() @@ -981,9 +1605,10 @@ func newMetricSnowflakeQueryBytesWrittenAvg(cfg MetricConfig) metricSnowflakeQue } type metricSnowflakeQueryCompilationTimeAvg 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 snowflake.query.compilation_time.avg metric with initial data. @@ -999,17 +1624,59 @@ func (m *metricSnowflakeQueryCompilationTimeAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1022,6 +1689,11 @@ func (m *metricSnowflakeQueryCompilationTimeAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryCompilationTimeAvg) 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() @@ -1039,9 +1711,10 @@ func newMetricSnowflakeQueryCompilationTimeAvg(cfg MetricConfig) metricSnowflake } type metricSnowflakeQueryDataScannedCacheAvg 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 snowflake.query.data_scanned_cache.avg metric with initial data. @@ -1057,17 +1730,59 @@ func (m *metricSnowflakeQueryDataScannedCacheAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1080,6 +1795,11 @@ func (m *metricSnowflakeQueryDataScannedCacheAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryDataScannedCacheAvg) 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() @@ -1097,9 +1817,10 @@ func newMetricSnowflakeQueryDataScannedCacheAvg(cfg MetricConfig) metricSnowflak } type metricSnowflakeQueryExecuted 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 snowflake.query.executed metric with initial data. @@ -1115,11 +1836,41 @@ func (m *metricSnowflakeQueryExecuted) 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, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + + 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("warehouse_name", warehouseNameAttributeValue) + 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. @@ -1132,6 +1883,11 @@ func (m *metricSnowflakeQueryExecuted) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryExecuted) 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() @@ -1149,9 +1905,10 @@ func newMetricSnowflakeQueryExecuted(cfg MetricConfig) metricSnowflakeQueryExecu } type metricSnowflakeQueryExecutionTimeAvg 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 snowflake.query.execution_time.avg metric with initial data. @@ -1167,17 +1924,59 @@ func (m *metricSnowflakeQueryExecutionTimeAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1190,6 +1989,11 @@ func (m *metricSnowflakeQueryExecutionTimeAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryExecutionTimeAvg) 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() @@ -1207,9 +2011,10 @@ func newMetricSnowflakeQueryExecutionTimeAvg(cfg MetricConfig) metricSnowflakeQu } type metricSnowflakeQueryPartitionsScannedAvg 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 snowflake.query.partitions_scanned.avg metric with initial data. @@ -1225,17 +2030,59 @@ func (m *metricSnowflakeQueryPartitionsScannedAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1248,6 +2095,11 @@ func (m *metricSnowflakeQueryPartitionsScannedAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryPartitionsScannedAvg) 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() @@ -1265,9 +2117,10 @@ func newMetricSnowflakeQueryPartitionsScannedAvg(cfg MetricConfig) metricSnowfla } type metricSnowflakeQueryQueuedOverload 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 snowflake.query.queued_overload metric with initial data. @@ -1283,11 +2136,41 @@ func (m *metricSnowflakeQueryQueuedOverload) recordDataPoint(start pcommon.Times 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, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + + 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("warehouse_name", warehouseNameAttributeValue) + 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. @@ -1300,6 +2183,11 @@ func (m *metricSnowflakeQueryQueuedOverload) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryQueuedOverload) 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() @@ -1317,9 +2205,10 @@ func newMetricSnowflakeQueryQueuedOverload(cfg MetricConfig) metricSnowflakeQuer } type metricSnowflakeQueryQueuedProvision 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 snowflake.query.queued_provision metric with initial data. @@ -1335,11 +2224,41 @@ func (m *metricSnowflakeQueryQueuedProvision) 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, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + + 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("warehouse_name", warehouseNameAttributeValue) + 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. @@ -1352,6 +2271,11 @@ func (m *metricSnowflakeQueryQueuedProvision) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueryQueuedProvision) 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() @@ -1369,9 +2293,10 @@ func newMetricSnowflakeQueryQueuedProvision(cfg MetricConfig) metricSnowflakeQue } type metricSnowflakeQueuedOverloadTimeAvg 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 snowflake.queued_overload_time.avg metric with initial data. @@ -1387,17 +2312,59 @@ func (m *metricSnowflakeQueuedOverloadTimeAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1410,6 +2377,11 @@ func (m *metricSnowflakeQueuedOverloadTimeAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueuedOverloadTimeAvg) 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() @@ -1427,9 +2399,10 @@ func newMetricSnowflakeQueuedOverloadTimeAvg(cfg MetricConfig) metricSnowflakeQu } type metricSnowflakeQueuedProvisioningTimeAvg 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 snowflake.queued_provisioning_time.avg metric with initial data. @@ -1445,17 +2418,59 @@ func (m *metricSnowflakeQueuedProvisioningTimeAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1468,6 +2483,11 @@ func (m *metricSnowflakeQueuedProvisioningTimeAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueuedProvisioningTimeAvg) 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() @@ -1485,9 +2505,10 @@ func newMetricSnowflakeQueuedProvisioningTimeAvg(cfg MetricConfig) metricSnowfla } type metricSnowflakeQueuedRepairTimeAvg 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 snowflake.queued_repair_time.avg metric with initial data. @@ -1503,17 +2524,59 @@ func (m *metricSnowflakeQueuedRepairTimeAvg) recordDataPoint(start pcommon.Times 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1526,6 +2589,11 @@ func (m *metricSnowflakeQueuedRepairTimeAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeQueuedRepairTimeAvg) 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() @@ -1543,9 +2611,10 @@ func newMetricSnowflakeQueuedRepairTimeAvg(cfg MetricConfig) metricSnowflakeQueu } type metricSnowflakeRowsDeletedAvg 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 snowflake.rows_deleted.avg metric with initial data. @@ -1561,17 +2630,59 @@ func (m *metricSnowflakeRowsDeletedAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1584,6 +2695,11 @@ func (m *metricSnowflakeRowsDeletedAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeRowsDeletedAvg) 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() @@ -1601,9 +2717,10 @@ func newMetricSnowflakeRowsDeletedAvg(cfg MetricConfig) metricSnowflakeRowsDelet } type metricSnowflakeRowsInsertedAvg 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 snowflake.rows_inserted.avg metric with initial data. @@ -1619,17 +2736,59 @@ func (m *metricSnowflakeRowsInsertedAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1642,6 +2801,11 @@ func (m *metricSnowflakeRowsInsertedAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeRowsInsertedAvg) 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() @@ -1659,9 +2823,10 @@ func newMetricSnowflakeRowsInsertedAvg(cfg MetricConfig) metricSnowflakeRowsInse } type metricSnowflakeRowsProducedAvg 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 snowflake.rows_produced.avg metric with initial data. @@ -1677,17 +2842,59 @@ func (m *metricSnowflakeRowsProducedAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1700,6 +2907,11 @@ func (m *metricSnowflakeRowsProducedAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeRowsProducedAvg) 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() @@ -1717,9 +2929,10 @@ func newMetricSnowflakeRowsProducedAvg(cfg MetricConfig) metricSnowflakeRowsProd } type metricSnowflakeRowsUnloadedAvg 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 snowflake.rows_unloaded.avg metric with initial data. @@ -1735,17 +2948,59 @@ func (m *metricSnowflakeRowsUnloadedAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1758,6 +3013,11 @@ func (m *metricSnowflakeRowsUnloadedAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeRowsUnloadedAvg) 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() @@ -1775,9 +3035,10 @@ func newMetricSnowflakeRowsUnloadedAvg(cfg MetricConfig) metricSnowflakeRowsUnlo } type metricSnowflakeRowsUpdatedAvg 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 snowflake.rows_updated.avg metric with initial data. @@ -1793,17 +3054,59 @@ func (m *metricSnowflakeRowsUpdatedAvg) 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -1816,6 +3119,11 @@ func (m *metricSnowflakeRowsUpdatedAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeRowsUpdatedAvg) 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() @@ -1833,9 +3141,10 @@ func newMetricSnowflakeRowsUpdatedAvg(cfg MetricConfig) metricSnowflakeRowsUpdat } type metricSnowflakeSessionIDCount 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 snowflake.session_id.count metric with initial data. @@ -1851,11 +3160,41 @@ func (m *metricSnowflakeSessionIDCount) 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, "user_name") { + dp.Attributes().PutStr("user_name", userNameAttributeValue) + } + + 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("user_name", userNameAttributeValue) + 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. @@ -1868,6 +3207,11 @@ func (m *metricSnowflakeSessionIDCount) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeSessionIDCount) 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() @@ -1885,9 +3229,10 @@ func newMetricSnowflakeSessionIDCount(cfg MetricConfig) metricSnowflakeSessionID } type metricSnowflakeStorageFailsafeBytesTotal 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 snowflake.storage.failsafe_bytes.total metric with initial data. @@ -1902,10 +3247,38 @@ func (m *metricSnowflakeStorageFailsafeBytesTotal) recordDataPoint(start pcommon if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + + 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) + 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. @@ -1918,6 +3291,11 @@ func (m *metricSnowflakeStorageFailsafeBytesTotal) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeStorageFailsafeBytesTotal) 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() @@ -1935,9 +3313,10 @@ func newMetricSnowflakeStorageFailsafeBytesTotal(cfg MetricConfig) metricSnowfla } type metricSnowflakeStorageStageBytesTotal 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 snowflake.storage.stage_bytes.total metric with initial data. @@ -1952,10 +3331,38 @@ func (m *metricSnowflakeStorageStageBytesTotal) recordDataPoint(start pcommon.Ti if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + + 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) + 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. @@ -1968,6 +3375,11 @@ func (m *metricSnowflakeStorageStageBytesTotal) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeStorageStageBytesTotal) 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() @@ -1985,9 +3397,10 @@ func newMetricSnowflakeStorageStageBytesTotal(cfg MetricConfig) metricSnowflakeS } type metricSnowflakeStorageStorageBytesTotal 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 snowflake.storage.storage_bytes.total metric with initial data. @@ -2002,10 +3415,38 @@ func (m *metricSnowflakeStorageStorageBytesTotal) recordDataPoint(start pcommon. if !m.config.Enabled { return } - dp := m.data.Gauge().DataPoints().AppendEmpty() + + dp := pmetric.NewNumberDataPoint() dp.SetStartTimestamp(start) dp.SetTimestamp(ts) + + 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) + 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. @@ -2018,6 +3459,11 @@ func (m *metricSnowflakeStorageStorageBytesTotal) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeStorageStorageBytesTotal) 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() @@ -2035,9 +3481,10 @@ func newMetricSnowflakeStorageStorageBytesTotal(cfg MetricConfig) metricSnowflak } type metricSnowflakeTotalElapsedTimeAvg 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 snowflake.total_elapsed_time.avg metric with initial data. @@ -2053,17 +3500,59 @@ func (m *metricSnowflakeTotalElapsedTimeAvg) recordDataPoint(start pcommon.Times 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, "schema_name") { + dp.Attributes().PutStr("schema_name", schemaNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "execution_status") { + dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "error_message") { + dp.Attributes().PutStr("error_message", errorMessageAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "query_type") { + dp.Attributes().PutStr("query_type", queryTypeAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_name") { + dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "database_name") { + dp.Attributes().PutStr("database_name", databaseNameAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "warehouse_size") { + dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + } + + 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("schema_name", schemaNameAttributeValue) - dp.Attributes().PutStr("execution_status", executionStatusAttributeValue) - dp.Attributes().PutStr("error_message", errorMessageAttributeValue) - dp.Attributes().PutStr("query_type", queryTypeAttributeValue) - dp.Attributes().PutStr("warehouse_name", warehouseNameAttributeValue) - dp.Attributes().PutStr("database_name", databaseNameAttributeValue) - dp.Attributes().PutStr("warehouse_size", warehouseSizeAttributeValue) + 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. @@ -2076,6 +3565,11 @@ func (m *metricSnowflakeTotalElapsedTimeAvg) updateCapacity() { // emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. func (m *metricSnowflakeTotalElapsedTimeAvg) 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/snowflakereceiver/internal/metadata/generated_metrics_test.go b/receiver/snowflakereceiver/internal/metadata/generated_metrics_test.go index 7c79dcc0d082d..caded47d26263 100644 --- a/receiver/snowflakereceiver/internal/metadata/generated_metrics_test.go +++ b/receiver/snowflakereceiver/internal/metadata/generated_metrics_test.go @@ -19,6 +19,7 @@ const ( testDataSetDefault testDataSet = iota testDataSetAll testDataSetNone + testDataSetReag ) func TestMetricsBuilder(t *testing.T) { @@ -36,6 +37,11 @@ func TestMetricsBuilder(t *testing.T) { metricsSet: testDataSetAll, resAttrsSet: testDataSetAll, }, + { + name: "reaggregate_set", + metricsSet: testDataSetReag, + resAttrsSet: testDataSetReag, + }, { name: "none_set", metricsSet: testDataSetNone, @@ -60,133 +66,276 @@ 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["SnowflakeBillingCloudServiceTotal"] = mb.metricSnowflakeBillingCloudServiceTotal.config.AggregationStrategy + aggMap["SnowflakeBillingTotalCreditTotal"] = mb.metricSnowflakeBillingTotalCreditTotal.config.AggregationStrategy + aggMap["SnowflakeBillingVirtualWarehouseTotal"] = mb.metricSnowflakeBillingVirtualWarehouseTotal.config.AggregationStrategy + aggMap["SnowflakeBillingWarehouseCloudServiceTotal"] = mb.metricSnowflakeBillingWarehouseCloudServiceTotal.config.AggregationStrategy + aggMap["SnowflakeBillingWarehouseTotalCreditTotal"] = mb.metricSnowflakeBillingWarehouseTotalCreditTotal.config.AggregationStrategy + aggMap["SnowflakeBillingWarehouseVirtualWarehouseTotal"] = mb.metricSnowflakeBillingWarehouseVirtualWarehouseTotal.config.AggregationStrategy + aggMap["SnowflakeDatabaseBytesScannedAvg"] = mb.metricSnowflakeDatabaseBytesScannedAvg.config.AggregationStrategy + aggMap["SnowflakeDatabaseQueryCount"] = mb.metricSnowflakeDatabaseQueryCount.config.AggregationStrategy + aggMap["SnowflakeLoginsTotal"] = mb.metricSnowflakeLoginsTotal.config.AggregationStrategy + aggMap["SnowflakePipeCreditsUsedTotal"] = mb.metricSnowflakePipeCreditsUsedTotal.config.AggregationStrategy + aggMap["SnowflakeQueryBlocked"] = mb.metricSnowflakeQueryBlocked.config.AggregationStrategy + aggMap["SnowflakeQueryBytesDeletedAvg"] = mb.metricSnowflakeQueryBytesDeletedAvg.config.AggregationStrategy + aggMap["SnowflakeQueryBytesSpilledLocalAvg"] = mb.metricSnowflakeQueryBytesSpilledLocalAvg.config.AggregationStrategy + aggMap["SnowflakeQueryBytesSpilledRemoteAvg"] = mb.metricSnowflakeQueryBytesSpilledRemoteAvg.config.AggregationStrategy + aggMap["SnowflakeQueryBytesWrittenAvg"] = mb.metricSnowflakeQueryBytesWrittenAvg.config.AggregationStrategy + aggMap["SnowflakeQueryCompilationTimeAvg"] = mb.metricSnowflakeQueryCompilationTimeAvg.config.AggregationStrategy + aggMap["SnowflakeQueryDataScannedCacheAvg"] = mb.metricSnowflakeQueryDataScannedCacheAvg.config.AggregationStrategy + aggMap["SnowflakeQueryExecuted"] = mb.metricSnowflakeQueryExecuted.config.AggregationStrategy + aggMap["SnowflakeQueryExecutionTimeAvg"] = mb.metricSnowflakeQueryExecutionTimeAvg.config.AggregationStrategy + aggMap["SnowflakeQueryPartitionsScannedAvg"] = mb.metricSnowflakeQueryPartitionsScannedAvg.config.AggregationStrategy + aggMap["SnowflakeQueryQueuedOverload"] = mb.metricSnowflakeQueryQueuedOverload.config.AggregationStrategy + aggMap["SnowflakeQueryQueuedProvision"] = mb.metricSnowflakeQueryQueuedProvision.config.AggregationStrategy + aggMap["SnowflakeQueuedOverloadTimeAvg"] = mb.metricSnowflakeQueuedOverloadTimeAvg.config.AggregationStrategy + aggMap["SnowflakeQueuedProvisioningTimeAvg"] = mb.metricSnowflakeQueuedProvisioningTimeAvg.config.AggregationStrategy + aggMap["SnowflakeQueuedRepairTimeAvg"] = mb.metricSnowflakeQueuedRepairTimeAvg.config.AggregationStrategy + aggMap["SnowflakeRowsDeletedAvg"] = mb.metricSnowflakeRowsDeletedAvg.config.AggregationStrategy + aggMap["SnowflakeRowsInsertedAvg"] = mb.metricSnowflakeRowsInsertedAvg.config.AggregationStrategy + aggMap["SnowflakeRowsProducedAvg"] = mb.metricSnowflakeRowsProducedAvg.config.AggregationStrategy + aggMap["SnowflakeRowsUnloadedAvg"] = mb.metricSnowflakeRowsUnloadedAvg.config.AggregationStrategy + aggMap["SnowflakeRowsUpdatedAvg"] = mb.metricSnowflakeRowsUpdatedAvg.config.AggregationStrategy + aggMap["SnowflakeSessionIDCount"] = mb.metricSnowflakeSessionIDCount.config.AggregationStrategy + aggMap["SnowflakeStorageFailsafeBytesTotal"] = mb.metricSnowflakeStorageFailsafeBytesTotal.config.AggregationStrategy + aggMap["SnowflakeStorageStageBytesTotal"] = mb.metricSnowflakeStorageStageBytesTotal.config.AggregationStrategy + aggMap["SnowflakeStorageStorageBytesTotal"] = mb.metricSnowflakeStorageStorageBytesTotal.config.AggregationStrategy + aggMap["SnowflakeTotalElapsedTimeAvg"] = mb.metricSnowflakeTotalElapsedTimeAvg.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.RecordSnowflakeBillingCloudServiceTotalDataPoint(ts, 1, "service_type-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeBillingCloudServiceTotalDataPoint(ts, 3, "service_type-val-2") + } allMetricsCount++ mb.RecordSnowflakeBillingTotalCreditTotalDataPoint(ts, 1, "service_type-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeBillingTotalCreditTotalDataPoint(ts, 3, "service_type-val-2") + } allMetricsCount++ mb.RecordSnowflakeBillingVirtualWarehouseTotalDataPoint(ts, 1, "service_type-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeBillingVirtualWarehouseTotalDataPoint(ts, 3, "service_type-val-2") + } allMetricsCount++ mb.RecordSnowflakeBillingWarehouseCloudServiceTotalDataPoint(ts, 1, "warehouse_name-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeBillingWarehouseCloudServiceTotalDataPoint(ts, 3, "warehouse_name-val-2") + } allMetricsCount++ mb.RecordSnowflakeBillingWarehouseTotalCreditTotalDataPoint(ts, 1, "warehouse_name-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeBillingWarehouseTotalCreditTotalDataPoint(ts, 3, "warehouse_name-val-2") + } allMetricsCount++ mb.RecordSnowflakeBillingWarehouseVirtualWarehouseTotalDataPoint(ts, 1, "warehouse_name-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeBillingWarehouseVirtualWarehouseTotalDataPoint(ts, 3, "warehouse_name-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeDatabaseBytesScannedAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeDatabaseBytesScannedAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeDatabaseQueryCountDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeDatabaseQueryCountDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } allMetricsCount++ mb.RecordSnowflakeLoginsTotalDataPoint(ts, 1, "error_message-val", "reported_client_type-val", "is_success-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeLoginsTotalDataPoint(ts, 3, "error_message-val-2", "reported_client_type-val-2", "is_success-val-2") + } allMetricsCount++ mb.RecordSnowflakePipeCreditsUsedTotalDataPoint(ts, 1, "pipe_name-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakePipeCreditsUsedTotalDataPoint(ts, 3, "pipe_name-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeQueryBlockedDataPoint(ts, 1, "warehouse_name-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryBlockedDataPoint(ts, 3, "warehouse_name-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeQueryBytesDeletedAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryBytesDeletedAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } allMetricsCount++ mb.RecordSnowflakeQueryBytesSpilledLocalAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryBytesSpilledLocalAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } allMetricsCount++ mb.RecordSnowflakeQueryBytesSpilledRemoteAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryBytesSpilledRemoteAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeQueryBytesWrittenAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryBytesWrittenAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeQueryCompilationTimeAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryCompilationTimeAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } allMetricsCount++ mb.RecordSnowflakeQueryDataScannedCacheAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryDataScannedCacheAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeQueryExecutedDataPoint(ts, 1, "warehouse_name-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryExecutedDataPoint(ts, 3, "warehouse_name-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeQueryExecutionTimeAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryExecutionTimeAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } allMetricsCount++ mb.RecordSnowflakeQueryPartitionsScannedAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryPartitionsScannedAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeQueryQueuedOverloadDataPoint(ts, 1, "warehouse_name-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryQueuedOverloadDataPoint(ts, 3, "warehouse_name-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeQueryQueuedProvisionDataPoint(ts, 1, "warehouse_name-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueryQueuedProvisionDataPoint(ts, 3, "warehouse_name-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeQueuedOverloadTimeAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueuedOverloadTimeAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeQueuedProvisioningTimeAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueuedProvisioningTimeAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeQueuedRepairTimeAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeQueuedRepairTimeAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } allMetricsCount++ mb.RecordSnowflakeRowsDeletedAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeRowsDeletedAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } allMetricsCount++ mb.RecordSnowflakeRowsInsertedAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeRowsInsertedAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } allMetricsCount++ mb.RecordSnowflakeRowsProducedAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeRowsProducedAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } allMetricsCount++ mb.RecordSnowflakeRowsUnloadedAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeRowsUnloadedAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } allMetricsCount++ mb.RecordSnowflakeRowsUpdatedAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeRowsUpdatedAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } allMetricsCount++ mb.RecordSnowflakeSessionIDCountDataPoint(ts, 1, "user_name-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeSessionIDCountDataPoint(ts, 3, "user_name-val-2") + } allMetricsCount++ mb.RecordSnowflakeStorageFailsafeBytesTotalDataPoint(ts, 1) + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeStorageFailsafeBytesTotalDataPoint(ts, 3) + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeStorageStageBytesTotalDataPoint(ts, 1) + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeStorageStageBytesTotalDataPoint(ts, 3) + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeStorageStorageBytesTotalDataPoint(ts, 1) + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeStorageStorageBytesTotalDataPoint(ts, 3) + } defaultMetricsCount++ allMetricsCount++ mb.RecordSnowflakeTotalElapsedTimeAvgDataPoint(ts, 1, "schema_name-val", "execution_status-val", "error_message-val", "query_type-val", "warehouse_name-val", "database_name-val", "warehouse_size-val") + if tt.name == "reaggregate_set" { + mb.RecordSnowflakeTotalElapsedTimeAvgDataPoint(ts, 3, "schema_name-val-2", "execution_status-val-2", "error_message-val-2", "query_type-val-2", "warehouse_name-val-2", "database_name-val-2", "warehouse_size-val-2") + } rb := mb.NewResourceBuilder() rb.SetSnowflakeAccountName("snowflake.account.name-val") @@ -213,869 +362,1970 @@ func TestMetricsBuilder(t *testing.T) { for i := 0; i < ms.Len(); i++ { switch ms.At(i).Name() { case "snowflake.billing.cloud_service.total": - assert.False(t, validatedMetrics["snowflake.billing.cloud_service.total"], "Found a duplicate in the metrics slice: snowflake.billing.cloud_service.total") - validatedMetrics["snowflake.billing.cloud_service.total"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Reported total credits used in the cloud service over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{credits}", 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("service_type") - assert.True(t, ok) - assert.Equal(t, "service_type-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.billing.cloud_service.total"], "Found a duplicate in the metrics slice: snowflake.billing.cloud_service.total") + validatedMetrics["snowflake.billing.cloud_service.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Reported total credits used in the cloud service over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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("service_type") + assert.True(t, ok) + assert.Equal(t, "service_type-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.billing.cloud_service.total"], "Found a duplicate in the metrics slice: snowflake.billing.cloud_service.total") + validatedMetrics["snowflake.billing.cloud_service.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Reported total credits used in the cloud service over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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["snowflake.billing.cloud_service.total"] { + 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("service_type") + assert.False(t, ok) + } case "snowflake.billing.total_credit.total": - assert.False(t, validatedMetrics["snowflake.billing.total_credit.total"], "Found a duplicate in the metrics slice: snowflake.billing.total_credit.total") - validatedMetrics["snowflake.billing.total_credit.total"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Reported total credits used across account over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{credits}", 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("service_type") - assert.True(t, ok) - assert.Equal(t, "service_type-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.billing.total_credit.total"], "Found a duplicate in the metrics slice: snowflake.billing.total_credit.total") + validatedMetrics["snowflake.billing.total_credit.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Reported total credits used across account over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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("service_type") + assert.True(t, ok) + assert.Equal(t, "service_type-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.billing.total_credit.total"], "Found a duplicate in the metrics slice: snowflake.billing.total_credit.total") + validatedMetrics["snowflake.billing.total_credit.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Reported total credits used across account over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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["snowflake.billing.total_credit.total"] { + 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("service_type") + assert.False(t, ok) + } case "snowflake.billing.virtual_warehouse.total": - assert.False(t, validatedMetrics["snowflake.billing.virtual_warehouse.total"], "Found a duplicate in the metrics slice: snowflake.billing.virtual_warehouse.total") - validatedMetrics["snowflake.billing.virtual_warehouse.total"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Reported total credits used by virtual warehouse service over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{credits}", 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("service_type") - assert.True(t, ok) - assert.Equal(t, "service_type-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.billing.virtual_warehouse.total"], "Found a duplicate in the metrics slice: snowflake.billing.virtual_warehouse.total") + validatedMetrics["snowflake.billing.virtual_warehouse.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Reported total credits used by virtual warehouse service over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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("service_type") + assert.True(t, ok) + assert.Equal(t, "service_type-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.billing.virtual_warehouse.total"], "Found a duplicate in the metrics slice: snowflake.billing.virtual_warehouse.total") + validatedMetrics["snowflake.billing.virtual_warehouse.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Reported total credits used by virtual warehouse service over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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["snowflake.billing.virtual_warehouse.total"] { + 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("service_type") + assert.False(t, ok) + } case "snowflake.billing.warehouse.cloud_service.total": - assert.False(t, validatedMetrics["snowflake.billing.warehouse.cloud_service.total"], "Found a duplicate in the metrics slice: snowflake.billing.warehouse.cloud_service.total") - validatedMetrics["snowflake.billing.warehouse.cloud_service.total"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Credits used across cloud service for given warehouse over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{credits}", 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("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.billing.warehouse.cloud_service.total"], "Found a duplicate in the metrics slice: snowflake.billing.warehouse.cloud_service.total") + validatedMetrics["snowflake.billing.warehouse.cloud_service.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Credits used across cloud service for given warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.billing.warehouse.cloud_service.total"], "Found a duplicate in the metrics slice: snowflake.billing.warehouse.cloud_service.total") + validatedMetrics["snowflake.billing.warehouse.cloud_service.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Credits used across cloud service for given warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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["snowflake.billing.warehouse.cloud_service.total"] { + 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("warehouse_name") + assert.False(t, ok) + } case "snowflake.billing.warehouse.total_credit.total": - assert.False(t, validatedMetrics["snowflake.billing.warehouse.total_credit.total"], "Found a duplicate in the metrics slice: snowflake.billing.warehouse.total_credit.total") - validatedMetrics["snowflake.billing.warehouse.total_credit.total"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Total credits used associated with given warehouse over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{credits}", 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("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.billing.warehouse.total_credit.total"], "Found a duplicate in the metrics slice: snowflake.billing.warehouse.total_credit.total") + validatedMetrics["snowflake.billing.warehouse.total_credit.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Total credits used associated with given warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.billing.warehouse.total_credit.total"], "Found a duplicate in the metrics slice: snowflake.billing.warehouse.total_credit.total") + validatedMetrics["snowflake.billing.warehouse.total_credit.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Total credits used associated with given warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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["snowflake.billing.warehouse.total_credit.total"] { + 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("warehouse_name") + assert.False(t, ok) + } case "snowflake.billing.warehouse.virtual_warehouse.total": - assert.False(t, validatedMetrics["snowflake.billing.warehouse.virtual_warehouse.total"], "Found a duplicate in the metrics slice: snowflake.billing.warehouse.virtual_warehouse.total") - validatedMetrics["snowflake.billing.warehouse.virtual_warehouse.total"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Total credits used by virtual warehouse service for given warehouse over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{credits}", 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("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.billing.warehouse.virtual_warehouse.total"], "Found a duplicate in the metrics slice: snowflake.billing.warehouse.virtual_warehouse.total") + validatedMetrics["snowflake.billing.warehouse.virtual_warehouse.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Total credits used by virtual warehouse service for given warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.billing.warehouse.virtual_warehouse.total"], "Found a duplicate in the metrics slice: snowflake.billing.warehouse.virtual_warehouse.total") + validatedMetrics["snowflake.billing.warehouse.virtual_warehouse.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Total credits used by virtual warehouse service for given warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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["snowflake.billing.warehouse.virtual_warehouse.total"] { + 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("warehouse_name") + assert.False(t, ok) + } case "snowflake.database.bytes_scanned.avg": - assert.False(t, validatedMetrics["snowflake.database.bytes_scanned.avg"], "Found a duplicate in the metrics slice: snowflake.database.bytes_scanned.avg") - validatedMetrics["snowflake.database.bytes_scanned.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average bytes scanned in a database over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.database.bytes_scanned.avg"], "Found a duplicate in the metrics slice: snowflake.database.bytes_scanned.avg") + validatedMetrics["snowflake.database.bytes_scanned.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average bytes scanned in a database over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.database.bytes_scanned.avg"], "Found a duplicate in the metrics slice: snowflake.database.bytes_scanned.avg") + validatedMetrics["snowflake.database.bytes_scanned.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average bytes scanned in a database over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["snowflake.database.bytes_scanned.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.database.query.count": - assert.False(t, validatedMetrics["snowflake.database.query.count"], "Found a duplicate in the metrics slice: snowflake.database.query.count") - validatedMetrics["snowflake.database.query.count"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Total query count for database over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "1", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.database.query.count"], "Found a duplicate in the metrics slice: snowflake.database.query.count") + validatedMetrics["snowflake.database.query.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Total query count for database over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.database.query.count"], "Found a duplicate in the metrics slice: snowflake.database.query.count") + validatedMetrics["snowflake.database.query.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Total query count for database over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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["snowflake.database.query.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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.logins.total": - assert.False(t, validatedMetrics["snowflake.logins.total"], "Found a duplicate in the metrics slice: snowflake.logins.total") - validatedMetrics["snowflake.logins.total"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Total login attempts for account over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "1", 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("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("reported_client_type") - assert.True(t, ok) - assert.Equal(t, "reported_client_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("is_success") - assert.True(t, ok) - assert.Equal(t, "is_success-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.logins.total"], "Found a duplicate in the metrics slice: snowflake.logins.total") + validatedMetrics["snowflake.logins.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Total login attempts for account over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("reported_client_type") + assert.True(t, ok) + assert.Equal(t, "reported_client_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("is_success") + assert.True(t, ok) + assert.Equal(t, "is_success-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.logins.total"], "Found a duplicate in the metrics slice: snowflake.logins.total") + validatedMetrics["snowflake.logins.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Total login attempts for account over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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["snowflake.logins.total"] { + 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("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("reported_client_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("is_success") + assert.False(t, ok) + } case "snowflake.pipe.credits_used.total": - assert.False(t, validatedMetrics["snowflake.pipe.credits_used.total"], "Found a duplicate in the metrics slice: snowflake.pipe.credits_used.total") - validatedMetrics["snowflake.pipe.credits_used.total"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Snow pipe credits contotaled over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{credits}", 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("pipe_name") - assert.True(t, ok) - assert.Equal(t, "pipe_name-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.pipe.credits_used.total"], "Found a duplicate in the metrics slice: snowflake.pipe.credits_used.total") + validatedMetrics["snowflake.pipe.credits_used.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Snow pipe credits contotaled over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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("pipe_name") + assert.True(t, ok) + assert.Equal(t, "pipe_name-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.pipe.credits_used.total"], "Found a duplicate in the metrics slice: snowflake.pipe.credits_used.total") + validatedMetrics["snowflake.pipe.credits_used.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Snow pipe credits contotaled over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{credits}", 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["snowflake.pipe.credits_used.total"] { + 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("pipe_name") + assert.False(t, ok) + } case "snowflake.query.blocked": - assert.False(t, validatedMetrics["snowflake.query.blocked"], "Found a duplicate in the metrics slice: snowflake.query.blocked") - validatedMetrics["snowflake.query.blocked"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Blocked query count for warehouse over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "1", 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("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.blocked"], "Found a duplicate in the metrics slice: snowflake.query.blocked") + validatedMetrics["snowflake.query.blocked"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Blocked query count for warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.blocked"], "Found a duplicate in the metrics slice: snowflake.query.blocked") + validatedMetrics["snowflake.query.blocked"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Blocked query count for warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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["snowflake.query.blocked"] { + 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("warehouse_name") + assert.False(t, ok) + } case "snowflake.query.bytes_deleted.avg": - assert.False(t, validatedMetrics["snowflake.query.bytes_deleted.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_deleted.avg") - validatedMetrics["snowflake.query.bytes_deleted.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average bytes deleted in database over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.bytes_deleted.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_deleted.avg") + validatedMetrics["snowflake.query.bytes_deleted.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average bytes deleted in database over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.bytes_deleted.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_deleted.avg") + validatedMetrics["snowflake.query.bytes_deleted.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average bytes deleted in database over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["snowflake.query.bytes_deleted.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.query.bytes_spilled.local.avg": - assert.False(t, validatedMetrics["snowflake.query.bytes_spilled.local.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_spilled.local.avg") - validatedMetrics["snowflake.query.bytes_spilled.local.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average bytes spilled (intermediate results do not fit in memory) by local storage over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.bytes_spilled.local.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_spilled.local.avg") + validatedMetrics["snowflake.query.bytes_spilled.local.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average bytes spilled (intermediate results do not fit in memory) by local storage over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.bytes_spilled.local.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_spilled.local.avg") + validatedMetrics["snowflake.query.bytes_spilled.local.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average bytes spilled (intermediate results do not fit in memory) by local storage over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["snowflake.query.bytes_spilled.local.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.query.bytes_spilled.remote.avg": - assert.False(t, validatedMetrics["snowflake.query.bytes_spilled.remote.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_spilled.remote.avg") - validatedMetrics["snowflake.query.bytes_spilled.remote.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average bytes spilled (intermediate results do not fit in memory) by remote storage over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.bytes_spilled.remote.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_spilled.remote.avg") + validatedMetrics["snowflake.query.bytes_spilled.remote.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average bytes spilled (intermediate results do not fit in memory) by remote storage over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.bytes_spilled.remote.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_spilled.remote.avg") + validatedMetrics["snowflake.query.bytes_spilled.remote.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average bytes spilled (intermediate results do not fit in memory) by remote storage over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["snowflake.query.bytes_spilled.remote.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.query.bytes_written.avg": - assert.False(t, validatedMetrics["snowflake.query.bytes_written.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_written.avg") - validatedMetrics["snowflake.query.bytes_written.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average bytes written by database over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) - attrVal, ok := dp.Attributes().Get("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.bytes_written.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_written.avg") + validatedMetrics["snowflake.query.bytes_written.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average bytes written by database over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.bytes_written.avg"], "Found a duplicate in the metrics slice: snowflake.query.bytes_written.avg") + validatedMetrics["snowflake.query.bytes_written.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average bytes written by database over the last 24 hour window.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["snowflake.query.bytes_written.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.query.compilation_time.avg": - assert.False(t, validatedMetrics["snowflake.query.compilation_time.avg"], "Found a duplicate in the metrics slice: snowflake.query.compilation_time.avg") - validatedMetrics["snowflake.query.compilation_time.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average time taken to compile query over the last 24 hour window.", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.compilation_time.avg"], "Found a duplicate in the metrics slice: snowflake.query.compilation_time.avg") + validatedMetrics["snowflake.query.compilation_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average time taken to compile query over the last 24 hour window.", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.compilation_time.avg"], "Found a duplicate in the metrics slice: snowflake.query.compilation_time.avg") + validatedMetrics["snowflake.query.compilation_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average time taken to compile query over the last 24 hour window.", 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["snowflake.query.compilation_time.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.query.data_scanned_cache.avg": - assert.False(t, validatedMetrics["snowflake.query.data_scanned_cache.avg"], "Found a duplicate in the metrics slice: snowflake.query.data_scanned_cache.avg") - validatedMetrics["snowflake.query.data_scanned_cache.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average percentage of data scanned from cache over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "1", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.data_scanned_cache.avg"], "Found a duplicate in the metrics slice: snowflake.query.data_scanned_cache.avg") + validatedMetrics["snowflake.query.data_scanned_cache.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average percentage of data scanned from cache over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.data_scanned_cache.avg"], "Found a duplicate in the metrics slice: snowflake.query.data_scanned_cache.avg") + validatedMetrics["snowflake.query.data_scanned_cache.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average percentage of data scanned from cache over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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["snowflake.query.data_scanned_cache.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.query.executed": - assert.False(t, validatedMetrics["snowflake.query.executed"], "Found a duplicate in the metrics slice: snowflake.query.executed") - validatedMetrics["snowflake.query.executed"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Executed query count for warehouse over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "1", 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("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.executed"], "Found a duplicate in the metrics slice: snowflake.query.executed") + validatedMetrics["snowflake.query.executed"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Executed query count for warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.executed"], "Found a duplicate in the metrics slice: snowflake.query.executed") + validatedMetrics["snowflake.query.executed"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Executed query count for warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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["snowflake.query.executed"] { + 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("warehouse_name") + assert.False(t, ok) + } case "snowflake.query.execution_time.avg": - assert.False(t, validatedMetrics["snowflake.query.execution_time.avg"], "Found a duplicate in the metrics slice: snowflake.query.execution_time.avg") - validatedMetrics["snowflake.query.execution_time.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average time spent executing queries in database over the last 24 hour window.", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.execution_time.avg"], "Found a duplicate in the metrics slice: snowflake.query.execution_time.avg") + validatedMetrics["snowflake.query.execution_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average time spent executing queries in database over the last 24 hour window.", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.execution_time.avg"], "Found a duplicate in the metrics slice: snowflake.query.execution_time.avg") + validatedMetrics["snowflake.query.execution_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average time spent executing queries in database over the last 24 hour window.", 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["snowflake.query.execution_time.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.query.partitions_scanned.avg": - assert.False(t, validatedMetrics["snowflake.query.partitions_scanned.avg"], "Found a duplicate in the metrics slice: snowflake.query.partitions_scanned.avg") - validatedMetrics["snowflake.query.partitions_scanned.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Number of partitions scanned during query so far over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "1", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.partitions_scanned.avg"], "Found a duplicate in the metrics slice: snowflake.query.partitions_scanned.avg") + validatedMetrics["snowflake.query.partitions_scanned.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of partitions scanned during query so far over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.partitions_scanned.avg"], "Found a duplicate in the metrics slice: snowflake.query.partitions_scanned.avg") + validatedMetrics["snowflake.query.partitions_scanned.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of partitions scanned during query so far over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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["snowflake.query.partitions_scanned.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.query.queued_overload": - assert.False(t, validatedMetrics["snowflake.query.queued_overload"], "Found a duplicate in the metrics slice: snowflake.query.queued_overload") - validatedMetrics["snowflake.query.queued_overload"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Overloaded query count for warehouse over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "1", 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("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.queued_overload"], "Found a duplicate in the metrics slice: snowflake.query.queued_overload") + validatedMetrics["snowflake.query.queued_overload"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Overloaded query count for warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.queued_overload"], "Found a duplicate in the metrics slice: snowflake.query.queued_overload") + validatedMetrics["snowflake.query.queued_overload"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Overloaded query count for warehouse over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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["snowflake.query.queued_overload"] { + 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("warehouse_name") + assert.False(t, ok) + } case "snowflake.query.queued_provision": - assert.False(t, validatedMetrics["snowflake.query.queued_provision"], "Found a duplicate in the metrics slice: snowflake.query.queued_provision") - validatedMetrics["snowflake.query.queued_provision"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Number of compute resources queued for provisioning over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "1", 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("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.query.queued_provision"], "Found a duplicate in the metrics slice: snowflake.query.queued_provision") + validatedMetrics["snowflake.query.queued_provision"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of compute resources queued for provisioning over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.query.queued_provision"], "Found a duplicate in the metrics slice: snowflake.query.queued_provision") + validatedMetrics["snowflake.query.queued_provision"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of compute resources queued for provisioning over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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["snowflake.query.queued_provision"] { + 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("warehouse_name") + assert.False(t, ok) + } case "snowflake.queued_overload_time.avg": - assert.False(t, validatedMetrics["snowflake.queued_overload_time.avg"], "Found a duplicate in the metrics slice: snowflake.queued_overload_time.avg") - validatedMetrics["snowflake.queued_overload_time.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average time spent in warehouse queue due to warehouse being overloaded over the last 24 hour window.", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.queued_overload_time.avg"], "Found a duplicate in the metrics slice: snowflake.queued_overload_time.avg") + validatedMetrics["snowflake.queued_overload_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average time spent in warehouse queue due to warehouse being overloaded over the last 24 hour window.", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.queued_overload_time.avg"], "Found a duplicate in the metrics slice: snowflake.queued_overload_time.avg") + validatedMetrics["snowflake.queued_overload_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average time spent in warehouse queue due to warehouse being overloaded over the last 24 hour window.", 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["snowflake.queued_overload_time.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.queued_provisioning_time.avg": - assert.False(t, validatedMetrics["snowflake.queued_provisioning_time.avg"], "Found a duplicate in the metrics slice: snowflake.queued_provisioning_time.avg") - validatedMetrics["snowflake.queued_provisioning_time.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average time spent in warehouse queue waiting for resources to provision over the last 24 hour window.", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.queued_provisioning_time.avg"], "Found a duplicate in the metrics slice: snowflake.queued_provisioning_time.avg") + validatedMetrics["snowflake.queued_provisioning_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average time spent in warehouse queue waiting for resources to provision over the last 24 hour window.", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.queued_provisioning_time.avg"], "Found a duplicate in the metrics slice: snowflake.queued_provisioning_time.avg") + validatedMetrics["snowflake.queued_provisioning_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average time spent in warehouse queue waiting for resources to provision over the last 24 hour window.", 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["snowflake.queued_provisioning_time.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.queued_repair_time.avg": - assert.False(t, validatedMetrics["snowflake.queued_repair_time.avg"], "Found a duplicate in the metrics slice: snowflake.queued_repair_time.avg") - validatedMetrics["snowflake.queued_repair_time.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average time spent in warehouse queue waiting for compute resources to be repaired over the last 24 hour window.", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.queued_repair_time.avg"], "Found a duplicate in the metrics slice: snowflake.queued_repair_time.avg") + validatedMetrics["snowflake.queued_repair_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average time spent in warehouse queue waiting for compute resources to be repaired over the last 24 hour window.", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.queued_repair_time.avg"], "Found a duplicate in the metrics slice: snowflake.queued_repair_time.avg") + validatedMetrics["snowflake.queued_repair_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average time spent in warehouse queue waiting for compute resources to be repaired over the last 24 hour window.", 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["snowflake.queued_repair_time.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.rows_deleted.avg": - assert.False(t, validatedMetrics["snowflake.rows_deleted.avg"], "Found a duplicate in the metrics slice: snowflake.rows_deleted.avg") - validatedMetrics["snowflake.rows_deleted.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Number of rows deleted from a table (or tables) over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{rows}", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.rows_deleted.avg"], "Found a duplicate in the metrics slice: snowflake.rows_deleted.avg") + validatedMetrics["snowflake.rows_deleted.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of rows deleted from a table (or tables) over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{rows}", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.rows_deleted.avg"], "Found a duplicate in the metrics slice: snowflake.rows_deleted.avg") + validatedMetrics["snowflake.rows_deleted.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of rows deleted from a table (or tables) over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{rows}", 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["snowflake.rows_deleted.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.rows_inserted.avg": - assert.False(t, validatedMetrics["snowflake.rows_inserted.avg"], "Found a duplicate in the metrics slice: snowflake.rows_inserted.avg") - validatedMetrics["snowflake.rows_inserted.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Number of rows inserted into a table (or tables) over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{rows}", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.rows_inserted.avg"], "Found a duplicate in the metrics slice: snowflake.rows_inserted.avg") + validatedMetrics["snowflake.rows_inserted.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of rows inserted into a table (or tables) over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{rows}", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.rows_inserted.avg"], "Found a duplicate in the metrics slice: snowflake.rows_inserted.avg") + validatedMetrics["snowflake.rows_inserted.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of rows inserted into a table (or tables) over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{rows}", 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["snowflake.rows_inserted.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.rows_produced.avg": - assert.False(t, validatedMetrics["snowflake.rows_produced.avg"], "Found a duplicate in the metrics slice: snowflake.rows_produced.avg") - validatedMetrics["snowflake.rows_produced.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average number of rows produced by statement over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{rows}", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.rows_produced.avg"], "Found a duplicate in the metrics slice: snowflake.rows_produced.avg") + validatedMetrics["snowflake.rows_produced.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average number of rows produced by statement over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{rows}", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.rows_produced.avg"], "Found a duplicate in the metrics slice: snowflake.rows_produced.avg") + validatedMetrics["snowflake.rows_produced.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average number of rows produced by statement over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{rows}", 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["snowflake.rows_produced.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.rows_unloaded.avg": - assert.False(t, validatedMetrics["snowflake.rows_unloaded.avg"], "Found a duplicate in the metrics slice: snowflake.rows_unloaded.avg") - validatedMetrics["snowflake.rows_unloaded.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average number of rows unloaded during data export over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{rows}", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.rows_unloaded.avg"], "Found a duplicate in the metrics slice: snowflake.rows_unloaded.avg") + validatedMetrics["snowflake.rows_unloaded.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average number of rows unloaded during data export over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{rows}", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.rows_unloaded.avg"], "Found a duplicate in the metrics slice: snowflake.rows_unloaded.avg") + validatedMetrics["snowflake.rows_unloaded.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average number of rows unloaded during data export over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{rows}", 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["snowflake.rows_unloaded.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.rows_updated.avg": - assert.False(t, validatedMetrics["snowflake.rows_updated.avg"], "Found a duplicate in the metrics slice: snowflake.rows_updated.avg") - validatedMetrics["snowflake.rows_updated.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average number of rows updated in a table over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "{rows}", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.rows_updated.avg"], "Found a duplicate in the metrics slice: snowflake.rows_updated.avg") + validatedMetrics["snowflake.rows_updated.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average number of rows updated in a table over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{rows}", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.rows_updated.avg"], "Found a duplicate in the metrics slice: snowflake.rows_updated.avg") + validatedMetrics["snowflake.rows_updated.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average number of rows updated in a table over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "{rows}", 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["snowflake.rows_updated.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } case "snowflake.session_id.count": - assert.False(t, validatedMetrics["snowflake.session_id.count"], "Found a duplicate in the metrics slice: snowflake.session_id.count") - validatedMetrics["snowflake.session_id.count"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Distinct session id's associated with snowflake username over the last 24 hour window.", ms.At(i).Description()) - assert.Equal(t, "1", 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("user_name") - assert.True(t, ok) - assert.Equal(t, "user_name-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.session_id.count"], "Found a duplicate in the metrics slice: snowflake.session_id.count") + validatedMetrics["snowflake.session_id.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Distinct session id's associated with snowflake username over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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("user_name") + assert.True(t, ok) + assert.Equal(t, "user_name-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.session_id.count"], "Found a duplicate in the metrics slice: snowflake.session_id.count") + validatedMetrics["snowflake.session_id.count"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Distinct session id's associated with snowflake username over the last 24 hour window.", ms.At(i).Description()) + assert.Equal(t, "1", 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["snowflake.session_id.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("user_name") + assert.False(t, ok) + } case "snowflake.storage.failsafe_bytes.total": - assert.False(t, validatedMetrics["snowflake.storage.failsafe_bytes.total"], "Found a duplicate in the metrics slice: snowflake.storage.failsafe_bytes.total") - validatedMetrics["snowflake.storage.failsafe_bytes.total"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Number of bytes of data in Fail-safe.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.storage.failsafe_bytes.total"], "Found a duplicate in the metrics slice: snowflake.storage.failsafe_bytes.total") + validatedMetrics["snowflake.storage.failsafe_bytes.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of bytes of data in Fail-safe.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + } else { + assert.False(t, validatedMetrics["snowflake.storage.failsafe_bytes.total"], "Found a duplicate in the metrics slice: snowflake.storage.failsafe_bytes.total") + validatedMetrics["snowflake.storage.failsafe_bytes.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of bytes of data in Fail-safe.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["snowflake.storage.failsafe_bytes.total"] { + 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) + } + } case "snowflake.storage.stage_bytes.total": - assert.False(t, validatedMetrics["snowflake.storage.stage_bytes.total"], "Found a duplicate in the metrics slice: snowflake.storage.stage_bytes.total") - validatedMetrics["snowflake.storage.stage_bytes.total"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Number of bytes of stage storage used by files in all internal stages (named, table, user).", 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.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.storage.stage_bytes.total"], "Found a duplicate in the metrics slice: snowflake.storage.stage_bytes.total") + validatedMetrics["snowflake.storage.stage_bytes.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of bytes of stage storage used by files in all internal stages (named, table, user).", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + } else { + assert.False(t, validatedMetrics["snowflake.storage.stage_bytes.total"], "Found a duplicate in the metrics slice: snowflake.storage.stage_bytes.total") + validatedMetrics["snowflake.storage.stage_bytes.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of bytes of stage storage used by files in all internal stages (named, table, user).", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["snowflake.storage.stage_bytes.total"] { + 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) + } + } case "snowflake.storage.storage_bytes.total": - assert.False(t, validatedMetrics["snowflake.storage.storage_bytes.total"], "Found a duplicate in the metrics slice: snowflake.storage.storage_bytes.total") - validatedMetrics["snowflake.storage.storage_bytes.total"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Number of bytes of table storage used, including bytes for data currently in Time Travel.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) - assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.storage.storage_bytes.total"], "Found a duplicate in the metrics slice: snowflake.storage.storage_bytes.total") + validatedMetrics["snowflake.storage.storage_bytes.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of bytes of table storage used, including bytes for data currently in Time Travel.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + } else { + assert.False(t, validatedMetrics["snowflake.storage.storage_bytes.total"], "Found a duplicate in the metrics slice: snowflake.storage.storage_bytes.total") + validatedMetrics["snowflake.storage.storage_bytes.total"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Number of bytes of table storage used, including bytes for data currently in Time Travel.", 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.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["snowflake.storage.storage_bytes.total"] { + 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) + } + } case "snowflake.total_elapsed_time.avg": - assert.False(t, validatedMetrics["snowflake.total_elapsed_time.avg"], "Found a duplicate in the metrics slice: snowflake.total_elapsed_time.avg") - validatedMetrics["snowflake.total_elapsed_time.avg"] = true - assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) - assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Average elapsed time over the last 24 hour window.", 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("schema_name") - assert.True(t, ok) - assert.Equal(t, "schema_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("execution_status") - assert.True(t, ok) - assert.Equal(t, "execution_status-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("error_message") - assert.True(t, ok) - assert.Equal(t, "error_message-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("query_type") - assert.True(t, ok) - assert.Equal(t, "query_type-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_name") - assert.True(t, ok) - assert.Equal(t, "warehouse_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("database_name") - assert.True(t, ok) - assert.Equal(t, "database_name-val", attrVal.Str()) - attrVal, ok = dp.Attributes().Get("warehouse_size") - assert.True(t, ok) - assert.Equal(t, "warehouse_size-val", attrVal.Str()) + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["snowflake.total_elapsed_time.avg"], "Found a duplicate in the metrics slice: snowflake.total_elapsed_time.avg") + validatedMetrics["snowflake.total_elapsed_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average elapsed time over the last 24 hour window.", 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("schema_name") + assert.True(t, ok) + assert.Equal(t, "schema_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("execution_status") + assert.True(t, ok) + assert.Equal(t, "execution_status-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("error_message") + assert.True(t, ok) + assert.Equal(t, "error_message-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("query_type") + assert.True(t, ok) + assert.Equal(t, "query_type-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_name") + assert.True(t, ok) + assert.Equal(t, "warehouse_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("database_name") + assert.True(t, ok) + assert.Equal(t, "database_name-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("warehouse_size") + assert.True(t, ok) + assert.Equal(t, "warehouse_size-val", attrVal.Str()) + } else { + assert.False(t, validatedMetrics["snowflake.total_elapsed_time.avg"], "Found a duplicate in the metrics slice: snowflake.total_elapsed_time.avg") + validatedMetrics["snowflake.total_elapsed_time.avg"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Average elapsed time over the last 24 hour window.", 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["snowflake.total_elapsed_time.avg"] { + 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("schema_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("execution_status") + assert.False(t, ok) + _, ok = dp.Attributes().Get("error_message") + assert.False(t, ok) + _, ok = dp.Attributes().Get("query_type") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("database_name") + assert.False(t, ok) + _, ok = dp.Attributes().Get("warehouse_size") + assert.False(t, ok) + } } } }) diff --git a/receiver/snowflakereceiver/internal/metadata/testdata/config.yaml b/receiver/snowflakereceiver/internal/metadata/testdata/config.yaml index ca8d86db65628..82163002b6475 100644 --- a/receiver/snowflakereceiver/internal/metadata/testdata/config.yaml +++ b/receiver/snowflakereceiver/internal/metadata/testdata/config.yaml @@ -3,74 +3,219 @@ all_set: metrics: snowflake.billing.cloud_service.total: enabled: true + attributes: ["service_type"] snowflake.billing.total_credit.total: enabled: true + attributes: ["service_type"] snowflake.billing.virtual_warehouse.total: enabled: true + attributes: ["service_type"] snowflake.billing.warehouse.cloud_service.total: enabled: true + attributes: ["warehouse_name"] snowflake.billing.warehouse.total_credit.total: enabled: true + attributes: ["warehouse_name"] snowflake.billing.warehouse.virtual_warehouse.total: enabled: true + attributes: ["warehouse_name"] snowflake.database.bytes_scanned.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.database.query.count: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.logins.total: enabled: true + attributes: ["error_message","reported_client_type","is_success"] snowflake.pipe.credits_used.total: enabled: true + attributes: ["pipe_name"] snowflake.query.blocked: enabled: true + attributes: ["warehouse_name"] snowflake.query.bytes_deleted.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.bytes_spilled.local.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.bytes_spilled.remote.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.bytes_written.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.compilation_time.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.data_scanned_cache.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.executed: enabled: true + attributes: ["warehouse_name"] snowflake.query.execution_time.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.partitions_scanned.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.queued_overload: enabled: true + attributes: ["warehouse_name"] snowflake.query.queued_provision: enabled: true + attributes: ["warehouse_name"] snowflake.queued_overload_time.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.queued_provisioning_time.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.queued_repair_time.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.rows_deleted.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.rows_inserted.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.rows_produced.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.rows_unloaded.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.rows_updated.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.session_id.count: enabled: true + attributes: ["user_name"] snowflake.storage.failsafe_bytes.total: enabled: true + attributes: [] snowflake.storage.stage_bytes.total: enabled: true + attributes: [] snowflake.storage.storage_bytes.total: enabled: true + attributes: [] snowflake.total_elapsed_time.avg: enabled: true + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] + resource_attributes: + snowflake.account.name: + enabled: true +reaggregate_set: + metrics: + snowflake.billing.cloud_service.total: + enabled: true + attributes: [] + snowflake.billing.total_credit.total: + enabled: true + attributes: [] + snowflake.billing.virtual_warehouse.total: + enabled: true + attributes: [] + snowflake.billing.warehouse.cloud_service.total: + enabled: true + attributes: [] + snowflake.billing.warehouse.total_credit.total: + enabled: true + attributes: [] + snowflake.billing.warehouse.virtual_warehouse.total: + enabled: true + attributes: [] + snowflake.database.bytes_scanned.avg: + enabled: true + attributes: [] + snowflake.database.query.count: + enabled: true + attributes: [] + snowflake.logins.total: + enabled: true + attributes: [] + snowflake.pipe.credits_used.total: + enabled: true + attributes: [] + snowflake.query.blocked: + enabled: true + attributes: [] + snowflake.query.bytes_deleted.avg: + enabled: true + attributes: [] + snowflake.query.bytes_spilled.local.avg: + enabled: true + attributes: [] + snowflake.query.bytes_spilled.remote.avg: + enabled: true + attributes: [] + snowflake.query.bytes_written.avg: + enabled: true + attributes: [] + snowflake.query.compilation_time.avg: + enabled: true + attributes: [] + snowflake.query.data_scanned_cache.avg: + enabled: true + attributes: [] + snowflake.query.executed: + enabled: true + attributes: [] + snowflake.query.execution_time.avg: + enabled: true + attributes: [] + snowflake.query.partitions_scanned.avg: + enabled: true + attributes: [] + snowflake.query.queued_overload: + enabled: true + attributes: [] + snowflake.query.queued_provision: + enabled: true + attributes: [] + snowflake.queued_overload_time.avg: + enabled: true + attributes: [] + snowflake.queued_provisioning_time.avg: + enabled: true + attributes: [] + snowflake.queued_repair_time.avg: + enabled: true + attributes: [] + snowflake.rows_deleted.avg: + enabled: true + attributes: [] + snowflake.rows_inserted.avg: + enabled: true + attributes: [] + snowflake.rows_produced.avg: + enabled: true + attributes: [] + snowflake.rows_unloaded.avg: + enabled: true + attributes: [] + snowflake.rows_updated.avg: + enabled: true + attributes: [] + snowflake.session_id.count: + enabled: true + attributes: [] + snowflake.storage.failsafe_bytes.total: + enabled: true + attributes: [] + snowflake.storage.stage_bytes.total: + enabled: true + attributes: [] + snowflake.storage.storage_bytes.total: + enabled: true + attributes: [] + snowflake.total_elapsed_time.avg: + enabled: true + attributes: [] resource_attributes: snowflake.account.name: enabled: true @@ -78,74 +223,109 @@ none_set: metrics: snowflake.billing.cloud_service.total: enabled: false + attributes: ["service_type"] snowflake.billing.total_credit.total: enabled: false + attributes: ["service_type"] snowflake.billing.virtual_warehouse.total: enabled: false + attributes: ["service_type"] snowflake.billing.warehouse.cloud_service.total: enabled: false + attributes: ["warehouse_name"] snowflake.billing.warehouse.total_credit.total: enabled: false + attributes: ["warehouse_name"] snowflake.billing.warehouse.virtual_warehouse.total: enabled: false + attributes: ["warehouse_name"] snowflake.database.bytes_scanned.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.database.query.count: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.logins.total: enabled: false + attributes: ["error_message","reported_client_type","is_success"] snowflake.pipe.credits_used.total: enabled: false + attributes: ["pipe_name"] snowflake.query.blocked: enabled: false + attributes: ["warehouse_name"] snowflake.query.bytes_deleted.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.bytes_spilled.local.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.bytes_spilled.remote.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.bytes_written.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.compilation_time.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.data_scanned_cache.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.executed: enabled: false + attributes: ["warehouse_name"] snowflake.query.execution_time.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.partitions_scanned.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.query.queued_overload: enabled: false + attributes: ["warehouse_name"] snowflake.query.queued_provision: enabled: false + attributes: ["warehouse_name"] snowflake.queued_overload_time.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.queued_provisioning_time.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.queued_repair_time.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.rows_deleted.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.rows_inserted.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.rows_produced.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.rows_unloaded.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.rows_updated.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] snowflake.session_id.count: enabled: false + attributes: ["user_name"] snowflake.storage.failsafe_bytes.total: enabled: false + attributes: [] snowflake.storage.stage_bytes.total: enabled: false + attributes: [] snowflake.storage.storage_bytes.total: enabled: false + attributes: [] snowflake.total_elapsed_time.avg: enabled: false + attributes: ["schema_name","execution_status","error_message","query_type","warehouse_name","database_name","warehouse_size"] resource_attributes: snowflake.account.name: enabled: false diff --git a/receiver/snowflakereceiver/metadata.yaml b/receiver/snowflakereceiver/metadata.yaml index 620a6fb085e94..d630f0172cb8a 100644 --- a/receiver/snowflakereceiver/metadata.yaml +++ b/receiver/snowflakereceiver/metadata.yaml @@ -8,6 +8,8 @@ status: codeowners: active: [dmitryax, shalper2] +reaggregation_enabled: true + # every meter will have these attributes resource_attributes: snowflake.account.name: @@ -19,39 +21,51 @@ attributes: database_name: description: Name of database being queried (default is snowflake). type: string + requirement_level: recommended error_message: description: Error message reported by query if present. type: string + requirement_level: recommended execution_status: description: Execution status of query being reported. type: string + requirement_level: recommended is_success: description: Login status (success or failure). type: string + requirement_level: recommended pipe_name: description: Name of snowpipe. type: string + requirement_level: recommended query_type: description: Type of query performed. type: string + requirement_level: recommended reported_client_type: description: Client type used for attempt. type: string + requirement_level: recommended schema_name: description: Name of schema associated with query result. type: string + requirement_level: recommended service_type: description: Service type associated with metric query. type: string + requirement_level: recommended user_name: description: Username in query being reported. type: string + requirement_level: recommended warehouse_name: description: Name of warehouse in query being reported on. type: string + requirement_level: recommended warehouse_size: description: Size of warehouse being reported on. type: string + requirement_level: recommended # sql query associated with each group of metrics included metrics: From ae61d6c3569553dfaea983685c69889147fcca17 Mon Sep 17 00:00:00 2001 From: shalper2 Date: Thu, 15 Jan 2026 09:48:30 -0600 Subject: [PATCH 2/2] chlog --- .../45396-snowflake-enable-reaggregation.yaml | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 .chloggen/45396-snowflake-enable-reaggregation.yaml diff --git a/.chloggen/45396-snowflake-enable-reaggregation.yaml b/.chloggen/45396-snowflake-enable-reaggregation.yaml new file mode 100644 index 0000000000000..4665b4185557f --- /dev/null +++ b/.chloggen/45396-snowflake-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/snowflake + +# 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]