X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fxapp%2Fmetrics_test.go;h=aad90b194db1a7fa3e94a2f952f7f653c95ba550;hb=refs%2Fheads%2Falarm_wa;hp=ff70ab3e8944833daa8d05de6f26fc6ae895b215;hpb=90f6dd45c9874dbfa8673fc1c0e12a3595951241;p=ric-plt%2Fxapp-frame.git diff --git a/pkg/xapp/metrics_test.go b/pkg/xapp/metrics_test.go old mode 100644 new mode 100755 index ff70ab3..aad90b1 --- a/pkg/xapp/metrics_test.go +++ b/pkg/xapp/metrics_test.go @@ -23,29 +23,446 @@ import ( "testing" ) -var mCVect map[string]CounterVec -var mGVect map[string]GaugeVec +func TestMetricCounter(t *testing.T) { + TestCounterOpt := CounterOpts{Name: "CounterBlaah1", Help: "CounterBlaah1"} + ret1 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter") + ret1.Inc() + ret2 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter") + ret2.Inc() + if ret1 != ret2 { + t.Errorf("ret1 not same than ret2. cache not working?") + } +} + +func TestMetricCounterGroup(t *testing.T) { + var TestCounterOpts = []CounterOpts{ + {Name: "CounterBlaah1", Help: "CounterBlaah1"}, + {Name: "CounterBlaah2", Help: "CounterBlaah2"}, + {Name: "CounterBlaah3", Help: "CounterBlaah3"}, + {Name: "CounterBlaah4", Help: "CounterBlaah4"}, + } + + ret1 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup") + + if len(ret1) == 0 { + t.Errorf("ret1 counter group is empty") + } + + ret1["CounterBlaah1"].Inc() + ret1["CounterBlaah2"].Inc() + ret1["CounterBlaah3"].Inc() + ret1["CounterBlaah4"].Inc() + + ret2 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup") + + if len(ret2) == 0 { + t.Errorf("ret2 counter group is empty") + } + + ret2["CounterBlaah1"].Inc() + ret2["CounterBlaah2"].Inc() + ret2["CounterBlaah3"].Inc() + ret2["CounterBlaah4"].Inc() + + if len(ret1) != len(ret2) { + t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2)) + } +} + +func TestMetricLabeledCounter(t *testing.T) { + // + // + c_1_1 := Metric.RegisterLabeledCounter( + CounterOpts{Name: "counter1", Help: "counter1"}, + []string{"name", "event"}, + []string{"name1", "event1"}, + "SUBSYSTEML0") + + c_1_2 := Metric.RegisterLabeledCounter( + CounterOpts{Name: "counter1", Help: "counter1"}, + []string{"name", "event"}, + []string{"name1", "event1"}, + "SUBSYSTEML0") + + c_1_1.Inc() + c_1_2.Inc() + if c_1_1 != c_1_2 { + t.Errorf("c_1_1 not same than c_1_2. cache not working?") + } + + // + // + c_2_1 := Metric.RegisterLabeledCounter( + CounterOpts{Name: "counter1", Help: "counter1"}, + []string{"name", "event"}, + []string{"name1", "event2"}, + "SUBSYSTEML0") + + c_2_2 := Metric.RegisterLabeledCounter( + CounterOpts{Name: "counter1", Help: "counter1"}, + []string{"name", "event"}, + []string{"name1", "event2"}, + "SUBSYSTEML0") + + c_2_1.Inc() + c_2_2.Inc() + if c_2_1 != c_2_2 { + t.Errorf("c_2_1 not same than c_2_2. cache not working?") + } + + if c_1_1 == c_2_1 { + t.Errorf("c_1_1 same than c_2_1. what?") + } + if c_1_2 == c_2_2 { + t.Errorf("c_1_2 same than c_2_2. what?") + } + +} + +func TestMetricLabeledCounterMismatch(t *testing.T) { + Metric.RegisterLabeledCounter( + CounterOpts{Name: "counter1", Help: "counter1"}, + []string{"name", "event"}, + []string{"name1", "event1"}, + "SUBSYSTEMLERR") + + Metric.RegisterLabeledCounter( + CounterOpts{Name: "counter1", Help: "counter1"}, + []string{"name", "eventmismatch"}, + []string{"name1", "event1"}, + "SUBSYSTEMLERR") +} + +func TestMetricLabeledCounterGroup(t *testing.T) { + // + // + c_grp1 := Metric.RegisterLabeledCounterGroup( + []CounterOpts{{Name: "counter1", Help: "counter1"}}, + []string{"name", "event"}, + []string{"name1", "event1"}, + "SUBSYSTEML1") + + if _, ok := c_grp1["counter1"]; ok == false { + t.Errorf("c_grp1 counter1 not exists") + } + c_grp1["counter1"].Inc() + + // + // + c_grp2 := Metric.RegisterLabeledCounterGroup( + []CounterOpts{{Name: "counter1", Help: "counter1"}}, + []string{"name", "event"}, + []string{"name1", "event2"}, + "SUBSYSTEML1") + + if _, ok := c_grp2["counter1"]; ok == false { + t.Errorf("c_grp2 counter1 not exists") + } + c_grp2["counter1"].Inc() +} + +func TestMetricGauge(t *testing.T) { + TestGaugeOpts := CounterOpts{Name: "GaugeBlaah1", Help: "GaugeBlaah1"} + ret1 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge") + ret1.Inc() + ret2 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge") + ret2.Inc() + if ret1 != ret2 { + t.Errorf("ret1 not same than ret2. cache not working?") + } +} + +func TestMetricGaugeGroup(t *testing.T) { + var TestGaugeOpts = []CounterOpts{ + {Name: "GaugeBlaah1", Help: "GaugeBlaah1"}, + {Name: "GaugeBlaah2", Help: "GaugeBlaah2"}, + {Name: "GaugeBlaah3", Help: "GaugeBlaah3"}, + {Name: "GaugeBlaah4", Help: "GaugeBlaah4"}, + } + + ret1 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup") + + if len(ret1) == 0 { + t.Errorf("ret1 gauge group is empty") + } + + ret1["GaugeBlaah1"].Inc() + ret1["GaugeBlaah2"].Inc() + ret1["GaugeBlaah3"].Inc() + ret1["GaugeBlaah4"].Inc() + + ret2 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup") + + if len(ret2) == 0 { + t.Errorf("ret2 gauge group is empty") + } + + ret2["GaugeBlaah1"].Inc() + ret2["GaugeBlaah2"].Inc() + ret2["GaugeBlaah3"].Inc() + ret2["GaugeBlaah4"].Inc() + + if len(ret1) != len(ret2) { + t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2)) + } +} + +func TestMetricLabeledGauge(t *testing.T) { + // + // + c_1_1 := Metric.RegisterLabeledGauge( + CounterOpts{Name: "gauge1", Help: "gauge1"}, + []string{"name", "event"}, + []string{"name1", "event1"}, + "SUBSYSTEML0") + + c_1_2 := Metric.RegisterLabeledGauge( + CounterOpts{Name: "gauge1", Help: "gauge1"}, + []string{"name", "event"}, + []string{"name1", "event1"}, + "SUBSYSTEML0") + + c_1_1.Inc() + c_1_2.Inc() + if c_1_1 != c_1_2 { + t.Errorf("c_1_1 not same than c_1_2. cache not working?") + } + + // + // + c_2_1 := Metric.RegisterLabeledGauge( + CounterOpts{Name: "gauge1", Help: "gauge1"}, + []string{"name", "event"}, + []string{"name1", "event2"}, + "SUBSYSTEML0") + + c_2_2 := Metric.RegisterLabeledGauge( + CounterOpts{Name: "gauge1", Help: "gauge1"}, + []string{"name", "event"}, + []string{"name1", "event2"}, + "SUBSYSTEML0") + + c_2_1.Inc() + c_2_2.Inc() + if c_2_1 != c_2_2 { + t.Errorf("c_2_1 not same than c_2_2. cache not working?") + } + + if c_1_1 == c_2_1 { + t.Errorf("c_1_1 same than c_2_1. what?") + } + if c_1_2 == c_2_2 { + t.Errorf("c_1_2 same than c_2_2. what?") + } + +} + +func TestMetricLabeledGaugeMismatch(t *testing.T) { + Metric.RegisterLabeledGauge( + CounterOpts{Name: "gauge1", Help: "gauge1"}, + []string{"name", "event"}, + []string{"name1", "event1"}, + "SUBSYSTEMLERR") + + Metric.RegisterLabeledGauge( + CounterOpts{Name: "gauge1", Help: "gauge1"}, + []string{"name", "eventmismatch"}, + []string{"name1", "event1"}, + "SUBSYSTEMLERR") +} + +func TestMetricLabeledGaugeGroup(t *testing.T) { + // + // + g_grp1 := Metric.RegisterLabeledGaugeGroup( + []CounterOpts{{Name: "gauge1", Help: "gauge1"}}, + []string{"name", "event"}, + []string{"name1", "event1"}, + "SUBSYSTEML1") + + if _, ok := g_grp1["gauge1"]; ok == false { + t.Errorf("g_grp1 gauge1 not exists") + } + g_grp1["gauge1"].Inc() + + // + // + g_grp2 := Metric.RegisterLabeledGaugeGroup( + []CounterOpts{{Name: "gauge1", Help: "gauge1"}}, + []string{"name", "event"}, + []string{"name1", "event2"}, + "SUBSYSTEML1") + + if _, ok := g_grp2["gauge1"]; ok == false { + t.Errorf("g_grp2 gauge1 not exists") + } + g_grp2["gauge1"].Inc() +} + +func TestMetricGroupCache(t *testing.T) { + // + // + c_grp1 := Metric.RegisterLabeledCounterGroup( + []CounterOpts{{Name: "counter1", Help: "counter1"}}, + []string{"name", "event"}, + []string{"name1", "event1"}, + "SUBSYSTEML1") + if _, ok := c_grp1["counter1"]; ok == false { + t.Errorf("c_grp1 counter1 not exists") + } + c_grp1["counter1"].Inc() + + // + // + c_grp2 := Metric.RegisterLabeledCounterGroup( + []CounterOpts{{Name: "counter1", Help: "counter1"}}, + []string{"name", "event"}, + []string{"name1", "event2"}, + "SUBSYSTEML1") + if _, ok := c_grp2["counter1"]; ok == false { + t.Errorf("c_grp2 counter1 not exists") + } + c_grp2["counter1"].Inc() + + // + // + g_grp1 := Metric.RegisterLabeledGaugeGroup( + []CounterOpts{{Name: "gauge1", Help: "gauge1"}}, + []string{"name", "event"}, + []string{"name1", "event1"}, + "SUBSYSTEML1") + if _, ok := g_grp1["gauge1"]; ok == false { + t.Errorf("g_grp1 gauge1 not exists") + } + g_grp1["gauge1"].Inc() + + // + // + g_grp2 := Metric.RegisterLabeledGaugeGroup( + []CounterOpts{{Name: "gauge1", Help: "gauge1"}}, + []string{"name", "event"}, + []string{"name1", "event2"}, + "SUBSYSTEML1") + if _, ok := g_grp2["gauge1"]; ok == false { + t.Errorf("g_grp2 gauge1 not exists") + } + g_grp2["gauge1"].Inc() + + // + // + m_grp := NewMetricGroupsCache() + m_grp.CombineCounterGroupsWithPrefix("event1_", c_grp1) + m_grp.CombineCounterGroupsWithPrefix("event2_", c_grp2) + m_grp.CombineGaugeGroupsWithPrefix("event1_", g_grp1) + m_grp.CombineGaugeGroupsWithPrefix("event2_", g_grp2) + + if m_grp == nil { + t.Errorf("Cache failed") + } + + if m_grp.CIs("event1_counter1") == false { + t.Errorf("m_grp.Counters event1_counter1 not exists") + } + m_grp.CInc("event1_counter1") + + if m_grp.CIs("event2_counter1") == false { + t.Errorf("m_grp.Counters event2_counter1 not exists") + } + m_grp.CInc("event2_counter1") + + if m_grp.GIs("event1_gauge1") == false { + t.Errorf("m_grp.Gauges event1_gauge1 not exists") + } + m_grp.GInc("event1_gauge1") + + if m_grp.GIs("event2_gauge1") == false { + t.Errorf("m_grp.Gauges event2_gauge1 not exists") + } + m_grp.GInc("event2_gauge1") + + m_grp.CAdd("event2_counter1", 1) + m_grp.CGet("event2_counter1") + m_grp.GGet("event2_gauge1") + m_grp.GDec("event2_gauge1") + m_grp.GSet("event2_gauge1", 1) +} + +// ---- +// VECTORS ARE OLD WAY +// *Labeled* will do all work under the hood +// ---- + +var mCVect CounterVec +var mGVect GaugeVec + +var mCGroupVect map[string]CounterVec +var mGGroupVect map[string]GaugeVec func TestMetricSetup(t *testing.T) { - mCVect = Metric.RegisterCounterVecGroup( + mCVect = Metric.RegisterCounterVec(CounterOpts{Name: "counter1", Help: "counter1"}, []string{"name", "event"}, "SUBSYSTEM0") + + mCGroupVect = Metric.RegisterCounterVecGroup( []CounterOpts{ {Name: "counter1", Help: "counter1"}, }, []string{"name", "event"}, - "SUBSYSTEM") + "SUBSYSTEM1") + + mGVect = Metric.RegisterGaugeVec(CounterOpts{Name: "gauge1", Help: "gauge1"}, []string{"name", "event"}, "SUBSYSTEM0") - mGVect = Metric.RegisterGaugeVecGroup( + mGGroupVect = Metric.RegisterGaugeVecGroup( []CounterOpts{ - {Name: "counter2", Help: "counter2"}, + {Name: "gauge1", Help: "gauge1"}, }, []string{"name", "event"}, - "SUBSYSTEM") + "SUBSYSTEM1") + + tmpCVect := Metric.RegisterCounterVec(CounterOpts{Name: "counter1", Help: "counter1"}, []string{"name", "event"}, "SUBSYSTEM0") + + if tmpCVect.Vec != mCVect.Vec { + t.Errorf("tmpCVect not same than mCVect. cache not working?") + } + + tmpGVect := Metric.RegisterGaugeVec(CounterOpts{Name: "gauge1", Help: "gauge1"}, []string{"name", "event"}, "SUBSYSTEM0") + + if tmpGVect.Vec != mGVect.Vec { + t.Errorf("tmpGVect not same than mGVect. cache not working?") + } + + Metric.RegisterCounterVec(CounterOpts{Name: "counter1", Help: "counter1"}, []string{"name", "eventMismatch"}, "SUBSYSTEM0") + Metric.RegisterGaugeVec(CounterOpts{Name: "gauge1", Help: "gauge1"}, []string{"name", "eventMismatch"}, "SUBSYSTEM0") + } func TestMetricCounterVector(t *testing.T) { // // - c_grp1 := Metric.GetCounterGroupFromVects([]string{"name1", "event1"}, mCVect) + c_1_1 := Metric.GetCounterFromVect([]string{"name1", "event1"}, mCVect) + c_1_1.Inc() + c_1_2 := Metric.GetCounterFromVect([]string{"name1", "event1"}, mCVect) + c_1_2.Inc() + if c_1_1 != c_1_2 { + t.Errorf("c_1_1 not same than c_1_2. cache not working?") + } + // + // + c_2_1 := Metric.GetCounterFromVect([]string{"name1", "event2"}, mCVect) + c_2_1.Inc() + c_2_2 := Metric.GetCounterFromVect([]string{"name1", "event2"}, mCVect) + c_2_2.Inc() + if c_2_1 != c_2_2 { + t.Errorf("c_2_1 not same than c_2_2. cache not working?") + } + if c_1_1 == c_2_1 { + t.Errorf("c_1_1 same than c_2_1. what?") + } + +} + +func TestMetricCounterGroupVector(t *testing.T) { + // + // + c_grp1 := Metric.GetCounterGroupFromVects([]string{"name1", "event1"}, mCGroupVect) if _, ok := c_grp1["counter1"]; ok == false { t.Errorf("c_grp1 counter1 not exists") } @@ -53,7 +470,7 @@ func TestMetricCounterVector(t *testing.T) { // // - c_grp2 := Metric.GetCounterGroupFromVects([]string{"name1", "event2"}, mCVect) + c_grp2 := Metric.GetCounterGroupFromVects([]string{"name1", "event2"}, mCGroupVect) if _, ok := c_grp2["counter1"]; ok == false { t.Errorf("c_grp2 counter1 not exists") } @@ -63,25 +480,49 @@ func TestMetricCounterVector(t *testing.T) { func TestMetricGaugeVector(t *testing.T) { // // - g_grp1 := Metric.GetGaugeGroupFromVects([]string{"name1", "event1"}, mGVect) - if _, ok := g_grp1["counter2"]; ok == false { - t.Errorf("g_grp1 counter2 not exists") + c_1_1 := Metric.GetGaugeFromVect([]string{"name1", "event1"}, mGVect) + c_1_1.Inc() + c_1_2 := Metric.GetGaugeFromVect([]string{"name1", "event1"}, mGVect) + c_1_2.Inc() + if c_1_1 != c_1_2 { + t.Errorf("c_1_1 not same than c_1_2. cache not working?") } - g_grp1["counter2"].Inc() + // + // + c_2_1 := Metric.GetGaugeFromVect([]string{"name1", "event2"}, mGVect) + c_2_1.Inc() + c_2_2 := Metric.GetGaugeFromVect([]string{"name1", "event2"}, mGVect) + c_2_2.Inc() + if c_2_1 != c_2_2 { + t.Errorf("c_2_1 not same than c_2_2. cache not working?") + } + if c_1_1 == c_2_1 { + t.Errorf("c_1_1 same than c_2_1. what?") + } +} + +func TestMetricGaugeGroupVector(t *testing.T) { + // + // + g_grp1 := Metric.GetGaugeGroupFromVects([]string{"name1", "event1"}, mGGroupVect) + if _, ok := g_grp1["gauge1"]; ok == false { + t.Errorf("g_grp1 gauge1 not exists") + } + g_grp1["gauge1"].Inc() // // - g_grp2 := Metric.GetGaugeGroupFromVects([]string{"name1", "event2"}, mGVect) - if _, ok := g_grp2["counter2"]; ok == false { - t.Errorf("g_grp2 counter2 not exists") + g_grp2 := Metric.GetGaugeGroupFromVects([]string{"name1", "event2"}, mGGroupVect) + if _, ok := g_grp2["gauge1"]; ok == false { + t.Errorf("g_grp2 gauge1 not exists") } - g_grp2["counter2"].Inc() + g_grp2["gauge1"].Inc() } -func TestMetricCounterVectorPrefix(t *testing.T) { +func TestMetricCounterGroupVectorPrefix(t *testing.T) { // // - c_grp1 := Metric.GetCounterGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mCVect) + c_grp1 := Metric.GetCounterGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mCGroupVect) if _, ok := c_grp1["event1_counter1"]; ok == false { t.Errorf("c_grp1 event1_counter1 not exists") } @@ -89,7 +530,7 @@ func TestMetricCounterVectorPrefix(t *testing.T) { // // - c_grp2 := Metric.GetCounterGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mCVect) + c_grp2 := Metric.GetCounterGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mCGroupVect) if _, ok := c_grp2["event2_counter1"]; ok == false { t.Errorf("c_grp2 event2_counter1 not exists") } @@ -97,126 +538,133 @@ func TestMetricCounterVectorPrefix(t *testing.T) { // // - c_grp := Metric.CombineCounterGroups(c_grp1, c_grp2) + m_grp := NewMetricGroupsCache() + m_grp.CombineCounterGroups(c_grp1, c_grp2) // // - if _, ok := c_grp["event1_counter1"]; ok == false { - t.Errorf("c_grp event1_counter1 not exists") + if m_grp.CIs("event1_counter1") == false { + t.Errorf("m_grp event1_counter1 not exists") } - c_grp["event1_counter1"].Inc() + m_grp.CInc("event1_counter1") // // - if _, ok := c_grp["event2_counter1"]; ok == false { - t.Errorf("c_grp event2_counter1 not exists") + if m_grp.CIs("event2_counter1") == false { + t.Errorf("m_grp event2_counter1 not exists") } - c_grp["event2_counter1"].Inc() + + m_grp.CAdd("event2_counter1", 1) + m_grp.CGet("event2_counter1") } -func TestMetricGaugeVectorPrefix(t *testing.T) { +func TestMetricGaugeGroupVectorPrefix(t *testing.T) { // // - g_grp1 := Metric.GetGaugeGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mGVect) - if _, ok := g_grp1["event1_counter2"]; ok == false { - t.Errorf("g_grp1 event1_counter2 not exists") + g_grp1 := Metric.GetGaugeGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mGGroupVect) + if _, ok := g_grp1["event1_gauge1"]; ok == false { + t.Errorf("g_grp1 event1_gauge1 not exists") } - g_grp1["event1_counter2"].Inc() + g_grp1["event1_gauge1"].Inc() // // - g_grp2 := Metric.GetGaugeGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mGVect) - if _, ok := g_grp2["event2_counter2"]; ok == false { - t.Errorf("g_grp2 event2_counter2 not exists") + g_grp2 := Metric.GetGaugeGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mGGroupVect) + if _, ok := g_grp2["event2_gauge1"]; ok == false { + t.Errorf("g_grp2 event2_gauge1 not exists") } - g_grp2["event2_counter2"].Inc() + g_grp2["event2_gauge1"].Inc() - // - // - g_grp := Metric.CombineGaugeGroups(g_grp1, g_grp2) + m_grp := NewMetricGroupsCache() + m_grp.CombineGaugeGroups(g_grp1, g_grp2) // // - if _, ok := g_grp["event1_counter2"]; ok == false { - t.Errorf("g_grp event1_counter2 not exists") + if m_grp.GIs("event1_gauge1") == false { + t.Errorf("m_grp event1_gauge1 not exists") } - g_grp["event1_counter2"].Inc() + m_grp.GInc("event1_gauge1") // // - if _, ok := g_grp["event2_counter2"]; ok == false { - t.Errorf("g_grp event2_counter2 not exists") + if m_grp.GIs("event2_gauge1") == false { + t.Errorf("m_grp event2_gauge1 not exists") } - g_grp["event2_counter2"].Inc() + m_grp.GInc("event2_gauge1") + + m_grp.GGet("event2_gauge1") + m_grp.GDec("event2_gauge1") + m_grp.GSet("event2_gauge1", 1) } -func TestMetricGroupCache(t *testing.T) { +func TestMetricGroupCacheWithVect(t *testing.T) { // // - c_grp1 := Metric.GetCounterGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mCVect) - if _, ok := c_grp1["event1_counter1"]; ok == false { - t.Errorf("c_grp1 event1_counter1 not exists") + c_grp1 := Metric.GetCounterGroupFromVects([]string{"name1", "event1"}, mCGroupVect) + if _, ok := c_grp1["counter1"]; ok == false { + t.Errorf("c_grp1 counter1 not exists") } - c_grp1["event1_counter1"].Inc() + c_grp1["counter1"].Inc() // // - c_grp2 := Metric.GetCounterGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mCVect) - if _, ok := c_grp2["event2_counter1"]; ok == false { - t.Errorf("c_grp2 event2_counter1 not exists") + c_grp2 := Metric.GetCounterGroupFromVects([]string{"name1", "event2"}, mCGroupVect) + if _, ok := c_grp2["counter1"]; ok == false { + t.Errorf("c_grp2 counter1 not exists") } - c_grp2["event2_counter1"].Inc() + c_grp2["counter1"].Inc() // // - g_grp1 := Metric.GetGaugeGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mGVect) - if _, ok := g_grp1["event1_counter2"]; ok == false { - t.Errorf("g_grp1 event1_counter2 not exists") + g_grp1 := Metric.GetGaugeGroupFromVects([]string{"name1", "event1"}, mGGroupVect) + if _, ok := g_grp1["gauge1"]; ok == false { + t.Errorf("g_grp1 gauge1 not exists") } - g_grp1["event1_counter2"].Inc() + g_grp1["gauge1"].Inc() // // - g_grp2 := Metric.GetGaugeGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mGVect) - if _, ok := g_grp2["event2_counter2"]; ok == false { - t.Errorf("g_grp2 event2_counter2 not exists") + g_grp2 := Metric.GetGaugeGroupFromVects([]string{"name1", "event2"}, mGGroupVect) + if _, ok := g_grp2["gauge1"]; ok == false { + t.Errorf("g_grp2 gauge1 not exists") } - g_grp2["event2_counter2"].Inc() + g_grp2["gauge1"].Inc() // // - cacheid := "CACHEID" - entry := Metric.GroupCacheGet(cacheid) - if entry == nil { - Metric.GroupCacheAddCounters(cacheid, c_grp1) - Metric.GroupCacheAddCounters(cacheid, c_grp2) - Metric.GroupCacheAddGauges(cacheid, g_grp1) - Metric.GroupCacheAddGauges(cacheid, g_grp2) - entry = Metric.GroupCacheGet(cacheid) - } + m_grp := NewMetricGroupsCache() + m_grp.CombineCounterGroupsWithPrefix("event1_", c_grp1) + m_grp.CombineCounterGroupsWithPrefix("event2_", c_grp2) + m_grp.CombineGaugeGroupsWithPrefix("event1_", g_grp1) + m_grp.CombineGaugeGroupsWithPrefix("event2_", g_grp2) - if entry == nil { + if m_grp == nil { t.Errorf("Cache failed") } - if _, ok := entry.Counters["event1_counter1"]; ok == false { - t.Errorf("entry.Counters event1_counter1 not exists") + if m_grp.CIs("event1_counter1") == false { + t.Errorf("m_grp.Counters event1_counter1 not exists") } - entry.Counters["event1_counter1"].Inc() + m_grp.CInc("event1_counter1") - if _, ok := entry.Counters["event2_counter1"]; ok == false { - t.Errorf("entry.Counters event2_counter1 not exists") + if m_grp.CIs("event2_counter1") == false { + t.Errorf("m_grp.Counters event2_counter1 not exists") } - entry.Counters["event2_counter1"].Inc() + m_grp.CInc("event2_counter1") - if _, ok := entry.Gauges["event1_counter2"]; ok == false { - t.Errorf("entry.Gauges event1_counter2 not exists") + if m_grp.GIs("event1_gauge1") == false { + t.Errorf("m_grp.Gauges event1_gauge1 not exists") } - entry.Gauges["event1_counter2"].Inc() + m_grp.GInc("event1_gauge1") - if _, ok := entry.Gauges["event2_counter2"]; ok == false { - t.Errorf("entry.Gauges event2_counter2 not exists") + if m_grp.GIs("event2_gauge1") == false { + t.Errorf("m_grp.Gauges event2_gauge1 not exists") } - entry.Gauges["event2_counter2"].Inc() + m_grp.GInc("event2_gauge1") + m_grp.CAdd("event2_counter1", 1) + m_grp.CGet("event2_counter1") + m_grp.GGet("event2_gauge1") + m_grp.GDec("event2_gauge1") + m_grp.GSet("event2_gauge1", 1) }