How to use Has method of metrics Package

Best K6 code snippet using metrics.Has

accumulator.go

Source:accumulator.go

...207		}208	}209	return nil, false210}211func (a *Accumulator) HasTag(measurement string, key string) bool {212	for _, p := range a.Metrics {213		if p.Measurement == measurement {214			_, ok := p.Tags[key]215			return ok216		}217	}218	return false219}220func (a *Accumulator) TagValue(measurement string, key string) string {221	for _, p := range a.Metrics {222		if p.Measurement == measurement {223			v, ok := p.Tags[key]224			if !ok {225				return ""226			}227			return v228		}229	}230	return ""231}232// Calls the given Gather function and returns the first error found.233func (a *Accumulator) GatherError(gf func(telegraf.Accumulator) error) error {234	if err := gf(a); err != nil {235		return err236	}237	if len(a.Errors) > 0 {238		return a.Errors[0]239	}240	return nil241}242// NFields returns the total number of fields in the accumulator, across all243// measurements244func (a *Accumulator) NFields() int {245	a.Lock()246	defer a.Unlock()247	counter := 0248	for _, pt := range a.Metrics {249		for range pt.Fields {250			counter++251		}252	}253	return counter254}255// Wait waits for the given number of metrics to be added to the accumulator.256func (a *Accumulator) Wait(n int) {257	a.Lock()258	if a.Cond == nil {259		a.Cond = sync.NewCond(&a.Mutex)260	}261	for int(a.NMetrics()) < n {262		a.Cond.Wait()263	}264	a.Unlock()265}266// WaitError waits for the given number of errors to be added to the accumulator.267func (a *Accumulator) WaitError(n int) {268	a.Lock()269	if a.Cond == nil {270		a.Cond = sync.NewCond(&a.Mutex)271	}272	for len(a.Errors) < n {273		a.Cond.Wait()274	}275	a.Unlock()276}277func (a *Accumulator) AssertContainsTaggedFields(278	t *testing.T,279	measurement string,280	fields map[string]interface{},281	tags map[string]string,282) {283	a.Lock()284	defer a.Unlock()285	for _, p := range a.Metrics {286		if !reflect.DeepEqual(tags, p.Tags) {287			continue288		}289		if p.Measurement == measurement && reflect.DeepEqual(fields, p.Fields) {290			return291		}292	}293	msg := fmt.Sprintf("unknown measurement %s with tags %v", measurement, tags)294	assert.Fail(t, msg)295}296func (a *Accumulator) AssertDoesNotContainsTaggedFields(297	t *testing.T,298	measurement string,299	fields map[string]interface{},300	tags map[string]string,301) {302	a.Lock()303	defer a.Unlock()304	for _, p := range a.Metrics {305		if !reflect.DeepEqual(tags, p.Tags) {306			continue307		}308		if p.Measurement == measurement && reflect.DeepEqual(fields, p.Fields) {309			msg := fmt.Sprintf(310				"found measurement %s with tagged fields (tags %v) which should not be there",311				measurement, tags)312			assert.Fail(t, msg)313		}314	}315	return316}317func (a *Accumulator) AssertContainsFields(318	t *testing.T,319	measurement string,320	fields map[string]interface{},321) {322	a.Lock()323	defer a.Unlock()324	for _, p := range a.Metrics {325		if p.Measurement == measurement {326			assert.Equal(t, fields, p.Fields)327			return328		}329	}330	msg := fmt.Sprintf("unknown measurement %s", measurement)331	assert.Fail(t, msg)332}333func (a *Accumulator) HasPoint(334	measurement string,335	tags map[string]string,336	fieldKey string,337	fieldValue interface{},338) bool {339	a.Lock()340	defer a.Unlock()341	for _, p := range a.Metrics {342		if p.Measurement != measurement {343			continue344		}345		if !reflect.DeepEqual(tags, p.Tags) {346			continue347		}348		v, ok := p.Fields[fieldKey]349		if ok && reflect.DeepEqual(v, fieldValue) {350			return true351		}352	}353	return false354}355func (a *Accumulator) AssertDoesNotContainMeasurement(t *testing.T, measurement string) {356	a.Lock()357	defer a.Unlock()358	for _, p := range a.Metrics {359		if p.Measurement == measurement {360			msg := fmt.Sprintf("found unexpected measurement %s", measurement)361			assert.Fail(t, msg)362		}363	}364}365// HasTimestamp returns true if the measurement has a matching Time value366func (a *Accumulator) HasTimestamp(measurement string, timestamp time.Time) bool {367	a.Lock()368	defer a.Unlock()369	for _, p := range a.Metrics {370		if p.Measurement == measurement {371			return timestamp.Equal(p.Time)372		}373	}374	return false375}376// HasField returns true if the given measurement has a field with the given377// name378func (a *Accumulator) HasField(measurement string, field string) bool {379	a.Lock()380	defer a.Unlock()381	for _, p := range a.Metrics {382		if p.Measurement == measurement {383			if _, ok := p.Fields[field]; ok {384				return true385			}386		}387	}388	return false389}390// HasIntField returns true if the measurement has an Int value391func (a *Accumulator) HasIntField(measurement string, field string) bool {392	a.Lock()393	defer a.Unlock()394	for _, p := range a.Metrics {395		if p.Measurement == measurement {396			for fieldname, value := range p.Fields {397				if fieldname == field {398					_, ok := value.(int)399					return ok400				}401			}402		}403	}404	return false405}406// HasInt64Field returns true if the measurement has an Int64 value407func (a *Accumulator) HasInt64Field(measurement string, field string) bool {408	a.Lock()409	defer a.Unlock()410	for _, p := range a.Metrics {411		if p.Measurement == measurement {412			for fieldname, value := range p.Fields {413				if fieldname == field {414					_, ok := value.(int64)415					return ok416				}417			}418		}419	}420	return false421}422// HasInt32Field returns true if the measurement has an Int value423func (a *Accumulator) HasInt32Field(measurement string, field string) bool {424	a.Lock()425	defer a.Unlock()426	for _, p := range a.Metrics {427		if p.Measurement == measurement {428			for fieldname, value := range p.Fields {429				if fieldname == field {430					_, ok := value.(int32)431					return ok432				}433			}434		}435	}436	return false437}438// HasStringField returns true if the measurement has an String value439func (a *Accumulator) HasStringField(measurement string, field string) bool {440	a.Lock()441	defer a.Unlock()442	for _, p := range a.Metrics {443		if p.Measurement == measurement {444			for fieldname, value := range p.Fields {445				if fieldname == field {446					_, ok := value.(string)447					return ok448				}449			}450		}451	}452	return false453}454// HasUIntField returns true if the measurement has a UInt value455func (a *Accumulator) HasUIntField(measurement string, field string) bool {456	a.Lock()457	defer a.Unlock()458	for _, p := range a.Metrics {459		if p.Measurement == measurement {460			for fieldname, value := range p.Fields {461				if fieldname == field {462					_, ok := value.(uint64)463					return ok464				}465			}466		}467	}468	return false469}470// HasFloatField returns true if the given measurement has a float value471func (a *Accumulator) HasFloatField(measurement string, field string) bool {472	a.Lock()473	defer a.Unlock()474	for _, p := range a.Metrics {475		if p.Measurement == measurement {476			for fieldname, value := range p.Fields {477				if fieldname == field {478					_, ok := value.(float64)479					return ok480				}481			}482		}483	}484	return false485}486// HasMeasurement returns true if the accumulator has a measurement with the487// given name488func (a *Accumulator) HasMeasurement(measurement string) bool {489	a.Lock()490	defer a.Unlock()491	for _, p := range a.Metrics {492		if p.Measurement == measurement {493			return true494		}495	}496	return false497}498// IntField returns the int value of the given measurement and field or false.499func (a *Accumulator) IntField(measurement string, field string) (int, bool) {500	a.Lock()501	defer a.Unlock()502	for _, p := range a.Metrics {...

filtering.go

Source:filtering.go

...44		}45	}46	return enabledMetrics47}48// HasEnabledMetricInGroup returns true if there are any metrics enabled that49// fall into the given group.50func (mf *monitorFiltering) HasEnabledMetricInGroup(group string) bool {51	if mf.metadata == nil {52		return false53	}54	for _, m := range mf.EnabledMetrics() {55		// TODO: If metric names in metadata.yaml ever support wildcards this56		// will have to be enhanced.57		if mf.metadata.Metrics[m].Group == group {58			return true59		}60	}61	return false62}63// HasAnyExtraMetrics returns true if there is any custom metric64// enabled for this output instance.65func (mf *monitorFiltering) HasAnyExtraMetrics() bool {66	return mf.hasExtraMetrics67}68func buildFilterSet(metadata *Metadata, conf config.MonitorCustomConfig) (*dpfilters.FilterSet, error) {69	coreConfig := conf.MonitorConfigCore()70	filter, err := coreConfig.FilterSet()71	if err != nil {72		return nil, err73	}74	excludeFilters := []dpfilters.DatapointFilter{filter}75	// If sendAll is true or there are no metrics don't bother setting up76	// filtering77	if metadata != nil && len(metadata.Metrics) > 0 && !metadata.SendAll {78		// Make a copy of extra metrics from config so we don't alter what the user configured.79		extraMetrics := append([]string{}, coreConfig.ExtraMetrics...)80		// Monitors can add additional extra metrics to allow through such as based on config flags.81		if monitorExtra, ok := conf.(config.ExtraMetrics); ok {82			extraMetrics = append(extraMetrics, monitorExtra.GetExtraMetrics()...)83		}84		includedMetricsFilter, err := newMetricsFilter(metadata, extraMetrics, coreConfig.ExtraGroups)85		if err != nil {86			return nil, fmt.Errorf("unable to construct extraMetrics filter: %s", err)87		}88		// Prepend the included metrics filter.89		excludeFilters = append([]dpfilters.DatapointFilter{dpfilters.Negate(includedMetricsFilter)}, excludeFilters...)90	}91	filterSet := &dpfilters.FilterSet{92		ExcludeFilters: excludeFilters,93	}94	return filterSet, nil95}96var _ dpfilters.DatapointFilter = &extraMetricsFilter{}97// Filter of datapoints based on included status and user configuration of98// extraMetrics and extraGroups.99type extraMetricsFilter struct {100	metadata     *Metadata101	extraMetrics map[string]bool102	stringFilter *filter.BasicStringFilter103}104func validateMetricName(metadata *Metadata, metricName string) error {105	if strings.TrimSpace(metricName) == "" {106		return errors.New("metric name cannot be empty")107	}108	if metadata.SendUnknown {109		// The metrics list isn't exhaustive so can't do extra validation.110		return nil111	}112	if strings.ContainsRune(metricName, '*') {113		// Make sure a metric pattern matches at least one metric.114		m, err := filter.NewBasicStringFilter([]string{metricName})115		if err != nil {116			return err117		}118		for metric := range metadata.Metrics {119			if m.Matches(metric) {120				return nil121			}122		}123		logrus.Warnf("extraMetrics: metric pattern '%s' did not match any available metrics for monitor %s",124			metricName, metadata.MonitorType)125	}126	if !metadata.HasMetric(metricName) {127		logrus.Warnf("extraMetrics: metric '%s' does not exist for monitor %s", metricName, metadata.MonitorType)128	}129	return nil130}131func validateGroup(metadata *Metadata, group string) ([]string, error) {132	if strings.TrimSpace(group) == "" {133		return nil, errors.New("group cannot be empty")134	}135	metrics, ok := metadata.GroupMetricsMap[group]136	if !ok {137		logrus.Warnf("extraMetrics: group %s does not exist for monitor %s", group, metadata.MonitorType)138	}139	return metrics, nil140}141func newMetricsFilter(metadata *Metadata, extraMetrics, extraGroups []string) (*extraMetricsFilter, error) {142	var filterItems []string143	for _, metric := range extraMetrics {144		if err := validateMetricName(metadata, metric); err != nil {145			return nil, err146		}147		// If the user specified a metric that's already included no need to add it.148		if !metadata.DefaultMetrics[metric] {149			filterItems = append(filterItems, metric)150		}151	}152	for _, group := range extraGroups {153		metrics, err := validateGroup(metadata, group)154		if err != nil {155			return nil, err156		}157		filterItems = append(filterItems, metrics...)158	}159	basicFilter, err := filter.NewBasicStringFilter(filterItems)160	if err != nil {161		return nil, fmt.Errorf("unable to construct filter with items %s: %s", filterItems, err)162	}163	effectiveMetrics := map[string]bool{}164	// Precompute set of metrics that matches the filter. This isn't a complete165	// set of metrics that are enabled in the case of metrics that aren't included166	// in metadata. But it provides a fast path for known metrics.167	for metric := range metadata.Metrics {168		if basicFilter.Matches(metric) {169			effectiveMetrics[metric] = true170		}171	}172	return &extraMetricsFilter{metadata, effectiveMetrics, basicFilter}, nil173}174func (mf *extraMetricsFilter) Matches(dp *datapoint.Datapoint) bool {175	if len(mf.metadata.Metrics) == 0 {176		// This monitor has no defined metrics so send everything by default.177		return true178	}179	if !mf.metadata.HasMetric(dp.Metric) && mf.metadata.SendUnknown {180		// This metric is unknown to the metadata and the monitor has requested181		// to send all unknown metrics.182		return true183	}184	if mf.metadata.HasDefaultMetric(dp.Metric) {185		// It's an included metric so send by default.186		return true187	}188	if mf.extraMetrics[dp.Metric] {189		// User has explicitly chosen to send this metric (or a group that this metric belongs to).190		return true191	}192	// Lastly check if it matches filter. If it's a known metric from metadata will get matched193	// above so this is a last check for unknown metrics.194	return mf.stringFilter.Matches(dp.Metric)195}...

cadvisor_test.go

Source:cadvisor_test.go

...18	"github.com/stretchr/testify/assert"19	"github.com/google/cadvisor/container"20)21func TestTcpMetricsAreDisabledByDefault(t *testing.T) {22	assert.True(t, ignoreMetrics.Has(container.NetworkTcpUsageMetrics))23	flag.Parse()24	assert.True(t, ignoreMetrics.Has(container.NetworkTcpUsageMetrics))25}26func TestAdvancedTcpMetricsAreDisabledByDefault(t *testing.T) {27	assert.True(t, ignoreMetrics.Has(container.NetworkAdvancedTcpUsageMetrics))28	flag.Parse()29	assert.True(t, ignoreMetrics.Has(container.NetworkAdvancedTcpUsageMetrics))30}31func TestUdpMetricsAreDisabledByDefault(t *testing.T) {32	assert.True(t, ignoreMetrics.Has(container.NetworkUdpUsageMetrics))33	flag.Parse()34	assert.True(t, ignoreMetrics.Has(container.NetworkUdpUsageMetrics))35}36func TestReferencedMemoryMetricsIsDisabledByDefault(t *testing.T) {37	assert.True(t, ignoreMetrics.Has(container.ReferencedMemoryMetrics))38	flag.Parse()39	assert.True(t, ignoreMetrics.Has(container.ReferencedMemoryMetrics))40}41func TestCPUTopologyMetricsAreDisabledByDefault(t *testing.T) {42	assert.True(t, ignoreMetrics.Has(container.CPUTopologyMetrics))43	flag.Parse()44	assert.True(t, ignoreMetrics.Has(container.CPUTopologyMetrics))45}46func TestMemoryNumaMetricsAreDisabledByDefault(t *testing.T) {47	assert.True(t, ignoreMetrics.Has(container.MemoryNumaMetrics))48	flag.Parse()49	assert.True(t, ignoreMetrics.Has(container.MemoryNumaMetrics))50}51func TestEnableAndIgnoreMetrics(t *testing.T) {52	tests := []struct {53		value    string54		expected []container.MetricKind55	}{56		{"", []container.MetricKind{}},57		{"disk", []container.MetricKind{container.DiskUsageMetrics}},58		{"disk,tcp,network", []container.MetricKind{container.DiskUsageMetrics, container.NetworkTcpUsageMetrics, container.NetworkUsageMetrics}},59	}60	for _, test := range tests {61		for _, sets := range []container.MetricSet{enableMetrics, ignoreMetrics} {62			assert.NoError(t, sets.Set(test.value))63			assert.Equal(t, len(test.expected), len(sets))64			for _, expected := range test.expected {65				assert.True(t, sets.Has(expected), "Missing %s", expected)66			}67		}68	}69}70func TestToIncludedMetrics(t *testing.T) {71	ignores := []container.MetricSet{72		{73			container.CpuUsageMetrics: struct{}{},74		},75		{},76		container.AllMetrics,77	}78	expected := []container.MetricSet{79		{...

Has

Using AI Code Generation

1import (2func main() {3    fmt.Println("Hello, playground")4    g := promauto.NewGauge(prometheus.GaugeOpts{5    })6    g.Set(42)7    g.Inc()8    g.Dec()9    g.Add(5)10    g.Sub(3)11    g.Set(123)12    g.Delete()13    fmt.Println(g.Has())14}15import (16func main() {17    fmt.Println("Hello, playground")18    g := promauto.NewGauge(prometheus.GaugeOpts{19    })20    g.Set(42)21    g.Inc()22    g.Dec()23    g.Add(5)24    g.Sub(3)25    g.Set(123)26    g.Delete()27    fmt.Println(g.Has())28}29import (

Has

Using AI Code Generation

1import (2func main() {3    m := metrics.NewCounter()4    m.Inc(1)5    fmt.Println(m.Count())6    fmt.Println(m.Has(1))7}8import (9func main() {10    m := metrics.NewCounter()11    m.Inc(1)12    fmt.Println(m.Count())13    fmt.Println(m.Has(2))14}15import (16func main() {17    m := metrics.NewCounter()18    m.Inc(1)19    fmt.Println(m.Count())20    fmt.Println(m.Has(0))21}22import (23func main() {24    m := metrics.NewCounter()25    m.Inc(1)26    fmt.Println(m.Count())27    fmt.Println(m.Has(-1))28}29import (30func main() {31    m := metrics.NewCounter()32    m.Inc(1)33    fmt.Println(m.Count())34    fmt.Println(m.Has(1))35    m.Inc(1)36    fmt.Println(m.Count())37    fmt.Println(m.Has(2))38}39import (40func main() {41    m := metrics.NewCounter()42    m.Inc(1)43    fmt.Println(m.Count())44    fmt.Println(m.Has(1))45    m.Inc(1)46    fmt.Println(m.Count())47    fmt.Println(m.Has(1))48}

Has

Using AI Code Generation

1import (2func main() {3config := cluster.NewConfig()4brokers := []string{"kafka:9092"}5topics := []string{"topic1"}6consumer, err := cluster.NewConsumer(brokers, "group1", topics, config)7if err != nil {8panic(err)9}10defer consumer.Close()11metrics := NewMetrics()12registry := prometheus.NewRegistry()13registry.MustRegister(metrics)14handler := promhttp.HandlerFor(registry, promhttp.HandlerOpts{})15server := &http.Server{16}17go server.ListenAndServe()18for {19select {20case msg, ok := <-consumer.Messages():21if ok {22metrics.IncMessageCount(msg.Topic)23consumer.MarkOffset(msg, "")24}25}26}27}28}

Has

Using AI Code Generation

1import (2func main() {3    scope, closer := tally.NewRootScope(tally.ScopeOptions{4    }, 1 * time.Second)5    defer closer.Close()6    scope.Counter("bar").Inc(1)7    scope.Gauge("qux").Update(42)8    scope.Timer("baz").Record(300 * time.Millisecond)9    scope.Histogram("quux", tally.DefaultBuckets).RecordValue(42)10    scope.Histogram("quuz", tally.ValueBuckets([]float64{1, 2, 3})).RecordValue(42)11    has := scope.Snapshot().HasCounters("bar")12    fmt.Println("Has counter bar: ", has)13}14import (15func main() {16    scope, closer := tally.NewRootScope(tally.ScopeOptions{

Has

Using AI Code Generation

1import (2func main() {3        fmt.Println("Hello, playground")4        m1 := prometheus.NewCounter(prometheus.CounterOpts{5        })6        m2 := prometheus.NewCounter(prometheus.CounterOpts{7        })8        m3 := prometheus.NewCounter(prometheus.CounterOpts{9        })10        m4 := prometheus.NewCounter(prometheus.CounterOpts{11        })12        m5 := prometheus.NewCounter(prometheus.CounterOpts{13        })14        m6 := prometheus.NewCounter(prometheus.CounterOpts{15        })16        m7 := prometheus.NewCounter(prometheus.CounterOpts{17        })18        m8 := prometheus.NewCounter(prometheus.CounterOpts{19        })20        m9 := prometheus.NewCounter(prometheus.CounterOpts{21        })22        m10 := prometheus.NewCounter(prometheus.CounterOpts{23        })24        m11 := prometheus.NewCounter(prometheus.CounterOpts{25        })26        m12 := prometheus.NewCounter(prometheus.CounterOpts{27        })28        m13 := prometheus.NewCounter(prometheus.CounterOpts{29        })30        m14 := prometheus.NewCounter(prometheus.CounterOpts{31        })32        m15 := prometheus.NewCounter(prometheus.CounterOpts{33        })34        m16 := prometheus.NewCounter(prometheus.CounterOpts{

Has

Using AI Code Generation

1import (2func main() {3  m := metrics.NewRegistry()4  c := metrics.NewCounter()5  m.Register("counter", c)6  g := metrics.NewGauge()7  m.Register("gauge", g)8  h := metrics.NewHistogram(metrics.NewUniformSample(100))9  m.Register("histogram", h)10  mt := metrics.NewMeter()11  m.Register("meter", mt)12  t := metrics.NewTimer()13  m.Register("timer", t)14  if m.Has("counter") {15    log.Println("counter exist")16  }17  if !m.Has("foo") {18    log.Println("foo does not exist")19  }20  if m.Has("gauge") {21    log.Println("gauge exist")22  }23  if !m.Has("foo") {24    log.Println("foo does not exist")25  }26  if m.Has("histogram") {27    log.Println("histogram exist")28  }29  if !m.Has("foo") {30    log.Println("foo does not exist")31  }32  if m.Has("meter") {33    log.Println("meter exist")34  }35  if !m.Has("foo") {36    log.Println("foo does not exist")37  }38  if m.Has("timer") {39    log.Println("timer exist")40  }41  if !m.Has("foo") {42    log.Println("foo does not exist")43  }44  time.Sleep(10 * time.Second)45}

Has

Using AI Code Generation

1import (2type Metrics struct {3	Has  func(string) bool4	Get  func(string) (interface{}, bool)5	Set  func(string, interface{})6}7func MetricsFactory() *Metrics {8	return &Metrics{9		Has: func(key string) bool { return true },10		Get: func(key string) (interface{}, bool) { return nil, true },11		Set: func(key string, value interface{}) {},12	}13}14func main() {15	metrics := MetricsFactory()16	fmt.Println(metrics.Has("test"))17}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.