base(title, targets, desc=''):
      heatmap.new(title)
      + heatmap.queryOptions.withTargets(targets)
      + heatmap.queryOptions.withInterval('1m')
      + options.calculation.xBuckets.withMode('size')
      + options.calculation.xBuckets.withValue('1min')
      + options.withCellGap(0)
      + options.color.withMode('scheme')
      + options.color.withScheme('Spectral')
      + options.color.withSteps(128)

apiVersion: release-notes/v2
kind: feature
area: telemetry
issue: []
releaseNotes:
  - |

	// Counts contains the weights for each histogram bucket.
	//
	// Given N buckets, Count[n] is the weight of the range
	// [bucket[n], bucket[n+1]), for 0 <= n < N.
	Counts []uint64

	// Buckets contains the boundaries of the histogram buckets, in increasing order.
	//
	// Buckets[0] is the inclusive lower bound of the minimum bucket while
	// Buckets[len(Buckets)-1] is the exclusive upper bound of the maximum bucket.

// It should never be used directly since buckets are
// distributed deterministically.
// Therefore no cluster locks are required.
var localMetacacheMgr = &metacacheManager{
	buckets: make(map[string]*bucketMetacache),
	trash:   make(map[string]metacache),
}

type metacacheManager struct {
	mu      sync.RWMutex
	init    sync.Once
	buckets map[string]*bucketMetacache

		h.Buckets = h.Buckets[:cap(h.Buckets)]
	}
	h.Buckets[bucket]++
	if bucket < h.MinBucket || h.MaxBucket == 0 {
		h.MinBucket = bucket
	}
	if bucket > h.MaxBucket {
		h.MaxBucket = bucket
	}
	h.Count++
}

// BucketMin returns the minimum duration value for a provided bucket.
func (h *TimeHistogram) BucketMin(bucket int) time.Duration {
	return time.Duration(math.Exp(float64(bucket) * logDiv))
}

                testCoverage to buckets
            } else {
                testCoverage to mergeUnknownSubprojectsIntoFirstAvailableBucket(buckets, model.subprojects.subprojects.filter { subprojectsInModelButNotInBucketJson.contains(it.name) })
            }
        }
    }

	// Values are placed in buckets based solely on the most
	// significant set bit. Thus, buckets are power-of-2 sized.
	// Values are then placed into sub-buckets based on the value of
	// the next timeHistSubBucketBits most significant bits. Thus,
	// sub-buckets are linear within a bucket.
	//
	// Therefore, the number of sub-buckets (timeHistNumSubBuckets)
	// defines the error. This error may be computed as

		if vi, ok := deletedBuckets[v.Name]; ok {
			bi.Deleted = vi.Created
		}
		buckets = append(buckets, bi)
	}

	for _, v := range deletedBuckets {
		if _, ok := healBuckets[v.Name]; !ok {
			buckets = append(buckets, BucketInfo{
				Name:    v.Name,
				Deleted: v.Created,
			})
		}
	}

	return buckets, nil
}

func cloneDrives(drives []StorageAPI) []StorageAPI {

func main() {
	m := map[string]struct{}{}

	// Fill m up to the max for 4 buckets = 48 entries.
	for i := 0; i < 48; i++ {
		m[fmt.Sprintf("%d", i)] = struct{}{}
	}

	// Add a 49th entry, to start a grow to 8 buckets.
	m["foo"] = struct{}{}

	// Remove that 49th entry. m is still growing to 8 buckets,
	// but a clone of m will only have 4 buckets because it
	// only needs to fit 48 entries.
	delete(m, "foo")

	testHistogramName := "vec_element_simple"
	t0 := time.Now()
	clk := testclock.NewFakePassiveClock(t0)
	buckets := []float64{0, 1}
	vec := NewTestableTimingRatioHistogramVec(clk.Now,
		&compbasemetrics.TimingHistogramOpts{Name: testHistogramName, Buckets: buckets},
		"alabel",
	)
	toRegister := vec.metrics()
	registry := compbasemetrics.NewKubeRegistry()
	for _, reg := range toRegister {