[Azure Monitor] Add default timegrain to Azure Storage Account metricset (#46786) (#46851)

mergify[bot] · zmoog · web-flow · commit 0f58fd09f836 · 2025-09-30T17:43:53.000+02:00
Adds a new `default_timegrain` configuration option to allow users to customize the timegrain used in the Storage Account metricset. The default value remains PT5M, but users can now choose a different value. Without this option, users can only collect metrics with a PT5M time grain. It is a sensible default, but some users want to collect metrics with a PT1M time grain. To learn more, see elastic/integrations#15464. (cherry picked from commit 8f145b9) # Conflicts: # docs/reference/metricbeat/metricbeat-metricset-azure-storage.md # x-pack/metricbeat/module/azure/storage/_meta/docs.md Co-authored-by: Maurizio Branca <maurizio.branca@elastic.co>
diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc
@@ -364,6 +364,27 @@ https://github.com/elastic/beats/compare/v8.8.1\...main[Check the HEAD diff]
 - Only watch metadata for ReplicaSets in metricbeat k8s module {pull}41289[41289]
 - Preserve queries for debugging when `merge_results: true` in SQL module {pull}42271[42271]
 - Collect more fields from ES node/stats metrics and only those that are necessary {pull}42421[42421]
+- Add new metricset wmi for the windows module. {pull}42017[42017]
+- Update beat module with apm-server tail sampling monitoring metrics fields {pull}42569[42569]
+- Log every 401 response from Kubernetes API Server {pull}42714[42714]
+- Add a new `match_by_parent_instance` option to `perfmon` module. {pull}43002[43002]
+- Add a warning log to metricbeat.vsphere in case vSphere connection has been configured as insecure. {pull}43104[43104]
+- Changed the Elasticsearch module behavior to only pull settings from non-system indices. {pull}43243[43243]
+- Exclude dotted indices from settings pull in Elasticsearch module. {pull}43306[43306]
+- Add a `jetstream` metricset to the NATS module {pull}43310[43310]
+- Updated Meraki API endpoint for Channel Utilization data. Switched to `GetOrganizationWirelessDevicesChannelUtilizationByDevice`. {pull}43485[43485]
+- Upgrade Prometheus Library to v0.300.1. {pull}43540[43540]
+- Add GCP Dataproc metadata collector in GCP module. {pull}43518[43518]
+- Add new metrics to vSphere Virtual Machine dataset (CPU usage percentage, disk average usage, disk read/write rate, number of disk reads/writes, memory usage percentage). {pull}44205[44205]
+- Added checks for the Resty response object in all Meraki module API calls to ensure proper handling of nil responses. {pull}44193[44193]
+- Add latency config option to Azure Monitor module. {pull}44366[44366]
+- Increase default polling period for MongoDB module from 10s to 60s {pull}44781[44781]
+- Upgrade github.com/microsoft/go-mssqldb from v1.7.2 to v1.8.2 {pull}44990[44990]
+- Add SSL support for sql module: drivers mysql, postgres, and mssql. {pull}44748[44748]
+- Add support for Kafka 4.0 in the Kafka module. {pull}44723[44723]
+- Add NTP response validation for system/ntp module. {pull}46184[46184]
+- Add vertexai_logs metricset to GCP for prompt response collection from VertexAI service. {pull}46383[46383]
+- Add default timegrain to Azure Storage Account metricset. {pull}46786[46786]
 
 *Metricbeat*
 
diff --git a/docs/reference/metricbeat/metricbeat-metricset-azure-storage.md b/docs/reference/metricbeat/metricbeat-metricset-azure-storage.md
@@ -0,0 +1,148 @@
+---
+mapped_pages:
+  - https://www.elastic.co/guide/en/beats/metricbeat/current/metricbeat-metricset-azure-storage.html
+applies_to:
+  stack: ga
+---
+
+% This file is generated! See scripts/docs_collector.py
+
+# Azure storage metricset [metricbeat-metricset-azure-storage]
+
+This is the storage metricset of the module azure.
+
+This metricset allows users to retrieve all metrics from specified storage accounts.
+
+## Metricset-specific configuration notes [_metricset_specific_configuration_notes_11]
+
+`refresh_list_interval`
+:   Resources will be retrieved at each fetch call (`period` interval), this means a number of Azure REST calls will be executed each time. This will be helpful if the azure users will be adding/removing resources that could match the configuration options so they will not added/removed to the list. To reduce on the number of API calls we are executing to retrieve the resources each time, users can configure this setting and make sure the list or resources will not be refreshed as often. This is also beneficial for performance and rate/ cost reasons ([https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-manager-request-limits](https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-manager-request-limits)).
+
+`resources`
+:   This will contain all options for identifying resources and configuring the desired metrics
+
+### Config options to identify resources [_config_options_to_identify_resources_11]
+
+`resource_id`
+:   (*[]string*) The fully qualified ID’s of the resource, including the resource name and resource type. Has the format `/subscriptions/{{guid}}/resourceGroups/{{resource-group-name}}/providers/{{resource-provider-namespace}}/{resource-type}/{{resource-name}}`. Should return a list of resources.
+
+`resource_group`
+:   (*[]string*) This option will return all storage accounts inside the resource group.
+
+`service_type`
+:   (*[]string*) This configuration key can be used with any of the 2 options above, for example:
+
+```
+resources:
+    - resource_id: ""
+      service_type: ["blob", "table"]
+    - resource_group: ""
+      service_type: ["queue", "file"]
+```
+
+It will filter the metric values to be returned by specific metric namespaces. The supported metrics and namespaces can be found here [https://docs.microsoft.com/en-us/azure/azure-monitor/platform/metrics-supported#microsoftstoragestorageaccounts](https://docs.microsoft.com/en-us/azure/azure-monitor/platform/metrics-supported#microsoftstoragestorageaccounts). The service type values allowed are `blob`, `table`, `queue`, `file` based on the namespaces  `Microsoft.Storage/storageAccounts/blobServices`,`Microsoft.Storage/storageAccounts/tableServices`,`Microsoft.Storage/storageAccounts/fileServices`,`Microsoft.Storage/storageAccounts/queueServices`. If no service_type is specified all values are applied.
+
+Also, if the `resources` option is not specified, then all the storage accounts from the entire subscription will be selected. The primary aggregation value will be retrieved for all the metrics contained in the namespaces. The aggregation options are `avg`, `sum`, `min`, `max`, `total`, `count`.
+
+A default non configurable timegrain of 5 min is set so users are advised to configure an interval of 300s or  a multiply of it.
+
+`default_timegrain`:
+:   (*string*) Sets the default time grain to use when collecting storage account metrics. Defaults to PT5M.
+
+To collect storage account metrics with a PT1M time grain, we recommend using one of the following configurations:
+
+```yaml
+# (1) With `period: 60s` and `default_timegrain: "PT1M"`, the metricset 
+# collects 1 data point every 60s.
+- module: azure
+  metricsets:
+  - storage
+  enabled: true
+  period: 60s
+  client_id: '${AZURE_CLIENT_ID:""}'
+  client_secret: '${AZURE_CLIENT_SECRET:""}'
+  tenant_id: '${AZURE_TENANT_ID:""}'
+  subscription_id: '${AZURE_SUBSCRIPTION_ID:""}'
+  refresh_list_interval: 3600s # 1h
+  enable_batch_api: true
+  default_timegrain: "PT1M"
+```
+
+```yaml
+# (2) With `period: 300s` and `default_timegrain: "PT1M"`, the metricset
+# collects 5 data points every 300s (5 minutes) — one for each minute, 
+# but all data points arrive after 5 minutes
+- module: azure
+  metricsets:
+  - storage
+  enabled: true
+  period: 300s
+  client_id: '${AZURE_CLIENT_ID:""}'
+  client_secret: '${AZURE_CLIENT_SECRET:""}'
+  tenant_id: '${AZURE_TENANT_ID:""}'
+  subscription_id: '${AZURE_SUBSCRIPTION_ID:""}'
+  refresh_list_interval: 3600s # 1h
+  enable_batch_api: true
+  default_timegrain: "PT1M"
+```
+
+These two configurations trade off scalability and freshness. Configuration (1) prioritizes freshness over scalability, while configuration (2) prioritizes scalability over freshness.
+
+Suggested changes:
+
+- `enable_batch_api: true`: Retrieves metric values for multiple Azure resources in one API call, supporting more storage accounts.
+- `refresh_list_interval: 3600s`: Looks for new storage accounts every 60 minutes instead of 10 minutes, helping to avoid or reduce gaps when monitoring many storage accounts.
+
+Note: By setting the collection `period: 1m`, the metricset only has 60s to collect all metric values instead of 300s, so it can handle fewer storage accounts. Keep in mind that the storage accounts metricset collects metrics for five different namespaces (storage account, blob, file, queue, and table).
+
+## Fields [_fields]
+
+For a description of each field in the metricset, see the [exported fields](/reference/metricbeat/exported-fields-azure.md) section.
+
+Here is an example document generated by this metricset:
+
+```json
+{
+    "@timestamp": "2017-10-12T08:05:34.853Z",
+    "azure": {
+        "namespace": "Microsoft.Storage/storageAccounts/queueServices",
+        "resource": {
+            "group": "obs-infrastructure",
+            "type": "Microsoft.Storage/storageAccounts"
+        },
+        "storage": {
+            "queue_capacity": {
+                "avg": 0
+            },
+            "queue_count": {
+                "avg": 0
+            },
+            "queue_message_count": {
+                "avg": 0
+            }
+        },
+        "subscription_id": "fd675b6f-b5e5-426e-ac45-d1f876d0ffa6",
+        "timegrain": "PT1H"
+    },
+    "cloud": {
+        "instance": {
+            "id": "/subscriptions/fd675b6f-b5e5-426e-ac45-d1f876d0ffa6/resourceGroups/obs-infrastructure/providers/Microsoft.Storage/storageAccounts/urcbyscmrkbygsawinvm/queueServices/default",
+            "name": "urcbyscmrkbygsawinvm"
+        },
+        "provider": "azure",
+        "region": "westeurope"
+    },
+    "event": {
+        "dataset": "azure.storage",
+        "duration": 115000,
+        "module": "azure"
+    },
+    "metricset": {
+        "name": "storage",
+        "period": 10000
+    },
+    "service": {
+        "type": "azure"
+    }
+}
+```
diff --git a/x-pack/metricbeat/module/azure/azure.go b/x-pack/metricbeat/module/azure/azure.go
@@ -75,7 +75,7 @@ var supportedMonitorMetricsets = []string{"monitor", "container_registry", "cont
 // NewMetricSet will instantiate a new azure metricset
 func NewMetricSet(base mb.BaseMetricSet) (*MetricSet, error) {
 	metricsetName := base.Name()
-	var config Config
+	config := createDefaultConfig()
 	err := base.Module().UnpackConfig(&config)
 	if err != nil {
 		return nil, fmt.Errorf("error unpack raw module config using UnpackConfig: %w", err)
diff --git a/x-pack/metricbeat/module/azure/client_utils.go b/x-pack/metricbeat/module/azure/client_utils.go
@@ -19,9 +19,6 @@ import (
 	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/monitor/armmonitor"
 )
 
-// DefaultTimeGrain is set as default timegrain for the azure metrics
-const DefaultTimeGrain = "PT5M"
-
 var instanceIdRegex = regexp.MustCompile(`.*?(\d+)$`)
 
 // mapMetricValues should map the metric values
diff --git a/x-pack/metricbeat/module/azure/config.go b/x-pack/metricbeat/module/azure/config.go
@@ -51,6 +51,22 @@ type Config struct {
 	BillingScopeAccountId  string `config:"billing_scope_account_id"` // retrieve usage details from billing account ID scope
 	// Use BatchApi for metric values collection
 	EnableBatchApi bool `config:"enable_batch_api"` // defaults to false
+	// DefaultTimeGrain sets the default time interval when the resource config
+	// doesn't specify one. If no time grain is configured, this value will be
+	// used whenever possible.
+	//
+	// When the metric definition doesn't support this time grain, we fall back
+	// to the smallest supported interval.
+	//
+	// Note: currently, this is only used for the storage metricset.
+	DefaultTimeGrain string `config:"default_timegrain"` // defaults to PT5M
+}
+
+// createDefaultConfig creates a default config for the metricset.
+func createDefaultConfig() Config {
+	return Config{
+		DefaultTimeGrain: "PT5M",
+	}
 }
 
 // ResourceConfig contains resource and metric list specific configuration.
diff --git a/x-pack/metricbeat/module/azure/storage/_meta/docs.md b/x-pack/metricbeat/module/azure/storage/_meta/docs.md
@@ -0,0 +1,85 @@
+This is the storage metricset of the module azure.
+
+This metricset allows users to retrieve all metrics from specified storage accounts.
+
+## Metricset-specific configuration notes [_metricset_specific_configuration_notes_11]
+
+`refresh_list_interval`
+:   Resources will be retrieved at each fetch call (`period` interval), this means a number of Azure REST calls will be executed each time. This will be helpful if the azure users will be adding/removing resources that could match the configuration options so they will not added/removed to the list. To reduce on the number of API calls we are executing to retrieve the resources each time, users can configure this setting and make sure the list or resources will not be refreshed as often. This is also beneficial for performance and rate/ cost reasons ([https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-manager-request-limits](https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-manager-request-limits)).
+
+`resources`
+:   This will contain all options for identifying resources and configuring the desired metrics
+
+### Config options to identify resources [_config_options_to_identify_resources_11]
+
+`resource_id`
+:   (*[]string*) The fully qualified ID’s of the resource, including the resource name and resource type. Has the format `/subscriptions/{{guid}}/resourceGroups/{{resource-group-name}}/providers/{{resource-provider-namespace}}/{resource-type}/{{resource-name}}`. Should return a list of resources.
+
+`resource_group`
+:   (*[]string*) This option will return all storage accounts inside the resource group.
+
+`service_type`
+:   (*[]string*) This configuration key can be used with any of the 2 options above, for example:
+
+```
+resources:
+    - resource_id: ""
+      service_type: ["blob", "table"]
+    - resource_group: ""
+      service_type: ["queue", "file"]
+```
+
+It will filter the metric values to be returned by specific metric namespaces. The supported metrics and namespaces can be found here [https://docs.microsoft.com/en-us/azure/azure-monitor/platform/metrics-supported#microsoftstoragestorageaccounts](https://docs.microsoft.com/en-us/azure/azure-monitor/platform/metrics-supported#microsoftstoragestorageaccounts). The service type values allowed are `blob`, `table`, `queue`, `file` based on the namespaces  `Microsoft.Storage/storageAccounts/blobServices`,`Microsoft.Storage/storageAccounts/tableServices`,`Microsoft.Storage/storageAccounts/fileServices`,`Microsoft.Storage/storageAccounts/queueServices`. If no service_type is specified all values are applied.
+
+Also, if the `resources` option is not specified, then all the storage accounts from the entire subscription will be selected. The primary aggregation value will be retrieved for all the metrics contained in the namespaces. The aggregation options are `avg`, `sum`, `min`, `max`, `total`, `count`.
+
+A default non configurable timegrain of 5 min is set so users are advised to configure an interval of 300s or  a multiply of it.
+
+`default_timegrain`:
+:   (*string*) Sets the default time grain to use when collecting storage account metrics. Defaults to PT5M.
+
+To collect storage account metrics with a PT1M time grain, we recommend using one of the following configurations:
+
+```yaml
+# (1) With `period: 60s` and `default_timegrain: "PT1M"`, the metricset 
+# collects 1 data point every 60s.
+- module: azure
+  metricsets:
+  - storage
+  enabled: true
+  period: 60s
+  client_id: '${AZURE_CLIENT_ID:""}'
+  client_secret: '${AZURE_CLIENT_SECRET:""}'
+  tenant_id: '${AZURE_TENANT_ID:""}'
+  subscription_id: '${AZURE_SUBSCRIPTION_ID:""}'
+  refresh_list_interval: 3600s # 1h
+  enable_batch_api: true
+  default_timegrain: "PT1M"
+```
+
+```yaml
+# (2) With `period: 300s` and `default_timegrain: "PT1M"`, the metricset
+# collects 5 data points every 300s (5 minutes) — one for each minute, 
+# but all data points arrive after 5 minutes
+- module: azure
+  metricsets:
+  - storage
+  enabled: true
+  period: 300s
+  client_id: '${AZURE_CLIENT_ID:""}'
+  client_secret: '${AZURE_CLIENT_SECRET:""}'
+  tenant_id: '${AZURE_TENANT_ID:""}'
+  subscription_id: '${AZURE_SUBSCRIPTION_ID:""}'
+  refresh_list_interval: 3600s # 1h
+  enable_batch_api: true
+  default_timegrain: "PT1M"
+```
+
+These two configurations trade off scalability and freshness. Configuration (1) prioritizes freshness over scalability, while configuration (2) prioritizes scalability over freshness.
+
+Suggested changes:
+
+- `enable_batch_api: true`: Retrieves metric values for multiple Azure resources in one API call, supporting more storage accounts.
+- `refresh_list_interval: 3600s`: Looks for new storage accounts every 60 minutes instead of 10 minutes, helping to avoid or reduce gaps when monitoring many storage accounts.
+
+Note: By setting the collection `period: 1m`, the metricset only has 60s to collect all metric values instead of 300s, so it can handle fewer storage accounts. Keep in mind that the storage accounts metricset collects metrics for five different namespaces (storage account, blob, file, queue, and table).
diff --git a/x-pack/metricbeat/module/azure/storage/client_helper.go b/x-pack/metricbeat/module/azure/storage/client_helper.go
@@ -58,7 +58,7 @@ func mapMetrics(client *azure.Client, resources []*armresources.GenericResourceE
 			}
 
 			// some metrics do not support the default PT5M timegrain so they will have to be grouped in a different API call, else call will fail
-			groupedMetrics := groupOnTimeGrain(filteredMetricDefinitions)
+			groupedMetrics := groupOnTimeGrain(filteredMetricDefinitions, client.Config.DefaultTimeGrain)
 
 			for time, groupedMetricList := range groupedMetrics {
 				// metrics will have to be grouped by allowed dimensions
@@ -80,11 +80,11 @@ func mapMetrics(client *azure.Client, resources []*armresources.GenericResourceE
 }
 
 // groupOnTimeGrain - some metrics do not support the default timegrain value so the closest supported timegrain will be selected
-func groupOnTimeGrain(list []armmonitor.MetricDefinition) map[string][]armmonitor.MetricDefinition {
+func groupOnTimeGrain(list []armmonitor.MetricDefinition, defaultTimeGrain string) map[string][]armmonitor.MetricDefinition {
 	var groupedList = make(map[string][]armmonitor.MetricDefinition)
 
 	for _, metric := range list {
-		timegrain := retrieveSupportedMetricAvailability(metric.MetricAvailabilities)
+		timegrain := retrieveSupportedMetricAvailability(metric.MetricAvailabilities, defaultTimeGrain)
 		if _, ok := groupedList[timegrain]; !ok {
 			groupedList[timegrain] = make([]armmonitor.MetricDefinition, 0)
 		}
@@ -94,21 +94,17 @@ func groupOnTimeGrain(list []armmonitor.MetricDefinition) map[string][]armmonito
 }
 
 // retrieveSupportedMetricAvailability func will return the default timegrain if supported, else will return the next timegrain
-func retrieveSupportedMetricAvailability(availabilities []*armmonitor.MetricAvailability) string {
+func retrieveSupportedMetricAvailability(availabilities []*armmonitor.MetricAvailability, defaultTimeGrain string) string {
 	// common case in metrics supported by storage account - one availability
 	if len(availabilities) == 1 {
 		return *availabilities[0].TimeGrain
 	}
 	// check if the default timegrain is supported
 	for _, availability := range availabilities {
-		if *availability.TimeGrain == azure.DefaultTimeGrain {
-			return azure.DefaultTimeGrain
+		if *availability.TimeGrain == defaultTimeGrain {
+			return defaultTimeGrain
 		}
 	}
-	// select first timegrain, should be bigger than the min timegrain of 1M, timegrains are returned in asc order
-	if *availabilities[0].TimeGrain != "PT1M" {
-		return *availabilities[0].TimeGrain
-	}
 	return *availabilities[1].TimeGrain
 }
 
diff --git a/x-pack/metricbeat/module/azure/storage/client_helper_concurrent.go b/x-pack/metricbeat/module/azure/storage/client_helper_concurrent.go
@@ -67,7 +67,7 @@ func getStorageMappedResourceDefinitions(client *azure.BatchClient, resourceId s
 			filteredMetricDefinitions = append(filteredMetricDefinitions, *metricDefinition)
 		}
 		// some metrics do not support the default PT5M timegrain so they will have to be grouped in a different API call, else call will fail
-		groupedMetrics := groupOnTimeGrain(filteredMetricDefinitions)
+		groupedMetrics := groupOnTimeGrain(filteredMetricDefinitions, client.Config.DefaultTimeGrain)
 		for time, groupedMetricList := range groupedMetrics {
 			// metrics will have to be grouped by allowed dimensions
 			dimMetrics := groupMetricsByAllowedDimensions(groupedMetricList)
diff --git a/x-pack/metricbeat/module/azure/storage/client_helper_test.go b/x-pack/metricbeat/module/azure/storage/client_helper_test.go
@@ -166,7 +166,7 @@ func TestFilterOnTimeGrain(t *testing.T) {
 		{MetricAvailabilities: availability2},
 		{MetricAvailabilities: availability3},
 	}
-	response := groupOnTimeGrain(list)
+	response := groupOnTimeGrain(list, "PT5M")
 	assert.Equal(t, len(response), 2)
 	result := [][]armmonitor.MetricDefinition{
 		{
@@ -184,11 +184,11 @@ func TestFilterOnTimeGrain(t *testing.T) {
 }
 
 func TestRetrieveSupportedMetricAvailability(t *testing.T) {
-	response := retrieveSupportedMetricAvailability(availability1)
+	response := retrieveSupportedMetricAvailability(availability1, "PT5M")
 	assert.Equal(t, response, time2)
-	response = retrieveSupportedMetricAvailability(availability2)
+	response = retrieveSupportedMetricAvailability(availability2, "PT5M")
 	assert.Equal(t, response, time3)
-	response = retrieveSupportedMetricAvailability(availability3)
+	response = retrieveSupportedMetricAvailability(availability3, "PT5M")
 	assert.Equal(t, response, time3)
 }
 

Original file line number	Diff line number	Diff line change
`@@ -19,9 +19,6 @@ import (`
`19`	`19`	`"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/monitor/armmonitor"`
`20`	`20`	`)`
`21`	`21`
`22`		`-// DefaultTimeGrain is set as default timegrain for the azure metrics`
`23`		`-const DefaultTimeGrain = "PT5M"`
`24`		`-`
`25`	`22`	var instanceIdRegex = regexp.MustCompile(`.*?(\d+)$`)
`26`	`23`
`27`	`24`	`// mapMetricValues should map the metric values`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ func mapMetrics(client azure.Client, resources []armresources.GenericResourceE`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`// some metrics do not support the default PT5M timegrain so they will have to be grouped in a different API call, else call will fail`
`61`		`- groupedMetrics := groupOnTimeGrain(filteredMetricDefinitions)`
	`61`	`+ groupedMetrics := groupOnTimeGrain(filteredMetricDefinitions, client.Config.DefaultTimeGrain)`
`62`	`62`
`63`	`63`	`for time, groupedMetricList := range groupedMetrics {`
`64`	`64`	`// metrics will have to be grouped by allowed dimensions`
`@@ -80,11 +80,11 @@ func mapMetrics(client azure.Client, resources []armresources.GenericResourceE`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`// groupOnTimeGrain - some metrics do not support the default timegrain value so the closest supported timegrain will be selected`
`83`		`-func groupOnTimeGrain(list []armmonitor.MetricDefinition) map[string][]armmonitor.MetricDefinition {`
	`83`	`+func groupOnTimeGrain(list []armmonitor.MetricDefinition, defaultTimeGrain string) map[string][]armmonitor.MetricDefinition {`
`84`	`84`	`var groupedList = make(map[string][]armmonitor.MetricDefinition)`
`85`	`85`
`86`	`86`	`for _, metric := range list {`
`87`		`- timegrain := retrieveSupportedMetricAvailability(metric.MetricAvailabilities)`
	`87`	`+ timegrain := retrieveSupportedMetricAvailability(metric.MetricAvailabilities, defaultTimeGrain)`
`88`	`88`	`if _, ok := groupedList[timegrain]; !ok {`
`89`	`89`	`groupedList[timegrain] = make([]armmonitor.MetricDefinition, 0)`
`90`	`90`	`}`
`@@ -94,21 +94,17 @@ func groupOnTimeGrain(list []armmonitor.MetricDefinition) map[string][]armmonito`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`// retrieveSupportedMetricAvailability func will return the default timegrain if supported, else will return the next timegrain`
`97`		`-func retrieveSupportedMetricAvailability(availabilities []*armmonitor.MetricAvailability) string {`
	`97`	`+func retrieveSupportedMetricAvailability(availabilities []*armmonitor.MetricAvailability, defaultTimeGrain string) string {`
`98`	`98`	`// common case in metrics supported by storage account - one availability`
`99`	`99`	`if len(availabilities) == 1 {`
`100`	`100`	`return *availabilities[0].TimeGrain`
`101`	`101`	`}`
`102`	`102`	`// check if the default timegrain is supported`
`103`	`103`	`for _, availability := range availabilities {`
`104`		`- if *availability.TimeGrain == azure.DefaultTimeGrain {`
`105`		`- return azure.DefaultTimeGrain`
	`104`	`+ if *availability.TimeGrain == defaultTimeGrain {`
	`105`	`+ return defaultTimeGrain`
`106`	`106`	`}`
`107`	`107`	`}`
`108`		`- // select first timegrain, should be bigger than the min timegrain of 1M, timegrains are returned in asc order`
`109`		`- if *availabilities[0].TimeGrain != "PT1M" {`
`110`		`- return *availabilities[0].TimeGrain`
`111`		`- }`
`112`	`108`	`return *availabilities[1].TimeGrain`
`113`	`109`	`}`
`114`	`110`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ func getStorageMappedResourceDefinitions(client *azure.BatchClient, resourceId s`
`67`	`67`	`filteredMetricDefinitions = append(filteredMetricDefinitions, *metricDefinition)`
`68`	`68`	`}`
`69`	`69`	`// some metrics do not support the default PT5M timegrain so they will have to be grouped in a different API call, else call will fail`
`70`		`- groupedMetrics := groupOnTimeGrain(filteredMetricDefinitions)`
	`70`	`+ groupedMetrics := groupOnTimeGrain(filteredMetricDefinitions, client.Config.DefaultTimeGrain)`
`71`	`71`	`for time, groupedMetricList := range groupedMetrics {`
`72`	`72`	`// metrics will have to be grouped by allowed dimensions`
`73`	`73`	`dimMetrics := groupMetricsByAllowedDimensions(groupedMetricList)`
Original file line number	Diff line number	Diff line change
`@@ -166,7 +166,7 @@ func TestFilterOnTimeGrain(t *testing.T) {`
`166`	`166`	`{MetricAvailabilities: availability2},`
`167`	`167`	`{MetricAvailabilities: availability3},`
`168`	`168`	`}`
`169`		`- response := groupOnTimeGrain(list)`
	`169`	`+ response := groupOnTimeGrain(list, "PT5M")`
`170`	`170`	`assert.Equal(t, len(response), 2)`
`171`	`171`	`result := [][]armmonitor.MetricDefinition{`
`172`	`172`	`{`
`@@ -184,11 +184,11 @@ func TestFilterOnTimeGrain(t *testing.T) {`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`func TestRetrieveSupportedMetricAvailability(t *testing.T) {`
`187`		`- response := retrieveSupportedMetricAvailability(availability1)`
	`187`	`+ response := retrieveSupportedMetricAvailability(availability1, "PT5M")`
`188`	`188`	`assert.Equal(t, response, time2)`
`189`		`- response = retrieveSupportedMetricAvailability(availability2)`
	`189`	`+ response = retrieveSupportedMetricAvailability(availability2, "PT5M")`
`190`	`190`	`assert.Equal(t, response, time3)`
`191`		`- response = retrieveSupportedMetricAvailability(availability3)`
	`191`	`+ response = retrieveSupportedMetricAvailability(availability3, "PT5M")`
`192`	`192`	`assert.Equal(t, response, time3)`
`193`	`193`	`}`
`194`	`194`