}

var _ Metric = &distribution{}

func newDistribution(o options) *distribution {
	d, err := meter().Float64Histogram(o.name,
		api.WithDescription(o.description),
		api.WithUnit(string(o.unit)))
	if err != nil {
		log.Fatalf("failed to create distribution: %v", err)
	}
	r := &distribution{d: d}
	r.baseMetric = baseMetric{
		name: o.name,
		rest: r,
	}
	return r
}

	precomputedAddOption []api.AddOption
}

var _ Metric = &counter{}

func newCounter(o options) *counter {
	c, err := meter().Float64Counter(o.name,
		api.WithDescription(o.description),
		api.WithUnit(string(o.unit)))
	if err != nil {
		log.Fatalf("failed to create counter: %v", err)
	}
	r := &counter{c: c}
	r.baseMetric = baseMetric{
		name: o.name,
		rest: r,
	}
	return r
}

			defer r.attributeSetsMutex.Unlock()
			for _, gv := range r.attributeSets {
				observer.Observe(gv.val, gv.opt...)
			}
			return nil
		}),
		api.WithDescription(o.description),
		api.WithUnit(string(o.unit)))
	if err != nil {
		log.Fatalf("failed to create gauge: %v", err)
	}
	r.g = g
	r.baseMetric = baseMetric{
		name: o.name,
		rest: r,
	}
	return r
}

		// 4M default limit for gRPC, 10M config will start to strain system,
		// 40M is likely upper-bound on config sizes supported.
		[]float64{1, 10000, 1000000, 4000000, 10000000, 40000000},
		monitoring.WithUnit(monitoring.Bytes),
	)
)

func recordXDSClients(version string, delta float64) {
	xdsClientTrackerMutex.Lock()
	defer xdsClientTrackerMutex.Unlock()
	xdsClientTracker[version] += delta

		"Number of hook events observed",
	)

	testDistribution = monitoring.NewDistribution(
		"test_buckets",
		"Testing distribution functionality",
		[]float64{0, 2.5, 7, 8, 10, 99, 154.3},
		monitoring.WithUnit(monitoring.Seconds),
	)

	testGauge = monitoring.NewGauge(
		"test_gauge",
		"Testing gauge functionality",
	)

	testDisabledSum = monitoring.NewSum(
		"events_disabled_total",