Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Remove unnecessary interfaces from pdata #3506

Merged
merged 1 commit into from
Jun 28, 2021
Merged

Remove unnecessary interfaces from pdata #3506

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
24 changes: 0 additions & 24 deletions model/pdata/errors.go
View file
Open in desktop

This file was deleted.

27 changes: 0 additions & 27 deletions model/pdata/errors_test.go
View file
Open in desktop

This file was deleted.

82 changes: 0 additions & 82 deletions model/pdata/logs.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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).
Expand Down
96 changes: 0 additions & 96 deletions model/pdata/logs_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,6 @@
package pdata

import (
"errors"
"testing"

"github.com/stretchr/testify/assert"
Expand All @@ -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())
Expand Down
82 changes: 0 additions & 82 deletions model/pdata/metrics.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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.
//
Expand Down
Loading