Change Marshaler/Unmarshaler to be consistent with other interfaces

exporter/fileexporter/file_exporter.go

@@ -44,23 +44,23 @@ func (e *fileExporter) Capabilities() consumer.Capabilities {
 }
 
 func (e *fileExporter) ConsumeTraces(_ context.Context, td pdata.Traces) error {
-	buf, err := tracesMarshaler.Marshal(td)
+	buf, err := tracesMarshaler.MarshalTraces(td)
 	if err != nil {
 		return err
 	}
 	return exportMessageAsLine(e, buf)
 }
 
 func (e *fileExporter) ConsumeMetrics(_ context.Context, md pdata.Metrics) error {
-	buf, err := metricsMarshaler.Marshal(md)
+	buf, err := metricsMarshaler.MarshalMetrics(md)
 	if err != nil {
 		return err
 	}
 	return exportMessageAsLine(e, buf)
 }
 
 func (e *fileExporter) ConsumeLogs(_ context.Context, ld pdata.Logs) error {
-	buf, err := logsMarshaler.Marshal(ld)
+	buf, err := logsMarshaler.MarshalLogs(ld)
 	if err != nil {
 		return err
 	}

exporter/fileexporter/file_exporter_test.go

@@ -40,7 +40,7 @@ func TestFileTracesExporter(t *testing.T) {
 	unmarshaler := otlp.NewJSONTracesUnmarshaler()
 	buf, err := ioutil.ReadFile(fe.path)
 	assert.NoError(t, err)
-	got, err := unmarshaler.Unmarshal(buf)
+	got, err := unmarshaler.UnmarshalTraces(buf)
 	assert.NoError(t, err)
 	assert.EqualValues(t, td, got)
 }
@@ -68,7 +68,7 @@ func TestFileMetricsExporter(t *testing.T) {
 	unmarshaler := otlp.NewJSONMetricsUnmarshaler()
 	buf, err := ioutil.ReadFile(fe.path)
 	assert.NoError(t, err)
-	got, err := unmarshaler.Unmarshal(buf)
+	got, err := unmarshaler.UnmarshalMetrics(buf)
 	assert.NoError(t, err)
 	assert.EqualValues(t, md, got)
 }
@@ -96,7 +96,7 @@ func TestFileLogsExporter(t *testing.T) {
 	unmarshaler := otlp.NewJSONLogsUnmarshaler()
 	buf, err := ioutil.ReadFile(fe.path)
 	assert.NoError(t, err)
-	got, err := unmarshaler.Unmarshal(buf)
+	got, err := unmarshaler.UnmarshalLogs(buf)
 	assert.NoError(t, err)
 	assert.EqualValues(t, ld, got)
 }

exporter/kafkaexporter/pdata_marshaler.go

@@ -26,7 +26,7 @@ type pdataLogsMarshaler struct {
 }
 
 func (p pdataLogsMarshaler) Marshal(ld pdata.Logs, topic string) ([]*sarama.ProducerMessage, error) {
-	bts, err := p.marshaler.Marshal(ld)
+	bts, err := p.marshaler.MarshalLogs(ld)
 	if err != nil {
 		return nil, err
 	}
@@ -55,7 +55,7 @@ type pdataMetricsMarshaler struct {
 }
 
 func (p pdataMetricsMarshaler) Marshal(ld pdata.Metrics, topic string) ([]*sarama.ProducerMessage, error) {
-	bts, err := p.marshaler.Marshal(ld)
+	bts, err := p.marshaler.MarshalMetrics(ld)
 	if err != nil {
 		return nil, err
 	}
@@ -84,7 +84,7 @@ type pdataTracesMarshaler struct {
 }
 
 func (p pdataTracesMarshaler) Marshal(td pdata.Traces, topic string) ([]*sarama.ProducerMessage, error) {
-	bts, err := p.marshaler.Marshal(td)
+	bts, err := p.marshaler.MarshalTraces(td)
 	if err != nil {
 		return nil, err
 	}

exporter/loggingexporter/logging_exporter.go

@@ -44,7 +44,7 @@ func (s *loggingExporter) pushTraces(_ context.Context, td pdata.Traces) error {
 		return nil
 	}
 
-	buf, err := s.tracesMarshaler.Marshal(td)
+	buf, err := s.tracesMarshaler.MarshalTraces(td)
 	if err != nil {
 		return err
 	}
@@ -59,7 +59,7 @@ func (s *loggingExporter) pushMetrics(_ context.Context, md pdata.Metrics) error
 		return nil
 	}
 
-	buf, err := s.metricsMarshaler.Marshal(md)
+	buf, err := s.metricsMarshaler.MarshalMetrics(md)
 	if err != nil {
 		return err
 	}
@@ -74,7 +74,7 @@ func (s *loggingExporter) pushLogs(_ context.Context, ld pdata.Logs) error {
 		return nil
 	}
 
-	buf, err := s.logsMarshaler.Marshal(ld)
+	buf, err := s.logsMarshaler.MarshalLogs(ld)
 	if err != nil {
 		return err
 	}

exporter/loggingexporter/logging_exporter_test.go

@@ -69,34 +69,26 @@ func TestLoggingExporterErrors(t *testing.T) {
 	require.NotNil(t, le)
 
 	errWant := errors.New("my error")
-	le.tracesMarshaler = &errTracesMarshaler{err: errWant}
-	le.metricsMarshaler = &errMetricsMarshaler{err: errWant}
-	le.logsMarshaler = &errLogsMarshaler{err: errWant}
+	le.tracesMarshaler = &errMarshaler{err: errWant}
+	le.metricsMarshaler = &errMarshaler{err: errWant}
+	le.logsMarshaler = &errMarshaler{err: errWant}
 	assert.Equal(t, errWant, le.pushTraces(context.Background(), pdata.NewTraces()))
 	assert.Equal(t, errWant, le.pushMetrics(context.Background(), pdata.NewMetrics()))
 	assert.Equal(t, errWant, le.pushLogs(context.Background(), pdata.NewLogs()))
 }
 
-type errLogsMarshaler struct {
+type errMarshaler struct {
 	err error
 }
 
-func (e errLogsMarshaler) Marshal(pdata.Logs) ([]byte, error) {
+func (e errMarshaler) MarshalLogs(pdata.Logs) ([]byte, error) {
 	return nil, e.err
 }
 
-type errMetricsMarshaler struct {
-	err error
-}
-
-func (e errMetricsMarshaler) Marshal(pdata.Metrics) ([]byte, error) {
+func (e errMarshaler) MarshalMetrics(pdata.Metrics) ([]byte, error) {
 	return nil, e.err
 }
 
-type errTracesMarshaler struct {
-	err error
-}
-
-func (e errTracesMarshaler) Marshal(pdata.Traces) ([]byte, error) {
+func (e errMarshaler) MarshalTraces(pdata.Traces) ([]byte, error) {
 	return nil, e.err
 }

exporter/otlphttpexporter/otlp.go

@@ -100,7 +100,7 @@ func (e *exporter) start(_ context.Context, host component.Host) error {
 }
 
 func (e *exporter) pushTraces(ctx context.Context, td pdata.Traces) error {
-	request, err := tracesMarshaler.Marshal(td)
+	request, err := tracesMarshaler.MarshalTraces(td)
 	if err != nil {
 		return consumererror.Permanent(err)
 	}
@@ -109,15 +109,15 @@ func (e *exporter) pushTraces(ctx context.Context, td pdata.Traces) error {
 }
 
 func (e *exporter) pushMetrics(ctx context.Context, md pdata.Metrics) error {
-	request, err := metricsMarshaler.Marshal(md)
+	request, err := metricsMarshaler.MarshalMetrics(md)
 	if err != nil {
 		return consumererror.Permanent(err)
 	}
 	return e.export(ctx, e.metricsURL, request)
 }
 
 func (e *exporter) pushLogs(ctx context.Context, ld pdata.Logs) error {
-	request, err := logsMarshaler.Marshal(ld)
+	request, err := logsMarshaler.MarshalLogs(ld)
 	if err != nil {
 		return consumererror.Permanent(err)
 	}

internal/otlp/pb_test.go

@@ -22,18 +22,18 @@ import (
 
 func TestProtobufLogsUnmarshaler_error(t *testing.T) {
 	p := NewProtobufLogsUnmarshaler()
-	_, err := p.Unmarshal([]byte("+$%"))
+	_, err := p.UnmarshalLogs([]byte("+$%"))
 	assert.Error(t, err)
 }
 
 func TestProtobufMetricsUnmarshaler_error(t *testing.T) {
 	p := NewProtobufMetricsUnmarshaler()
-	_, err := p.Unmarshal([]byte("+$%"))
+	_, err := p.UnmarshalMetrics([]byte("+$%"))
 	assert.Error(t, err)
 }
 
 func TestProtobufTracesUnmarshaler_error(t *testing.T) {
 	p := NewProtobufTracesUnmarshaler()
-	_, err := p.Unmarshal([]byte("+$%"))
+	_, err := p.UnmarshalTraces([]byte("+$%"))
 	assert.Error(t, err)
 }

internal/otlptext/logs.go

@@ -25,8 +25,8 @@ func NewTextLogsMarshaler() pdata.LogsMarshaler {
 
 type logsMarshaler struct{}
 
-// Marshal data to text.
-func (logsMarshaler) Marshal(ld pdata.Logs) ([]byte, error) {
+// MarshalLogs pdata.Logs to OTLP text.
+func (logsMarshaler) MarshalLogs(ld pdata.Logs) ([]byte, error) {
 	buf := dataBuffer{}
 	rls := ld.ResourceLogs()
 	for i := 0; i < rls.Len(); i++ {

internal/otlptext/logs_test.go

@@ -39,7 +39,7 @@ func TestLogs(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			logs, err := NewTextLogsMarshaler().Marshal(tt.args.ld)
+			logs, err := NewTextLogsMarshaler().MarshalLogs(tt.args.ld)
 			assert.NoError(t, err)
 			if !tt.empty {
 				assert.NotEmpty(t, logs)

internal/otlptext/metrics.go

@@ -25,8 +25,8 @@ func NewTextMetricsMarshaler() pdata.MetricsMarshaler {
 
 type metricsMarshaler struct{}
 
-// Marshal data to text.
-func (metricsMarshaler) Marshal(md pdata.Metrics) ([]byte, error) {
+// MarshalMetrics pdata.Metrics to OTLP text.
+func (metricsMarshaler) MarshalMetrics(md pdata.Metrics) ([]byte, error) {
 	buf := dataBuffer{}
 	rms := md.ResourceMetrics()
 	for i := 0; i < rms.Len(); i++ {

internal/otlptext/metrics_test.go

@@ -39,7 +39,7 @@ func TestMetrics(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			metrics, err := NewTextMetricsMarshaler().Marshal(tt.args.md)
+			metrics, err := NewTextMetricsMarshaler().MarshalMetrics(tt.args.md)
 			assert.NoError(t, err)
 			if !tt.empty {
 				assert.NotEmpty(t, metrics)

internal/otlptext/traces.go

@@ -25,8 +25,8 @@ func NewTextTracesMarshaler() pdata.TracesMarshaler {
 
 type tracesMarshaler struct{}
 
-// Marshal data to text.
-func (tracesMarshaler) Marshal(td pdata.Traces) ([]byte, error) {
+// MarshalTraces pdata.Traces to OTLP text.
+func (tracesMarshaler) MarshalTraces(td pdata.Traces) ([]byte, error) {
 	buf := dataBuffer{}
 	rss := td.ResourceSpans()
 	for i := 0; i < rss.Len(); i++ {

internal/otlptext/traces_test.go

@@ -37,7 +37,7 @@ func TestTraces(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			traces, err := NewTextTracesMarshaler().Marshal(tt.args.td)
+			traces, err := NewTextTracesMarshaler().MarshalTraces(tt.args.td)
 			assert.NoError(t, err)
 			if !tt.empty {
 				assert.NotEmpty(t, traces)

model/pdata/logs.go

@@ -52,9 +52,9 @@ type ToLogsTranslator interface {
 
 // LogsMarshaler marshals pdata.Logs into bytes.
 type LogsMarshaler interface {
-	// Marshal the given pdata.Logs into bytes.
+	// MarshalLogs the given pdata.Logs into bytes.
 	// If the error is not nil, the returned bytes slice cannot be used.
-	Marshal(td Logs) ([]byte, error)
+	MarshalLogs(td Logs) ([]byte, error)
 }
 
 type logsMarshaler struct {
@@ -70,8 +70,8 @@ func NewLogsMarshaler(encoder LogsEncoder, translator FromLogsTranslator) LogsMa
 	}
 }
 
-// Marshal pdata.Logs into bytes.
-func (t *logsMarshaler) Marshal(td Logs) ([]byte, error) {
+// 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)
@@ -85,9 +85,9 @@ func (t *logsMarshaler) Marshal(td Logs) ([]byte, error) {
 
 // LogsUnmarshaler unmarshalls bytes into pdata.Logs.
 type LogsUnmarshaler interface {
-	// Unmarshal the given bytes into pdata.Logs.
+	// UnmarshalLogs the given bytes into pdata.Logs.
 	// If the error is not nil, the returned pdata.Logs cannot be used.
-	Unmarshal(buf []byte) (Logs, error)
+	UnmarshalLogs(buf []byte) (Logs, error)
 }
 
 type logsUnmarshaler struct {
@@ -103,8 +103,8 @@ func NewLogsUnmarshaler(decoder LogsDecoder, translator ToLogsTranslator) LogsUn
 	}
 }
 
-// Unmarshal bytes into pdata.Logs. On error pdata.Logs is invalid.
-func (t *logsUnmarshaler) Unmarshal(buf []byte) (Logs, error) {
+// 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)

model/pdata/logs_test.go

@@ -35,7 +35,7 @@ func TestLogsMarshal_TranslationError(t *testing.T) {
 
 	translator.On("FromLogs", ld).Return(nil, errors.New("translation failed"))
 
-	_, err := lm.Marshal(ld)
+	_, err := lm.MarshalLogs(ld)
 	assert.Error(t, err)
 	assert.EqualError(t, err, "converting pdata to model failed: translation failed")
 }
@@ -51,7 +51,7 @@ func TestLogsMarshal_SerializeError(t *testing.T) {
 	translator.On("FromLogs", ld).Return(expectedModel, nil)
 	encoder.On("EncodeLogs", expectedModel).Return(nil, errors.New("serialization failed"))
 
-	_, err := lm.Marshal(ld)
+	_, err := lm.MarshalLogs(ld)
 	assert.Error(t, err)
 	assert.EqualError(t, err, "marshal failed: serialization failed")
 }
@@ -68,7 +68,7 @@ func TestLogsMarshal_Encode(t *testing.T) {
 	translator.On("FromLogs", expectedLogs).Return(expectedModel, nil)
 	encoder.On("EncodeLogs", expectedModel).Return(expectedBytes, nil)
 
-	actualBytes, err := lm.Marshal(expectedLogs)
+	actualBytes, err := lm.MarshalLogs(expectedLogs)
 	assert.NoError(t, err)
 	assert.Equal(t, expectedBytes, actualBytes)
 }
@@ -83,7 +83,7 @@ func TestLogsUnmarshal_EncodingError(t *testing.T) {
 
 	encoder.On("DecodeLogs", expectedBytes).Return(expectedModel, errors.New("decode failed"))
 
-	_, err := lu.Unmarshal(expectedBytes)
+	_, err := lu.UnmarshalLogs(expectedBytes)
 	assert.Error(t, err)
 	assert.EqualError(t, err, "unmarshal failed: decode failed")
 }
@@ -99,7 +99,7 @@ func TestLogsUnmarshal_TranslationError(t *testing.T) {
 	encoder.On("DecodeLogs", expectedBytes).Return(expectedModel, nil)
 	translator.On("ToLogs", expectedModel).Return(NewLogs(), errors.New("translation failed"))
 
-	_, err := lu.Unmarshal(expectedBytes)
+	_, err := lu.UnmarshalLogs(expectedBytes)
 	assert.Error(t, err)
 	assert.EqualError(t, err, "converting model to pdata failed: translation failed")
 }
@@ -116,7 +116,7 @@ func TestLogsUnmarshal_Decode(t *testing.T) {
 	encoder.On("DecodeLogs", expectedBytes).Return(expectedModel, nil)
 	translator.On("ToLogs", expectedModel).Return(expectedLogs, nil)
 
-	actualLogs, err := lu.Unmarshal(expectedBytes)
+	actualLogs, err := lu.UnmarshalLogs(expectedBytes)
 	assert.NoError(t, err)
 	assert.Equal(t, expectedLogs, actualLogs)
 }