diff --git a/model/pdata/errors.go b/model/pdata/errors.go deleted file mode 100644 index 4ba7eaa8d72..00000000000 --- a/model/pdata/errors.go +++ /dev/null @@ -1,24 +0,0 @@ -// Copyright The OpenTelemetry 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 pdata - -import ( - "fmt" -) - -// NewErrIncompatibleType returns errIncompatibleType instance -func NewErrIncompatibleType(expected, given interface{}) error { - return fmt.Errorf("expected model type %T but given %T", expected, given) -} diff --git a/model/pdata/errors_test.go b/model/pdata/errors_test.go deleted file mode 100644 index d6a99aebef8..00000000000 --- a/model/pdata/errors_test.go +++ /dev/null @@ -1,27 +0,0 @@ -// Copyright The OpenTelemetry 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 pdata - -import ( - "testing" - - zipkinmodel "github.com/openzipkin/zipkin-go/model" - "github.com/stretchr/testify/assert" -) - -func TestNewErrIncompatibleType(t *testing.T) { - err := NewErrIncompatibleType([]*zipkinmodel.SpanModel{}, "given") - assert.EqualError(t, err, "expected model type []*model.SpanModel but given string") -} diff --git a/model/pdata/logs.go b/model/pdata/logs.go index 62e67f51c7a..35831d72631 100644 --- a/model/pdata/logs.go +++ b/model/pdata/logs.go @@ -15,41 +15,11 @@ package pdata import ( - "fmt" - "go.opentelemetry.io/collector/internal" otlpcollectorlog "go.opentelemetry.io/collector/internal/data/protogen/collector/logs/v1" otlplogs "go.opentelemetry.io/collector/internal/data/protogen/logs/v1" ) -// LogsDecoder is an interface to decode bytes into protocol-specific data model. -type LogsDecoder interface { - // DecodeLogs decodes bytes into protocol-specific data model. - // If the error is not nil, the returned interface cannot be used. - DecodeLogs(buf []byte) (interface{}, error) -} - -// LogsEncoder is an interface to encode protocol-specific data model into bytes. -type LogsEncoder interface { - // EncodeLogs encodes protocol-specific data model into bytes. - // If the error is not nil, the returned bytes slice cannot be used. - EncodeLogs(model interface{}) ([]byte, error) -} - -// FromLogsTranslator is an interface to translate pdata.Logs into protocol-specific data model. -type FromLogsTranslator interface { - // FromLogs translates pdata.Logs into protocol-specific data model. - // If the error is not nil, the returned pdata.Logs cannot be used. - FromLogs(ld Logs) (interface{}, error) -} - -// ToLogsTranslator is an interface to translate a protocol-specific data model into pdata.Traces. -type ToLogsTranslator interface { - // ToLogs translates a protocol-specific data model into pdata.Logs. - // If the error is not nil, the returned pdata.Logs cannot be used. - ToLogs(src interface{}) (Logs, error) -} - // LogsMarshaler marshals pdata.Logs into bytes. type LogsMarshaler interface { // MarshalLogs the given pdata.Logs into bytes. @@ -57,32 +27,6 @@ type LogsMarshaler interface { MarshalLogs(td Logs) ([]byte, error) } -type logsMarshaler struct { - encoder LogsEncoder - translator FromLogsTranslator -} - -// NewLogsMarshaler returns a new LogsMarshaler. -func NewLogsMarshaler(encoder LogsEncoder, translator FromLogsTranslator) LogsMarshaler { - return &logsMarshaler{ - encoder: encoder, - translator: translator, - } -} - -// MarshalLogs pdata.Logs into bytes. -func (t *logsMarshaler) MarshalLogs(td Logs) ([]byte, error) { - model, err := t.translator.FromLogs(td) - if err != nil { - return nil, fmt.Errorf("converting pdata to model failed: %w", err) - } - buf, err := t.encoder.EncodeLogs(model) - if err != nil { - return nil, fmt.Errorf("marshal failed: %w", err) - } - return buf, nil -} - // LogsUnmarshaler unmarshalls bytes into pdata.Logs. type LogsUnmarshaler interface { // UnmarshalLogs the given bytes into pdata.Logs. @@ -90,32 +34,6 @@ type LogsUnmarshaler interface { UnmarshalLogs(buf []byte) (Logs, error) } -type logsUnmarshaler struct { - decoder LogsDecoder - translator ToLogsTranslator -} - -// NewLogsUnmarshaler returns a new LogsUnmarshaler. -func NewLogsUnmarshaler(decoder LogsDecoder, translator ToLogsTranslator) LogsUnmarshaler { - return &logsUnmarshaler{ - decoder: decoder, - translator: translator, - } -} - -// UnmarshalLogs bytes into pdata.Logs. On error pdata.Logs is invalid. -func (t *logsUnmarshaler) UnmarshalLogs(buf []byte) (Logs, error) { - model, err := t.decoder.DecodeLogs(buf) - if err != nil { - return Logs{}, fmt.Errorf("unmarshal failed: %w", err) - } - td, err := t.translator.ToLogs(model) - if err != nil { - return Logs{}, fmt.Errorf("converting model to pdata failed: %w", err) - } - return td, nil -} - // Logs is the top-level struct that is propagated through the logs pipeline. // // This is a reference type (like builtin map). diff --git a/model/pdata/logs_test.go b/model/pdata/logs_test.go index 282043bf74e..4a79fcc26d6 100644 --- a/model/pdata/logs_test.go +++ b/model/pdata/logs_test.go @@ -15,7 +15,6 @@ package pdata import ( - "errors" "testing" "github.com/stretchr/testify/assert" @@ -26,101 +25,6 @@ import ( otlplogs "go.opentelemetry.io/collector/internal/data/protogen/logs/v1" ) -func TestLogsMarshal_TranslationError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - lm := NewLogsMarshaler(encoder, translator) - ld := NewLogs() - - translator.On("FromLogs", ld).Return(nil, errors.New("translation failed")) - - _, err := lm.MarshalLogs(ld) - assert.Error(t, err) - assert.EqualError(t, err, "converting pdata to model failed: translation failed") -} - -func TestLogsMarshal_SerializeError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - lm := NewLogsMarshaler(encoder, translator) - ld := NewLogs() - expectedModel := struct{}{} - - translator.On("FromLogs", ld).Return(expectedModel, nil) - encoder.On("EncodeLogs", expectedModel).Return(nil, errors.New("serialization failed")) - - _, err := lm.MarshalLogs(ld) - assert.Error(t, err) - assert.EqualError(t, err, "marshal failed: serialization failed") -} - -func TestLogsMarshal_Encode(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - lm := NewLogsMarshaler(encoder, translator) - expectedLogs := NewLogs() - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - translator.On("FromLogs", expectedLogs).Return(expectedModel, nil) - encoder.On("EncodeLogs", expectedModel).Return(expectedBytes, nil) - - actualBytes, err := lm.MarshalLogs(expectedLogs) - assert.NoError(t, err) - assert.Equal(t, expectedBytes, actualBytes) -} - -func TestLogsUnmarshal_EncodingError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - lu := NewLogsUnmarshaler(encoder, translator) - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - encoder.On("DecodeLogs", expectedBytes).Return(expectedModel, errors.New("decode failed")) - - _, err := lu.UnmarshalLogs(expectedBytes) - assert.Error(t, err) - assert.EqualError(t, err, "unmarshal failed: decode failed") -} - -func TestLogsUnmarshal_TranslationError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - lu := NewLogsUnmarshaler(encoder, translator) - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - encoder.On("DecodeLogs", expectedBytes).Return(expectedModel, nil) - translator.On("ToLogs", expectedModel).Return(NewLogs(), errors.New("translation failed")) - - _, err := lu.UnmarshalLogs(expectedBytes) - assert.Error(t, err) - assert.EqualError(t, err, "converting model to pdata failed: translation failed") -} - -func TestLogsUnmarshal_Decode(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - lu := NewLogsUnmarshaler(encoder, translator) - expectedLogs := NewLogs() - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - encoder.On("DecodeLogs", expectedBytes).Return(expectedModel, nil) - translator.On("ToLogs", expectedModel).Return(expectedLogs, nil) - - actualLogs, err := lu.UnmarshalLogs(expectedBytes) - assert.NoError(t, err) - assert.Equal(t, expectedLogs, actualLogs) -} - func TestLogRecordCount(t *testing.T) { md := NewLogs() assert.EqualValues(t, 0, md.LogRecordCount()) diff --git a/model/pdata/metrics.go b/model/pdata/metrics.go index 8cf05e7de11..971393a7d03 100644 --- a/model/pdata/metrics.go +++ b/model/pdata/metrics.go @@ -15,41 +15,11 @@ package pdata import ( - "fmt" - "go.opentelemetry.io/collector/internal" otlpcollectormetrics "go.opentelemetry.io/collector/internal/data/protogen/collector/metrics/v1" otlpmetrics "go.opentelemetry.io/collector/internal/data/protogen/metrics/v1" ) -// MetricsDecoder is an interface to decode bytes into protocol-specific data model. -type MetricsDecoder interface { - // DecodeMetrics decodes bytes into protocol-specific data model. - // If the error is not nil, the returned interface cannot be used. - DecodeMetrics(buf []byte) (interface{}, error) -} - -// MetricsEncoder is an interface to encode protocol-specific data model into bytes. -type MetricsEncoder interface { - // EncodeMetrics encodes protocol-specific data model into bytes. - // If the error is not nil, the returned bytes slice cannot be used. - EncodeMetrics(model interface{}) ([]byte, error) -} - -// FromMetricsTranslator is an interface to translate pdata.Metrics into protocol-specific data model. -type FromMetricsTranslator interface { - // FromMetrics translates pdata.Metrics into protocol-specific data model. - // If the error is not nil, the returned pdata.Metrics cannot be used. - FromMetrics(md Metrics) (interface{}, error) -} - -// ToMetricsTranslator is an interface to translate a protocol-specific data model into pdata.Traces. -type ToMetricsTranslator interface { - // ToMetrics translates a protocol-specific data model into pdata.Metrics. - // If the error is not nil, the returned pdata.Metrics cannot be used. - ToMetrics(src interface{}) (Metrics, error) -} - // MetricsMarshaler marshals pdata.Metrics into bytes. type MetricsMarshaler interface { // MarshalMetrics the given pdata.Metrics into bytes. @@ -57,32 +27,6 @@ type MetricsMarshaler interface { MarshalMetrics(td Metrics) ([]byte, error) } -type metricsMarshaler struct { - encoder MetricsEncoder - translator FromMetricsTranslator -} - -// NewMetricsMarshaler returns a new MetricsMarshaler. -func NewMetricsMarshaler(encoder MetricsEncoder, translator FromMetricsTranslator) MetricsMarshaler { - return &metricsMarshaler{ - encoder: encoder, - translator: translator, - } -} - -// MarshalMetrics pdata.Metrics into bytes. -func (t *metricsMarshaler) MarshalMetrics(td Metrics) ([]byte, error) { - model, err := t.translator.FromMetrics(td) - if err != nil { - return nil, fmt.Errorf("converting pdata to model failed: %w", err) - } - buf, err := t.encoder.EncodeMetrics(model) - if err != nil { - return nil, fmt.Errorf("marshal failed: %w", err) - } - return buf, nil -} - // MetricsUnmarshaler unmarshalls bytes into pdata.Metrics. type MetricsUnmarshaler interface { // UnmarshalMetrics the given bytes into pdata.Metrics. @@ -90,32 +34,6 @@ type MetricsUnmarshaler interface { UnmarshalMetrics(buf []byte) (Metrics, error) } -type metricsUnmarshaler struct { - decoder MetricsDecoder - translator ToMetricsTranslator -} - -// NewMetricsUnmarshaler returns a new MetricsUnmarshaler. -func NewMetricsUnmarshaler(decoder MetricsDecoder, translator ToMetricsTranslator) MetricsUnmarshaler { - return &metricsUnmarshaler{ - decoder: decoder, - translator: translator, - } -} - -// UnmarshalMetrics bytes into pdata.Metrics. On error pdata.Metrics is invalid. -func (t *metricsUnmarshaler) UnmarshalMetrics(buf []byte) (Metrics, error) { - model, err := t.decoder.DecodeMetrics(buf) - if err != nil { - return Metrics{}, fmt.Errorf("unmarshal failed: %w", err) - } - td, err := t.translator.ToMetrics(model) - if err != nil { - return Metrics{}, fmt.Errorf("converting model to pdata failed: %w", err) - } - return td, nil -} - // Metrics is an opaque interface that allows transition to the new internal Metrics data, but also facilitates the // transition to the new components, especially for traces. // diff --git a/model/pdata/metrics_test.go b/model/pdata/metrics_test.go index f903ade1fd8..477b0fbfa97 100644 --- a/model/pdata/metrics_test.go +++ b/model/pdata/metrics_test.go @@ -15,7 +15,6 @@ package pdata import ( - "errors" "testing" gogoproto "github.com/gogo/protobuf/proto" @@ -36,101 +35,6 @@ const ( endTime = uint64(12578940000000054321) ) -func TestMetricsMarshal_TranslationError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - mm := NewMetricsMarshaler(encoder, translator) - md := NewMetrics() - - translator.On("FromMetrics", md).Return(nil, errors.New("translation failed")) - - _, err := mm.MarshalMetrics(md) - assert.Error(t, err) - assert.EqualError(t, err, "converting pdata to model failed: translation failed") -} - -func TestMetricsMarshal_SerializeError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - mm := NewMetricsMarshaler(encoder, translator) - md := NewMetrics() - expectedModel := struct{}{} - - translator.On("FromMetrics", md).Return(expectedModel, nil) - encoder.On("EncodeMetrics", expectedModel).Return(nil, errors.New("serialization failed")) - - _, err := mm.MarshalMetrics(md) - assert.Error(t, err) - assert.EqualError(t, err, "marshal failed: serialization failed") -} - -func TestMetricsMarshal_Encode(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - mm := NewMetricsMarshaler(encoder, translator) - expectedMetrics := NewMetrics() - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - translator.On("FromMetrics", expectedMetrics).Return(expectedModel, nil) - encoder.On("EncodeMetrics", expectedModel).Return(expectedBytes, nil) - - actualBytes, err := mm.MarshalMetrics(expectedMetrics) - assert.NoError(t, err) - assert.Equal(t, expectedBytes, actualBytes) -} - -func TestMetricsUnmarshal_EncodingError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - mu := NewMetricsUnmarshaler(encoder, translator) - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - encoder.On("DecodeMetrics", expectedBytes).Return(expectedModel, errors.New("decode failed")) - - _, err := mu.UnmarshalMetrics(expectedBytes) - assert.Error(t, err) - assert.EqualError(t, err, "unmarshal failed: decode failed") -} - -func TestMetricsUnmarshal_TranslationError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - mu := NewMetricsUnmarshaler(encoder, translator) - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - encoder.On("DecodeMetrics", expectedBytes).Return(expectedModel, nil) - translator.On("ToMetrics", expectedModel).Return(NewMetrics(), errors.New("translation failed")) - - _, err := mu.UnmarshalMetrics(expectedBytes) - assert.Error(t, err) - assert.EqualError(t, err, "converting model to pdata failed: translation failed") -} - -func TestMetricsUnmarshal_Decode(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - mu := NewMetricsUnmarshaler(encoder, translator) - expectedMetrics := NewMetrics() - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - encoder.On("DecodeMetrics", expectedBytes).Return(expectedModel, nil) - translator.On("ToMetrics", expectedModel).Return(expectedMetrics, nil) - - actualMetrics, err := mu.UnmarshalMetrics(expectedBytes) - assert.NoError(t, err) - assert.Equal(t, expectedMetrics, actualMetrics) -} - func TestCopyData(t *testing.T) { tests := []struct { name string diff --git a/model/pdata/mocks_test.go b/model/pdata/mocks_test.go deleted file mode 100644 index 239e0848c16..00000000000 --- a/model/pdata/mocks_test.go +++ /dev/null @@ -1,109 +0,0 @@ -// Copyright The OpenTelemetry 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 pdata - -import ( - "github.com/stretchr/testify/mock" -) - -var ( - _ TracesEncoder = (*mockEncoder)(nil) - _ TracesDecoder = (*mockEncoder)(nil) -) - -type mockEncoder struct { - mock.Mock -} - -func (m *mockEncoder) EncodeTraces(model interface{}) ([]byte, error) { - args := m.Called(model) - err := args.Error(1) - if err != nil { - return nil, err - } - return args.Get(0).([]byte), err -} - -func (m *mockEncoder) DecodeTraces(bytes []byte) (interface{}, error) { - args := m.Called(bytes) - return args.Get(0), args.Error(1) -} - -func (m *mockEncoder) EncodeMetrics(model interface{}) ([]byte, error) { - args := m.Called(model) - err := args.Error(1) - if err != nil { - return nil, err - } - return args.Get(0).([]byte), err -} - -func (m *mockEncoder) DecodeMetrics(bytes []byte) (interface{}, error) { - args := m.Called(bytes) - return args.Get(0), args.Error(1) -} - -func (m *mockEncoder) EncodeLogs(model interface{}) ([]byte, error) { - args := m.Called(model) - err := args.Error(1) - if err != nil { - return nil, err - } - return args.Get(0).([]byte), err -} - -func (m *mockEncoder) DecodeLogs(bytes []byte) (interface{}, error) { - args := m.Called(bytes) - return args.Get(0), args.Error(1) -} - -var ( - _ ToTracesTranslator = (*mockTranslator)(nil) - _ FromTracesTranslator = (*mockTranslator)(nil) -) - -type mockTranslator struct { - mock.Mock -} - -func (m *mockTranslator) ToTraces(src interface{}) (Traces, error) { - args := m.Called(src) - return args.Get(0).(Traces), args.Error(1) -} - -func (m *mockTranslator) FromTraces(md Traces) (interface{}, error) { - args := m.Called(md) - return args.Get(0), args.Error(1) -} - -func (m *mockTranslator) ToMetrics(src interface{}) (Metrics, error) { - args := m.Called(src) - return args.Get(0).(Metrics), args.Error(1) -} - -func (m *mockTranslator) FromMetrics(md Metrics) (interface{}, error) { - args := m.Called(md) - return args.Get(0), args.Error(1) -} - -func (m *mockTranslator) ToLogs(src interface{}) (Logs, error) { - args := m.Called(src) - return args.Get(0).(Logs), args.Error(1) -} - -func (m *mockTranslator) FromLogs(md Logs) (interface{}, error) { - args := m.Called(md) - return args.Get(0), args.Error(1) -} diff --git a/model/pdata/traces.go b/model/pdata/traces.go index ff5e14331fd..06429b8c7be 100644 --- a/model/pdata/traces.go +++ b/model/pdata/traces.go @@ -15,41 +15,11 @@ package pdata import ( - "fmt" - "go.opentelemetry.io/collector/internal" otlpcollectortrace "go.opentelemetry.io/collector/internal/data/protogen/collector/trace/v1" otlptrace "go.opentelemetry.io/collector/internal/data/protogen/trace/v1" ) -// TracesDecoder is an interface to decode bytes into protocol-specific data model. -type TracesDecoder interface { - // DecodeTraces decodes bytes into protocol-specific data model. - // If the error is not nil, the returned interface cannot be used. - DecodeTraces(buf []byte) (interface{}, error) -} - -// TracesEncoder is an interface to encode protocol-specific data model into bytes. -type TracesEncoder interface { - // EncodeTraces encodes protocol-specific data model into bytes. - // If the error is not nil, the returned bytes slice cannot be used. - EncodeTraces(model interface{}) ([]byte, error) -} - -// FromTracesTranslator is an interface to translate pdata.Traces into protocol-specific data model. -type FromTracesTranslator interface { - // FromTraces translates pdata.Traces into protocol-specific data model. - // If the error is not nil, the returned pdata.Traces cannot be used. - FromTraces(td Traces) (interface{}, error) -} - -// ToTracesTranslator is an interface to translate a protocol-specific data model into pdata.Traces. -type ToTracesTranslator interface { - // ToTraces translates a protocol-specific data model into pdata.Traces. - // If the error is not nil, the returned pdata.Traces cannot be used. - ToTraces(src interface{}) (Traces, error) -} - // TracesMarshaler marshals pdata.Traces into bytes. type TracesMarshaler interface { // MarshalTraces the given pdata.Traces into bytes. @@ -57,32 +27,6 @@ type TracesMarshaler interface { MarshalTraces(td Traces) ([]byte, error) } -type tracesMarshaler struct { - encoder TracesEncoder - translator FromTracesTranslator -} - -// NewTracesMarshaler returns a new TracesMarshaler. -func NewTracesMarshaler(encoder TracesEncoder, translator FromTracesTranslator) TracesMarshaler { - return &tracesMarshaler{ - encoder: encoder, - translator: translator, - } -} - -// MarshalTraces pdata.Traces into bytes. -func (t *tracesMarshaler) MarshalTraces(td Traces) ([]byte, error) { - model, err := t.translator.FromTraces(td) - if err != nil { - return nil, fmt.Errorf("converting pdata to model failed: %w", err) - } - buf, err := t.encoder.EncodeTraces(model) - if err != nil { - return nil, fmt.Errorf("marshal failed: %w", err) - } - return buf, nil -} - // TracesUnmarshaler unmarshalls bytes into pdata.Traces. type TracesUnmarshaler interface { // UnmarshalTraces the given bytes into pdata.Traces. @@ -90,32 +34,6 @@ type TracesUnmarshaler interface { UnmarshalTraces(buf []byte) (Traces, error) } -type tracesUnmarshaler struct { - decoder TracesDecoder - translator ToTracesTranslator -} - -// NewTracesUnmarshaler returns a new TracesUnmarshaler. -func NewTracesUnmarshaler(decoder TracesDecoder, translator ToTracesTranslator) TracesUnmarshaler { - return &tracesUnmarshaler{ - decoder: decoder, - translator: translator, - } -} - -// UnmarshalTraces bytes into pdata.Traces. On error pdata.Traces is invalid. -func (t *tracesUnmarshaler) UnmarshalTraces(buf []byte) (Traces, error) { - model, err := t.decoder.DecodeTraces(buf) - if err != nil { - return Traces{}, fmt.Errorf("unmarshal failed: %w", err) - } - td, err := t.translator.ToTraces(model) - if err != nil { - return Traces{}, fmt.Errorf("converting model to pdata failed: %w", err) - } - return td, nil -} - // Traces is the top-level struct that is propagated through the traces pipeline. type Traces struct { orig *otlpcollectortrace.ExportTraceServiceRequest diff --git a/model/pdata/traces_test.go b/model/pdata/traces_test.go index 7d1921aaf4c..07edb15e2fc 100644 --- a/model/pdata/traces_test.go +++ b/model/pdata/traces_test.go @@ -15,7 +15,6 @@ package pdata import ( - "errors" "testing" gogoproto "github.com/gogo/protobuf/proto" @@ -29,101 +28,6 @@ import ( otlptrace "go.opentelemetry.io/collector/internal/data/protogen/trace/v1" ) -func TestTracesMarshal_TranslationError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - tm := NewTracesMarshaler(encoder, translator) - td := NewTraces() - - translator.On("FromTraces", td).Return(nil, errors.New("translation failed")) - - _, err := tm.MarshalTraces(td) - assert.Error(t, err) - assert.EqualError(t, err, "converting pdata to model failed: translation failed") -} - -func TestTracesMarshal_SerializeError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - tm := NewTracesMarshaler(encoder, translator) - td := NewTraces() - expectedModel := struct{}{} - - translator.On("FromTraces", td).Return(expectedModel, nil) - encoder.On("EncodeTraces", expectedModel).Return(nil, errors.New("serialization failed")) - - _, err := tm.MarshalTraces(td) - assert.Error(t, err) - assert.EqualError(t, err, "marshal failed: serialization failed") -} - -func TestTracesMarshal_Encode(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - tm := NewTracesMarshaler(encoder, translator) - expectedTraces := NewTraces() - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - translator.On("FromTraces", expectedTraces).Return(expectedModel, nil) - encoder.On("EncodeTraces", expectedModel).Return(expectedBytes, nil) - - actualBytes, err := tm.MarshalTraces(expectedTraces) - assert.NoError(t, err) - assert.Equal(t, expectedBytes, actualBytes) -} - -func TestTracesUnmarshal_EncodingError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - tu := NewTracesUnmarshaler(encoder, translator) - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - encoder.On("DecodeTraces", expectedBytes).Return(expectedModel, errors.New("decode failed")) - - _, err := tu.UnmarshalTraces(expectedBytes) - assert.Error(t, err) - assert.EqualError(t, err, "unmarshal failed: decode failed") -} - -func TestTracesUnmarshal_TranslationError(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - tu := NewTracesUnmarshaler(encoder, translator) - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - encoder.On("DecodeTraces", expectedBytes).Return(expectedModel, nil) - translator.On("ToTraces", expectedModel).Return(NewTraces(), errors.New("translation failed")) - - _, err := tu.UnmarshalTraces(expectedBytes) - assert.Error(t, err) - assert.EqualError(t, err, "converting model to pdata failed: translation failed") -} - -func TestTracesUnmarshal_Decode(t *testing.T) { - translator := &mockTranslator{} - encoder := &mockEncoder{} - - tu := NewTracesUnmarshaler(encoder, translator) - expectedTraces := NewTraces() - expectedBytes := []byte{1, 2, 3} - expectedModel := struct{}{} - - encoder.On("DecodeTraces", expectedBytes).Return(expectedModel, nil) - translator.On("ToTraces", expectedModel).Return(expectedTraces, nil) - - actualTraces, err := tu.UnmarshalTraces(expectedBytes) - assert.NoError(t, err) - assert.Equal(t, expectedTraces, actualTraces) -} - func TestSpanCount(t *testing.T) { md := NewTraces() assert.EqualValues(t, 0, md.SpanCount())