mirror of
https://github.com/Luzifer/nginx-sso.git
synced 2024-12-20 21:01:17 +00:00
424 lines
12 KiB
Go
424 lines
12 KiB
Go
// Copyright 2019, OpenCensus Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
package view
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"encoding/json"
|
|
"github.com/google/go-cmp/cmp"
|
|
"go.opencensus.io/metric/metricdata"
|
|
"go.opencensus.io/stats"
|
|
"go.opencensus.io/tag"
|
|
)
|
|
|
|
type recordValWithTag struct {
|
|
tags []tag.Tag
|
|
value interface{}
|
|
}
|
|
type testToMetrics struct {
|
|
vi *viewInternal
|
|
view *View
|
|
recordValue []recordValWithTag
|
|
wantMetric *metricdata.Metric
|
|
}
|
|
|
|
var (
|
|
// tag objects.
|
|
tk1 tag.Key
|
|
tk2 tag.Key
|
|
tk3 tag.Key
|
|
tk1v1 tag.Tag
|
|
tk1v2 tag.Tag
|
|
tk2v2 tag.Tag
|
|
tk3v3 tag.Tag
|
|
tags []tag.Tag
|
|
labelValues []metricdata.LabelValue
|
|
labelKeys []string
|
|
|
|
recordsInt64 []recordValWithTag
|
|
recordsFloat64 []recordValWithTag
|
|
|
|
// distribution objects.
|
|
aggDist *Aggregation
|
|
aggCnt *Aggregation
|
|
aggS *Aggregation
|
|
aggL *Aggregation
|
|
buckOpt *metricdata.BucketOptions
|
|
|
|
// exemplar objects.
|
|
attachments metricdata.Attachments
|
|
|
|
// views and descriptors
|
|
viewTypeFloat64Distribution *View
|
|
viewTypeInt64Distribution *View
|
|
viewTypeInt64Count *View
|
|
viewTypeFloat64Count *View
|
|
viewTypeFloat64Sum *View
|
|
viewTypeInt64Sum *View
|
|
viewTypeFloat64LastValue *View
|
|
viewTypeInt64LastValue *View
|
|
mdTypeFloat64CumulativeDistribution metricdata.Descriptor
|
|
mdTypeInt64CumulativeDistribution metricdata.Descriptor
|
|
mdTypeInt64CumulativeCount metricdata.Descriptor
|
|
mdTypeFloat64CumulativeCount metricdata.Descriptor
|
|
mdTypeInt64CumulativeSum metricdata.Descriptor
|
|
mdTypeFloat64CumulativeSum metricdata.Descriptor
|
|
mdTypeInt64CumulativeLastValue metricdata.Descriptor
|
|
mdTypeFloat64CumulativeLastValue metricdata.Descriptor
|
|
)
|
|
|
|
const (
|
|
nameInt64DistM1 = "viewToMetricTest_Int64_Distribution/m1"
|
|
nameFloat64DistM1 = "viewToMetricTest_Float64_Distribution/m1"
|
|
nameInt64CountM1 = "viewToMetricTest_Int64_Count/m1"
|
|
nameFloat64CountM1 = "viewToMetricTest_Float64_Count/m1"
|
|
nameInt64SumM1 = "viewToMetricTest_Int64_Sum/m1"
|
|
nameFloat64SumM1 = "viewToMetricTest_Float64_Sum/m1"
|
|
nameInt64LastValueM1 = "viewToMetricTest_Int64_LastValue/m1"
|
|
nameFloat64LastValueM1 = "viewToMetricTest_Float64_LastValue/m1"
|
|
v1 = "v1"
|
|
v2 = "v2"
|
|
v3 = "v3"
|
|
)
|
|
|
|
func init() {
|
|
initTags()
|
|
initAgg()
|
|
initViews()
|
|
initMetricDescriptors()
|
|
|
|
}
|
|
|
|
func initTags() {
|
|
tk1, _ = tag.NewKey("k1")
|
|
tk2, _ = tag.NewKey("k2")
|
|
tk3, _ = tag.NewKey("k3")
|
|
tk1v1 = tag.Tag{Key: tk1, Value: v1}
|
|
tk1v2 = tag.Tag{Key: tk1, Value: v2}
|
|
tk2v2 = tag.Tag{Key: tk2, Value: v2}
|
|
tk3v3 = tag.Tag{Key: tk3, Value: v3}
|
|
|
|
tags = []tag.Tag{tk1v1, tk2v2}
|
|
labelValues = []metricdata.LabelValue{
|
|
{Value: v1, Present: true},
|
|
{Value: v2, Present: true},
|
|
}
|
|
labelKeys = []string{tk1.Name(), tk2.Name()}
|
|
|
|
recordsInt64 = []recordValWithTag{
|
|
{tags: tags, value: int64(2)},
|
|
{tags: tags, value: int64(4)},
|
|
}
|
|
recordsFloat64 = []recordValWithTag{
|
|
{tags: tags, value: float64(1.5)},
|
|
{tags: tags, value: float64(5.4)},
|
|
}
|
|
}
|
|
|
|
func initAgg() {
|
|
aggDist = Distribution(2.0)
|
|
aggCnt = Count()
|
|
aggS = Sum()
|
|
aggL = LastValue()
|
|
buckOpt = &metricdata.BucketOptions{Bounds: []float64{2.0}}
|
|
}
|
|
|
|
func initViews() {
|
|
// View objects
|
|
viewTypeInt64Distribution = &View{
|
|
Name: nameInt64DistM1,
|
|
TagKeys: []tag.Key{tk1, tk2},
|
|
Measure: stats.Int64(nameInt64DistM1, "", stats.UnitDimensionless),
|
|
Aggregation: aggDist,
|
|
}
|
|
viewTypeFloat64Distribution = &View{
|
|
Name: nameFloat64DistM1,
|
|
TagKeys: []tag.Key{tk1, tk2},
|
|
Measure: stats.Float64(nameFloat64DistM1, "", stats.UnitDimensionless),
|
|
Aggregation: aggDist,
|
|
}
|
|
viewTypeInt64Count = &View{
|
|
Name: nameInt64CountM1,
|
|
TagKeys: []tag.Key{tk1, tk2},
|
|
Measure: stats.Int64(nameInt64CountM1, "", stats.UnitDimensionless),
|
|
Aggregation: aggCnt,
|
|
}
|
|
viewTypeFloat64Count = &View{
|
|
Name: nameFloat64CountM1,
|
|
TagKeys: []tag.Key{tk1, tk2},
|
|
Measure: stats.Float64(nameFloat64CountM1, "", stats.UnitDimensionless),
|
|
Aggregation: aggCnt,
|
|
}
|
|
viewTypeInt64Sum = &View{
|
|
Name: nameInt64SumM1,
|
|
TagKeys: []tag.Key{tk1, tk2},
|
|
Measure: stats.Int64(nameInt64SumM1, "", stats.UnitBytes),
|
|
Aggregation: aggS,
|
|
}
|
|
viewTypeFloat64Sum = &View{
|
|
Name: nameFloat64SumM1,
|
|
TagKeys: []tag.Key{tk1, tk2},
|
|
Measure: stats.Float64(nameFloat64SumM1, "", stats.UnitMilliseconds),
|
|
Aggregation: aggS,
|
|
}
|
|
viewTypeInt64LastValue = &View{
|
|
Name: nameInt64LastValueM1,
|
|
TagKeys: []tag.Key{tk1, tk2},
|
|
Measure: stats.Int64(nameInt64LastValueM1, "", stats.UnitDimensionless),
|
|
Aggregation: aggL,
|
|
}
|
|
viewTypeFloat64LastValue = &View{
|
|
Name: nameFloat64LastValueM1,
|
|
TagKeys: []tag.Key{tk1, tk2},
|
|
Measure: stats.Float64(nameFloat64LastValueM1, "", stats.UnitDimensionless),
|
|
Aggregation: aggL,
|
|
}
|
|
}
|
|
|
|
func initMetricDescriptors() {
|
|
// Metric objects
|
|
mdTypeFloat64CumulativeDistribution = metricdata.Descriptor{
|
|
Name: nameFloat64DistM1, Description: "", Unit: metricdata.UnitDimensionless,
|
|
Type: metricdata.TypeCumulativeDistribution, LabelKeys: labelKeys,
|
|
}
|
|
mdTypeInt64CumulativeDistribution = metricdata.Descriptor{
|
|
Name: nameInt64DistM1, Description: "", Unit: metricdata.UnitDimensionless,
|
|
Type: metricdata.TypeCumulativeDistribution, LabelKeys: labelKeys,
|
|
}
|
|
mdTypeInt64CumulativeCount = metricdata.Descriptor{
|
|
Name: nameInt64CountM1, Description: "", Unit: metricdata.UnitDimensionless,
|
|
Type: metricdata.TypeCumulativeInt64, LabelKeys: labelKeys,
|
|
}
|
|
mdTypeFloat64CumulativeCount = metricdata.Descriptor{
|
|
Name: nameFloat64CountM1, Description: "", Unit: metricdata.UnitDimensionless,
|
|
Type: metricdata.TypeCumulativeInt64, LabelKeys: labelKeys,
|
|
}
|
|
mdTypeInt64CumulativeSum = metricdata.Descriptor{
|
|
Name: nameInt64SumM1, Description: "", Unit: metricdata.UnitBytes,
|
|
Type: metricdata.TypeCumulativeInt64, LabelKeys: labelKeys,
|
|
}
|
|
mdTypeFloat64CumulativeSum = metricdata.Descriptor{
|
|
Name: nameFloat64SumM1, Description: "", Unit: metricdata.UnitMilliseconds,
|
|
Type: metricdata.TypeCumulativeFloat64, LabelKeys: labelKeys,
|
|
}
|
|
mdTypeInt64CumulativeLastValue = metricdata.Descriptor{
|
|
Name: nameInt64LastValueM1, Description: "", Unit: metricdata.UnitDimensionless,
|
|
Type: metricdata.TypeGaugeInt64, LabelKeys: labelKeys,
|
|
}
|
|
mdTypeFloat64CumulativeLastValue = metricdata.Descriptor{
|
|
Name: nameFloat64LastValueM1, Description: "", Unit: metricdata.UnitDimensionless,
|
|
Type: metricdata.TypeGaugeFloat64, LabelKeys: labelKeys,
|
|
}
|
|
}
|
|
|
|
func Test_ViewToMetric(t *testing.T) {
|
|
startTime := time.Now().Add(-time.Duration(60 * time.Second))
|
|
now := time.Now()
|
|
tests := []*testToMetrics{
|
|
{
|
|
view: viewTypeInt64Distribution,
|
|
recordValue: recordsInt64,
|
|
wantMetric: &metricdata.Metric{
|
|
Descriptor: mdTypeInt64CumulativeDistribution,
|
|
TimeSeries: []*metricdata.TimeSeries{
|
|
{Points: []metricdata.Point{
|
|
{Value: &metricdata.Distribution{
|
|
Count: 2,
|
|
Sum: 6.0,
|
|
SumOfSquaredDeviation: 2,
|
|
BucketOptions: buckOpt,
|
|
Buckets: []metricdata.Bucket{
|
|
{Count: 0, Exemplar: nil},
|
|
{Count: 2, Exemplar: nil},
|
|
},
|
|
},
|
|
Time: now,
|
|
},
|
|
},
|
|
LabelValues: labelValues,
|
|
StartTime: startTime,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
view: viewTypeFloat64Distribution,
|
|
recordValue: recordsFloat64,
|
|
wantMetric: &metricdata.Metric{
|
|
Descriptor: mdTypeFloat64CumulativeDistribution,
|
|
TimeSeries: []*metricdata.TimeSeries{
|
|
{
|
|
Points: []metricdata.Point{
|
|
{
|
|
Value: &metricdata.Distribution{
|
|
Count: 2,
|
|
Sum: 6.9,
|
|
SumOfSquaredDeviation: 7.605000000000001,
|
|
BucketOptions: buckOpt,
|
|
Buckets: []metricdata.Bucket{
|
|
{Count: 1, Exemplar: nil}, // TODO: [rghetia] add exemplar test.
|
|
{Count: 1, Exemplar: nil},
|
|
},
|
|
},
|
|
Time: now,
|
|
},
|
|
},
|
|
LabelValues: labelValues,
|
|
StartTime: startTime,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
view: viewTypeInt64Count,
|
|
recordValue: recordsInt64,
|
|
wantMetric: &metricdata.Metric{
|
|
Descriptor: mdTypeInt64CumulativeCount,
|
|
TimeSeries: []*metricdata.TimeSeries{
|
|
{Points: []metricdata.Point{
|
|
metricdata.NewInt64Point(now, 2),
|
|
},
|
|
LabelValues: labelValues,
|
|
StartTime: startTime,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
view: viewTypeFloat64Count,
|
|
recordValue: recordsFloat64,
|
|
wantMetric: &metricdata.Metric{
|
|
Descriptor: mdTypeFloat64CumulativeCount,
|
|
TimeSeries: []*metricdata.TimeSeries{
|
|
{Points: []metricdata.Point{
|
|
metricdata.NewInt64Point(now, 2),
|
|
},
|
|
LabelValues: labelValues,
|
|
StartTime: startTime,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
view: viewTypeInt64Sum,
|
|
recordValue: recordsInt64,
|
|
wantMetric: &metricdata.Metric{
|
|
Descriptor: mdTypeInt64CumulativeSum,
|
|
TimeSeries: []*metricdata.TimeSeries{
|
|
{Points: []metricdata.Point{
|
|
metricdata.NewInt64Point(now, 6),
|
|
},
|
|
LabelValues: labelValues,
|
|
StartTime: startTime,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
view: viewTypeFloat64Sum,
|
|
recordValue: recordsFloat64,
|
|
wantMetric: &metricdata.Metric{
|
|
Descriptor: mdTypeFloat64CumulativeSum,
|
|
TimeSeries: []*metricdata.TimeSeries{
|
|
{Points: []metricdata.Point{
|
|
metricdata.NewFloat64Point(now, 6.9),
|
|
},
|
|
LabelValues: labelValues,
|
|
StartTime: startTime,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
view: viewTypeInt64LastValue,
|
|
recordValue: recordsInt64,
|
|
wantMetric: &metricdata.Metric{
|
|
Descriptor: mdTypeInt64CumulativeLastValue,
|
|
TimeSeries: []*metricdata.TimeSeries{
|
|
{Points: []metricdata.Point{
|
|
metricdata.NewInt64Point(now, 4),
|
|
},
|
|
LabelValues: labelValues,
|
|
StartTime: time.Time{},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
view: viewTypeFloat64LastValue,
|
|
recordValue: recordsFloat64,
|
|
wantMetric: &metricdata.Metric{
|
|
Descriptor: mdTypeFloat64CumulativeLastValue,
|
|
TimeSeries: []*metricdata.TimeSeries{
|
|
{Points: []metricdata.Point{
|
|
metricdata.NewFloat64Point(now, 5.4),
|
|
},
|
|
LabelValues: labelValues,
|
|
StartTime: time.Time{},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
wantMetrics := []*metricdata.Metric{}
|
|
for _, tc := range tests {
|
|
tc.vi, _ = defaultWorker.tryRegisterView(tc.view)
|
|
tc.vi.clearRows()
|
|
tc.vi.subscribe()
|
|
wantMetrics = append(wantMetrics, tc.wantMetric)
|
|
}
|
|
|
|
for i, tc := range tests {
|
|
for _, r := range tc.recordValue {
|
|
mods := []tag.Mutator{}
|
|
for _, tg := range r.tags {
|
|
mods = append(mods, tag.Insert(tg.Key, tg.Value))
|
|
}
|
|
ctx, err := tag.New(context.Background(), mods...)
|
|
if err != nil {
|
|
t.Errorf("%v: New = %v", tc.view.Name, err)
|
|
}
|
|
var v float64
|
|
switch i := r.value.(type) {
|
|
case float64:
|
|
v = float64(i)
|
|
case int64:
|
|
v = float64(i)
|
|
default:
|
|
t.Errorf("unexpected value type %v", r.tags)
|
|
}
|
|
tc.vi.addSample(tag.FromContext(ctx), v, nil, now)
|
|
}
|
|
|
|
gotMetric := viewToMetric(tc.vi, now, startTime)
|
|
if !cmp.Equal(gotMetric, tc.wantMetric) {
|
|
// JSON format is strictly for checking the content when test fails. Do not use JSON
|
|
// format to determine if the two values are same as it doesn't differentiate between
|
|
// int64(2) and float64(2.0)
|
|
t.Errorf("#%d: Unmatched \nGot:\n\t%v\nWant:\n\t%v\nGot Serialized:%s\nWant Serialized:%s\n",
|
|
i, gotMetric, tc.wantMetric, serializeAsJSON(gotMetric), serializeAsJSON(tc.wantMetric))
|
|
}
|
|
}
|
|
}
|
|
|
|
func serializeAsJSON(v interface{}) string {
|
|
blob, _ := json.MarshalIndent(v, "", " ")
|
|
return string(blob)
|
|
}
|