+ timeSeries.standardOptions.withUnit('short')
      + timeSeries.standardOptions.withDecimals(0),

    seconds(title, targets, desc=''):
      self.base(title, targets, desc)
      + timeSeries.standardOptions.withUnit('s'),

    connections(title, targets, desc=''):
      self.base(title, targets, desc)
      + timeSeries.standardOptions.withUnit('cps'),

    dns(title, targets, desc=''):

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) {
		opts.unit = unit
	}
}

package monitoring_test

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

var pushLatency = monitoring.NewGauge(
	"push_latency_seconds",
	"Duration, measured in seconds, of the last push",
	monitoring.WithUnit(monitoring.Seconds),
)

func ExampleNewGauge() {
	// only the last recorded value (99.2) will be exported for this gauge
	pushLatency.Record(77.3)
	pushLatency.Record(22.8)
	pushLatency.Record(99.2)

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() {
	receivedBytes.With(method.Value("/projects/1")).Record(458)

}

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",