From 52c9e7fd7a2b78d46b9f70fbae416481af9295a7 Mon Sep 17 00:00:00 2001 From: Bogdan Drutu Date: Sat, 29 Aug 2020 19:12:06 -0700 Subject: [PATCH] Add initial draft of the oneof generator, fixes issue in contrib (#1677) Signed-off-by: Bogdan Drutu --- cmd/pdatagen/internal/base_fields.go | 24 +++++++++ cmd/pdatagen/internal/metrics_structs.go | 8 +++ consumer/pdata/generated_metrics.go | 3 ++ consumer/pdata/generated_metrics_test.go | 5 ++ consumer/pdata/metric.go | 29 +++++++++++ consumer/pdata/metric_test.go | 66 ++++++++++++++++++++++++ 6 files changed, 135 insertions(+) diff --git a/cmd/pdatagen/internal/base_fields.go b/cmd/pdatagen/internal/base_fields.go index ae4dfe978d2..c1f6868a332 100644 --- a/cmd/pdatagen/internal/base_fields.go +++ b/cmd/pdatagen/internal/base_fields.go @@ -314,3 +314,27 @@ func (ptf *primitiveTypedField) generateCopyToValue(sb *strings.Builder) { } var _ baseField = (*primitiveTypedField)(nil) + +// oneofField is used in case where the proto defines an "oneof". +type oneofField struct { + copyFuncName string + originFieldName string + testVal string + fillTestName string +} + +func (one oneofField) generateAccessors(*messageStruct, *strings.Builder) {} + +func (one oneofField) generateAccessorsTest(*messageStruct, *strings.Builder) {} + +func (one oneofField) generateSetWithTestValue(sb *strings.Builder) { + sb.WriteString("\t(*tv.orig)." + one.originFieldName + " = " + one.testVal + "\n") + sb.WriteString("\ttv." + one.fillTestName + "().InitEmpty()\n") + sb.WriteString("\tfillTest" + one.fillTestName + "(tv." + one.fillTestName + "())") +} + +func (one oneofField) generateCopyToValue(sb *strings.Builder) { + sb.WriteString("\t" + one.copyFuncName + "((*ms.orig), (*dest.orig))") +} + +var _ baseField = (*oneofField)(nil) diff --git a/cmd/pdatagen/internal/metrics_structs.go b/cmd/pdatagen/internal/metrics_structs.go index fa84a14cf7b..6fbcab0d300 100644 --- a/cmd/pdatagen/internal/metrics_structs.go +++ b/cmd/pdatagen/internal/metrics_structs.go @@ -118,6 +118,7 @@ var metric = &messageStruct{ defaultVal: `""`, testVal: `"1"`, }, + oneofDataField, }, } @@ -419,3 +420,10 @@ var aggregationTemporalityField = &primitiveTypedField{ defaultVal: "AggregationTemporalityUnspecified", testVal: "AggregationTemporalityCumulative", } + +var oneofDataField = &oneofField{ + copyFuncName: "copyData", + originFieldName: "Data", + testVal: "&otlpmetrics.Metric_IntGauge{}", + fillTestName: "IntGauge", +} diff --git a/consumer/pdata/generated_metrics.go b/consumer/pdata/generated_metrics.go index ee4752a77be..c913cf10eea 100644 --- a/consumer/pdata/generated_metrics.go +++ b/consumer/pdata/generated_metrics.go @@ -607,6 +607,8 @@ func (ms Metric) SetUnit(v string) { (*ms.orig).Unit = v } + + // CopyTo copies all properties from the current struct to the dest. func (ms Metric) CopyTo(dest Metric) { if ms.IsNil() { @@ -619,6 +621,7 @@ func (ms Metric) CopyTo(dest Metric) { dest.SetName(ms.Name()) dest.SetDescription(ms.Description()) dest.SetUnit(ms.Unit()) + copyData((*ms.orig), (*dest.orig)) } // IntGauge represents the type of a int scalar metric that always exports the "current value" for every data point. diff --git a/consumer/pdata/generated_metrics_test.go b/consumer/pdata/generated_metrics_test.go index 74699e51581..2addd2adeea 100644 --- a/consumer/pdata/generated_metrics_test.go +++ b/consumer/pdata/generated_metrics_test.go @@ -489,6 +489,8 @@ func TestMetric_Unit(t *testing.T) { assert.EqualValues(t, testValUnit, ms.Unit()) } + + func TestIntGauge_InitEmpty(t *testing.T) { ms := NewIntGauge() assert.True(t, ms.IsNil()) @@ -1849,6 +1851,9 @@ func fillTestMetric(tv Metric) { tv.SetName("test_name") tv.SetDescription("test_description") tv.SetUnit("1") + (*tv.orig).Data = &otlpmetrics.Metric_IntGauge{} + tv.IntGauge().InitEmpty() + fillTestIntGauge(tv.IntGauge()) } func generateTestIntGauge() IntGauge { diff --git a/consumer/pdata/metric.go b/consumer/pdata/metric.go index 34c917bb460..0cc2d26ecda 100644 --- a/consumer/pdata/metric.go +++ b/consumer/pdata/metric.go @@ -201,6 +201,35 @@ func (ms Metric) SetDoubleHistogram(data DoubleHistogram) { } } +func copyData(src, dest *otlpmetrics.Metric) { + switch (src).Data.(type) { + case *otlpmetrics.Metric_IntGauge: + dest.Data = &otlpmetrics.Metric_IntGauge{ + IntGauge: src.Data.(*otlpmetrics.Metric_IntGauge).IntGauge, + } + case *otlpmetrics.Metric_DoubleGauge: + dest.Data = &otlpmetrics.Metric_DoubleGauge{ + DoubleGauge: src.Data.(*otlpmetrics.Metric_DoubleGauge).DoubleGauge, + } + case *otlpmetrics.Metric_IntSum: + dest.Data = &otlpmetrics.Metric_IntSum{ + IntSum: src.Data.(*otlpmetrics.Metric_IntSum).IntSum, + } + case *otlpmetrics.Metric_DoubleSum: + dest.Data = &otlpmetrics.Metric_DoubleSum{ + DoubleSum: src.Data.(*otlpmetrics.Metric_DoubleSum).DoubleSum, + } + case *otlpmetrics.Metric_IntHistogram: + dest.Data = &otlpmetrics.Metric_IntHistogram{ + IntHistogram: src.Data.(*otlpmetrics.Metric_IntHistogram).IntHistogram, + } + case *otlpmetrics.Metric_DoubleHistogram: + dest.Data = &otlpmetrics.Metric_DoubleHistogram{ + DoubleHistogram: src.Data.(*otlpmetrics.Metric_DoubleHistogram).DoubleHistogram, + } + } +} + // DeprecatedNewResource temporary public function. func DeprecatedNewResource(orig **otlpresource.Resource) Resource { return newResource(orig) diff --git a/consumer/pdata/metric_test.go b/consumer/pdata/metric_test.go index c2223f486a8..5d414ca1b00 100644 --- a/consumer/pdata/metric_test.go +++ b/consumer/pdata/metric_test.go @@ -25,6 +25,72 @@ import ( otlpmetrics "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/metrics/v1" ) +func TestCopyData(t *testing.T) { + tests := []struct { + name string + src *otlpmetrics.Metric + }{ + { + name: "IntGauge", + src: &otlpmetrics.Metric{ + Data: &otlpmetrics.Metric_IntGauge{ + IntGauge: &otlpmetrics.IntGauge{}, + }, + }, + }, + { + name: "DoubleGauge", + src: &otlpmetrics.Metric{ + Data: &otlpmetrics.Metric_DoubleGauge{ + DoubleGauge: &otlpmetrics.DoubleGauge{}, + }, + }, + }, + { + name: "IntSum", + src: &otlpmetrics.Metric{ + Data: &otlpmetrics.Metric_IntSum{ + IntSum: &otlpmetrics.IntSum{}, + }, + }, + }, + { + name: "DoubleSum", + src: &otlpmetrics.Metric{ + Data: &otlpmetrics.Metric_DoubleSum{ + DoubleSum: &otlpmetrics.DoubleSum{}, + }, + }, + }, + { + name: "IntHistogram", + src: &otlpmetrics.Metric{ + Data: &otlpmetrics.Metric_IntHistogram{ + IntHistogram: &otlpmetrics.IntHistogram{}, + }, + }, + }, + { + name: "DoubleHistogram", + src: &otlpmetrics.Metric{ + Data: &otlpmetrics.Metric_DoubleHistogram{ + DoubleHistogram: &otlpmetrics.DoubleHistogram{}, + }, + }, + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + dest := &otlpmetrics.Metric{} + assert.Nil(t, dest.Data) + assert.NotNil(t, test.src.Data) + copyData(test.src, dest) + assert.EqualValues(t, test.src, dest) + }) + } +} + func TestResourceMetricsWireCompatibility(t *testing.T) { // This test verifies that OTLP ProtoBufs generated using goproto lib in // opentelemetry-proto repository OTLP ProtoBufs generated using gogoproto lib in