Remove unnecessary interfaces from pdata

Based on the current experience, they are not necessary.

Signed-off-by: Bogdan Drutu <[email protected]>

Author: bogdandrutu

model/pdata/logs.go

@@ -15,107 +15,25 @@
 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.
 	// If the error is not nil, the returned bytes slice cannot be used.
 	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.
 	// If the error is not nil, the returned pdata.Logs cannot be used.
 	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).

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())

model/pdata/metrics.go

@@ -15,107 +15,25 @@
 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.
 	// If the error is not nil, the returned bytes slice cannot be used.
 	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.
 	// If the error is not nil, the returned pdata.Metrics cannot be used.
 	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.
 //