Try it free

Adjust network dashboards and alerts to the polling interval

  • Latest Dynatrace
  • How-to guide
  • 6-min read
  • Published Nov 11, 2026

Network extensions let you set the polling interval to any value from 1 to 60 minutes. Intervals longer than 1 minute change how some metrics behave, so custom dashboards, notebooks, and alerts that were built for 1-minute polling can show wrong values or stop triggering.

This page applies to Latest Dynatrace. In Dynatrace Managed, you can't correct the values at query time, so keep the polling interval at 1 minute.

What changes with a longer polling interval

Count metrics (metric keys ending in .count, such as com.dynatrace.extension.network_device.if.bytes_in.count) report how much a counter increased since the previous poll. The longer the polling interval, the larger each value.

The metric stays accurate and totals over any period are unchanged, but anything built around the values of the old polling interval is affected:

  • Thresholds on the values no longer fit. For example, suppose that with 1-minute polling an interface usually receives about 60 MB of traffic between polls, and you set an alert to fire when that value goes above 90 MB, which is 50 percent more than usual. If you then change the polling interval from 1 to 5 minutes, each value becomes about 300 MB (5 × 60 MB), and the alert fires even though the traffic is unchanged.
  • For the same reason, conversions to a rate that divide by a fixed number of seconds, such as bytes to bits per second, return a rate that is too high by a factor equal to the polling interval in minutes. With 5-minute polling, the rate is 5 times too high.
  • When the chart resolution doesn't match the polling interval, buckets contain different numbers of values. For example, with 3-minute polling and 5-minute buckets, some buckets contain one value and others contain two, so a sum gives inconsistent results.
  • Every alert, not only those on count metrics, receives fewer samples in the same sliding window.
  • In views that don't connect data points, you may also see gaps between polls.

Update your queries

Metrics from network extensions carry a polling.interval dimension with the interval in minutes, for example "5". Use it to normalize each count to "per minute", so your conversions and thresholds keep working whatever the polling interval is.

The following example converts interface traffic to bits per second.

Before

timeseries bytes_in = sum(com.dynatrace.extension.network_device.if.bytes_in.count),
by: {dt.smartscape.ext_network_interface}
| fieldsAdd bits_per_second = bytes_in[] * 8 / 60

After

timeseries bytes_in = sum(com.dynatrace.extension.network_device.if.bytes_in.count, rollup: avg),
by: {dt.smartscape.ext_network_interface, polling.interval},
union: true
// Normalize each value to "per minute"
| fieldsAdd polling_minutes = coalesce(toDouble(polling.interval), 1)
| fieldsAdd bytes_in_has_value = iCollectArray(if(isNotNull(bytes_in[]), 1, else: 0))
| fieldsAdd bytes_in = bytes_in[] / polling_minutes
// Merge back into one series per interface, keeping gaps as gaps
| summarize {
bytes_in_summed = sum(bytes_in[]),
bytes_in_samples = sum(bytes_in_has_value[]),
interval = takeFirst(interval),
timeframe = takeFirst(timeframe)
}, by: {dt.smartscape.ext_network_interface}
| fieldsAdd bytes_in = iCollectArray(if(bytes_in_samples[] > 0, bytes_in_summed[], else: null))
| fieldsRemove bytes_in_summed, bytes_in_samples
| fieldsAdd bits_per_second = bytes_in[] * 8 / 60

After normalization, all count metrics are counts per minute, whatever the polling interval. Any conversion you apply afterward must start from counts per minute. For example, divide by 60 to get a rate per second, as in the last line of the example.

Adapt the example to your own query

  1. Use sum(<metric>.count, rollup: avg) for each count metric. After normalization, the values are rates, so you must average the samples in a time bucket, not add them: five samples of 10 per minute are still 10 per minute. The sum adds up the series that your by: doesn't split apart, for example, total traffic of a device across its interfaces. If you already split down to one series per entity, such as per interface, avg(<metric>.count) returns the same result.
  2. Add polling.interval to by:, or add by: {polling.interval} if your query has none. Add union: true so that data without the dimension is kept.
  3. Divide each count by coalesce(toDouble(polling.interval), 1). The 1 covers data without the dimension, such as data recorded before it existed or sent by extension versions without a configurable interval. Those extensions polled every minute.
  4. Merge the series back with summarize by your original by: fields, keeping interval and timeframe with takeFirst. Restore null where no series had a sample, because summing empty buckets would show 0. Then remove the helper fields.
  5. Remove default: 0 from the count aggregation. Zero-filling before the merge hides the gaps.

Update your alerts

Alerts created from an alert template

Delete the alert and create it again from the updated alert template. The updated templates already normalize the values to the polling interval. What you do next depends on where the template comes from:

  • Templates in Infrastructure & Operations Infrastructure & Operations set the sliding window and violating samples automatically. Check that they suit your needs. If you change a polling interval later, create the alert again.
  • Templates shipped with an extension use a sliding window that assumes 1-minute polling. Adjust it as described in Sliding windows and missing data.

Custom alerts on count metrics

Replace the alert query with the updated version from Update your queries.

Sliding windows and missing data

Alert sliding windows assume one value per minute. With a longer polling interval, fewer values fall into the same window, so alerts might no longer trigger as you configured them. Longer polling intervals affect every alert on the metrics of these extensions, including alerts created from templates, not only alerts on count metrics.

For example, an alert with the default of 3 violating samples out of 5 never triggers with 5-minute polling, because a 5-minute window contains only one value.

In the alert's Advanced tab in Anomaly Detection - new Anomaly Detection (see Configure an advanced custom alert), adjust the sliding window and the number of violating samples to the new polling interval:

  • Make the window at least as long as the polling interval.
  • Make the window long enough to hold the number of violating samples you require.

It is recommended to keep both the polling interval and the sliding window reasonably small for accurate alert detection. Larger windows detect problems later and can miss short ones.

If Alert on missing data is turned on, review it as well. With a longer polling interval, most 1-minute buckets are empty, and the alert can fire only because of those gaps. For details, see Anomaly detection configuration.

Related tags
Infrastructure ObservabilityExtensionsExtensions