Google Cloud Monitoring: Fix bucket bound for distributions

[andresmgot]

What this PR does / why we need it:

In a DISTRIBUTION response, there are two values that affect this PR: BucketCounts and ExplicitBuckets.Bounds. For the following values:

BucketCounts: [0, 1, 2, 3]
ExplicitBuckets.Bounds: [0, 10, 20]

It means that the bucket {-Inf:0} has 0 values, {0:10} has 1, {10:20} has 2 and {20:+Inf} has 3.

Since we are using the upper bound to generate the frame name, frame names should be: 0, 10, 20 and 20+.

Prior to this PR, values outside the last bound were not taken into account causing a panic error.

Which issue(s) this PR fixes:

Fixes #56181

Special notes for your reviewer:

[andresmgot]

this does not really represent reallity since in BucketCounts if the rest of values are 0, it's just ommited for performance reasons (that's why usually BucketCounts.length is smaller than the ExplicitBounds) but it's helpful to represent the issue in a unit test.

[github-actions]

Backend code coverage report for PR #56565

Plugin	Main	PR	Difference
cloudmonitoring	57.7%	57.8%	.1%

[github-actions]

Frontend code coverage report for PR #56565
No changes

[grafanabot]

Drone build failed: https://drone.grafana.net/grafana/grafana-enterprise/36789

[aangelisc]

The code here looks fine to me. I'm not overly familiar on GCM so would benefit from a more in-depth explanation of the problem if possible 😊

[andresmgot]

I'm not overly familiar on GCM so would benefit from a more in-depth explanation of the problem if possible

The problem is basically that the number of "buckets" (metric) is bigger than the number of the bucket "bounds" or limits. Prior to this PR, it was not considered values over the last limit but it's something that can happen. A couple of examples to try to explain it.

1. Buckets without reaching the limit (less bucket counts than explicit buckets):

Explicit bucket bound:      0   10  20  30
                         <--|---|---|---|-->
Bucket count:             1   0   2   0   0  

For this case, ExplicitBuckets.Bounds is [0, 10, 20, 30] and BucketCounts is [1, 0, 2] (since it omits the last values if it's always 0). This means that there are 1 value in the bucket that goes from -Infinite to 0, 0 values in the bucket that goes from 0 to 10 and 2 in the bucket that goes from 10 to 20.

2. Buckets with values over the limit (more bucket counts than explicit buckets):

Explicit bucket bound:      0   10  20  30
                         <--|---|---|---|-->
Bucket count:             1   0   2   0   1  

For this case, the ExplicitBuckets.Bounds is the same, but the BucketCounts is [1, 0, 2, 0, 1], meaning that there is 1 value in the bucket between 30 and +Infinite. This is what was not covered in the previous code (it assumed there were never values in that last bucket).

Hopefully that is more clear, but let me know if you have more questions, we can jump into a call :)

[yaelleC]

Could we simplify with ternary operator:

Suggested change

	if n < len(bucketOptions.ExplicitBuckets.Bounds) {
	bucketBound = fmt.Sprintf("%g", bucketOptions.ExplicitBuckets.Bounds[n])
	} else {
	lastBound := bucketOptions.ExplicitBuckets.Bounds[len(bucketOptions.ExplicitBuckets.Bounds)-1]
	bucketBound = fmt.Sprintf("%g+", lastBound)
	}
	i := n < len(bucketOptions.ExplicitBuckets.Bounds) ? n : len(bucketOptions.ExplicitBuckets.Bounds)-1
	bucketBound = fmt.Sprintf("%g+",bucketOptions.ExplicitBuckets.Bounds[i])

[andresmgot]

there is no ternary operator in Go :) Also, the + of %g+ is only added for the case in which the index is outside bounds