To calculate aggregate sum of data points with resolution in time of one minute, you can specify that resolution in the range selector like this
sum_over_time(my_requests[$__range:1m])
To calculate aggregate sum of data points with resolution in time of one minute, you can specify that resolution in the range selector like this
sum_over_time(my_requests[$__range:1m])
i think smth like this should work
sum_over_time(sum(sum_over_time(my_requests[$__interval]))[$__range:$__interval])
The inner query
sum(sum_over_time(my_requests[$__interval]))
will run $__range/$__interval times and result will be summed
promql function to sum distinct for gauge value
How to sum up Gauges in PromQL (for alerting) - PromQL - Prometheus Monitoring System
prometheus - How to sum up Gauges in PromQL (for alerting) - Stack Overflow
grafana - prometheus: is it possible to use event number of gauge as a counter? - Stack Overflow
count_over_time(response_time_ms[1m]) will tell you the number of samples, not the number of times your Gauge was updated within (what I assume to be) a Java process. Based on the value of 10 you're seeing, I'm assuming your scrape interval is 6 seconds.
For an explanation of why this doesn't work as you would expect it, a Gauge is simply a Java object wrapping a double value. Every time you set its value, that value changes, but nothing more. There's no count of how many times the value changed or any notification sent to Prometheus that this happened. Prometheus simply polls every 6 seconds and collects whatever value was there at the time (never the wiser that the value changed 15 times since the last time it was collected). This is why gauges are intended to measure single values that go up and down (such as memory utilization: it's now 645 MB, in 6 seconds it's 648 MB, in 12 seconds 543 MB): you know the value constantly changes, but the best you can do is sample it every now and then.
For something like request latency, you should use a Histogram: it's basically a counter for the number of observations (i.e. number of requests); a counter for the sum of all observations (i.e. how long all requests put together took); and separate counters for each bucket (i.e. how many requests took less than 1 ms; how many requests took less than 10 ms; etc.). From this you can get an accurate average over any multiple of your scrape interval (i.e. change in total time divided by change in number of requests) as well as estimates for any percentile (including the median). How precise said percentiles are depends on the bucket sizes you choose (and how well they actually match the actual measurements).
Or, if all you're interested in is the number of requests, then a counter that's incremented on every request will be enough. To adjust for counter resets (e.g. job restarts), you should use increase() rather than the simple difference suggested above:
increase(number_of_requests_total[1m])
If you want to count number of requests in some specific time from now (in last 1m in this case) just use
number_of_requests_counter - number_of_requests_counter offset 1m
If you want to have sth like requests per second, than use
rate(number_of_requests_counter[1m])
I can tell you why it's not working with your Gauge, but first of all specify what do you assign to this metric. I mean, do you assing some avarage, last response time, or some other stuff?
For response time you should use Summary or Histogram (more info here)