Skip to content

Commit 9e240bc

Browse files
bogdandrutubogdandrutu
authored
Add Marshaler/Unmarshaler interfaces for Logs and Metrics (#3351)
Signed-off-by: Bogdan Drutu <bogdandrutu@gmail.com>
1 parent c6ca733 commit 9e240bc

File tree

5 files changed

+373
-17
lines changed

5 files changed

+373
-17
lines changed

‎internal/model/marshaler.go‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -50,3 +50,65 @@ func (t *tracesMarshaler) Marshal(td pdata.Traces) ([]byte, error) {
5050
}
5151
return buf, nil
5252
}
53+
54+
// MetricsMarshaler marshals pdata.Metrics into bytes.
55+
type MetricsMarshaler interface {
56+
Marshal(td pdata.Metrics) ([]byte, error)
57+
}
58+
59+
type metricsMarshaler struct {
60+
encoder MetricsEncoder
61+
translator FromMetricsTranslator
62+
}
63+
64+
// NewMetricsMarshaler returns a new MetricsMarshaler.
65+
func NewMetricsMarshaler(encoder MetricsEncoder, translator FromMetricsTranslator) MetricsMarshaler {
66+
return &metricsMarshaler{
67+
encoder: encoder,
68+
translator: translator,
69+
}
70+
}
71+
72+
// Marshal pdata.Metrics into bytes. On error []byte is nil.
73+
func (t *metricsMarshaler) Marshal(td pdata.Metrics) ([]byte, error) {
74+
model, err := t.translator.FromMetrics(td)
75+
if err != nil {
76+
return nil, fmt.Errorf("converting pdata to model failed: %w", err)
77+
}
78+
buf, err := t.encoder.EncodeMetrics(model)
79+
if err != nil {
80+
return nil, fmt.Errorf("marshal failed: %w", err)
81+
}
82+
return buf, nil
83+
}
84+
85+
// LogsMarshaler marshals pdata.Logs into bytes.
86+
type LogsMarshaler interface {
87+
Marshal(td pdata.Logs) ([]byte, error)
88+
}
89+
90+
type logsMarshaler struct {
91+
encoder LogsEncoder
92+
translator FromLogsTranslator
93+
}
94+
95+
// NewLogsMarshaler returns a new LogsMarshaler.
96+
func NewLogsMarshaler(encoder LogsEncoder, translator FromLogsTranslator) LogsMarshaler {
97+
return &logsMarshaler{
98+
encoder: encoder,
99+
translator: translator,
100+
}
101+
}
102+
103+
// Marshal pdata.Logs into bytes. On error []byte is nil.
104+
func (t *logsMarshaler) Marshal(td pdata.Logs) ([]byte, error) {
105+
model, err := t.translator.FromLogs(td)
106+
if err != nil {
107+
return nil, fmt.Errorf("converting pdata to model failed: %w", err)
108+
}
109+
buf, err := t.encoder.EncodeLogs(model)
110+
if err != nil {
111+
return nil, fmt.Errorf("marshal failed: %w", err)
112+
}
113+
return buf, nil
114+
}

‎internal/model/marshaler_test.go‎

Lines changed: 99 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -27,13 +27,12 @@ func TestTracesMarshal_TranslationError(t *testing.T) {
2727
translator := &mockTranslator{}
2828
encoder := &mockEncoder{}
2929

30-
d := NewTracesMarshaler(encoder, translator)
30+
tm := NewTracesMarshaler(encoder, translator)
3131
td := pdata.NewTraces()
3232

3333
translator.On("FromTraces", td).Return(nil, errors.New("translation failed"))
3434

35-
_, err := d.Marshal(td)
36-
35+
_, err := tm.Marshal(td)
3736
assert.Error(t, err)
3837
assert.EqualError(t, err, "converting pdata to model failed: translation failed")
3938
}
@@ -42,15 +41,14 @@ func TestTracesMarshal_SerializeError(t *testing.T) {
4241
translator := &mockTranslator{}
4342
encoder := &mockEncoder{}
4443

45-
d := NewTracesMarshaler(encoder, translator)
44+
tm := NewTracesMarshaler(encoder, translator)
4645
td := pdata.NewTraces()
4746
expectedModel := struct{}{}
4847

4948
translator.On("FromTraces", td).Return(expectedModel, nil)
5049
encoder.On("EncodeTraces", expectedModel).Return(nil, errors.New("serialization failed"))
5150

52-
_, err := d.Marshal(td)
53-
51+
_, err := tm.Marshal(td)
5452
assert.Error(t, err)
5553
assert.EqualError(t, err, "marshal failed: serialization failed")
5654
}
@@ -59,16 +57,109 @@ func TestTracesMarshal_Encode(t *testing.T) {
5957
translator := &mockTranslator{}
6058
encoder := &mockEncoder{}
6159

62-
d := NewTracesMarshaler(encoder, translator)
60+
tm := NewTracesMarshaler(encoder, translator)
6361
expectedTraces := pdata.NewTraces()
6462
expectedBytes := []byte{1, 2, 3}
6563
expectedModel := struct{}{}
6664

6765
translator.On("FromTraces", expectedTraces).Return(expectedModel, nil)
6866
encoder.On("EncodeTraces", expectedModel).Return(expectedBytes, nil)
6967

70-
actualBytes, err := d.Marshal(expectedTraces)
68+
actualBytes, err := tm.Marshal(expectedTraces)
69+
assert.NoError(t, err)
70+
assert.Equal(t, expectedBytes, actualBytes)
71+
}
72+
73+
func TestMetricsMarshal_TranslationError(t *testing.T) {
74+
translator := &mockTranslator{}
75+
encoder := &mockEncoder{}
76+
77+
mm := NewMetricsMarshaler(encoder, translator)
78+
md := pdata.NewMetrics()
79+
80+
translator.On("FromMetrics", md).Return(nil, errors.New("translation failed"))
81+
82+
_, err := mm.Marshal(md)
83+
assert.Error(t, err)
84+
assert.EqualError(t, err, "converting pdata to model failed: translation failed")
85+
}
86+
87+
func TestMetricsMarshal_SerializeError(t *testing.T) {
88+
translator := &mockTranslator{}
89+
encoder := &mockEncoder{}
90+
91+
mm := NewMetricsMarshaler(encoder, translator)
92+
md := pdata.NewMetrics()
93+
expectedModel := struct{}{}
94+
95+
translator.On("FromMetrics", md).Return(expectedModel, nil)
96+
encoder.On("EncodeMetrics", expectedModel).Return(nil, errors.New("serialization failed"))
97+
98+
_, err := mm.Marshal(md)
99+
assert.Error(t, err)
100+
assert.EqualError(t, err, "marshal failed: serialization failed")
101+
}
102+
103+
func TestMetricsMarshal_Encode(t *testing.T) {
104+
translator := &mockTranslator{}
105+
encoder := &mockEncoder{}
106+
107+
mm := NewMetricsMarshaler(encoder, translator)
108+
expectedMetrics := pdata.NewMetrics()
109+
expectedBytes := []byte{1, 2, 3}
110+
expectedModel := struct{}{}
111+
112+
translator.On("FromMetrics", expectedMetrics).Return(expectedModel, nil)
113+
encoder.On("EncodeMetrics", expectedModel).Return(expectedBytes, nil)
114+
115+
actualBytes, err := mm.Marshal(expectedMetrics)
116+
assert.NoError(t, err)
117+
assert.Equal(t, expectedBytes, actualBytes)
118+
}
119+
120+
func TestLogsMarshal_TranslationError(t *testing.T) {
121+
translator := &mockTranslator{}
122+
encoder := &mockEncoder{}
123+
124+
lm := NewLogsMarshaler(encoder, translator)
125+
ld := pdata.NewLogs()
126+
127+
translator.On("FromLogs", ld).Return(nil, errors.New("translation failed"))
128+
129+
_, err := lm.Marshal(ld)
130+
assert.Error(t, err)
131+
assert.EqualError(t, err, "converting pdata to model failed: translation failed")
132+
}
133+
134+
func TestLogsMarshal_SerializeError(t *testing.T) {
135+
translator := &mockTranslator{}
136+
encoder := &mockEncoder{}
137+
138+
lm := NewLogsMarshaler(encoder, translator)
139+
ld := pdata.NewLogs()
140+
expectedModel := struct{}{}
141+
142+
translator.On("FromLogs", ld).Return(expectedModel, nil)
143+
encoder.On("EncodeLogs", expectedModel).Return(nil, errors.New("serialization failed"))
144+
145+
_, err := lm.Marshal(ld)
146+
assert.Error(t, err)
147+
assert.EqualError(t, err, "marshal failed: serialization failed")
148+
}
149+
150+
func TestLogsMarshal_Encode(t *testing.T) {
151+
translator := &mockTranslator{}
152+
encoder := &mockEncoder{}
153+
154+
lm := NewLogsMarshaler(encoder, translator)
155+
expectedLogs := pdata.NewLogs()
156+
expectedBytes := []byte{1, 2, 3}
157+
expectedModel := struct{}{}
158+
159+
translator.On("FromLogs", expectedLogs).Return(expectedModel, nil)
160+
encoder.On("EncodeLogs", expectedModel).Return(expectedBytes, nil)
71161

162+
actualBytes, err := lm.Marshal(expectedLogs)
72163
assert.NoError(t, err)
73164
assert.Equal(t, expectedBytes, actualBytes)
74165
}

‎internal/model/mocks_test.go‎

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,34 @@ func (m *mockEncoder) DecodeTraces(bytes []byte) (interface{}, error) {
4343
return args.Get(0), args.Error(1)
4444
}
4545

46+
func (m *mockEncoder) EncodeMetrics(model interface{}) ([]byte, error) {
47+
args := m.Called(model)
48+
err := args.Error(1)
49+
if err != nil {
50+
return nil, err
51+
}
52+
return args.Get(0).([]byte), err
53+
}
54+
55+
func (m *mockEncoder) DecodeMetrics(bytes []byte) (interface{}, error) {
56+
args := m.Called(bytes)
57+
return args.Get(0), args.Error(1)
58+
}
59+
60+
func (m *mockEncoder) EncodeLogs(model interface{}) ([]byte, error) {
61+
args := m.Called(model)
62+
err := args.Error(1)
63+
if err != nil {
64+
return nil, err
65+
}
66+
return args.Get(0).([]byte), err
67+
}
68+
69+
func (m *mockEncoder) DecodeLogs(bytes []byte) (interface{}, error) {
70+
args := m.Called(bytes)
71+
return args.Get(0), args.Error(1)
72+
}
73+
4674
var (
4775
_ ToTracesTranslator = (*mockTranslator)(nil)
4876
_ FromTracesTranslator = (*mockTranslator)(nil)
@@ -61,3 +89,23 @@ func (m *mockTranslator) FromTraces(md pdata.Traces) (interface{}, error) {
6189
args := m.Called(md)
6290
return args.Get(0), args.Error(1)
6391
}
92+
93+
func (m *mockTranslator) ToMetrics(src interface{}) (pdata.Metrics, error) {
94+
args := m.Called(src)
95+
return args.Get(0).(pdata.Metrics), args.Error(1)
96+
}
97+
98+
func (m *mockTranslator) FromMetrics(md pdata.Metrics) (interface{}, error) {
99+
args := m.Called(md)
100+
return args.Get(0), args.Error(1)
101+
}
102+
103+
func (m *mockTranslator) ToLogs(src interface{}) (pdata.Logs, error) {
104+
args := m.Called(src)
105+
return args.Get(0).(pdata.Logs), args.Error(1)
106+
}
107+
108+
func (m *mockTranslator) FromLogs(md pdata.Logs) (interface{}, error) {
109+
args := m.Called(md)
110+
return args.Get(0), args.Error(1)
111+
}

‎internal/model/unmarshal.go‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -50,3 +50,65 @@ func (t *tracesUnmarshaler) Unmarshal(buf []byte) (pdata.Traces, error) {
5050
}
5151
return td, nil
5252
}
53+
54+
// MetricsUnmarshaler unmarshalls bytes into pdata.Metrics.
55+
type MetricsUnmarshaler interface {
56+
Unmarshal(buf []byte) (pdata.Metrics, error)
57+
}
58+
59+
type metricsUnmarshaler struct {
60+
encoder MetricsDecoder
61+
translator ToMetricsTranslator
62+
}
63+
64+
// NewMetricsUnmarshaler returns a new MetricsUnmarshaler.
65+
func NewMetricsUnmarshaler(encoder MetricsDecoder, translator ToMetricsTranslator) MetricsUnmarshaler {
66+
return &metricsUnmarshaler{
67+
encoder: encoder,
68+
translator: translator,
69+
}
70+
}
71+
72+
// Unmarshal bytes into pdata.Metrics. On error pdata.Metrics is invalid.
73+
func (t *metricsUnmarshaler) Unmarshal(buf []byte) (pdata.Metrics, error) {
74+
model, err := t.encoder.DecodeMetrics(buf)
75+
if err != nil {
76+
return pdata.Metrics{}, fmt.Errorf("unmarshal failed: %w", err)
77+
}
78+
td, err := t.translator.ToMetrics(model)
79+
if err != nil {
80+
return pdata.Metrics{}, fmt.Errorf("converting model to pdata failed: %w", err)
81+
}
82+
return td, nil
83+
}
84+
85+
// LogsUnmarshaler unmarshalls bytes into pdata.Logs.
86+
type LogsUnmarshaler interface {
87+
Unmarshal(buf []byte) (pdata.Logs, error)
88+
}
89+
90+
type logsUnmarshaler struct {
91+
encoder LogsDecoder
92+
translator ToLogsTranslator
93+
}
94+
95+
// NewLogsUnmarshaler returns a new LogsUnmarshaler.
96+
func NewLogsUnmarshaler(encoder LogsDecoder, translator ToLogsTranslator) LogsUnmarshaler {
97+
return &logsUnmarshaler{
98+
encoder: encoder,
99+
translator: translator,
100+
}
101+
}
102+
103+
// Unmarshal bytes into pdata.Logs. On error pdata.Logs is invalid.
104+
func (t *logsUnmarshaler) Unmarshal(buf []byte) (pdata.Logs, error) {
105+
model, err := t.encoder.DecodeLogs(buf)
106+
if err != nil {
107+
return pdata.Logs{}, fmt.Errorf("unmarshal failed: %w", err)
108+
}
109+
td, err := t.translator.ToLogs(model)
110+
if err != nil {
111+
return pdata.Logs{}, fmt.Errorf("converting model to pdata failed: %w", err)
112+
}
113+
return td, nil
114+
}

0 commit comments

Comments
 (0)