*
 * Promoting the stability level of the metric is a responsibility of the component owner, since it
 * involves explicitly acknowledging support for the metric across multiple releases, in accordance with
 * the metric stability policy.
 */
var (
	etcdRequestLatency = compbasemetrics.NewHistogramVec(
		&compbasemetrics.HistogramOpts{

	for name, def := range d.known {
		if def.Bounds == nil {
			continue
		}
		// for each histogram metric (i.e. those with bounds), set up a view explicitly defining those buckets.
		v := metric.WithView(metric.NewView(
			metric.Instrument{Name: name},
			metric.Stream{Aggregation: metric.AggregationExplicitBucketHistogram{
				Boundaries: def.Bounds,
			}},
		))
		opts = append(opts, v)
	}
	return opts

	"fmt"
	"runtime/metrics"
)

func ExampleRead_readingOneMetric() {
	// Name of the metric we want to read.
	const myMetric = "/memory/classes/heap/free:bytes"

	// Create a sample for the metric.
	sample := make([]metrics.Sample, 1)
	sample[0].Name = myMetric

	// Sample the metric.
	metrics.Read(sample)

	// Check if the metric is actually supported.
	// If it's not, the resulting value will always have
	// kind KindBad.

				Query: prometheus.Query{
					Metric:      "istio_tcp_connections_closed_total",
					Aggregation: "sum",
					Labels: map[string]string{
						"destination_service_name": "BlackHoleCluster",
					},
				},
			},
		},
		{
			Name:     "HTTPS Traffic Conflict",
			PortName: "https-conflict",
			Expected: Expected{
				Query: prometheus.Query{
					Metric:      "istio_tcp_connections_closed_total",

)

func TestOutboundTrafficPolicy_AllowAny(t *testing.T) {
	cases := []*TestCase{
		{
			Name:     "HTTP Traffic",
			PortName: "http",
			Expected: Expected{
				Query: prometheus.Query{
					Metric:      "istio_requests_total",
					Aggregation: "sum",
					Labels: map[string]string{
						"reporter":                 "source",
						"destination_service_name": "PassthroughCluster",

package monitoring

// Options encode changes to the options passed to a Metric at creation time.
type Options func(*options)

type options struct {
	enabledCondition func() bool
	unit             Unit
	name             string
	description      string
}

// WithUnit provides configuration options for a new Metric, providing unit of measure
// information for a new Metric.
func WithUnit(unit Unit) Options {
	return func(opts *options) {

	return vMetrics
}

func expectedFSStats() kubestats.FsStats {
	metric := expectedMetrics()
	available := uint64(metric.Available.Value())
	capacity := uint64(metric.Capacity.Value())
	used := uint64(metric.Used.Value())
	inodes := uint64(metric.Inodes.Value())
	inodesFree := uint64(metric.InodesFree.Value())
	inodesUsed := uint64(metric.InodesUsed.Value())
	return kubestats.FsStats{
		AvailableBytes: &available,

    matchLabels:
      app: productpage # Maps to an existing workload without conflicts in the same ns, no error
  metrics:
    - providers:
        - name: prometheus
      overrides:
        - match:
            metric: ALL_METRICS
          disabled: false
---
apiVersion: telemetry.istio.io/v1alpha1
kind: Telemetry
metadata:
  name: maps-to-nonexistent
  namespace: default
spec:
  selector:
    matchLabels:

  - containerResource:
      container: containerValue
      name: nameValue
      target:
        averageUtilization: 4
        averageValue: "0"
        type: typeValue
        value: "0"
    external:
      metric:
        name: nameValue
        selector:
          matchExpressions:
          - key: keyValue
            operator: operatorValue
            values:
            - valuesValue
          matchLabels:

          },
          "target": {
            "type": "typeValue",
            "value": "0",
            "averageValue": "0",
            "averageUtilization": 4
          },
          "metric": {
            "name": "nameValue",
            "selector": {
              "matchLabels": {
                "matchLabelsKey": "matchLabelsValue"
              },
              "matchExpressions": [
                {