rdsSendErrPushes = pushes.With(typeTag.Value("rds_senderr"))

	debounceTime = monitoring.NewDistribution(
		"pilot_debounce_time",
		"Delay in seconds between the first config enters debouncing and the merged push request is pushed into the push queue.",
		[]float64{.01, .1, 1, 3, 5, 10, 20, 30},
	)

	pushContextInitTime = monitoring.NewDistribution(
		"pilot_pushcontext_init_seconds",
		"Total time in seconds Pilot takes to init pushContext.",

	})
	depth = monitoring.NewGauge("pilot_worker_queue_depth", "Depth of the controller queues", enableMetric)

	latency = monitoring.NewDistribution("pilot_worker_queue_latency",
		"Latency before the item is processed", []float64{.01, .1, .2, .5, 1, 3, 5}, enableMetric)

	workDuration = monitoring.NewDistribution("pilot_worker_queue_duration",
		"Time taken to process an item", []float64{.01, .1, .2, .5, 1, 3, 5}, enableMetric)
)

// limitations under the License.
package monitoring_test

import "istio.io/istio/pkg/monitoring"

var (
	method = monitoring.CreateLabel("method")

	receivedBytes = monitoring.NewDistribution(
		"received_bytes_total",
		"Distribution of received bytes by method",
		[]float64{10, 100, 1000, 10000},
		monitoring.WithUnit(monitoring.Bytes),
	)
)

func ExampleNewDistribution() {

	)

	totalSkippedInjections = monitoring.NewSum(
		"sidecar_injection_skip_total",
		"Total number of skipped sidecar injection requests.",
	)

	injectionTime = monitoring.NewDistribution(
		"sidecar_injection_time_seconds",
		"Total time taken for injection in seconds.",
		[]float64{.1, 1, 3, 5, 10, 20, 30, 60},
	)

		"Total number of DNS requests forwarded to upstream.",
	)

	failures = monitoring.NewSum(
		"dns_upstream_failures_total",
		"Total number of DNS failures.",
	)

	requestDuration = monitoring.NewDistribution(
		"dns_upstream_request_duration_seconds",
		"Total time in seconds Istio takes to get DNS response from upstream.",
		[]float64{.001, .005, 0.01, 0.1, 1, 5},
	)

	d api.Float64Histogram
	// precomputedRecordOption is just a precomputation to avoid allocations on each record call
	precomputedRecordOption []api.RecordOption
}

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)
	}

		"number of Wasm config conversion count and results, including success, no remote load, marshal failure, remote fetch failure, miss remote fetch hint.",
	)

	wasmConfigConversionDuration = monitoring.NewDistribution(
		"wasm_config_conversion_duration",
		"Total time in milliseconds istio-agent spends on converting remote load in Wasm config.",
		[]float64{1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384},
	)

		Description: description,
	})
	return newDerivedGauge(name, description)
}

// NewDistribution creates a new Metric with an aggregation type of Distribution. This means that the
// data collected by the Metric will be collected and exported as a histogram, with the specified bounds.
func NewDistribution(name, description string, bounds []float64, opts ...Options) Metric {
	knownMetrics.register(MetricDefinition{

		"Total number of XDS responses from pilot rejected by proxy.",
	)

	ResponseWriteTimeouts = monitoring.NewSum(
		"pilot_xds_write_timeout",
		"Pilot XDS response write timeouts.",
	)

	sendTime = monitoring.NewDistribution(
		"pilot_xds_send_time",
		"Total time in seconds Pilot takes to send generated configuration.",
		[]float64{.01, .1, 1, 3, 5, 10, 20, 30},
	)
)

func IncrementXDSRejects(xdsType string, node, errCode string) {

	)

	goofySum = testSum.With(kind.Value("goofy"))

	hookSum = monitoring.NewSum(
		"hook_total",
		"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",