From b59c1ab3b8730ff3490a5c24cddc070ca7b57669 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Tue, 29 Mar 2022 09:05:11 -0700 Subject: [PATCH] Adopt usage of split pdata in core --- client/doc_test.go | 4 +- component/componenttest/nop_exporter_test.go | 28 +++---- component/componenttest/nop_processor_test.go | 34 ++++---- component/receiver.go | 6 +- .../configgrpc/configgrpc_benchmark_test.go | 16 ++-- consumer/consumererror/signalerrors.go | 22 +++--- consumer/consumertest/consumer.go | 10 ++- consumer/consumertest/err.go | 10 ++- consumer/consumertest/err_test.go | 10 ++- consumer/consumertest/nop.go | 10 ++- consumer/consumertest/nop_test.go | 10 ++- consumer/consumertest/sink.go | 28 +++---- consumer/consumertest/sink_test.go | 10 ++- consumer/logs.go | 12 +-- consumer/logs_test.go | 18 ++--- consumer/metrics.go | 12 +-- consumer/metrics_test.go | 18 ++--- consumer/traces.go | 12 +-- consumer/traces_test.go | 18 ++--- exporter/exporterhelper/common_test.go | 4 +- .../internal/persistent_queue_test.go | 5 +- .../internal/persistent_storage_test.go | 6 +- exporter/exporterhelper/logs.go | 8 +- exporter/exporterhelper/logs_test.go | 12 +-- exporter/exporterhelper/metrics.go | 8 +- exporter/exporterhelper/metrics_test.go | 12 +-- exporter/exporterhelper/queued_retry_test.go | 4 +- exporter/exporterhelper/traces.go | 8 +- exporter/exporterhelper/traces_test.go | 14 ++-- exporter/loggingexporter/logging_exporter.go | 16 ++-- .../loggingexporter/logging_exporter_test.go | 22 +++--- exporter/otlpexporter/otlp.go | 10 ++- exporter/otlpexporter/otlp_test.go | 26 ++++--- exporter/otlphttpexporter/otlp.go | 10 ++- exporter/otlphttpexporter/otlp_test.go | 13 ++-- go.sum | 1 + .../err_or_sink_consumer.go | 7 +- internal/otlptext/databuffer.go | 29 +++---- internal/otlptext/logs.go | 8 +- internal/otlptext/logs_test.go | 6 +- internal/otlptext/metrics.go | 8 +- internal/otlptext/metrics_test.go | 6 +- internal/otlptext/traces.go | 8 +- internal/otlptext/traces_test.go | 6 +- internal/testcomponents/example_exporter.go | 20 ++--- .../testcomponents/example_exporter_test.go | 7 +- internal/testdata/log.go | 43 ++++++----- internal/testdata/metric.go | 77 ++++++++++--------- internal/testdata/trace.go | 25 +++--- model/internal/pdata/logs.go | 10 +-- model/internal/pdata/traces.go | 10 +-- model/otlp/json_marshaler.go | 16 ++-- model/otlp/json_test.go | 11 ++- model/otlp/json_unmarshaler.go | 15 ++-- model/otlp/pb_marshaler.go | 27 ++++--- model/otlp/pb_test.go | 9 ++- model/otlp/pb_unmarshaler.go | 9 ++- model/otlpgrpc/logs.go | 8 +- model/otlpgrpc/metrics.go | 8 +- model/otlpgrpc/traces.go | 8 +- processor/batchprocessor/batch_processor.go | 46 +++++------ .../batchprocessor/batch_processor_test.go | 42 +++++----- processor/batchprocessor/splitlogs.go | 16 ++-- processor/batchprocessor/splitlogs_test.go | 26 +++---- processor/batchprocessor/splitmetrics.go | 62 +++++++-------- processor/batchprocessor/splitmetrics_test.go | 70 ++++++++--------- processor/batchprocessor/splittraces.go | 16 ++-- processor/batchprocessor/splittraces_test.go | 12 +-- .../memorylimiterprocessor/memorylimiter.go | 10 ++- .../memorylimiter_test.go | 10 ++- processor/processorhelper/logs.go | 6 +- processor/processorhelper/logs_test.go | 10 +-- processor/processorhelper/metrics.go | 6 +- processor/processorhelper/metrics_test.go | 10 +-- processor/processorhelper/traces.go | 6 +- processor/processorhelper/traces_test.go | 10 +-- receiver/otlpreceiver/otlp_test.go | 21 ++--- receiver/scraperhelper/scraper.go | 8 +- receiver/scraperhelper/scrapercontroller.go | 4 +- .../scraperhelper/scrapercontroller_test.go | 10 +-- .../builder/pipelines_builder_test.go | 4 +- .../builder/receivers_builder_test.go | 4 +- service/internal/fanoutconsumer/logs.go | 6 +- service/internal/fanoutconsumer/metrics.go | 6 +- service/internal/fanoutconsumer/traces.go | 6 +- 85 files changed, 673 insertions(+), 602 deletions(-) diff --git a/client/doc_test.go b/client/doc_test.go index ee8f0bf97d1..d1d5dd66052 100644 --- a/client/doc_test.go +++ b/client/doc_test.go @@ -21,7 +21,7 @@ import ( "go.opentelemetry.io/collector/client" "go.opentelemetry.io/collector/consumer" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) func Example_receiver() { @@ -29,7 +29,7 @@ func Example_receiver() { var next consumer.Traces // You'll convert the incoming data into pipeline data - td := pdata.NewTraces() + td := traces.New() // You probably have a context with client metadata from your listener or // scraper diff --git a/component/componenttest/nop_exporter_test.go b/component/componenttest/nop_exporter_test.go index d1182ff2af4..f5ee2599aed 100644 --- a/component/componenttest/nop_exporter_test.go +++ b/component/componenttest/nop_exporter_test.go @@ -22,7 +22,9 @@ import ( "github.com/stretchr/testify/require" "go.opentelemetry.io/collector/config" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestNewNopExporterFactory(t *testing.T) { @@ -32,21 +34,21 @@ func TestNewNopExporterFactory(t *testing.T) { cfg := factory.CreateDefaultConfig() assert.Equal(t, &nopExporterConfig{ExporterSettings: config.NewExporterSettings(config.NewComponentID("nop"))}, cfg) - traces, err := factory.CreateTracesExporter(context.Background(), NewNopExporterCreateSettings(), cfg) + te, err := factory.CreateTracesExporter(context.Background(), NewNopExporterCreateSettings(), cfg) require.NoError(t, err) - assert.NoError(t, traces.Start(context.Background(), NewNopHost())) - assert.NoError(t, traces.ConsumeTraces(context.Background(), pdata.NewTraces())) - assert.NoError(t, traces.Shutdown(context.Background())) + assert.NoError(t, te.Start(context.Background(), NewNopHost())) + assert.NoError(t, te.ConsumeTraces(context.Background(), traces.New())) + assert.NoError(t, te.Shutdown(context.Background())) - metrics, err := factory.CreateMetricsExporter(context.Background(), NewNopExporterCreateSettings(), cfg) + me, err := factory.CreateMetricsExporter(context.Background(), NewNopExporterCreateSettings(), cfg) require.NoError(t, err) - assert.NoError(t, metrics.Start(context.Background(), NewNopHost())) - assert.NoError(t, metrics.ConsumeMetrics(context.Background(), pdata.NewMetrics())) - assert.NoError(t, metrics.Shutdown(context.Background())) + assert.NoError(t, me.Start(context.Background(), NewNopHost())) + assert.NoError(t, me.ConsumeMetrics(context.Background(), metrics.New())) + assert.NoError(t, me.Shutdown(context.Background())) - logs, err := factory.CreateLogsExporter(context.Background(), NewNopExporterCreateSettings(), cfg) + le, err := factory.CreateLogsExporter(context.Background(), NewNopExporterCreateSettings(), cfg) require.NoError(t, err) - assert.NoError(t, logs.Start(context.Background(), NewNopHost())) - assert.NoError(t, logs.ConsumeLogs(context.Background(), pdata.NewLogs())) - assert.NoError(t, logs.Shutdown(context.Background())) + assert.NoError(t, le.Start(context.Background(), NewNopHost())) + assert.NoError(t, le.ConsumeLogs(context.Background(), logs.New())) + assert.NoError(t, le.Shutdown(context.Background())) } diff --git a/component/componenttest/nop_processor_test.go b/component/componenttest/nop_processor_test.go index b82b1c344e2..3ec3e1d85b5 100644 --- a/component/componenttest/nop_processor_test.go +++ b/component/componenttest/nop_processor_test.go @@ -24,7 +24,9 @@ import ( "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/consumer" "go.opentelemetry.io/collector/consumer/consumertest" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestNewNopProcessorFactory(t *testing.T) { @@ -34,24 +36,24 @@ func TestNewNopProcessorFactory(t *testing.T) { cfg := factory.CreateDefaultConfig() assert.Equal(t, &nopProcessorConfig{ProcessorSettings: config.NewProcessorSettings(config.NewComponentID("nop"))}, cfg) - traces, err := factory.CreateTracesProcessor(context.Background(), NewNopProcessorCreateSettings(), cfg, consumertest.NewNop()) + tp, err := factory.CreateTracesProcessor(context.Background(), NewNopProcessorCreateSettings(), cfg, consumertest.NewNop()) require.NoError(t, err) - assert.Equal(t, consumer.Capabilities{MutatesData: false}, traces.Capabilities()) - assert.NoError(t, traces.Start(context.Background(), NewNopHost())) - assert.NoError(t, traces.ConsumeTraces(context.Background(), pdata.NewTraces())) - assert.NoError(t, traces.Shutdown(context.Background())) + assert.Equal(t, consumer.Capabilities{MutatesData: false}, tp.Capabilities()) + assert.NoError(t, tp.Start(context.Background(), NewNopHost())) + assert.NoError(t, tp.ConsumeTraces(context.Background(), traces.New())) + assert.NoError(t, tp.Shutdown(context.Background())) - metrics, err := factory.CreateMetricsProcessor(context.Background(), NewNopProcessorCreateSettings(), cfg, consumertest.NewNop()) + mp, err := factory.CreateMetricsProcessor(context.Background(), NewNopProcessorCreateSettings(), cfg, consumertest.NewNop()) require.NoError(t, err) - assert.Equal(t, consumer.Capabilities{MutatesData: false}, metrics.Capabilities()) - assert.NoError(t, metrics.Start(context.Background(), NewNopHost())) - assert.NoError(t, metrics.ConsumeMetrics(context.Background(), pdata.NewMetrics())) - assert.NoError(t, metrics.Shutdown(context.Background())) + assert.Equal(t, consumer.Capabilities{MutatesData: false}, mp.Capabilities()) + assert.NoError(t, mp.Start(context.Background(), NewNopHost())) + assert.NoError(t, mp.ConsumeMetrics(context.Background(), metrics.New())) + assert.NoError(t, mp.Shutdown(context.Background())) - logs, err := factory.CreateLogsProcessor(context.Background(), NewNopProcessorCreateSettings(), cfg, consumertest.NewNop()) + lp, err := factory.CreateLogsProcessor(context.Background(), NewNopProcessorCreateSettings(), cfg, consumertest.NewNop()) require.NoError(t, err) - assert.Equal(t, consumer.Capabilities{MutatesData: false}, logs.Capabilities()) - assert.NoError(t, logs.Start(context.Background(), NewNopHost())) - assert.NoError(t, logs.ConsumeLogs(context.Background(), pdata.NewLogs())) - assert.NoError(t, logs.Shutdown(context.Background())) + assert.Equal(t, consumer.Capabilities{MutatesData: false}, lp.Capabilities()) + assert.NoError(t, lp.Start(context.Background(), NewNopHost())) + assert.NoError(t, lp.ConsumeLogs(context.Background(), logs.New())) + assert.NoError(t, lp.Shutdown(context.Background())) } diff --git a/component/receiver.go b/component/receiver.go index 6ed6c44217e..def61a7ff46 100644 --- a/component/receiver.go +++ b/component/receiver.go @@ -67,7 +67,7 @@ type Receiver interface { // Its purpose is to translate data from any format to the collector's internal trace format. // TracesReceiver feeds a consumer.Traces with data. // -// For example it could be Zipkin data source which translates Zipkin spans into pdata.Traces. +// For example it could be Zipkin data source which translates Zipkin spans into traces.Traces. type TracesReceiver interface { Receiver } @@ -76,7 +76,7 @@ type TracesReceiver interface { // Its purpose is to translate data from any format to the collector's internal metrics format. // MetricsReceiver feeds a consumer.Metrics with data. // -// For example it could be Prometheus data source which translates Prometheus metrics into pdata.Metrics. +// For example it could be Prometheus data source which translates Prometheus metrics into metrics.Metrics. type MetricsReceiver interface { Receiver } @@ -85,7 +85,7 @@ type MetricsReceiver interface { // Its purpose is to translate data from any format to the collector's internal logs data format. // LogsReceiver feeds a consumer.Logs with data. // -// For example a LogsReceiver can read syslogs and convert them into pdata.Logs. +// For example a LogsReceiver can read syslogs and convert them into logs.Logs. type LogsReceiver interface { Receiver } diff --git a/config/configgrpc/configgrpc_benchmark_test.go b/config/configgrpc/configgrpc_benchmark_test.go index a96446e2eb7..115fd810e6f 100644 --- a/config/configgrpc/configgrpc_benchmark_test.go +++ b/config/configgrpc/configgrpc_benchmark_test.go @@ -32,7 +32,9 @@ import ( "go.opentelemetry.io/collector/internal/testdata" "go.opentelemetry.io/collector/model/otlp" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) func BenchmarkCompressors(b *testing.B) { @@ -106,27 +108,27 @@ type marshaler interface { } type logMarshaler struct { - pdata.LogsMarshaler + logs.Marshaler } func (m *logMarshaler) marshal(e interface{}) ([]byte, error) { - return m.MarshalLogs(e.(pdata.Logs)) + return m.MarshalLogs(e.(logs.Logs)) } type traceMarshaler struct { - pdata.TracesMarshaler + traces.Marshaler } func (m *traceMarshaler) marshal(e interface{}) ([]byte, error) { - return m.MarshalTraces(e.(pdata.Traces)) + return m.MarshalTraces(e.(traces.Traces)) } type metricsMarshaler struct { - pdata.MetricsMarshaler + metrics.Marshaler } func (m *metricsMarshaler) marshal(e interface{}) ([]byte, error) { - return m.MarshalMetrics(e.(pdata.Metrics)) + return m.MarshalMetrics(e.(metrics.Metrics)) } func setupTestPayloads() []testPayload { diff --git a/consumer/consumererror/signalerrors.go b/consumer/consumererror/signalerrors.go index f8c7e5bd53d..1e7dd31287d 100644 --- a/consumer/consumererror/signalerrors.go +++ b/consumer/consumererror/signalerrors.go @@ -15,18 +15,20 @@ package consumererror // import "go.opentelemetry.io/collector/consumer/consumererror" import ( - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) // Traces is an error that may carry associated Trace data for a subset of received data // that failed to be processed or sent. type Traces struct { error - failed pdata.Traces + failed traces.Traces } // NewTraces creates a Traces that can encapsulate received data that failed to be processed or sent. -func NewTraces(err error, failed pdata.Traces) error { +func NewTraces(err error, failed traces.Traces) error { return Traces{ error: err, failed: failed, @@ -34,7 +36,7 @@ func NewTraces(err error, failed pdata.Traces) error { } // GetTraces returns failed traces from the associated error. -func (err Traces) GetTraces() pdata.Traces { +func (err Traces) GetTraces() traces.Traces { return err.failed } @@ -47,11 +49,11 @@ func (err Traces) Unwrap() error { // that failed to be processed or sent. type Logs struct { error - failed pdata.Logs + failed logs.Logs } // NewLogs creates a Logs that can encapsulate received data that failed to be processed or sent. -func NewLogs(err error, failed pdata.Logs) error { +func NewLogs(err error, failed logs.Logs) error { return Logs{ error: err, failed: failed, @@ -59,7 +61,7 @@ func NewLogs(err error, failed pdata.Logs) error { } // GetLogs returns failed logs from the associated error. -func (err Logs) GetLogs() pdata.Logs { +func (err Logs) GetLogs() logs.Logs { return err.failed } @@ -72,11 +74,11 @@ func (err Logs) Unwrap() error { // that failed to be processed or sent. type Metrics struct { error - failed pdata.Metrics + failed metrics.Metrics } // NewMetrics creates a Metrics that can encapsulate received data that failed to be processed or sent. -func NewMetrics(err error, failed pdata.Metrics) error { +func NewMetrics(err error, failed metrics.Metrics) error { return Metrics{ error: err, failed: failed, @@ -84,7 +86,7 @@ func NewMetrics(err error, failed pdata.Metrics) error { } // GetMetrics returns failed metrics from the associated error. -func (err Metrics) GetMetrics() pdata.Metrics { +func (err Metrics) GetMetrics() metrics.Metrics { return err.failed } diff --git a/consumer/consumertest/consumer.go b/consumer/consumertest/consumer.go index a9cee267436..0419e092d82 100644 --- a/consumer/consumertest/consumer.go +++ b/consumer/consumertest/consumer.go @@ -18,7 +18,9 @@ import ( "context" "go.opentelemetry.io/collector/consumer" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) // Consumer is a convenience interface that implements all consumer interfaces. @@ -29,11 +31,11 @@ type Consumer interface { // Capabilities to implement the base consumer functionality. Capabilities() consumer.Capabilities // ConsumeTraces to implement the consumer.Traces. - ConsumeTraces(context.Context, pdata.Traces) error + ConsumeTraces(context.Context, traces.Traces) error // ConsumeMetrics to implement the consumer.Metrics. - ConsumeMetrics(context.Context, pdata.Metrics) error + ConsumeMetrics(context.Context, metrics.Metrics) error // ConsumeLogs to implement the consumer.Logs. - ConsumeLogs(context.Context, pdata.Logs) error + ConsumeLogs(context.Context, logs.Logs) error unexported() } diff --git a/consumer/consumertest/err.go b/consumer/consumertest/err.go index dc0cf989cc1..74bbce37835 100644 --- a/consumer/consumertest/err.go +++ b/consumer/consumertest/err.go @@ -17,7 +17,9 @@ package consumertest // import "go.opentelemetry.io/collector/consumer/consumert import ( "context" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) type errConsumer struct { @@ -27,15 +29,15 @@ type errConsumer struct { func (er *errConsumer) unexported() {} -func (er *errConsumer) ConsumeTraces(context.Context, pdata.Traces) error { +func (er *errConsumer) ConsumeTraces(context.Context, traces.Traces) error { return er.err } -func (er *errConsumer) ConsumeMetrics(context.Context, pdata.Metrics) error { +func (er *errConsumer) ConsumeMetrics(context.Context, metrics.Metrics) error { return er.err } -func (er *errConsumer) ConsumeLogs(context.Context, pdata.Logs) error { +func (er *errConsumer) ConsumeLogs(context.Context, logs.Logs) error { return er.err } diff --git a/consumer/consumertest/err_test.go b/consumer/consumertest/err_test.go index 382b3809086..6d41faaa5ae 100644 --- a/consumer/consumertest/err_test.go +++ b/consumer/consumertest/err_test.go @@ -22,7 +22,9 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestErr(t *testing.T) { @@ -30,7 +32,7 @@ func TestErr(t *testing.T) { ec := NewErr(err) require.NotNil(t, ec) assert.NotPanics(t, ec.unexported) - assert.Equal(t, err, ec.ConsumeLogs(context.Background(), pdata.NewLogs())) - assert.Equal(t, err, ec.ConsumeMetrics(context.Background(), pdata.NewMetrics())) - assert.Equal(t, err, ec.ConsumeTraces(context.Background(), pdata.NewTraces())) + assert.Equal(t, err, ec.ConsumeLogs(context.Background(), logs.New())) + assert.Equal(t, err, ec.ConsumeMetrics(context.Background(), metrics.New())) + assert.Equal(t, err, ec.ConsumeTraces(context.Background(), traces.New())) } diff --git a/consumer/consumertest/nop.go b/consumer/consumertest/nop.go index f48123677ca..f57204bdf7b 100644 --- a/consumer/consumertest/nop.go +++ b/consumer/consumertest/nop.go @@ -17,7 +17,9 @@ package consumertest // import "go.opentelemetry.io/collector/consumer/consumert import ( "context" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) var ( @@ -30,15 +32,15 @@ type nopConsumer struct { func (nc *nopConsumer) unexported() {} -func (nc *nopConsumer) ConsumeTraces(context.Context, pdata.Traces) error { +func (nc *nopConsumer) ConsumeTraces(context.Context, traces.Traces) error { return nil } -func (nc *nopConsumer) ConsumeMetrics(context.Context, pdata.Metrics) error { +func (nc *nopConsumer) ConsumeMetrics(context.Context, metrics.Metrics) error { return nil } -func (nc *nopConsumer) ConsumeLogs(context.Context, pdata.Logs) error { +func (nc *nopConsumer) ConsumeLogs(context.Context, logs.Logs) error { return nil } diff --git a/consumer/consumertest/nop_test.go b/consumer/consumertest/nop_test.go index a16b129808a..66a8a0f2138 100644 --- a/consumer/consumertest/nop_test.go +++ b/consumer/consumertest/nop_test.go @@ -21,14 +21,16 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestNop(t *testing.T) { nc := NewNop() require.NotNil(t, nc) assert.NotPanics(t, nc.unexported) - assert.NoError(t, nc.ConsumeLogs(context.Background(), pdata.NewLogs())) - assert.NoError(t, nc.ConsumeMetrics(context.Background(), pdata.NewMetrics())) - assert.NoError(t, nc.ConsumeTraces(context.Background(), pdata.NewTraces())) + assert.NoError(t, nc.ConsumeLogs(context.Background(), logs.New())) + assert.NoError(t, nc.ConsumeMetrics(context.Background(), metrics.New())) + assert.NoError(t, nc.ConsumeTraces(context.Background(), traces.New())) } diff --git a/consumer/consumertest/sink.go b/consumer/consumertest/sink.go index d9a23602222..6fa25d8d7f9 100644 --- a/consumer/consumertest/sink.go +++ b/consumer/consumertest/sink.go @@ -19,7 +19,9 @@ import ( "sync" "go.opentelemetry.io/collector/consumer" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) // TracesSink is a consumer.Traces that acts like a sink that @@ -27,14 +29,14 @@ import ( type TracesSink struct { nonMutatingConsumer mu sync.Mutex - traces []pdata.Traces + traces []traces.Traces spanCount int } var _ consumer.Traces = (*TracesSink)(nil) // ConsumeTraces stores traces to this sink. -func (ste *TracesSink) ConsumeTraces(_ context.Context, td pdata.Traces) error { +func (ste *TracesSink) ConsumeTraces(_ context.Context, td traces.Traces) error { ste.mu.Lock() defer ste.mu.Unlock() @@ -45,11 +47,11 @@ func (ste *TracesSink) ConsumeTraces(_ context.Context, td pdata.Traces) error { } // AllTraces returns the traces stored by this sink since last Reset. -func (ste *TracesSink) AllTraces() []pdata.Traces { +func (ste *TracesSink) AllTraces() []traces.Traces { ste.mu.Lock() defer ste.mu.Unlock() - copyTraces := make([]pdata.Traces, len(ste.traces)) + copyTraces := make([]traces.Traces, len(ste.traces)) copy(copyTraces, ste.traces) return copyTraces } @@ -75,14 +77,14 @@ func (ste *TracesSink) Reset() { type MetricsSink struct { nonMutatingConsumer mu sync.Mutex - metrics []pdata.Metrics + metrics []metrics.Metrics dataPointCount int } var _ consumer.Metrics = (*MetricsSink)(nil) // ConsumeMetrics stores metrics to this sink. -func (sme *MetricsSink) ConsumeMetrics(_ context.Context, md pdata.Metrics) error { +func (sme *MetricsSink) ConsumeMetrics(_ context.Context, md metrics.Metrics) error { sme.mu.Lock() defer sme.mu.Unlock() @@ -93,11 +95,11 @@ func (sme *MetricsSink) ConsumeMetrics(_ context.Context, md pdata.Metrics) erro } // AllMetrics returns the metrics stored by this sink since last Reset. -func (sme *MetricsSink) AllMetrics() []pdata.Metrics { +func (sme *MetricsSink) AllMetrics() []metrics.Metrics { sme.mu.Lock() defer sme.mu.Unlock() - copyMetrics := make([]pdata.Metrics, len(sme.metrics)) + copyMetrics := make([]metrics.Metrics, len(sme.metrics)) copy(copyMetrics, sme.metrics) return copyMetrics } @@ -123,14 +125,14 @@ func (sme *MetricsSink) Reset() { type LogsSink struct { nonMutatingConsumer mu sync.Mutex - logs []pdata.Logs + logs []logs.Logs logRecordCount int } var _ consumer.Logs = (*LogsSink)(nil) // ConsumeLogs stores logs to this sink. -func (sle *LogsSink) ConsumeLogs(_ context.Context, ld pdata.Logs) error { +func (sle *LogsSink) ConsumeLogs(_ context.Context, ld logs.Logs) error { sle.mu.Lock() defer sle.mu.Unlock() @@ -141,11 +143,11 @@ func (sle *LogsSink) ConsumeLogs(_ context.Context, ld pdata.Logs) error { } // AllLogs returns the logs stored by this sink since last Reset. -func (sle *LogsSink) AllLogs() []pdata.Logs { +func (sle *LogsSink) AllLogs() []logs.Logs { sle.mu.Lock() defer sle.mu.Unlock() - copyLogs := make([]pdata.Logs, len(sle.logs)) + copyLogs := make([]logs.Logs, len(sle.logs)) copy(copyLogs, sle.logs) return copyLogs } diff --git a/consumer/consumertest/sink_test.go b/consumer/consumertest/sink_test.go index 2098019471f..c783694052d 100644 --- a/consumer/consumertest/sink_test.go +++ b/consumer/consumertest/sink_test.go @@ -22,13 +22,15 @@ import ( "github.com/stretchr/testify/require" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestTracesSink(t *testing.T) { sink := new(TracesSink) td := testdata.GenerateTracesOneSpan() - want := make([]pdata.Traces, 0, 7) + want := make([]traces.Traces, 0, 7) for i := 0; i < 7; i++ { require.NoError(t, sink.ConsumeTraces(context.Background(), td)) want = append(want, td) @@ -43,7 +45,7 @@ func TestTracesSink(t *testing.T) { func TestMetricsSink(t *testing.T) { sink := new(MetricsSink) md := testdata.GenerateMetricsOneMetric() - want := make([]pdata.Metrics, 0, 7) + want := make([]metrics.Metrics, 0, 7) for i := 0; i < 7; i++ { require.NoError(t, sink.ConsumeMetrics(context.Background(), md)) want = append(want, md) @@ -58,7 +60,7 @@ func TestMetricsSink(t *testing.T) { func TestLogsSink(t *testing.T) { sink := new(LogsSink) md := testdata.GenerateLogsOneLogRecord() - want := make([]pdata.Logs, 0, 7) + want := make([]logs.Logs, 0, 7) for i := 0; i < 7; i++ { require.NoError(t, sink.ConsumeLogs(context.Background(), md)) want = append(want, md) diff --git a/consumer/logs.go b/consumer/logs.go index 2876c14978e..a81a37b667f 100644 --- a/consumer/logs.go +++ b/consumer/logs.go @@ -17,22 +17,22 @@ package consumer // import "go.opentelemetry.io/collector/consumer" import ( "context" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) -// Logs is an interface that receives pdata.Logs, processes it +// Logs is an interface that receives logs.Logs, processes it // as needed, and sends it to the next processing node if any or to the destination. type Logs interface { baseConsumer - // ConsumeLogs receives pdata.Logs for consumption. - ConsumeLogs(ctx context.Context, ld pdata.Logs) error + // ConsumeLogs receives logs.Logs for consumption. + ConsumeLogs(ctx context.Context, ld logs.Logs) error } // ConsumeLogsFunc is a helper function that is similar to ConsumeLogs. -type ConsumeLogsFunc func(ctx context.Context, ld pdata.Logs) error +type ConsumeLogsFunc func(ctx context.Context, ld logs.Logs) error // ConsumeLogs calls f(ctx, ld). -func (f ConsumeLogsFunc) ConsumeLogs(ctx context.Context, ld pdata.Logs) error { +func (f ConsumeLogsFunc) ConsumeLogs(ctx context.Context, ld logs.Logs) error { return f(ctx, ld) } diff --git a/consumer/logs_test.go b/consumer/logs_test.go index d3815937d96..0edd897b964 100644 --- a/consumer/logs_test.go +++ b/consumer/logs_test.go @@ -21,13 +21,13 @@ import ( "github.com/stretchr/testify/assert" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) func TestDefaultLogs(t *testing.T) { - cp, err := NewLogs(func(context.Context, pdata.Logs) error { return nil }) + cp, err := NewLogs(func(context.Context, logs.Logs) error { return nil }) assert.NoError(t, err) - assert.NoError(t, cp.ConsumeLogs(context.Background(), pdata.NewLogs())) + assert.NoError(t, cp.ConsumeLogs(context.Background(), logs.New())) assert.Equal(t, Capabilities{MutatesData: false}, cp.Capabilities()) } @@ -38,24 +38,24 @@ func TestNilFuncLogs(t *testing.T) { func TestWithCapabilitiesLogs(t *testing.T) { cp, err := NewLogs( - func(context.Context, pdata.Logs) error { return nil }, + func(context.Context, logs.Logs) error { return nil }, WithCapabilities(Capabilities{MutatesData: true})) assert.NoError(t, err) - assert.NoError(t, cp.ConsumeLogs(context.Background(), pdata.NewLogs())) + assert.NoError(t, cp.ConsumeLogs(context.Background(), logs.New())) assert.Equal(t, Capabilities{MutatesData: true}, cp.Capabilities()) } func TestConsumeLogs(t *testing.T) { consumeCalled := false - cp, err := NewLogs(func(context.Context, pdata.Logs) error { consumeCalled = true; return nil }) + cp, err := NewLogs(func(context.Context, logs.Logs) error { consumeCalled = true; return nil }) assert.NoError(t, err) - assert.NoError(t, cp.ConsumeLogs(context.Background(), pdata.NewLogs())) + assert.NoError(t, cp.ConsumeLogs(context.Background(), logs.New())) assert.True(t, consumeCalled) } func TestConsumeLogs_ReturnError(t *testing.T) { want := errors.New("my_error") - cp, err := NewLogs(func(context.Context, pdata.Logs) error { return want }) + cp, err := NewLogs(func(context.Context, logs.Logs) error { return want }) assert.NoError(t, err) - assert.Equal(t, want, cp.ConsumeLogs(context.Background(), pdata.NewLogs())) + assert.Equal(t, want, cp.ConsumeLogs(context.Background(), logs.New())) } diff --git a/consumer/metrics.go b/consumer/metrics.go index 43102cee7f1..45bc4fcb4a9 100644 --- a/consumer/metrics.go +++ b/consumer/metrics.go @@ -17,22 +17,22 @@ package consumer // import "go.opentelemetry.io/collector/consumer" import ( "context" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) -// Metrics is the new metrics consumer interface that receives pdata.Metrics, processes it +// Metrics is the new metrics consumer interface that receives metrics.Metrics, processes it // as needed, and sends it to the next processing node if any or to the destination. type Metrics interface { baseConsumer - // ConsumeMetrics receives pdata.Metrics for consumption. - ConsumeMetrics(ctx context.Context, md pdata.Metrics) error + // ConsumeMetrics receives metrics.Metrics for consumption. + ConsumeMetrics(ctx context.Context, md metrics.Metrics) error } // ConsumeMetricsFunc is a helper function that is similar to ConsumeMetrics. -type ConsumeMetricsFunc func(ctx context.Context, ld pdata.Metrics) error +type ConsumeMetricsFunc func(ctx context.Context, ld metrics.Metrics) error // ConsumeMetrics calls f(ctx, ld). -func (f ConsumeMetricsFunc) ConsumeMetrics(ctx context.Context, ld pdata.Metrics) error { +func (f ConsumeMetricsFunc) ConsumeMetrics(ctx context.Context, ld metrics.Metrics) error { return f(ctx, ld) } diff --git a/consumer/metrics_test.go b/consumer/metrics_test.go index f6b88568869..c964d6ef341 100644 --- a/consumer/metrics_test.go +++ b/consumer/metrics_test.go @@ -21,13 +21,13 @@ import ( "github.com/stretchr/testify/assert" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) func TestDefaultMetrics(t *testing.T) { - cp, err := NewMetrics(func(context.Context, pdata.Metrics) error { return nil }) + cp, err := NewMetrics(func(context.Context, metrics.Metrics) error { return nil }) assert.NoError(t, err) - assert.NoError(t, cp.ConsumeMetrics(context.Background(), pdata.NewMetrics())) + assert.NoError(t, cp.ConsumeMetrics(context.Background(), metrics.New())) assert.Equal(t, Capabilities{MutatesData: false}, cp.Capabilities()) } @@ -38,24 +38,24 @@ func TestNilFuncMetrics(t *testing.T) { func TestWithCapabilitiesMetrics(t *testing.T) { cp, err := NewMetrics( - func(context.Context, pdata.Metrics) error { return nil }, + func(context.Context, metrics.Metrics) error { return nil }, WithCapabilities(Capabilities{MutatesData: true})) assert.NoError(t, err) - assert.NoError(t, cp.ConsumeMetrics(context.Background(), pdata.NewMetrics())) + assert.NoError(t, cp.ConsumeMetrics(context.Background(), metrics.New())) assert.Equal(t, Capabilities{MutatesData: true}, cp.Capabilities()) } func TestConsumeMetrics(t *testing.T) { consumeCalled := false - cp, err := NewMetrics(func(context.Context, pdata.Metrics) error { consumeCalled = true; return nil }) + cp, err := NewMetrics(func(context.Context, metrics.Metrics) error { consumeCalled = true; return nil }) assert.NoError(t, err) - assert.NoError(t, cp.ConsumeMetrics(context.Background(), pdata.NewMetrics())) + assert.NoError(t, cp.ConsumeMetrics(context.Background(), metrics.New())) assert.True(t, consumeCalled) } func TestConsumeMetrics_ReturnError(t *testing.T) { want := errors.New("my_error") - cp, err := NewMetrics(func(context.Context, pdata.Metrics) error { return want }) + cp, err := NewMetrics(func(context.Context, metrics.Metrics) error { return want }) assert.NoError(t, err) - assert.Equal(t, want, cp.ConsumeMetrics(context.Background(), pdata.NewMetrics())) + assert.Equal(t, want, cp.ConsumeMetrics(context.Background(), metrics.New())) } diff --git a/consumer/traces.go b/consumer/traces.go index 3852d7d253b..b4cde50c928 100644 --- a/consumer/traces.go +++ b/consumer/traces.go @@ -17,22 +17,22 @@ package consumer // import "go.opentelemetry.io/collector/consumer" import ( "context" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) -// Traces is an interface that receives pdata.Traces, processes it +// Traces is an interface that receives traces.Traces, processes it // as needed, and sends it to the next processing node if any or to the destination. type Traces interface { baseConsumer - // ConsumeTraces receives pdata.Traces for consumption. - ConsumeTraces(ctx context.Context, td pdata.Traces) error + // ConsumeTraces receives traces.Traces for consumption. + ConsumeTraces(ctx context.Context, td traces.Traces) error } // ConsumeTracesFunc is a helper function that is similar to ConsumeTraces. -type ConsumeTracesFunc func(ctx context.Context, ld pdata.Traces) error +type ConsumeTracesFunc func(ctx context.Context, ld traces.Traces) error // ConsumeTraces calls f(ctx, ld). -func (f ConsumeTracesFunc) ConsumeTraces(ctx context.Context, ld pdata.Traces) error { +func (f ConsumeTracesFunc) ConsumeTraces(ctx context.Context, ld traces.Traces) error { return f(ctx, ld) } diff --git a/consumer/traces_test.go b/consumer/traces_test.go index 41cd269cfe0..c9ffe25ec66 100644 --- a/consumer/traces_test.go +++ b/consumer/traces_test.go @@ -21,13 +21,13 @@ import ( "github.com/stretchr/testify/assert" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestDefaultTraces(t *testing.T) { - cp, err := NewTraces(func(context.Context, pdata.Traces) error { return nil }) + cp, err := NewTraces(func(context.Context, traces.Traces) error { return nil }) assert.NoError(t, err) - assert.NoError(t, cp.ConsumeTraces(context.Background(), pdata.NewTraces())) + assert.NoError(t, cp.ConsumeTraces(context.Background(), traces.New())) assert.Equal(t, Capabilities{MutatesData: false}, cp.Capabilities()) } @@ -38,24 +38,24 @@ func TestNilFuncTraces(t *testing.T) { func TestWithCapabilitiesTraces(t *testing.T) { cp, err := NewTraces( - func(context.Context, pdata.Traces) error { return nil }, + func(context.Context, traces.Traces) error { return nil }, WithCapabilities(Capabilities{MutatesData: true})) assert.NoError(t, err) - assert.NoError(t, cp.ConsumeTraces(context.Background(), pdata.NewTraces())) + assert.NoError(t, cp.ConsumeTraces(context.Background(), traces.New())) assert.Equal(t, Capabilities{MutatesData: true}, cp.Capabilities()) } func TestConsumeTraces(t *testing.T) { consumeCalled := false - cp, err := NewTraces(func(context.Context, pdata.Traces) error { consumeCalled = true; return nil }) + cp, err := NewTraces(func(context.Context, traces.Traces) error { consumeCalled = true; return nil }) assert.NoError(t, err) - assert.NoError(t, cp.ConsumeTraces(context.Background(), pdata.NewTraces())) + assert.NoError(t, cp.ConsumeTraces(context.Background(), traces.New())) assert.True(t, consumeCalled) } func TestConsumeTraces_ReturnError(t *testing.T) { want := errors.New("my_error") - cp, err := NewTraces(func(context.Context, pdata.Traces) error { return want }) + cp, err := NewTraces(func(context.Context, traces.Traces) error { return want }) assert.NoError(t, err) - assert.Equal(t, want, cp.ConsumeTraces(context.Background(), pdata.NewTraces())) + assert.Equal(t, want, cp.ConsumeTraces(context.Background(), traces.New())) } diff --git a/exporter/exporterhelper/common_test.go b/exporter/exporterhelper/common_test.go index 42559e212a2..0ae0bcf4633 100644 --- a/exporter/exporterhelper/common_test.go +++ b/exporter/exporterhelper/common_test.go @@ -28,7 +28,7 @@ import ( "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/consumer" "go.opentelemetry.io/collector/exporter/exporterhelper/internal" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) var ( @@ -71,7 +71,7 @@ func checkStatus(t *testing.T, sd sdktrace.ReadOnlySpan, err error) { } func nopTracePusher() consumer.ConsumeTracesFunc { - return func(ctx context.Context, ld pdata.Traces) error { + return func(ctx context.Context, ld traces.Traces) error { return nil } } diff --git a/exporter/exporterhelper/internal/persistent_queue_test.go b/exporter/exporterhelper/internal/persistent_queue_test.go index f94a4b35aa4..47e960f4302 100644 --- a/exporter/exporterhelper/internal/persistent_queue_test.go +++ b/exporter/exporterhelper/internal/persistent_queue_test.go @@ -32,6 +32,7 @@ import ( "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/extension/experimental/storage" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) func createTestQueue(extension storage.Extension, capacity int) *persistentQueue { @@ -167,8 +168,8 @@ func TestPersistentQueue_ConsumersProducers(t *testing.T) { } } -func newTraces(numTraces int, numSpans int) pdata.Traces { - traces := pdata.NewTraces() +func newTraces(numTraces int, numSpans int) traces.Traces { + traces := traces.New() batch := traces.ResourceSpans().AppendEmpty() batch.Resource().Attributes().InsertString("resource-attr", "some-resource") batch.Resource().Attributes().InsertInt("num-traces", int64(numTraces)) diff --git a/exporter/exporterhelper/internal/persistent_storage_test.go b/exporter/exporterhelper/internal/persistent_storage_test.go index d0a83ddfc42..59c6697fec4 100644 --- a/exporter/exporterhelper/internal/persistent_storage_test.go +++ b/exporter/exporterhelper/internal/persistent_storage_test.go @@ -35,7 +35,7 @@ import ( "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/extension/experimental/storage" "go.opentelemetry.io/collector/model/otlp" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) func createStorageExtension(_ string) storage.Extension { @@ -69,12 +69,12 @@ func createTemporaryDirectory() string { } type fakeTracesRequest struct { - td pdata.Traces + td traces.Traces processingFinishedCallback func() PersistentRequest } -func newFakeTracesRequest(td pdata.Traces) *fakeTracesRequest { +func newFakeTracesRequest(td traces.Traces) *fakeTracesRequest { return &fakeTracesRequest{ td: td, } diff --git a/exporter/exporterhelper/logs.go b/exporter/exporterhelper/logs.go index 3837d9a901c..2b8ede0a5a6 100644 --- a/exporter/exporterhelper/logs.go +++ b/exporter/exporterhelper/logs.go @@ -24,7 +24,7 @@ import ( "go.opentelemetry.io/collector/consumer/consumererror" "go.opentelemetry.io/collector/exporter/exporterhelper/internal" "go.opentelemetry.io/collector/model/otlp" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) var logsMarshaler = otlp.NewProtobufLogsMarshaler() @@ -32,11 +32,11 @@ var logsUnmarshaler = otlp.NewProtobufLogsUnmarshaler() type logsRequest struct { baseRequest - ld pdata.Logs + ld logs.Logs pusher consumer.ConsumeLogsFunc } -func newLogsRequest(ctx context.Context, ld pdata.Logs, pusher consumer.ConsumeLogsFunc) request { +func newLogsRequest(ctx context.Context, ld logs.Logs, pusher consumer.ConsumeLogsFunc) request { return &logsRequest{ baseRequest: baseRequest{ctx: ctx}, ld: ld, @@ -107,7 +107,7 @@ func NewLogsExporter( } }) - lc, err := consumer.NewLogs(func(ctx context.Context, ld pdata.Logs) error { + lc, err := consumer.NewLogs(func(ctx context.Context, ld logs.Logs) error { req := newLogsRequest(ctx, ld, pusher) err := be.sender.send(req) if errors.Is(err, errSendingQueueIsFull) { diff --git a/exporter/exporterhelper/logs_test.go b/exporter/exporterhelper/logs_test.go index 3bd0dcc9b3f..cd048c7123f 100644 --- a/exporter/exporterhelper/logs_test.go +++ b/exporter/exporterhelper/logs_test.go @@ -33,7 +33,7 @@ import ( "go.opentelemetry.io/collector/consumer/consumererror" "go.opentelemetry.io/collector/internal/obsreportconfig/obsmetrics" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" "go.opentelemetry.io/collector/obsreport/obsreporttest" ) @@ -50,10 +50,10 @@ var ( func TestLogsRequest(t *testing.T) { lr := newLogsRequest(context.Background(), testdata.GenerateLogsOneLogRecord(), nil) - logErr := consumererror.NewLogs(errors.New("some error"), pdata.NewLogs()) + logErr := consumererror.NewLogs(errors.New("some error"), logs.New()) assert.EqualValues( t, - newLogsRequest(context.Background(), pdata.NewLogs(), nil), + newLogsRequest(context.Background(), logs.New(), nil), lr.onError(logErr), ) } @@ -77,7 +77,7 @@ func TestLogsExporter_NilPushLogsData(t *testing.T) { } func TestLogsExporter_Default(t *testing.T) { - ld := pdata.NewLogs() + ld := logs.New() le, err := NewLogsExporter(&fakeLogsExporterConfig, componenttest.NewNopExporterCreateSettings(), newPushLogsData(nil)) assert.NotNil(t, le) assert.NoError(t, err) @@ -98,7 +98,7 @@ func TestLogsExporter_WithCapabilities(t *testing.T) { } func TestLogsExporter_Default_ReturnError(t *testing.T) { - ld := pdata.NewLogs() + ld := logs.New() want := errors.New("my_error") le, err := NewLogsExporter(&fakeLogsExporterConfig, componenttest.NewNopExporterCreateSettings(), newPushLogsData(want)) require.NoError(t, err) @@ -199,7 +199,7 @@ func TestLogsExporter_WithShutdown_ReturnError(t *testing.T) { } func newPushLogsData(retError error) consumer.ConsumeLogsFunc { - return func(ctx context.Context, td pdata.Logs) error { + return func(ctx context.Context, td logs.Logs) error { return retError } } diff --git a/exporter/exporterhelper/metrics.go b/exporter/exporterhelper/metrics.go index f17eefee955..88b4b196541 100644 --- a/exporter/exporterhelper/metrics.go +++ b/exporter/exporterhelper/metrics.go @@ -24,7 +24,7 @@ import ( "go.opentelemetry.io/collector/consumer/consumererror" "go.opentelemetry.io/collector/exporter/exporterhelper/internal" "go.opentelemetry.io/collector/model/otlp" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) var metricsMarshaler = otlp.NewProtobufMetricsMarshaler() @@ -32,11 +32,11 @@ var metricsUnmarshaler = otlp.NewProtobufMetricsUnmarshaler() type metricsRequest struct { baseRequest - md pdata.Metrics + md metrics.Metrics pusher consumer.ConsumeMetricsFunc } -func newMetricsRequest(ctx context.Context, md pdata.Metrics, pusher consumer.ConsumeMetricsFunc) request { +func newMetricsRequest(ctx context.Context, md metrics.Metrics, pusher consumer.ConsumeMetricsFunc) request { return &metricsRequest{ baseRequest: baseRequest{ctx: ctx}, md: md, @@ -108,7 +108,7 @@ func NewMetricsExporter( } }) - mc, err := consumer.NewMetrics(func(ctx context.Context, md pdata.Metrics) error { + mc, err := consumer.NewMetrics(func(ctx context.Context, md metrics.Metrics) error { req := newMetricsRequest(ctx, md, pusher) err := be.sender.send(req) if errors.Is(err, errSendingQueueIsFull) { diff --git a/exporter/exporterhelper/metrics_test.go b/exporter/exporterhelper/metrics_test.go index 0dfc62db76a..73e351e59be 100644 --- a/exporter/exporterhelper/metrics_test.go +++ b/exporter/exporterhelper/metrics_test.go @@ -33,7 +33,7 @@ import ( "go.opentelemetry.io/collector/consumer/consumererror" "go.opentelemetry.io/collector/internal/obsreportconfig/obsmetrics" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" "go.opentelemetry.io/collector/obsreport/obsreporttest" ) @@ -49,10 +49,10 @@ var ( func TestMetricsRequest(t *testing.T) { mr := newMetricsRequest(context.Background(), testdata.GenerateMetricsOneMetric(), nil) - metricsErr := consumererror.NewMetrics(errors.New("some error"), pdata.NewMetrics()) + metricsErr := consumererror.NewMetrics(errors.New("some error"), metrics.New()) assert.EqualValues( t, - newMetricsRequest(context.Background(), pdata.NewMetrics(), nil), + newMetricsRequest(context.Background(), metrics.New(), nil), mr.onError(metricsErr), ) } @@ -76,7 +76,7 @@ func TestMetricsExporter_NilPushMetricsData(t *testing.T) { } func TestMetricsExporter_Default(t *testing.T) { - md := pdata.NewMetrics() + md := metrics.New() me, err := NewMetricsExporter(&fakeMetricsExporterConfig, componenttest.NewNopExporterCreateSettings(), newPushMetricsData(nil)) assert.NoError(t, err) assert.NotNil(t, me) @@ -97,7 +97,7 @@ func TestMetricsExporter_WithCapabilities(t *testing.T) { } func TestMetricsExporter_Default_ReturnError(t *testing.T) { - md := pdata.NewMetrics() + md := metrics.New() want := errors.New("my_error") me, err := NewMetricsExporter(&fakeMetricsExporterConfig, componenttest.NewNopExporterCreateSettings(), newPushMetricsData(want)) require.NoError(t, err) @@ -200,7 +200,7 @@ func TestMetricsExporter_WithShutdown_ReturnError(t *testing.T) { } func newPushMetricsData(retError error) consumer.ConsumeMetricsFunc { - return func(ctx context.Context, td pdata.Metrics) error { + return func(ctx context.Context, td metrics.Metrics) error { return retError } } diff --git a/exporter/exporterhelper/queued_retry_test.go b/exporter/exporterhelper/queued_retry_test.go index 34c9b77daed..e0df7508645 100644 --- a/exporter/exporterhelper/queued_retry_test.go +++ b/exporter/exporterhelper/queued_retry_test.go @@ -34,7 +34,7 @@ import ( "go.opentelemetry.io/collector/exporter/exporterhelper/internal" "go.opentelemetry.io/collector/internal/testdata" "go.opentelemetry.io/collector/model/otlp" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" "go.opentelemetry.io/collector/obsreport/obsreporttest" ) @@ -428,7 +428,7 @@ func (m *mockRequest) export(ctx context.Context) error { } func (m *mockRequest) Marshal() ([]byte, error) { - return otlp.NewProtobufTracesMarshaler().MarshalTraces(pdata.NewTraces()) + return otlp.NewProtobufTracesMarshaler().MarshalTraces(traces.New()) } func (m *mockRequest) onError(error) request { diff --git a/exporter/exporterhelper/traces.go b/exporter/exporterhelper/traces.go index 1a10fb4c9c9..8ac8e640a81 100644 --- a/exporter/exporterhelper/traces.go +++ b/exporter/exporterhelper/traces.go @@ -24,7 +24,7 @@ import ( "go.opentelemetry.io/collector/consumer/consumererror" "go.opentelemetry.io/collector/exporter/exporterhelper/internal" "go.opentelemetry.io/collector/model/otlp" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) var tracesMarshaler = otlp.NewProtobufTracesMarshaler() @@ -32,11 +32,11 @@ var tracesUnmarshaler = otlp.NewProtobufTracesUnmarshaler() type tracesRequest struct { baseRequest - td pdata.Traces + td traces.Traces pusher consumer.ConsumeTracesFunc } -func newTracesRequest(ctx context.Context, td pdata.Traces, pusher consumer.ConsumeTracesFunc) request { +func newTracesRequest(ctx context.Context, td traces.Traces, pusher consumer.ConsumeTracesFunc) request { return &tracesRequest{ baseRequest: baseRequest{ctx: ctx}, td: td, @@ -109,7 +109,7 @@ func NewTracesExporter( } }) - tc, err := consumer.NewTraces(func(ctx context.Context, td pdata.Traces) error { + tc, err := consumer.NewTraces(func(ctx context.Context, td traces.Traces) error { req := newTracesRequest(ctx, td, pusher) err := be.sender.send(req) if errors.Is(err, errSendingQueueIsFull) { diff --git a/exporter/exporterhelper/traces_test.go b/exporter/exporterhelper/traces_test.go index efa81c908c9..9825da2a3e6 100644 --- a/exporter/exporterhelper/traces_test.go +++ b/exporter/exporterhelper/traces_test.go @@ -33,7 +33,7 @@ import ( "go.opentelemetry.io/collector/consumer/consumererror" "go.opentelemetry.io/collector/internal/obsreportconfig/obsmetrics" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" "go.opentelemetry.io/collector/obsreport/obsreporttest" ) @@ -49,8 +49,8 @@ var ( func TestTracesRequest(t *testing.T) { mr := newTracesRequest(context.Background(), testdata.GenerateTracesOneSpan(), nil) - traceErr := consumererror.NewTraces(errors.New("some error"), pdata.NewTraces()) - assert.EqualValues(t, newTracesRequest(context.Background(), pdata.NewTraces(), nil), mr.onError(traceErr)) + traceErr := consumererror.NewTraces(errors.New("some error"), traces.New()) + assert.EqualValues(t, newTracesRequest(context.Background(), traces.New(), nil), mr.onError(traceErr)) } func TestTracesExporter_InvalidName(t *testing.T) { @@ -72,7 +72,7 @@ func TestTracesExporter_NilPushTraceData(t *testing.T) { } func TestTracesExporter_Default(t *testing.T) { - td := pdata.NewTraces() + td := traces.New() te, err := NewTracesExporter(&fakeTracesExporterConfig, componenttest.NewNopExporterCreateSettings(), newTraceDataPusher(nil)) assert.NotNil(t, te) assert.NoError(t, err) @@ -93,7 +93,7 @@ func TestTracesExporter_WithCapabilities(t *testing.T) { } func TestTracesExporter_Default_ReturnError(t *testing.T) { - td := pdata.NewTraces() + td := traces.New() want := errors.New("my_error") te, err := NewTracesExporter(&fakeTracesExporterConfig, componenttest.NewNopExporterCreateSettings(), newTraceDataPusher(want)) require.NoError(t, err) @@ -200,7 +200,7 @@ func TestTracesExporter_WithShutdown_ReturnError(t *testing.T) { } func newTraceDataPusher(retError error) consumer.ConsumeTracesFunc { - return func(ctx context.Context, td pdata.Traces) error { + return func(ctx context.Context, td traces.Traces) error { return retError } } @@ -225,7 +225,7 @@ func checkRecordedMetricsForTracesExporter(t *testing.T, te component.TracesExpo } func generateTraceTraffic(t *testing.T, tracer trace.Tracer, te component.TracesExporter, numRequests int, wantError error) { - td := pdata.NewTraces() + td := traces.New() td.ResourceSpans().AppendEmpty().ScopeSpans().AppendEmpty().Spans().AppendEmpty() ctx, span := tracer.Start(context.Background(), fakeTraceParentSpanName) defer span.End() diff --git a/exporter/loggingexporter/logging_exporter.go b/exporter/loggingexporter/logging_exporter.go index 301e1b372b6..c1917309ec9 100644 --- a/exporter/loggingexporter/logging_exporter.go +++ b/exporter/loggingexporter/logging_exporter.go @@ -26,17 +26,19 @@ import ( "go.opentelemetry.io/collector/consumer" "go.opentelemetry.io/collector/exporter/exporterhelper" "go.opentelemetry.io/collector/internal/otlptext" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) type loggingExporter struct { logger *zap.Logger - logsMarshaler pdata.LogsMarshaler - metricsMarshaler pdata.MetricsMarshaler - tracesMarshaler pdata.TracesMarshaler + logsMarshaler logs.Marshaler + metricsMarshaler metrics.Marshaler + tracesMarshaler traces.Marshaler } -func (s *loggingExporter) pushTraces(_ context.Context, td pdata.Traces) error { +func (s *loggingExporter) pushTraces(_ context.Context, td traces.Traces) error { s.logger.Info("TracesExporter", zap.Int("#spans", td.SpanCount())) if !s.logger.Core().Enabled(zapcore.DebugLevel) { return nil @@ -50,7 +52,7 @@ func (s *loggingExporter) pushTraces(_ context.Context, td pdata.Traces) error { return nil } -func (s *loggingExporter) pushMetrics(_ context.Context, md pdata.Metrics) error { +func (s *loggingExporter) pushMetrics(_ context.Context, md metrics.Metrics) error { s.logger.Info("MetricsExporter", zap.Int("#metrics", md.MetricCount())) if !s.logger.Core().Enabled(zapcore.DebugLevel) { @@ -65,7 +67,7 @@ func (s *loggingExporter) pushMetrics(_ context.Context, md pdata.Metrics) error return nil } -func (s *loggingExporter) pushLogs(_ context.Context, ld pdata.Logs) error { +func (s *loggingExporter) pushLogs(_ context.Context, ld logs.Logs) error { s.logger.Info("LogsExporter", zap.Int("#logs", ld.LogRecordCount())) if !s.logger.Core().Enabled(zapcore.DebugLevel) { diff --git a/exporter/loggingexporter/logging_exporter_test.go b/exporter/loggingexporter/logging_exporter_test.go index d6ec66b5af5..3bfa9caf3ea 100644 --- a/exporter/loggingexporter/logging_exporter_test.go +++ b/exporter/loggingexporter/logging_exporter_test.go @@ -26,7 +26,9 @@ import ( "go.opentelemetry.io/collector/component/componenttest" "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestLoggingTracesExporterNoErrors(t *testing.T) { @@ -34,7 +36,7 @@ func TestLoggingTracesExporterNoErrors(t *testing.T) { require.NotNil(t, lte) assert.NoError(t, err) - assert.NoError(t, lte.ConsumeTraces(context.Background(), pdata.NewTraces())) + assert.NoError(t, lte.ConsumeTraces(context.Background(), traces.New())) assert.NoError(t, lte.ConsumeTraces(context.Background(), testdata.GenerateTracesTwoSpansSameResourceOneDifferent())) assert.NoError(t, lte.Shutdown(context.Background())) @@ -45,7 +47,7 @@ func TestLoggingMetricsExporterNoErrors(t *testing.T) { require.NotNil(t, lme) assert.NoError(t, err) - assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdata.NewMetrics())) + assert.NoError(t, lme.ConsumeMetrics(context.Background(), metrics.New())) assert.NoError(t, lme.ConsumeMetrics(context.Background(), testdata.GeneratMetricsAllTypesWithSampleDatapoints())) assert.NoError(t, lme.ConsumeMetrics(context.Background(), testdata.GenerateMetricsAllTypesEmptyDataPoint())) assert.NoError(t, lme.ConsumeMetrics(context.Background(), testdata.GenerateMetricsMetricTypeInvalid())) @@ -58,7 +60,7 @@ func TestLoggingLogsExporterNoErrors(t *testing.T) { require.NotNil(t, lle) assert.NoError(t, err) - assert.NoError(t, lle.ConsumeLogs(context.Background(), pdata.NewLogs())) + assert.NoError(t, lle.ConsumeLogs(context.Background(), logs.New())) assert.NoError(t, lle.ConsumeLogs(context.Background(), testdata.GenerateLogsOneEmptyResourceLogs())) assert.NoError(t, lle.ConsumeLogs(context.Background(), testdata.GenerateLogsNoLogRecords())) assert.NoError(t, lle.ConsumeLogs(context.Background(), testdata.GenerateLogsOneEmptyLogRecord())) @@ -74,23 +76,23 @@ func TestLoggingExporterErrors(t *testing.T) { 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())) + assert.Equal(t, errWant, le.pushTraces(context.Background(), traces.New())) + assert.Equal(t, errWant, le.pushMetrics(context.Background(), metrics.New())) + assert.Equal(t, errWant, le.pushLogs(context.Background(), logs.New())) } type errMarshaler struct { err error } -func (e errMarshaler) MarshalLogs(pdata.Logs) ([]byte, error) { +func (e errMarshaler) MarshalLogs(logs.Logs) ([]byte, error) { return nil, e.err } -func (e errMarshaler) MarshalMetrics(pdata.Metrics) ([]byte, error) { +func (e errMarshaler) MarshalMetrics(metrics.Metrics) ([]byte, error) { return nil, e.err } -func (e errMarshaler) MarshalTraces(pdata.Traces) ([]byte, error) { +func (e errMarshaler) MarshalTraces(traces.Traces) ([]byte, error) { return nil, e.err } diff --git a/exporter/otlpexporter/otlp.go b/exporter/otlpexporter/otlp.go index e8adbf44417..c9902f533f0 100644 --- a/exporter/otlpexporter/otlp.go +++ b/exporter/otlpexporter/otlp.go @@ -32,7 +32,9 @@ import ( "go.opentelemetry.io/collector/consumer/consumererror" "go.opentelemetry.io/collector/exporter/exporterhelper" "go.opentelemetry.io/collector/model/otlpgrpc" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) type exporter struct { @@ -96,21 +98,21 @@ func (e *exporter) shutdown(context.Context) error { return e.clientConn.Close() } -func (e *exporter) pushTraces(ctx context.Context, td pdata.Traces) error { +func (e *exporter) pushTraces(ctx context.Context, td traces.Traces) error { req := otlpgrpc.NewTracesRequest() req.SetTraces(td) _, err := e.traceExporter.Export(e.enhanceContext(ctx), req, e.callOptions...) return processError(err) } -func (e *exporter) pushMetrics(ctx context.Context, md pdata.Metrics) error { +func (e *exporter) pushMetrics(ctx context.Context, md metrics.Metrics) error { req := otlpgrpc.NewMetricsRequest() req.SetMetrics(md) _, err := e.metricExporter.Export(e.enhanceContext(ctx), req, e.callOptions...) return processError(err) } -func (e *exporter) pushLogs(ctx context.Context, ld pdata.Logs) error { +func (e *exporter) pushLogs(ctx context.Context, ld logs.Logs) error { req := otlpgrpc.NewLogsRequest() req.SetLogs(ld) _, err := e.logExporter.Export(e.enhanceContext(ctx), req, e.callOptions...) diff --git a/exporter/otlpexporter/otlp_test.go b/exporter/otlpexporter/otlp_test.go index 90075c4c075..dbec2a909b1 100644 --- a/exporter/otlpexporter/otlp_test.go +++ b/exporter/otlpexporter/otlp_test.go @@ -36,7 +36,9 @@ import ( "go.opentelemetry.io/collector/config/configtls" "go.opentelemetry.io/collector/internal/testdata" "go.opentelemetry.io/collector/model/otlpgrpc" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) type mockReceiver struct { @@ -55,7 +57,7 @@ func (r *mockReceiver) GetMetadata() metadata.MD { type mockTracesReceiver struct { mockReceiver - lastRequest pdata.Traces + lastRequest traces.Traces } func (r *mockTracesReceiver) Export(ctx context.Context, req otlpgrpc.TracesRequest) (otlpgrpc.TracesResponse, error) { @@ -69,7 +71,7 @@ func (r *mockTracesReceiver) Export(ctx context.Context, req otlpgrpc.TracesRequ return otlpgrpc.NewTracesResponse(), nil } -func (r *mockTracesReceiver) GetLastRequest() pdata.Traces { +func (r *mockTracesReceiver) GetLastRequest() traces.Traces { r.mux.Lock() defer r.mux.Unlock() return r.lastRequest @@ -108,7 +110,7 @@ func otlpTracesReceiverOnGRPCServer(ln net.Listener, useTLS bool) (*mockTracesRe type mockLogsReceiver struct { mockReceiver - lastRequest pdata.Logs + lastRequest logs.Logs } func (r *mockLogsReceiver) Export(ctx context.Context, req otlpgrpc.LogsRequest) (otlpgrpc.LogsResponse, error) { @@ -122,7 +124,7 @@ func (r *mockLogsReceiver) Export(ctx context.Context, req otlpgrpc.LogsRequest) return otlpgrpc.NewLogsResponse(), nil } -func (r *mockLogsReceiver) GetLastRequest() pdata.Logs { +func (r *mockLogsReceiver) GetLastRequest() logs.Logs { r.mux.Lock() defer r.mux.Unlock() return r.lastRequest @@ -146,7 +148,7 @@ func otlpLogsReceiverOnGRPCServer(ln net.Listener) *mockLogsReceiver { type mockMetricsReceiver struct { mockReceiver - lastRequest pdata.Metrics + lastRequest metrics.Metrics } func (r *mockMetricsReceiver) Export(ctx context.Context, req otlpgrpc.MetricsRequest) (otlpgrpc.MetricsResponse, error) { @@ -160,7 +162,7 @@ func (r *mockMetricsReceiver) Export(ctx context.Context, req otlpgrpc.MetricsRe return otlpgrpc.NewMetricsResponse(), nil } -func (r *mockMetricsReceiver) GetLastRequest() pdata.Metrics { +func (r *mockMetricsReceiver) GetLastRequest() metrics.Metrics { r.mux.Lock() defer r.mux.Unlock() return r.lastRequest @@ -220,7 +222,7 @@ func TestSendTraces(t *testing.T) { assert.EqualValues(t, 0, atomic.LoadInt32(&rcv.requestCount)) // Send empty trace. - td := pdata.NewTraces() + td := traces.New() assert.NoError(t, exp.ConsumeTraces(context.Background(), td)) // Wait until it is received. @@ -314,7 +316,7 @@ func TestSendTracesWhenEndpointHasHttpScheme(t *testing.T) { assert.EqualValues(t, 0, atomic.LoadInt32(&rcv.requestCount)) // Send empty trace. - td := pdata.NewTraces() + td := traces.New() assert.NoError(t, exp.ConsumeTraces(context.Background(), td)) // Wait until it is received. @@ -366,7 +368,7 @@ func TestSendMetrics(t *testing.T) { assert.EqualValues(t, 0, atomic.LoadInt32(&rcv.requestCount)) // Send empty metric. - md := pdata.NewMetrics() + md := metrics.New() assert.NoError(t, exp.ConsumeMetrics(context.Background(), md)) // Wait until it is received. @@ -513,7 +515,7 @@ func TestSendTraceDataServerStartWhileRequest(t *testing.T) { cancel() } -func startServerAndMakeRequest(t *testing.T, exp component.TracesExporter, td pdata.Traces, ln net.Listener) { +func startServerAndMakeRequest(t *testing.T, exp component.TracesExporter, td traces.Traces, ln net.Listener) { rcv, _ := otlpTracesReceiverOnGRPCServer(ln, false) defer rcv.srv.GracefulStop() // Ensure that initially there is no data in the receiver. @@ -572,7 +574,7 @@ func TestSendLogData(t *testing.T) { assert.EqualValues(t, 0, atomic.LoadInt32(&rcv.requestCount)) // Send empty request. - ld := pdata.NewLogs() + ld := logs.New() assert.NoError(t, exp.ConsumeLogs(context.Background(), ld)) // Wait until it is received. diff --git a/exporter/otlphttpexporter/otlp.go b/exporter/otlphttpexporter/otlp.go index 717e00e4931..4d31d722e4c 100644 --- a/exporter/otlphttpexporter/otlp.go +++ b/exporter/otlphttpexporter/otlp.go @@ -36,7 +36,9 @@ import ( "go.opentelemetry.io/collector/consumer/consumererror" "go.opentelemetry.io/collector/exporter/exporterhelper" "go.opentelemetry.io/collector/model/otlpgrpc" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) type exporter struct { @@ -91,7 +93,7 @@ func (e *exporter) start(_ context.Context, host component.Host) error { return nil } -func (e *exporter) pushTraces(ctx context.Context, td pdata.Traces) error { +func (e *exporter) pushTraces(ctx context.Context, td traces.Traces) error { tr := otlpgrpc.NewTracesRequest() tr.SetTraces(td) request, err := tr.MarshalProto() @@ -102,7 +104,7 @@ func (e *exporter) pushTraces(ctx context.Context, td pdata.Traces) error { return e.export(ctx, e.tracesURL, request) } -func (e *exporter) pushMetrics(ctx context.Context, md pdata.Metrics) error { +func (e *exporter) pushMetrics(ctx context.Context, md metrics.Metrics) error { tr := otlpgrpc.NewMetricsRequest() tr.SetMetrics(md) request, err := tr.MarshalProto() @@ -112,7 +114,7 @@ func (e *exporter) pushMetrics(ctx context.Context, md pdata.Metrics) error { return e.export(ctx, e.metricsURL, request) } -func (e *exporter) pushLogs(ctx context.Context, ld pdata.Logs) error { +func (e *exporter) pushLogs(ctx context.Context, ld logs.Logs) error { tr := otlpgrpc.NewLogsRequest() tr.SetLogs(ld) request, err := tr.MarshalProto() diff --git a/exporter/otlphttpexporter/otlp_test.go b/exporter/otlphttpexporter/otlp_test.go index d4391d5a1df..66e6b274b5e 100644 --- a/exporter/otlphttpexporter/otlp_test.go +++ b/exporter/otlphttpexporter/otlp_test.go @@ -47,6 +47,9 @@ import ( "go.opentelemetry.io/collector/internal/testutil" "go.opentelemetry.io/collector/model/otlpgrpc" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" "go.opentelemetry.io/collector/receiver/otlpreceiver" ) @@ -265,7 +268,7 @@ func TestIssue_4221(t *testing.T) { exp := startTracesExporter(t, "", svr.URL) - md := pdata.NewTraces() + md := traces.New() rms := md.ResourceSpans().AppendEmpty() rms.Resource().Attributes().UpsertString("service.name", "uop.stage-eu-1") rms.Resource().Attributes().UpsertString("outsystems.module.version", "903386") @@ -464,7 +467,7 @@ func TestErrorResponses(t *testing.T) { }) // generate traces - traces := pdata.NewTraces() + traces := traces.New() err = exp.ConsumeTraces(context.Background(), traces) assert.Error(t, err) @@ -542,7 +545,7 @@ func TestUserAgent(t *testing.T) { }) // generate data - traces := pdata.NewTraces() + traces := traces.New() err = exp.ConsumeTraces(context.Background(), traces) require.NoError(t, err) @@ -587,7 +590,7 @@ func TestUserAgent(t *testing.T) { }) // generate data - metrics := pdata.NewMetrics() + metrics := metrics.New() err = exp.ConsumeMetrics(context.Background(), metrics) require.NoError(t, err) @@ -632,7 +635,7 @@ func TestUserAgent(t *testing.T) { }) // generate data - logs := pdata.NewLogs() + logs := logs.New() err = exp.ConsumeLogs(context.Background(), logs) require.NoError(t, err) diff --git a/go.sum b/go.sum index 0b7f3b14fb2..106c704501c 100644 --- a/go.sum +++ b/go.sum @@ -67,6 +67,7 @@ github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kB github.com/cenkalti/backoff/v4 v4.1.2 h1:6Yo7N8UP2K6LWZnW94DLVSSrbobcWdVzAYOisuDPIFo= github.com/cenkalti/backoff/v4 v4.1.2/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE= diff --git a/internal/internalconsumertest/err_or_sink_consumer.go b/internal/internalconsumertest/err_or_sink_consumer.go index fb5f8914bf7..df3915a7035 100644 --- a/internal/internalconsumertest/err_or_sink_consumer.go +++ b/internal/internalconsumertest/err_or_sink_consumer.go @@ -20,7 +20,8 @@ import ( "go.opentelemetry.io/collector/consumer" "go.opentelemetry.io/collector/consumer/consumertest" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) type ErrOrSinkConsumer struct { @@ -42,7 +43,7 @@ func (esc *ErrOrSinkConsumer) Capabilities() consumer.Capabilities { } // ConsumeTraces stores traces to this sink. -func (esc *ErrOrSinkConsumer) ConsumeTraces(ctx context.Context, td pdata.Traces) error { +func (esc *ErrOrSinkConsumer) ConsumeTraces(ctx context.Context, td traces.Traces) error { esc.mu.Lock() defer esc.mu.Unlock() @@ -54,7 +55,7 @@ func (esc *ErrOrSinkConsumer) ConsumeTraces(ctx context.Context, td pdata.Traces } // ConsumeMetrics stores metrics to this sink. -func (esc *ErrOrSinkConsumer) ConsumeMetrics(ctx context.Context, md pdata.Metrics) error { +func (esc *ErrOrSinkConsumer) ConsumeMetrics(ctx context.Context, md metrics.Metrics) error { esc.mu.Lock() defer esc.mu.Unlock() diff --git a/internal/otlptext/databuffer.go b/internal/otlptext/databuffer.go index 356e26b91ab..6239d76d25b 100644 --- a/internal/otlptext/databuffer.go +++ b/internal/otlptext/databuffer.go @@ -22,6 +22,7 @@ import ( "strings" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) type dataBuffer struct { @@ -56,7 +57,7 @@ func (b *dataBuffer) logInstrumentationScope(il pdata.InstrumentationScope) { il.Version()) } -func (b *dataBuffer) logMetricDescriptor(md pdata.Metric) { +func (b *dataBuffer) logMetricDescriptor(md metrics.Metric) { b.logEntry("Descriptor:") b.logEntry(" -> Name: %s", md.Name()) b.logEntry(" -> Description: %s", md.Description()) @@ -64,32 +65,32 @@ func (b *dataBuffer) logMetricDescriptor(md pdata.Metric) { b.logEntry(" -> DataType: %s", md.DataType().String()) } -func (b *dataBuffer) logMetricDataPoints(m pdata.Metric) { +func (b *dataBuffer) logMetricDataPoints(m metrics.Metric) { switch m.DataType() { - case pdata.MetricDataTypeNone: + case metrics.MetricDataTypeNone: return - case pdata.MetricDataTypeGauge: + case metrics.MetricDataTypeGauge: b.logNumberDataPoints(m.Gauge().DataPoints()) - case pdata.MetricDataTypeSum: + case metrics.MetricDataTypeSum: data := m.Sum() b.logEntry(" -> IsMonotonic: %t", data.IsMonotonic()) b.logEntry(" -> AggregationTemporality: %s", data.AggregationTemporality().String()) b.logNumberDataPoints(data.DataPoints()) - case pdata.MetricDataTypeHistogram: + case metrics.MetricDataTypeHistogram: data := m.Histogram() b.logEntry(" -> AggregationTemporality: %s", data.AggregationTemporality().String()) b.logDoubleHistogramDataPoints(data.DataPoints()) - case pdata.MetricDataTypeExponentialHistogram: + case metrics.MetricDataTypeExponentialHistogram: data := m.ExponentialHistogram() b.logEntry(" -> AggregationTemporality: %s", data.AggregationTemporality().String()) b.logExponentialHistogramDataPoints(data.DataPoints()) - case pdata.MetricDataTypeSummary: + case metrics.MetricDataTypeSummary: data := m.Summary() b.logDoubleSummaryDataPoints(data.DataPoints()) } } -func (b *dataBuffer) logNumberDataPoints(ps pdata.NumberDataPointSlice) { +func (b *dataBuffer) logNumberDataPoints(ps metrics.NumberDataPointSlice) { for i := 0; i < ps.Len(); i++ { p := ps.At(i) b.logEntry("NumberDataPoints #%d", i) @@ -98,15 +99,15 @@ func (b *dataBuffer) logNumberDataPoints(ps pdata.NumberDataPointSlice) { b.logEntry("StartTimestamp: %s", p.StartTimestamp()) b.logEntry("Timestamp: %s", p.Timestamp()) switch p.ValueType() { - case pdata.MetricValueTypeInt: + case metrics.MetricValueTypeInt: b.logEntry("Value: %d", p.IntVal()) - case pdata.MetricValueTypeDouble: + case metrics.MetricValueTypeDouble: b.logEntry("Value: %f", p.DoubleVal()) } } } -func (b *dataBuffer) logDoubleHistogramDataPoints(ps pdata.HistogramDataPointSlice) { +func (b *dataBuffer) logDoubleHistogramDataPoints(ps metrics.HistogramDataPointSlice) { for i := 0; i < ps.Len(); i++ { p := ps.At(i) b.logEntry("HistogramDataPoints #%d", i) @@ -133,7 +134,7 @@ func (b *dataBuffer) logDoubleHistogramDataPoints(ps pdata.HistogramDataPointSli } } -func (b *dataBuffer) logExponentialHistogramDataPoints(ps pdata.ExponentialHistogramDataPointSlice) { +func (b *dataBuffer) logExponentialHistogramDataPoints(ps metrics.ExponentialHistogramDataPointSlice) { for i := 0; i < ps.Len(); i++ { p := ps.At(i) b.logEntry("ExponentialHistogramDataPoints #%d", i) @@ -181,7 +182,7 @@ func (b *dataBuffer) logExponentialHistogramDataPoints(ps pdata.ExponentialHisto } } -func (b *dataBuffer) logDoubleSummaryDataPoints(ps pdata.SummaryDataPointSlice) { +func (b *dataBuffer) logDoubleSummaryDataPoints(ps metrics.SummaryDataPointSlice) { for i := 0; i < ps.Len(); i++ { p := ps.At(i) b.logEntry("SummaryDataPoints #%d", i) diff --git a/internal/otlptext/logs.go b/internal/otlptext/logs.go index f68e3c90a05..1a762b5e470 100644 --- a/internal/otlptext/logs.go +++ b/internal/otlptext/logs.go @@ -15,18 +15,18 @@ package otlptext // import "go.opentelemetry.io/collector/internal/otlptext" import ( - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) // NewTextLogsMarshaler returns a serializer.LogsMarshaler to encode to OTLP text bytes. -func NewTextLogsMarshaler() pdata.LogsMarshaler { +func NewTextLogsMarshaler() logs.Marshaler { return textLogsMarshaler{} } type textLogsMarshaler struct{} -// MarshalLogs pdata.Logs to OTLP text. -func (textLogsMarshaler) MarshalLogs(ld pdata.Logs) ([]byte, error) { +// MarshalLogs logs.Logs to OTLP text. +func (textLogsMarshaler) MarshalLogs(ld logs.Logs) ([]byte, error) { buf := dataBuffer{} rls := ld.ResourceLogs() for i := 0; i < rls.Len(); i++ { diff --git a/internal/otlptext/logs_test.go b/internal/otlptext/logs_test.go index 137e3c73a25..44c4f741146 100644 --- a/internal/otlptext/logs_test.go +++ b/internal/otlptext/logs_test.go @@ -20,19 +20,19 @@ import ( "github.com/stretchr/testify/assert" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) func TestLogsText(t *testing.T) { type args struct { - ld pdata.Logs + ld logs.Logs } tests := []struct { name string args args empty bool }{ - {"empty logs", args{pdata.NewLogs()}, true}, + {"empty logs", args{logs.New()}, true}, {"logs data with empty resource log", args{testdata.GenerateLogsOneEmptyResourceLogs()}, false}, {"logs data with no log records", args{testdata.GenerateLogsNoLogRecords()}, false}, {"logs with one empty log", args{testdata.GenerateLogsOneEmptyLogRecord()}, false}, diff --git a/internal/otlptext/metrics.go b/internal/otlptext/metrics.go index 4e3d5e69b14..21684ab8b18 100644 --- a/internal/otlptext/metrics.go +++ b/internal/otlptext/metrics.go @@ -15,18 +15,18 @@ package otlptext // import "go.opentelemetry.io/collector/internal/otlptext" import ( - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) // NewTextMetricsMarshaler returns a serializer.MetricsMarshaler to encode to OTLP text bytes. -func NewTextMetricsMarshaler() pdata.MetricsMarshaler { +func NewTextMetricsMarshaler() metrics.Marshaler { return textMetricsMarshaler{} } type textMetricsMarshaler struct{} -// MarshalMetrics pdata.Metrics to OTLP text. -func (textMetricsMarshaler) MarshalMetrics(md pdata.Metrics) ([]byte, error) { +// MarshalMetrics metrics.Metrics to OTLP text. +func (textMetricsMarshaler) MarshalMetrics(md metrics.Metrics) ([]byte, error) { buf := dataBuffer{} rms := md.ResourceMetrics() for i := 0; i < rms.Len(); i++ { diff --git a/internal/otlptext/metrics_test.go b/internal/otlptext/metrics_test.go index 5213bda8df8..ede1443ca38 100644 --- a/internal/otlptext/metrics_test.go +++ b/internal/otlptext/metrics_test.go @@ -20,19 +20,19 @@ import ( "github.com/stretchr/testify/assert" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) func TestMetricsText(t *testing.T) { type args struct { - md pdata.Metrics + md metrics.Metrics } tests := []struct { name string args args empty bool }{ - {"empty metrics", args{pdata.NewMetrics()}, true}, + {"empty metrics", args{metrics.New()}, true}, {"metrics with all types and datapoints", args{testdata.GeneratMetricsAllTypesWithSampleDatapoints()}, false}, {"metrics with all types without datapoints", args{testdata.GenerateMetricsAllTypesEmptyDataPoint()}, false}, {"metrics with invalid metric types", args{testdata.GenerateMetricsMetricTypeInvalid()}, false}, diff --git a/internal/otlptext/traces.go b/internal/otlptext/traces.go index 7eb86f3c0df..37cd45d9a8f 100644 --- a/internal/otlptext/traces.go +++ b/internal/otlptext/traces.go @@ -15,18 +15,18 @@ package otlptext // import "go.opentelemetry.io/collector/internal/otlptext" import ( - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) // NewTextTracesMarshaler returns a serializer.TracesMarshaler to encode to OTLP text bytes. -func NewTextTracesMarshaler() pdata.TracesMarshaler { +func NewTextTracesMarshaler() traces.Marshaler { return textTracesMarshaler{} } type textTracesMarshaler struct{} -// MarshalTraces pdata.Traces to OTLP text. -func (textTracesMarshaler) MarshalTraces(td pdata.Traces) ([]byte, error) { +// MarshalTraces traces.Traces to OTLP text. +func (textTracesMarshaler) MarshalTraces(td traces.Traces) ([]byte, error) { buf := dataBuffer{} rss := td.ResourceSpans() for i := 0; i < rss.Len(); i++ { diff --git a/internal/otlptext/traces_test.go b/internal/otlptext/traces_test.go index 875dfb3227a..60028314fde 100644 --- a/internal/otlptext/traces_test.go +++ b/internal/otlptext/traces_test.go @@ -20,19 +20,19 @@ import ( "github.com/stretchr/testify/assert" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestTracesText(t *testing.T) { type args struct { - td pdata.Traces + td traces.Traces } tests := []struct { name string args args empty bool }{ - {"empty traces", args{pdata.NewTraces()}, true}, + {"empty traces", args{traces.New()}, true}, {"traces with two spans", args{testdata.GenerateTracesTwoSpansSameResource()}, false}, } for _, tt := range tests { diff --git a/internal/testcomponents/example_exporter.go b/internal/testcomponents/example_exporter.go index 984a3fb7dd3..1db6d695fc6 100644 --- a/internal/testcomponents/example_exporter.go +++ b/internal/testcomponents/example_exporter.go @@ -20,7 +20,9 @@ import ( "go.opentelemetry.io/collector/component" "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/consumer" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) var _ config.Unmarshallable = (*ExampleExporter)(nil) @@ -74,9 +76,9 @@ func createLogsExporter(context.Context, component.ExporterCreateSettings, confi // ExampleExporterConsumer stores consumed traces and metrics for testing purposes. type ExampleExporterConsumer struct { - Traces []pdata.Traces - Metrics []pdata.Metrics - Logs []pdata.Logs + Traces []traces.Traces + Metrics []metrics.Metrics + Logs []logs.Logs ExporterStarted bool ExporterShutdown bool } @@ -89,8 +91,8 @@ func (exp *ExampleExporterConsumer) Start(_ context.Context, _ component.Host) e return nil } -// ConsumeTraces receives pdata.Traces for processing by the consumer.Traces. -func (exp *ExampleExporterConsumer) ConsumeTraces(_ context.Context, td pdata.Traces) error { +// ConsumeTraces receives traces.Traces for processing by the consumer.Traces. +func (exp *ExampleExporterConsumer) ConsumeTraces(_ context.Context, td traces.Traces) error { exp.Traces = append(exp.Traces, td) return nil } @@ -99,13 +101,13 @@ func (exp *ExampleExporterConsumer) Capabilities() consumer.Capabilities { return consumer.Capabilities{MutatesData: false} } -// ConsumeMetrics receives pdata.Metrics for processing by the Metrics. -func (exp *ExampleExporterConsumer) ConsumeMetrics(_ context.Context, md pdata.Metrics) error { +// ConsumeMetrics receives metrics.Metrics for processing by the Metrics. +func (exp *ExampleExporterConsumer) ConsumeMetrics(_ context.Context, md metrics.Metrics) error { exp.Metrics = append(exp.Metrics, md) return nil } -func (exp *ExampleExporterConsumer) ConsumeLogs(_ context.Context, ld pdata.Logs) error { +func (exp *ExampleExporterConsumer) ConsumeLogs(_ context.Context, ld logs.Logs) error { exp.Logs = append(exp.Logs, ld) return nil } diff --git a/internal/testcomponents/example_exporter_test.go b/internal/testcomponents/example_exporter_test.go index 48ae7907b34..4e288d64858 100644 --- a/internal/testcomponents/example_exporter_test.go +++ b/internal/testcomponents/example_exporter_test.go @@ -21,7 +21,8 @@ import ( "github.com/stretchr/testify/assert" "go.opentelemetry.io/collector/component/componenttest" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestExampleExporterConsumer(t *testing.T) { @@ -33,12 +34,12 @@ func TestExampleExporterConsumer(t *testing.T) { assert.True(t, exp.ExporterStarted) assert.Equal(t, 0, len(exp.Traces)) - err = exp.ConsumeTraces(context.Background(), pdata.Traces{}) + err = exp.ConsumeTraces(context.Background(), traces.Traces{}) assert.NoError(t, err) assert.Equal(t, 1, len(exp.Traces)) assert.Equal(t, 0, len(exp.Metrics)) - err = exp.ConsumeMetrics(context.Background(), pdata.Metrics{}) + err = exp.ConsumeMetrics(context.Background(), metrics.Metrics{}) assert.NoError(t, err) assert.Equal(t, 1, len(exp.Metrics)) diff --git a/internal/testdata/log.go b/internal/testdata/log.go index 01167385829..16e3c690e0e 100644 --- a/internal/testdata/log.go +++ b/internal/testdata/log.go @@ -18,6 +18,7 @@ import ( "time" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) var ( @@ -25,32 +26,32 @@ var ( TestLogTimestamp = pdata.NewTimestampFromTime(TestLogTime) ) -func GenerateLogsOneEmptyResourceLogs() pdata.Logs { - ld := pdata.NewLogs() +func GenerateLogsOneEmptyResourceLogs() logs.Logs { + ld := logs.New() ld.ResourceLogs().AppendEmpty() return ld } -func GenerateLogsNoLogRecords() pdata.Logs { +func GenerateLogsNoLogRecords() logs.Logs { ld := GenerateLogsOneEmptyResourceLogs() initResource1(ld.ResourceLogs().At(0).Resource()) return ld } -func GenerateLogsOneEmptyLogRecord() pdata.Logs { +func GenerateLogsOneEmptyLogRecord() logs.Logs { ld := GenerateLogsNoLogRecords() rs0 := ld.ResourceLogs().At(0) rs0.ScopeLogs().AppendEmpty().LogRecords().AppendEmpty() return ld } -func GenerateLogsOneLogRecord() pdata.Logs { +func GenerateLogsOneLogRecord() logs.Logs { ld := GenerateLogsOneEmptyLogRecord() fillLogOne(ld.ResourceLogs().At(0).ScopeLogs().At(0).LogRecords().At(0)) return ld } -func GenerateLogsTwoLogRecordsSameResource() pdata.Logs { +func GenerateLogsTwoLogRecordsSameResource() logs.Logs { ld := GenerateLogsOneEmptyLogRecord() logs := ld.ResourceLogs().At(0).ScopeLogs().At(0).LogRecords() fillLogOne(logs.At(0)) @@ -58,8 +59,8 @@ func GenerateLogsTwoLogRecordsSameResource() pdata.Logs { return ld } -func GenerateLogsTwoLogRecordsSameResourceOneDifferent() pdata.Logs { - ld := pdata.NewLogs() +func GenerateLogsTwoLogRecordsSameResourceOneDifferent() logs.Logs { + ld := logs.New() rl0 := ld.ResourceLogs().AppendEmpty() initResource1(rl0.Resource()) logs := rl0.ScopeLogs().AppendEmpty().LogRecords() @@ -70,10 +71,10 @@ func GenerateLogsTwoLogRecordsSameResourceOneDifferent() pdata.Logs { fillLogThree(rl1.ScopeLogs().AppendEmpty().LogRecords().AppendEmpty()) return ld } -func fillLogOne(log pdata.LogRecord) { +func fillLogOne(log logs.LogRecord) { log.SetTimestamp(TestLogTimestamp) log.SetDroppedAttributesCount(1) - log.SetSeverityNumber(pdata.SeverityNumberINFO) + log.SetSeverityNumber(logs.SeverityNumberINFO) log.SetSeverityText("Info") log.SetSpanID(pdata.NewSpanID([8]byte{0x01, 0x02, 0x04, 0x08})) log.SetTraceID(pdata.NewTraceID([16]byte{0x08, 0x04, 0x02, 0x01})) @@ -85,10 +86,10 @@ func fillLogOne(log pdata.LogRecord) { log.Body().SetStringVal("This is a log message") } -func fillLogTwo(log pdata.LogRecord) { +func fillLogTwo(log logs.LogRecord) { log.SetTimestamp(TestLogTimestamp) log.SetDroppedAttributesCount(1) - log.SetSeverityNumber(pdata.SeverityNumberINFO) + log.SetSeverityNumber(logs.SeverityNumberINFO) log.SetSeverityText("Info") attrs := log.Attributes() @@ -98,25 +99,25 @@ func fillLogTwo(log pdata.LogRecord) { log.Body().SetStringVal("something happened") } -func fillLogThree(log pdata.LogRecord) { +func fillLogThree(log logs.LogRecord) { log.SetTimestamp(TestLogTimestamp) log.SetDroppedAttributesCount(1) - log.SetSeverityNumber(pdata.SeverityNumberWARN) + log.SetSeverityNumber(logs.SeverityNumberWARN) log.SetSeverityText("Warning") log.Body().SetStringVal("something else happened") } -func GenerateLogsManyLogRecordsSameResource(count int) pdata.Logs { +func GenerateLogsManyLogRecordsSameResource(count int) logs.Logs { ld := GenerateLogsOneEmptyLogRecord() - logs := ld.ResourceLogs().At(0).ScopeLogs().At(0).LogRecords() - logs.EnsureCapacity(count) + rls := ld.ResourceLogs().At(0).ScopeLogs().At(0).LogRecords() + rls.EnsureCapacity(count) for i := 0; i < count; i++ { - var l pdata.LogRecord - if i < logs.Len() { - l = logs.At(i) + var l logs.LogRecord + if i < rls.Len() { + l = rls.At(i) } else { - l = logs.AppendEmpty() + l = rls.AppendEmpty() } if i%2 == 0 { diff --git a/internal/testdata/metric.go b/internal/testdata/metric.go index 4fc2fe1e4cb..745c1aba958 100644 --- a/internal/testdata/metric.go +++ b/internal/testdata/metric.go @@ -18,6 +18,7 @@ import ( "time" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) var ( @@ -41,33 +42,33 @@ const ( TestSummaryMetricName = "summary" ) -func GenerateMetricsOneEmptyResourceMetrics() pdata.Metrics { - md := pdata.NewMetrics() +func GenerateMetricsOneEmptyResourceMetrics() metrics.Metrics { + md := metrics.New() md.ResourceMetrics().AppendEmpty() return md } -func GenerateMetricsNoLibraries() pdata.Metrics { +func GenerateMetricsNoLibraries() metrics.Metrics { md := GenerateMetricsOneEmptyResourceMetrics() ms0 := md.ResourceMetrics().At(0) initResource1(ms0.Resource()) return md } -func GenerateMetricsOneEmptyInstrumentationScope() pdata.Metrics { +func GenerateMetricsOneEmptyInstrumentationScope() metrics.Metrics { md := GenerateMetricsNoLibraries() md.ResourceMetrics().At(0).ScopeMetrics().AppendEmpty() return md } -func GenerateMetricsOneMetric() pdata.Metrics { +func GenerateMetricsOneMetric() metrics.Metrics { md := GenerateMetricsOneEmptyInstrumentationScope() rm0ils0 := md.ResourceMetrics().At(0).ScopeMetrics().At(0) initSumIntMetric(rm0ils0.Metrics().AppendEmpty()) return md } -func GenerateMetricsTwoMetrics() pdata.Metrics { +func GenerateMetricsTwoMetrics() metrics.Metrics { md := GenerateMetricsOneEmptyInstrumentationScope() rm0ils0 := md.ResourceMetrics().At(0).ScopeMetrics().At(0) initSumIntMetric(rm0ils0.Metrics().AppendEmpty()) @@ -75,40 +76,40 @@ func GenerateMetricsTwoMetrics() pdata.Metrics { return md } -func GenerateMetricsAllTypesEmptyDataPoint() pdata.Metrics { +func GenerateMetricsAllTypesEmptyDataPoint() metrics.Metrics { md := GenerateMetricsOneEmptyInstrumentationScope() ilm0 := md.ResourceMetrics().At(0).ScopeMetrics().At(0) ms := ilm0.Metrics() doubleGauge := ms.AppendEmpty() - initMetric(doubleGauge, TestGaugeDoubleMetricName, pdata.MetricDataTypeGauge) + initMetric(doubleGauge, TestGaugeDoubleMetricName, metrics.MetricDataTypeGauge) doubleGauge.Gauge().DataPoints().AppendEmpty() intGauge := ms.AppendEmpty() - initMetric(intGauge, TestGaugeIntMetricName, pdata.MetricDataTypeGauge) + initMetric(intGauge, TestGaugeIntMetricName, metrics.MetricDataTypeGauge) intGauge.Gauge().DataPoints().AppendEmpty() doubleSum := ms.AppendEmpty() - initMetric(doubleSum, TestSumDoubleMetricName, pdata.MetricDataTypeSum) + initMetric(doubleSum, TestSumDoubleMetricName, metrics.MetricDataTypeSum) doubleSum.Sum().DataPoints().AppendEmpty() intSum := ms.AppendEmpty() - initMetric(intSum, TestSumIntMetricName, pdata.MetricDataTypeSum) + initMetric(intSum, TestSumIntMetricName, metrics.MetricDataTypeSum) intSum.Sum().DataPoints().AppendEmpty() histogram := ms.AppendEmpty() - initMetric(histogram, TestHistogramMetricName, pdata.MetricDataTypeHistogram) + initMetric(histogram, TestHistogramMetricName, metrics.MetricDataTypeHistogram) histogram.Histogram().DataPoints().AppendEmpty() summary := ms.AppendEmpty() - initMetric(summary, TestSummaryMetricName, pdata.MetricDataTypeSummary) + initMetric(summary, TestSummaryMetricName, metrics.MetricDataTypeSummary) summary.Summary().DataPoints().AppendEmpty() return md } -func GenerateMetricsMetricTypeInvalid() pdata.Metrics { +func GenerateMetricsMetricTypeInvalid() metrics.Metrics { md := GenerateMetricsOneEmptyInstrumentationScope() ilm0 := md.ResourceMetrics().At(0).ScopeMetrics().At(0) - initMetric(ilm0.Metrics().AppendEmpty(), TestSumIntMetricName, pdata.MetricDataTypeNone) + initMetric(ilm0.Metrics().AppendEmpty(), TestSumIntMetricName, metrics.MetricDataTypeNone) return md } -func GeneratMetricsAllTypesWithSampleDatapoints() pdata.Metrics { +func GeneratMetricsAllTypesWithSampleDatapoints() metrics.Metrics { md := GenerateMetricsOneEmptyInstrumentationScope() ilm := md.ResourceMetrics().At(0).ScopeMetrics().At(0) @@ -123,8 +124,8 @@ func GeneratMetricsAllTypesWithSampleDatapoints() pdata.Metrics { return md } -func initGaugeIntMetric(im pdata.Metric) { - initMetric(im, TestGaugeIntMetricName, pdata.MetricDataTypeGauge) +func initGaugeIntMetric(im metrics.Metric) { + initMetric(im, TestGaugeIntMetricName, metrics.MetricDataTypeGauge) idps := im.Gauge().DataPoints() idp0 := idps.AppendEmpty() @@ -139,8 +140,8 @@ func initGaugeIntMetric(im pdata.Metric) { idp1.SetIntVal(456) } -func initGaugeDoubleMetric(im pdata.Metric) { - initMetric(im, TestGaugeDoubleMetricName, pdata.MetricDataTypeGauge) +func initGaugeDoubleMetric(im metrics.Metric) { + initMetric(im, TestGaugeDoubleMetricName, metrics.MetricDataTypeGauge) idps := im.Gauge().DataPoints() idp0 := idps.AppendEmpty() @@ -155,8 +156,8 @@ func initGaugeDoubleMetric(im pdata.Metric) { idp1.SetDoubleVal(4.56) } -func initSumIntMetric(im pdata.Metric) { - initMetric(im, TestSumIntMetricName, pdata.MetricDataTypeSum) +func initSumIntMetric(im metrics.Metric) { + initMetric(im, TestSumIntMetricName, metrics.MetricDataTypeSum) idps := im.Sum().DataPoints() idp0 := idps.AppendEmpty() @@ -171,8 +172,8 @@ func initSumIntMetric(im pdata.Metric) { idp1.SetIntVal(456) } -func initSumDoubleMetric(dm pdata.Metric) { - initMetric(dm, TestSumDoubleMetricName, pdata.MetricDataTypeSum) +func initSumDoubleMetric(dm metrics.Metric) { + initMetric(dm, TestSumDoubleMetricName, metrics.MetricDataTypeSum) ddps := dm.Sum().DataPoints() ddp0 := ddps.AppendEmpty() @@ -188,8 +189,8 @@ func initSumDoubleMetric(dm pdata.Metric) { ddp1.SetDoubleVal(4.56) } -func initHistogramMetric(hm pdata.Metric) { - initMetric(hm, TestHistogramMetricName, pdata.MetricDataTypeHistogram) +func initHistogramMetric(hm metrics.Metric) { + initMetric(hm, TestHistogramMetricName, metrics.MetricDataTypeHistogram) hdps := hm.Histogram().DataPoints() hdp0 := hdps.AppendEmpty() @@ -213,8 +214,8 @@ func initHistogramMetric(hm pdata.Metric) { hdp1.SetExplicitBounds([]float64{1}) } -func initExponentialHistogramMetric(hm pdata.Metric) { - initMetric(hm, TestExponentialHistogramMetricName, pdata.MetricDataTypeExponentialHistogram) +func initExponentialHistogramMetric(hm metrics.Metric) { + initMetric(hm, TestExponentialHistogramMetricName, metrics.MetricDataTypeExponentialHistogram) hdps := hm.ExponentialHistogram().DataPoints() hdp0 := hdps.AppendEmpty() @@ -264,8 +265,8 @@ func initExponentialHistogramMetric(hm pdata.Metric) { initMetricAttachment(exemplar.FilteredAttributes()) } -func initSummaryMetric(sm pdata.Metric) { - initMetric(sm, TestSummaryMetricName, pdata.MetricDataTypeSummary) +func initSummaryMetric(sm metrics.Metric) { + initMetric(sm, TestSummaryMetricName, metrics.MetricDataTypeSummary) sdps := sm.Summary().DataPoints() sdp0 := sdps.AppendEmpty() @@ -287,26 +288,26 @@ func initSummaryMetric(sm pdata.Metric) { quantile.SetValue(15) } -func initMetric(m pdata.Metric, name string, ty pdata.MetricDataType) { +func initMetric(m metrics.Metric, name string, ty metrics.MetricDataType) { m.SetName(name) m.SetDescription("") m.SetUnit("1") m.SetDataType(ty) switch ty { - case pdata.MetricDataTypeSum: + case metrics.MetricDataTypeSum: sum := m.Sum() sum.SetIsMonotonic(true) - sum.SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative) - case pdata.MetricDataTypeHistogram: + sum.SetAggregationTemporality(metrics.MetricAggregationTemporalityCumulative) + case metrics.MetricDataTypeHistogram: histo := m.Histogram() - histo.SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative) - case pdata.MetricDataTypeExponentialHistogram: + histo.SetAggregationTemporality(metrics.MetricAggregationTemporalityCumulative) + case metrics.MetricDataTypeExponentialHistogram: histo := m.ExponentialHistogram() - histo.SetAggregationTemporality(pdata.MetricAggregationTemporalityDelta) + histo.SetAggregationTemporality(metrics.MetricAggregationTemporalityDelta) } } -func GenerateMetricsManyMetricsSameResource(metricsCount int) pdata.Metrics { +func GenerateMetricsManyMetricsSameResource(metricsCount int) metrics.Metrics { md := GenerateMetricsOneEmptyInstrumentationScope() rs0ilm0 := md.ResourceMetrics().At(0).ScopeMetrics().At(0) rs0ilm0.Metrics().EnsureCapacity(metricsCount) diff --git a/internal/testdata/trace.go b/internal/testdata/trace.go index e96207c6d63..8d33f393c68 100644 --- a/internal/testdata/trace.go +++ b/internal/testdata/trace.go @@ -18,6 +18,7 @@ import ( "time" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) var ( @@ -31,33 +32,33 @@ var ( TestSpanEndTimestamp = pdata.NewTimestampFromTime(TestSpanEndTime) ) -func GenerateTracesOneEmptyResourceSpans() pdata.Traces { - td := pdata.NewTraces() +func GenerateTracesOneEmptyResourceSpans() traces.Traces { + td := traces.New() td.ResourceSpans().AppendEmpty() return td } -func GenerateTracesNoLibraries() pdata.Traces { +func GenerateTracesNoLibraries() traces.Traces { td := GenerateTracesOneEmptyResourceSpans() rs0 := td.ResourceSpans().At(0) initResource1(rs0.Resource()) return td } -func GenerateTracesOneEmptyInstrumentationScope() pdata.Traces { +func GenerateTracesOneEmptyInstrumentationScope() traces.Traces { td := GenerateTracesNoLibraries() td.ResourceSpans().At(0).ScopeSpans().AppendEmpty() return td } -func GenerateTracesOneSpan() pdata.Traces { +func GenerateTracesOneSpan() traces.Traces { td := GenerateTracesOneEmptyInstrumentationScope() rs0ils0 := td.ResourceSpans().At(0).ScopeSpans().At(0) fillSpanOne(rs0ils0.Spans().AppendEmpty()) return td } -func GenerateTracesTwoSpansSameResource() pdata.Traces { +func GenerateTracesTwoSpansSameResource() traces.Traces { td := GenerateTracesOneEmptyInstrumentationScope() rs0ils0 := td.ResourceSpans().At(0).ScopeSpans().At(0) fillSpanOne(rs0ils0.Spans().AppendEmpty()) @@ -65,8 +66,8 @@ func GenerateTracesTwoSpansSameResource() pdata.Traces { return td } -func GenerateTracesTwoSpansSameResourceOneDifferent() pdata.Traces { - td := pdata.NewTraces() +func GenerateTracesTwoSpansSameResourceOneDifferent() traces.Traces { + td := traces.New() rs0 := td.ResourceSpans().AppendEmpty() initResource1(rs0.Resource()) rs0ils0 := rs0.ScopeSpans().AppendEmpty() @@ -79,7 +80,7 @@ func GenerateTracesTwoSpansSameResourceOneDifferent() pdata.Traces { return td } -func GenerateTracesManySpansSameResource(spanCount int) pdata.Traces { +func GenerateTracesManySpansSameResource(spanCount int) traces.Traces { td := GenerateTracesOneEmptyInstrumentationScope() rs0ils0 := td.ResourceSpans().At(0).ScopeSpans().At(0) rs0ils0.Spans().EnsureCapacity(spanCount) @@ -89,7 +90,7 @@ func GenerateTracesManySpansSameResource(spanCount int) pdata.Traces { return td } -func fillSpanOne(span pdata.Span) { +func fillSpanOne(span traces.Span) { span.SetName("operationA") span.SetStartTimestamp(TestSpanStartTimestamp) span.SetEndTimestamp(TestSpanEndTimestamp) @@ -112,7 +113,7 @@ func fillSpanOne(span pdata.Span) { status.SetMessage("status-cancelled") } -func fillSpanTwo(span pdata.Span) { +func fillSpanTwo(span traces.Span) { span.SetName("operationB") span.SetStartTimestamp(TestSpanStartTimestamp) span.SetEndTimestamp(TestSpanEndTimestamp) @@ -124,7 +125,7 @@ func fillSpanTwo(span pdata.Span) { span.SetDroppedLinksCount(3) } -func fillSpanThree(span pdata.Span) { +func fillSpanThree(span traces.Span) { span.SetName("operationC") span.SetStartTimestamp(TestSpanStartTimestamp) span.SetEndTimestamp(TestSpanEndTimestamp) diff --git a/model/internal/pdata/logs.go b/model/internal/pdata/logs.go index 18c3626c6b8..ee00cd5371f 100644 --- a/model/internal/pdata/logs.go +++ b/model/internal/pdata/logs.go @@ -18,17 +18,17 @@ import ( otlplogs "go.opentelemetry.io/collector/model/internal/data/protogen/logs/v1" ) -// LogsMarshaler marshals pdata.Logs into bytes. +// LogsMarshaler marshals logs.Logs into bytes. type LogsMarshaler interface { - // MarshalLogs the given pdata.Logs into bytes. + // MarshalLogs the given logs.Logs into bytes. // If the error is not nil, the returned bytes slice cannot be used. MarshalLogs(ld Logs) ([]byte, error) } -// LogsUnmarshaler unmarshalls bytes into pdata.Logs. +// LogsUnmarshaler unmarshalls bytes into logs.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 the given bytes into logs.Logs. + // If the error is not nil, the returned logs.Logs cannot be used. UnmarshalLogs(buf []byte) (Logs, error) } diff --git a/model/internal/pdata/traces.go b/model/internal/pdata/traces.go index 18946f3b047..b749368791a 100644 --- a/model/internal/pdata/traces.go +++ b/model/internal/pdata/traces.go @@ -18,17 +18,17 @@ import ( otlptrace "go.opentelemetry.io/collector/model/internal/data/protogen/trace/v1" ) -// TracesMarshaler marshals pdata.Traces into bytes. +// TracesMarshaler marshals traces.Traces into bytes. type TracesMarshaler interface { - // MarshalTraces the given pdata.Traces into bytes. + // MarshalTraces the given traces.Traces into bytes. // If the error is not nil, the returned bytes slice cannot be used. MarshalTraces(td Traces) ([]byte, error) } -// TracesUnmarshaler unmarshalls bytes into pdata.Traces. +// TracesUnmarshaler unmarshalls bytes into traces.Traces. type TracesUnmarshaler interface { - // UnmarshalTraces the given bytes into pdata.Traces. - // If the error is not nil, the returned pdata.Traces cannot be used. + // UnmarshalTraces the given bytes into traces.Traces. + // If the error is not nil, the returned traces.Traces cannot be used. UnmarshalTraces(buf []byte) (Traces, error) } diff --git a/model/otlp/json_marshaler.go b/model/otlp/json_marshaler.go index f85c7f8bd6e..e5ff361469f 100644 --- a/model/otlp/json_marshaler.go +++ b/model/otlp/json_marshaler.go @@ -20,21 +20,23 @@ import ( "github.com/gogo/protobuf/jsonpb" ipdata "go.opentelemetry.io/collector/model/internal/pdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) // NewJSONTracesMarshaler returns a model.TracesMarshaler. Marshals to OTLP json bytes. -func NewJSONTracesMarshaler() pdata.TracesMarshaler { +func NewJSONTracesMarshaler() traces.Marshaler { return newJSONMarshaler() } // NewJSONMetricsMarshaler returns a model.MetricsMarshaler. Marshals to OTLP json bytes. -func NewJSONMetricsMarshaler() pdata.MetricsMarshaler { +func NewJSONMetricsMarshaler() metrics.Marshaler { return newJSONMarshaler() } // NewJSONLogsMarshaler returns a model.LogsMarshaler. Marshals to OTLP json bytes. -func NewJSONLogsMarshaler() pdata.LogsMarshaler { +func NewJSONLogsMarshaler() logs.Marshaler { return newJSONMarshaler() } @@ -46,19 +48,19 @@ func newJSONMarshaler() *jsonMarshaler { return &jsonMarshaler{delegate: jsonpb.Marshaler{}} } -func (e *jsonMarshaler) MarshalLogs(ld pdata.Logs) ([]byte, error) { +func (e *jsonMarshaler) MarshalLogs(ld logs.Logs) ([]byte, error) { buf := bytes.Buffer{} err := e.delegate.Marshal(&buf, ipdata.LogsToOtlp(ld)) return buf.Bytes(), err } -func (e *jsonMarshaler) MarshalMetrics(md pdata.Metrics) ([]byte, error) { +func (e *jsonMarshaler) MarshalMetrics(md metrics.Metrics) ([]byte, error) { buf := bytes.Buffer{} err := e.delegate.Marshal(&buf, ipdata.MetricsToOtlp(md)) return buf.Bytes(), err } -func (e *jsonMarshaler) MarshalTraces(td pdata.Traces) ([]byte, error) { +func (e *jsonMarshaler) MarshalTraces(td traces.Traces) ([]byte, error) { buf := bytes.Buffer{} err := e.delegate.Marshal(&buf, ipdata.TracesToOtlp(td)) return buf.Bytes(), err diff --git a/model/otlp/json_test.go b/model/otlp/json_test.go index 20438ab3443..536f48aa5d7 100644 --- a/model/otlp/json_test.go +++ b/model/otlp/json_test.go @@ -20,9 +20,12 @@ import ( "github.com/stretchr/testify/assert" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) -var tracesOTLP = func() pdata.Traces { +var tracesOTLP = func() traces.Traces { td := pdata.NewTraces() rs := td.ResourceSpans().AppendEmpty() rs.Resource().Attributes().UpsertString("host.name", "testHost") @@ -35,7 +38,7 @@ var tracesOTLP = func() pdata.Traces { var tracesJSON = `{"resourceSpans":[{"resource":{"attributes":[{"key":"host.name","value":{"stringValue":"testHost"}}]},"scopeSpans":[{"scope":{"name":"name","version":"version"},"spans":[{"traceId":"","spanId":"","parentSpanId":"","name":"testSpan","status":{}}]}]}]}` -var metricsOTLP = func() pdata.Metrics { +var metricsOTLP = func() metrics.Metrics { md := pdata.NewMetrics() rm := md.ResourceMetrics().AppendEmpty() rm.Resource().Attributes().UpsertString("host.name", "testHost") @@ -48,7 +51,7 @@ var metricsOTLP = func() pdata.Metrics { var metricsJSON = `{"resourceMetrics":[{"resource":{"attributes":[{"key":"host.name","value":{"stringValue":"testHost"}}]},"scopeMetrics":[{"scope":{"name":"name","version":"version"},"metrics":[{"name":"testMetric"}]}]}]}` -var logsOTLP = func() pdata.Logs { +var logsOTLP = func() logs.Logs { ld := pdata.NewLogs() rl := ld.ResourceLogs().AppendEmpty() rl.Resource().Attributes().UpsertString("host.name", "testHost") @@ -233,5 +236,5 @@ func TestMetricsNil(t *testing.T) { got, err := decoder.UnmarshalMetrics([]byte(jsonBuf)) assert.Error(t, err) - assert.EqualValues(t, pdata.Metrics{}, got) + assert.EqualValues(t, metrics.Metrics{}, got) } diff --git a/model/otlp/json_unmarshaler.go b/model/otlp/json_unmarshaler.go index b1db47d684b..560c1222f7a 100644 --- a/model/otlp/json_unmarshaler.go +++ b/model/otlp/json_unmarshaler.go @@ -25,6 +25,9 @@ import ( ipdata "go.opentelemetry.io/collector/model/internal/pdata" "go.opentelemetry.io/collector/model/otlpgrpc" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) type jsonUnmarshaler struct { @@ -50,28 +53,28 @@ func newJSONUnmarshaler() *jsonUnmarshaler { return &jsonUnmarshaler{delegate: jsonpb.Unmarshaler{}} } -func (d *jsonUnmarshaler) UnmarshalLogs(buf []byte) (pdata.Logs, error) { +func (d *jsonUnmarshaler) UnmarshalLogs(buf []byte) (logs.Logs, error) { ld := &otlplogs.LogsData{} if err := d.delegate.Unmarshal(bytes.NewReader(buf), ld); err != nil { - return pdata.Logs{}, err + return logs.Logs{}, err } otlpgrpc.InstrumentationLibraryLogsToScope(ld.ResourceLogs) return ipdata.LogsFromOtlp(ld), nil } -func (d *jsonUnmarshaler) UnmarshalMetrics(buf []byte) (pdata.Metrics, error) { +func (d *jsonUnmarshaler) UnmarshalMetrics(buf []byte) (metrics.Metrics, error) { md := &otlpmetrics.MetricsData{} if err := d.delegate.Unmarshal(bytes.NewReader(buf), md); err != nil { - return pdata.Metrics{}, err + return metrics.Metrics{}, err } otlpgrpc.InstrumentationLibraryMetricsToScope(md.ResourceMetrics) return ipdata.MetricsFromOtlp(md), nil } -func (d *jsonUnmarshaler) UnmarshalTraces(buf []byte) (pdata.Traces, error) { +func (d *jsonUnmarshaler) UnmarshalTraces(buf []byte) (traces.Traces, error) { td := &otlptrace.TracesData{} if err := d.delegate.Unmarshal(bytes.NewReader(buf), td); err != nil { - return pdata.Traces{}, err + return traces.Traces{}, err } otlpgrpc.InstrumentationLibrarySpansToScope(td.ResourceSpans) return ipdata.TracesFromOtlp(td), nil diff --git a/model/otlp/pb_marshaler.go b/model/otlp/pb_marshaler.go index 4c596723a98..b74e05d466a 100644 --- a/model/otlp/pb_marshaler.go +++ b/model/otlp/pb_marshaler.go @@ -17,20 +17,23 @@ package otlp // import "go.opentelemetry.io/collector/model/otlp" import ( ipdata "go.opentelemetry.io/collector/model/internal/pdata" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) -// NewProtobufTracesMarshaler returns a pdata.TracesMarshaler. Marshals to OTLP binary protobuf bytes. -func NewProtobufTracesMarshaler() pdata.TracesMarshaler { +// NewProtobufTracesMarshaler returns a traces.Marshaler. Marshals to OTLP binary protobuf bytes. +func NewProtobufTracesMarshaler() traces.Marshaler { return newPbMarshaler() } -// NewProtobufMetricsMarshaler returns a pdata.MetricsMarshaler. Marshals to OTLP binary protobuf bytes. -func NewProtobufMetricsMarshaler() pdata.MetricsMarshaler { +// NewProtobufMetricsMarshaler returns a metrics.Marshaler. Marshals to OTLP binary protobuf bytes. +func NewProtobufMetricsMarshaler() metrics.Marshaler { return newPbMarshaler() } -// NewProtobufLogsMarshaler returns a pdata.LogsMarshaler. Marshals to OTLP binary protobuf bytes. -func NewProtobufLogsMarshaler() pdata.LogsMarshaler { +// NewProtobufLogsMarshaler returns a logs.Marshaler. Marshals to OTLP binary protobuf bytes. +func NewProtobufLogsMarshaler() logs.Marshaler { return newPbMarshaler() } @@ -45,26 +48,26 @@ var _ pdata.TracesSizer = (*pbMarshaler)(nil) var _ pdata.MetricsSizer = (*pbMarshaler)(nil) var _ pdata.LogsSizer = (*pbMarshaler)(nil) -func (e *pbMarshaler) MarshalLogs(ld pdata.Logs) ([]byte, error) { +func (e *pbMarshaler) MarshalLogs(ld logs.Logs) ([]byte, error) { return ipdata.LogsToOtlp(ld).Marshal() } -func (e *pbMarshaler) MarshalMetrics(md pdata.Metrics) ([]byte, error) { +func (e *pbMarshaler) MarshalMetrics(md metrics.Metrics) ([]byte, error) { return ipdata.MetricsToOtlp(md).Marshal() } -func (e *pbMarshaler) MarshalTraces(td pdata.Traces) ([]byte, error) { +func (e *pbMarshaler) MarshalTraces(td traces.Traces) ([]byte, error) { return ipdata.TracesToOtlp(td).Marshal() } -func (e *pbMarshaler) TracesSize(td pdata.Traces) int { +func (e *pbMarshaler) TracesSize(td traces.Traces) int { return ipdata.TracesToOtlp(td).Size() } -func (e *pbMarshaler) MetricsSize(md pdata.Metrics) int { +func (e *pbMarshaler) MetricsSize(md metrics.Metrics) int { return ipdata.MetricsToOtlp(md).Size() } -func (e *pbMarshaler) LogsSize(ld pdata.Logs) int { +func (e *pbMarshaler) LogsSize(ld logs.Logs) int { return ipdata.LogsToOtlp(ld).Size() } diff --git a/model/otlp/pb_test.go b/model/otlp/pb_test.go index 3053f23fdd5..ef91c801287 100644 --- a/model/otlp/pb_test.go +++ b/model/otlp/pb_test.go @@ -22,6 +22,9 @@ import ( "github.com/stretchr/testify/require" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestProtobufLogsUnmarshaler_error(t *testing.T) { @@ -182,7 +185,7 @@ func BenchmarkTracesFromProtobuf(b *testing.B) { } } -func generateBenchmarkLogs(logsCount int) pdata.Logs { +func generateBenchmarkLogs(logsCount int) logs.Logs { endTime := pdata.NewTimestampFromTime(time.Now()) md := pdata.NewLogs() @@ -195,7 +198,7 @@ func generateBenchmarkLogs(logsCount int) pdata.Logs { return md } -func generateBenchmarkMetrics(metricsCount int) pdata.Metrics { +func generateBenchmarkMetrics(metricsCount int) metrics.Metrics { now := time.Now() startTime := pdata.NewTimestampFromTime(now.Add(-10 * time.Second)) endTime := pdata.NewTimestampFromTime(now) @@ -215,7 +218,7 @@ func generateBenchmarkMetrics(metricsCount int) pdata.Metrics { return md } -func generateBenchmarkTraces(metricsCount int) pdata.Traces { +func generateBenchmarkTraces(metricsCount int) traces.Traces { now := time.Now() startTime := pdata.NewTimestampFromTime(now.Add(-10 * time.Second)) endTime := pdata.NewTimestampFromTime(now) diff --git a/model/otlp/pb_unmarshaler.go b/model/otlp/pb_unmarshaler.go index 1140a092e10..82e6e84db1d 100644 --- a/model/otlp/pb_unmarshaler.go +++ b/model/otlp/pb_unmarshaler.go @@ -20,6 +20,9 @@ import ( otlptrace "go.opentelemetry.io/collector/model/internal/data/protogen/trace/v1" ipdata "go.opentelemetry.io/collector/model/internal/pdata" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) type pbUnmarshaler struct{} @@ -43,19 +46,19 @@ func newPbUnmarshaler() *pbUnmarshaler { return &pbUnmarshaler{} } -func (d *pbUnmarshaler) UnmarshalLogs(buf []byte) (pdata.Logs, error) { +func (d *pbUnmarshaler) UnmarshalLogs(buf []byte) (logs.Logs, error) { ld := &otlplogs.LogsData{} err := ld.Unmarshal(buf) return ipdata.LogsFromOtlp(ld), err } -func (d *pbUnmarshaler) UnmarshalMetrics(buf []byte) (pdata.Metrics, error) { +func (d *pbUnmarshaler) UnmarshalMetrics(buf []byte) (metrics.Metrics, error) { md := &otlpmetrics.MetricsData{} err := md.Unmarshal(buf) return ipdata.MetricsFromOtlp(md), err } -func (d *pbUnmarshaler) UnmarshalTraces(buf []byte) (pdata.Traces, error) { +func (d *pbUnmarshaler) UnmarshalTraces(buf []byte) (traces.Traces, error) { td := &otlptrace.TracesData{} err := td.Unmarshal(buf) return ipdata.TracesFromOtlp(td), err diff --git a/model/otlpgrpc/logs.go b/model/otlpgrpc/logs.go index 99c3e525d1f..218b398d6d6 100644 --- a/model/otlpgrpc/logs.go +++ b/model/otlpgrpc/logs.go @@ -25,7 +25,7 @@ import ( v1 "go.opentelemetry.io/collector/model/internal/data/protogen/common/v1" otlplogs "go.opentelemetry.io/collector/model/internal/data/protogen/logs/v1" ipdata "go.opentelemetry.io/collector/model/internal/pdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) var jsonMarshaler = &jsonpb.Marshaler{} @@ -145,11 +145,11 @@ func (lr LogsRequest) UnmarshalJSON(data []byte) error { return nil } -func (lr LogsRequest) SetLogs(ld pdata.Logs) { +func (lr LogsRequest) SetLogs(ld logs.Logs) { lr.orig.ResourceLogs = ipdata.LogsToOtlp(ld).ResourceLogs } -func (lr LogsRequest) Logs() pdata.Logs { +func (lr LogsRequest) Logs() logs.Logs { return ipdata.LogsFromOtlp(&otlplogs.LogsData{ResourceLogs: lr.orig.ResourceLogs}) } @@ -157,7 +157,7 @@ func (lr LogsRequest) Logs() pdata.Logs { // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type LogsClient interface { - // Export pdata.Logs to the server. + // Export logs.Logs to the server. // // For performance reasons, it is recommended to keep this RPC // alive for the entire life of the application. diff --git a/model/otlpgrpc/metrics.go b/model/otlpgrpc/metrics.go index bc8b0ea2b83..ce5aee89d45 100644 --- a/model/otlpgrpc/metrics.go +++ b/model/otlpgrpc/metrics.go @@ -24,7 +24,7 @@ import ( v1 "go.opentelemetry.io/collector/model/internal/data/protogen/common/v1" otlpmetrics "go.opentelemetry.io/collector/model/internal/data/protogen/metrics/v1" ipdata "go.opentelemetry.io/collector/model/internal/pdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) // MetricsResponse represents the response for gRPC client/server. @@ -137,11 +137,11 @@ func (mr MetricsRequest) UnmarshalJSON(data []byte) error { return nil } -func (mr MetricsRequest) SetMetrics(ld pdata.Metrics) { +func (mr MetricsRequest) SetMetrics(ld metrics.Metrics) { mr.orig.ResourceMetrics = ipdata.MetricsToOtlp(ld).ResourceMetrics } -func (mr MetricsRequest) Metrics() pdata.Metrics { +func (mr MetricsRequest) Metrics() metrics.Metrics { return ipdata.MetricsFromOtlp(&otlpmetrics.MetricsData{ResourceMetrics: mr.orig.ResourceMetrics}) } @@ -149,7 +149,7 @@ func (mr MetricsRequest) Metrics() pdata.Metrics { // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type MetricsClient interface { - // Export pdata.Metrics to the server. + // Export metrics.Metrics to the server. // // For performance reasons, it is recommended to keep this RPC // alive for the entire life of the application. diff --git a/model/otlpgrpc/traces.go b/model/otlpgrpc/traces.go index 2d0030956b1..f2a1b96f103 100644 --- a/model/otlpgrpc/traces.go +++ b/model/otlpgrpc/traces.go @@ -24,7 +24,7 @@ import ( v1 "go.opentelemetry.io/collector/model/internal/data/protogen/common/v1" otlptrace "go.opentelemetry.io/collector/model/internal/data/protogen/trace/v1" ipdata "go.opentelemetry.io/collector/model/internal/pdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) // TracesResponse represents the response for gRPC client/server. @@ -141,11 +141,11 @@ func (tr TracesRequest) UnmarshalJSON(data []byte) error { return nil } -func (tr TracesRequest) SetTraces(td pdata.Traces) { +func (tr TracesRequest) SetTraces(td traces.Traces) { tr.orig.ResourceSpans = ipdata.TracesToOtlp(td).ResourceSpans } -func (tr TracesRequest) Traces() pdata.Traces { +func (tr TracesRequest) Traces() traces.Traces { return ipdata.TracesFromOtlp(&otlptrace.TracesData{ResourceSpans: tr.orig.ResourceSpans}) } @@ -153,7 +153,7 @@ func (tr TracesRequest) Traces() pdata.Traces { // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type TracesClient interface { - // Export pdata.Traces to the server. + // Export traces.Traces to the server. // // For performance reasons, it is recommended to keep this RPC // alive for the entire life of the application. diff --git a/processor/batchprocessor/batch_processor.go b/processor/batchprocessor/batch_processor.go index c7974f08bdd..7b48907b036 100644 --- a/processor/batchprocessor/batch_processor.go +++ b/processor/batchprocessor/batch_processor.go @@ -28,7 +28,9 @@ import ( "go.opentelemetry.io/collector/config/configtelemetry" "go.opentelemetry.io/collector/consumer" "go.opentelemetry.io/collector/model/otlp" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) // batch_processor is a component that accepts spans and metrics, places them @@ -187,20 +189,20 @@ func (bp *batchProcessor) sendItems(triggerMeasure *stats.Int64Measure) { } // ConsumeTraces implements TracesProcessor -func (bp *batchProcessor) ConsumeTraces(_ context.Context, td pdata.Traces) error { +func (bp *batchProcessor) ConsumeTraces(_ context.Context, td traces.Traces) error { bp.newItem <- td return nil } // ConsumeMetrics implements MetricsProcessor -func (bp *batchProcessor) ConsumeMetrics(_ context.Context, md pdata.Metrics) error { +func (bp *batchProcessor) ConsumeMetrics(_ context.Context, md metrics.Metrics) error { // First thing is convert into a different internal format bp.newItem <- md return nil } // ConsumeLogs implements LogsProcessor -func (bp *batchProcessor) ConsumeLogs(_ context.Context, ld pdata.Logs) error { +func (bp *batchProcessor) ConsumeLogs(_ context.Context, ld logs.Logs) error { bp.newItem <- ld return nil } @@ -222,18 +224,18 @@ func newBatchLogsProcessor(set component.ProcessorCreateSettings, next consumer. type batchTraces struct { nextConsumer consumer.Traces - traceData pdata.Traces + traceData traces.Traces spanCount int - sizer pdata.TracesSizer + sizer traces.Sizer } func newBatchTraces(nextConsumer consumer.Traces) *batchTraces { - return &batchTraces{nextConsumer: nextConsumer, traceData: pdata.NewTraces(), sizer: otlp.NewProtobufTracesMarshaler().(pdata.TracesSizer)} + return &batchTraces{nextConsumer: nextConsumer, traceData: traces.New(), sizer: otlp.NewProtobufTracesMarshaler().(traces.Sizer)} } // add updates current batchTraces by adding new TraceData object func (bt *batchTraces) add(item interface{}) { - td := item.(pdata.Traces) + td := item.(traces.Traces) newSpanCount := td.SpanCount() if newSpanCount == 0 { return @@ -244,13 +246,13 @@ func (bt *batchTraces) add(item interface{}) { } func (bt *batchTraces) export(ctx context.Context, sendBatchMaxSize int) error { - var req pdata.Traces + var req traces.Traces if sendBatchMaxSize > 0 && bt.itemCount() > sendBatchMaxSize { req = splitTraces(sendBatchMaxSize, bt.traceData) bt.spanCount -= sendBatchMaxSize } else { req = bt.traceData - bt.traceData = pdata.NewTraces() + bt.traceData = traces.New() bt.spanCount = 0 } return bt.nextConsumer.ConsumeTraces(ctx, req) @@ -266,23 +268,23 @@ func (bt *batchTraces) size() int { type batchMetrics struct { nextConsumer consumer.Metrics - metricData pdata.Metrics + metricData metrics.Metrics dataPointCount int - sizer pdata.MetricsSizer + sizer metrics.Sizer } func newBatchMetrics(nextConsumer consumer.Metrics) *batchMetrics { - return &batchMetrics{nextConsumer: nextConsumer, metricData: pdata.NewMetrics(), sizer: otlp.NewProtobufMetricsMarshaler().(pdata.MetricsSizer)} + return &batchMetrics{nextConsumer: nextConsumer, metricData: metrics.New(), sizer: otlp.NewProtobufMetricsMarshaler().(metrics.Sizer)} } func (bm *batchMetrics) export(ctx context.Context, sendBatchMaxSize int) error { - var req pdata.Metrics + var req metrics.Metrics if sendBatchMaxSize > 0 && bm.dataPointCount > sendBatchMaxSize { req = splitMetrics(sendBatchMaxSize, bm.metricData) bm.dataPointCount -= sendBatchMaxSize } else { req = bm.metricData - bm.metricData = pdata.NewMetrics() + bm.metricData = metrics.New() bm.dataPointCount = 0 } return bm.nextConsumer.ConsumeMetrics(ctx, req) @@ -297,7 +299,7 @@ func (bm *batchMetrics) size() int { } func (bm *batchMetrics) add(item interface{}) { - md := item.(pdata.Metrics) + md := item.(metrics.Metrics) newDataPointCount := md.DataPointCount() if newDataPointCount == 0 { @@ -309,23 +311,23 @@ func (bm *batchMetrics) add(item interface{}) { type batchLogs struct { nextConsumer consumer.Logs - logData pdata.Logs + logData logs.Logs logCount int - sizer pdata.LogsSizer + sizer logs.Sizer } func newBatchLogs(nextConsumer consumer.Logs) *batchLogs { - return &batchLogs{nextConsumer: nextConsumer, logData: pdata.NewLogs(), sizer: otlp.NewProtobufLogsMarshaler().(pdata.LogsSizer)} + return &batchLogs{nextConsumer: nextConsumer, logData: logs.New(), sizer: otlp.NewProtobufLogsMarshaler().(logs.Sizer)} } func (bl *batchLogs) export(ctx context.Context, sendBatchMaxSize int) error { - var req pdata.Logs + var req logs.Logs if sendBatchMaxSize > 0 && bl.logCount > sendBatchMaxSize { req = splitLogs(sendBatchMaxSize, bl.logData) bl.logCount -= sendBatchMaxSize } else { req = bl.logData - bl.logData = pdata.NewLogs() + bl.logData = logs.New() bl.logCount = 0 } return bl.nextConsumer.ConsumeLogs(ctx, req) @@ -340,7 +342,7 @@ func (bl *batchLogs) size() int { } func (bl *batchLogs) add(item interface{}) { - ld := item.(pdata.Logs) + ld := item.(logs.Logs) newLogsCount := ld.LogRecordCount() if newLogsCount == 0 { diff --git a/processor/batchprocessor/batch_processor_test.go b/processor/batchprocessor/batch_processor_test.go index 0b23cb7bff8..6927fef217a 100644 --- a/processor/batchprocessor/batch_processor_test.go +++ b/processor/batchprocessor/batch_processor_test.go @@ -32,7 +32,9 @@ import ( "go.opentelemetry.io/collector/consumer/consumertest" "go.opentelemetry.io/collector/internal/testdata" "go.opentelemetry.io/collector/model/otlp" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestBatchProcessorSpansDelivered(t *testing.T) { @@ -46,7 +48,7 @@ func TestBatchProcessorSpansDelivered(t *testing.T) { requestCount := 1000 spansPerRequest := 100 - traceDataSlice := make([]pdata.Traces, 0, requestCount) + traceDataSlice := make([]traces.Traces, 0, requestCount) for requestNum := 0; requestNum < requestCount; requestNum++ { td := testdata.GenerateTracesManySpansSameResource(spansPerRequest) spans := td.ResourceSpans().At(0).ScopeSpans().At(0).Spans() @@ -58,7 +60,7 @@ func TestBatchProcessorSpansDelivered(t *testing.T) { } // Added to test logic that check for empty resources. - td := pdata.NewTraces() + td := traces.New() assert.NoError(t, batcher.ConsumeTraces(context.Background(), td)) require.NoError(t, batcher.Shutdown(context.Background())) @@ -98,7 +100,7 @@ func TestBatchProcessorSpansDeliveredEnforceBatchSize(t *testing.T) { } // Added to test logic that check for empty resources. - td := pdata.NewTraces() + td := traces.New() require.NoError(t, batcher.ConsumeTraces(context.Background(), td)) // wait for all spans to be reported @@ -120,7 +122,7 @@ func TestBatchProcessorSpansDeliveredEnforceBatchSize(t *testing.T) { } func TestBatchProcessorSentBySize(t *testing.T) { - sizer := otlp.NewProtobufTracesMarshaler().(pdata.TracesSizer) + sizer := otlp.NewProtobufTracesMarshaler().(traces.Sizer) views := MetricViews() require.NoError(t, view.Register(views...)) defer view.Unregister(views...) @@ -276,7 +278,7 @@ func TestBatchMetricProcessor_ReceivingData(t *testing.T) { require.NoError(t, err) require.NoError(t, batcher.Start(context.Background(), componenttest.NewNopHost())) - metricDataSlice := make([]pdata.Metrics, 0, requestCount) + metricDataSlice := make([]metrics.Metrics, 0, requestCount) for requestNum := 0; requestNum < requestCount; requestNum++ { md := testdata.GenerateMetricsManyMetricsSameResource(metricsPerRequest) @@ -289,7 +291,7 @@ func TestBatchMetricProcessor_ReceivingData(t *testing.T) { } // Added to test case with empty resources sent. - md := pdata.NewMetrics() + md := metrics.New() assert.NoError(t, batcher.ConsumeMetrics(context.Background(), md)) require.NoError(t, batcher.Shutdown(context.Background())) @@ -308,7 +310,7 @@ func TestBatchMetricProcessor_ReceivingData(t *testing.T) { } func TestBatchMetricProcessor_BatchSize(t *testing.T) { - sizer := otlp.NewProtobufMetricsMarshaler().(pdata.MetricsSizer) + sizer := otlp.NewProtobufMetricsMarshaler().(metrics.Sizer) views := MetricViews() require.NoError(t, view.Register(views...)) defer view.Unregister(views...) @@ -470,8 +472,8 @@ func getTestSpanName(requestNum, index int) string { return fmt.Sprintf("test-span-%d-%d", requestNum, index) } -func spansReceivedByName(tds []pdata.Traces) map[string]pdata.Span { - spansReceivedByName := map[string]pdata.Span{} +func spansReceivedByName(tds []traces.Traces) map[string]traces.Span { + spansReceivedByName := map[string]traces.Span{} for i := range tds { rss := tds[i].ResourceSpans() for i := 0; i < rss.Len(); i++ { @@ -488,8 +490,8 @@ func spansReceivedByName(tds []pdata.Traces) map[string]pdata.Span { return spansReceivedByName } -func metricsReceivedByName(mds []pdata.Metrics) map[string]pdata.Metric { - metricsReceivedByName := map[string]pdata.Metric{} +func metricsReceivedByName(mds []metrics.Metrics) map[string]metrics.Metric { + metricsReceivedByName := map[string]metrics.Metric{} for _, md := range mds { rms := md.ResourceMetrics() for i := 0; i < rms.Len(); i++ { @@ -511,7 +513,7 @@ func getTestMetricName(requestNum, index int) string { } func BenchmarkTraceSizeBytes(b *testing.B) { - sizer := otlp.NewProtobufTracesMarshaler().(pdata.TracesSizer) + sizer := otlp.NewProtobufTracesMarshaler().(traces.Sizer) td := testdata.GenerateTracesManySpansSameResource(8192) for n := 0; n < b.N; n++ { fmt.Println(sizer.TracesSize(td)) @@ -541,7 +543,7 @@ func BenchmarkBatchMetricProcessor(b *testing.B) { require.NoError(b, err) require.NoError(b, batcher.Start(ctx, componenttest.NewNopHost())) - mds := make([]pdata.Metrics, 0, b.N) + mds := make([]metrics.Metrics, 0, b.N) for n := 0; n < b.N; n++ { mds = append(mds, testdata.GenerateMetricsManyMetricsSameResource(metricsPerRequest), @@ -567,7 +569,7 @@ func (sme *metricsSink) Capabilities() consumer.Capabilities { } } -func (sme *metricsSink) ConsumeMetrics(_ context.Context, md pdata.Metrics) error { +func (sme *metricsSink) ConsumeMetrics(_ context.Context, md metrics.Metrics) error { sme.mu.Lock() defer sme.mu.Unlock() sme.metricsCount += md.MetricCount() @@ -592,7 +594,7 @@ func TestBatchLogProcessor_ReceivingData(t *testing.T) { require.NoError(t, err) require.NoError(t, batcher.Start(context.Background(), componenttest.NewNopHost())) - logDataSlice := make([]pdata.Logs, 0, requestCount) + logDataSlice := make([]logs.Logs, 0, requestCount) for requestNum := 0; requestNum < requestCount; requestNum++ { ld := testdata.GenerateLogsManyLogRecordsSameResource(logsPerRequest) @@ -605,7 +607,7 @@ func TestBatchLogProcessor_ReceivingData(t *testing.T) { } // Added to test case with empty resources sent. - ld := pdata.NewLogs() + ld := logs.New() assert.NoError(t, batcher.ConsumeLogs(context.Background(), ld)) require.NoError(t, batcher.Shutdown(context.Background())) @@ -624,7 +626,7 @@ func TestBatchLogProcessor_ReceivingData(t *testing.T) { } func TestBatchLogProcessor_BatchSize(t *testing.T) { - sizer := otlp.NewProtobufLogsMarshaler().(pdata.LogsSizer) + sizer := otlp.NewProtobufLogsMarshaler().(logs.Sizer) views := MetricViews() require.NoError(t, view.Register(views...)) defer view.Unregister(views...) @@ -767,8 +769,8 @@ func getTestLogSeverityText(requestNum, index int) string { return fmt.Sprintf("test-log-int-%d-%d", requestNum, index) } -func logsReceivedBySeverityText(lds []pdata.Logs) map[string]pdata.LogRecord { - logsReceivedBySeverityText := map[string]pdata.LogRecord{} +func logsReceivedBySeverityText(lds []logs.Logs) map[string]logs.LogRecord { + logsReceivedBySeverityText := map[string]logs.LogRecord{} for i := range lds { ld := lds[i] rms := ld.ResourceLogs() diff --git a/processor/batchprocessor/splitlogs.go b/processor/batchprocessor/splitlogs.go index df40efec179..015d3d835df 100644 --- a/processor/batchprocessor/splitlogs.go +++ b/processor/batchprocessor/splitlogs.go @@ -15,18 +15,18 @@ package batchprocessor // import "go.opentelemetry.io/collector/processor/batchprocessor" import ( - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) // splitLogs removes logrecords from the input data and returns a new data of the specified size. -func splitLogs(size int, src pdata.Logs) pdata.Logs { +func splitLogs(size int, src logs.Logs) logs.Logs { if src.LogRecordCount() <= size { return src } totalCopiedLogRecords := 0 - dest := pdata.NewLogs() + dest := logs.New() - src.ResourceLogs().RemoveIf(func(srcRl pdata.ResourceLogs) bool { + src.ResourceLogs().RemoveIf(func(srcRl logs.ResourceLogs) bool { // If we are done skip everything else. if totalCopiedLogRecords == size { return false @@ -42,7 +42,7 @@ func splitLogs(size int, src pdata.Logs) pdata.Logs { destRl := dest.ResourceLogs().AppendEmpty() srcRl.Resource().CopyTo(destRl.Resource()) - srcRl.ScopeLogs().RemoveIf(func(srcIll pdata.ScopeLogs) bool { + srcRl.ScopeLogs().RemoveIf(func(srcIll logs.ScopeLogs) bool { // If we are done skip everything else. if totalCopiedLogRecords == size { return false @@ -58,7 +58,7 @@ func splitLogs(size int, src pdata.Logs) pdata.Logs { destIll := destRl.ScopeLogs().AppendEmpty() srcIll.Scope().CopyTo(destIll.Scope()) - srcIll.LogRecords().RemoveIf(func(srcMetric pdata.LogRecord) bool { + srcIll.LogRecords().RemoveIf(func(srcMetric logs.LogRecord) bool { // If we are done skip everything else. if totalCopiedLogRecords == size { return false @@ -75,8 +75,8 @@ func splitLogs(size int, src pdata.Logs) pdata.Logs { return dest } -// resourceLRC calculates the total number of log records in the pdata.ResourceLogs. -func resourceLRC(rs pdata.ResourceLogs) (count int) { +// resourceLRC calculates the total number of log records in the logs.ResourceLogs. +func resourceLRC(rs logs.ResourceLogs) (count int) { for k := 0; k < rs.ScopeLogs().Len(); k++ { count += rs.ScopeLogs().At(k).LogRecords().Len() } diff --git a/processor/batchprocessor/splitlogs_test.go b/processor/batchprocessor/splitlogs_test.go index 76d874932f2..50a4ad61b66 100644 --- a/processor/batchprocessor/splitlogs_test.go +++ b/processor/batchprocessor/splitlogs_test.go @@ -20,7 +20,7 @@ import ( "github.com/stretchr/testify/assert" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) func TestSplitLogs_noop(t *testing.T) { @@ -30,7 +30,7 @@ func TestSplitLogs_noop(t *testing.T) { assert.Equal(t, td, split) i := 0 - td.ResourceLogs().At(0).ScopeLogs().At(0).LogRecords().RemoveIf(func(_ pdata.LogRecord) bool { + td.ResourceLogs().At(0).ScopeLogs().At(0).LogRecords().RemoveIf(func(_ logs.LogRecord) bool { i++ return i > 5 }) @@ -39,22 +39,22 @@ func TestSplitLogs_noop(t *testing.T) { func TestSplitLogs(t *testing.T) { ld := testdata.GenerateLogsManyLogRecordsSameResource(20) - logs := ld.ResourceLogs().At(0).ScopeLogs().At(0).LogRecords() - for i := 0; i < logs.Len(); i++ { - logs.At(i).SetSeverityText(getTestLogSeverityText(0, i)) + lrs := ld.ResourceLogs().At(0).ScopeLogs().At(0).LogRecords() + for i := 0; i < lrs.Len(); i++ { + lrs.At(i).SetSeverityText(getTestLogSeverityText(0, i)) } - cp := pdata.NewLogs() + cp := logs.New() cpLogs := cp.ResourceLogs().AppendEmpty().ScopeLogs().AppendEmpty().LogRecords() cpLogs.EnsureCapacity(5) ld.ResourceLogs().At(0).Resource().CopyTo( cp.ResourceLogs().At(0).Resource()) ld.ResourceLogs().At(0).ScopeLogs().At(0).Scope().CopyTo( cp.ResourceLogs().At(0).ScopeLogs().At(0).Scope()) - logs.At(0).CopyTo(cpLogs.AppendEmpty()) - logs.At(1).CopyTo(cpLogs.AppendEmpty()) - logs.At(2).CopyTo(cpLogs.AppendEmpty()) - logs.At(3).CopyTo(cpLogs.AppendEmpty()) - logs.At(4).CopyTo(cpLogs.AppendEmpty()) + lrs.At(0).CopyTo(cpLogs.AppendEmpty()) + lrs.At(1).CopyTo(cpLogs.AppendEmpty()) + lrs.At(2).CopyTo(cpLogs.AppendEmpty()) + lrs.At(3).CopyTo(cpLogs.AppendEmpty()) + lrs.At(4).CopyTo(cpLogs.AppendEmpty()) splitSize := 5 split := splitLogs(splitSize, ld) @@ -158,7 +158,7 @@ func TestSplitLogsMultipleILL(t *testing.T) { } func BenchmarkSplitLogs(b *testing.B) { - md := pdata.NewLogs() + md := logs.New() rms := md.ResourceLogs() for i := 0; i < 20; i++ { testdata.GenerateLogsManyLogRecordsSameResource(20).ResourceLogs().MoveAndAppendTo(md.ResourceLogs()) @@ -172,7 +172,7 @@ func BenchmarkSplitLogs(b *testing.B) { b.Skipf("SKIP: b.N too high, set -benchtime=x with n < 100000") } - clones := make([]pdata.Logs, b.N) + clones := make([]logs.Logs, b.N) for n := 0; n < b.N; n++ { clones[n] = md.Clone() } diff --git a/processor/batchprocessor/splitmetrics.go b/processor/batchprocessor/splitmetrics.go index f1c188984d0..4f07f576fde 100644 --- a/processor/batchprocessor/splitmetrics.go +++ b/processor/batchprocessor/splitmetrics.go @@ -15,19 +15,19 @@ package batchprocessor // import "go.opentelemetry.io/collector/processor/batchprocessor" import ( - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) // splitMetrics removes metrics from the input data and returns a new data of the specified size. -func splitMetrics(size int, src pdata.Metrics) pdata.Metrics { +func splitMetrics(size int, src metrics.Metrics) metrics.Metrics { dataPoints := src.DataPointCount() if dataPoints <= size { return src } totalCopiedDataPoints := 0 - dest := pdata.NewMetrics() + dest := metrics.New() - src.ResourceMetrics().RemoveIf(func(srcRs pdata.ResourceMetrics) bool { + src.ResourceMetrics().RemoveIf(func(srcRs metrics.ResourceMetrics) bool { // If we are done skip everything else. if totalCopiedDataPoints == size { return false @@ -43,7 +43,7 @@ func splitMetrics(size int, src pdata.Metrics) pdata.Metrics { destRs := dest.ResourceMetrics().AppendEmpty() srcRs.Resource().CopyTo(destRs.Resource()) - srcRs.ScopeMetrics().RemoveIf(func(srcIlm pdata.ScopeMetrics) bool { + srcRs.ScopeMetrics().RemoveIf(func(srcIlm metrics.ScopeMetrics) bool { // If we are done skip everything else. if totalCopiedDataPoints == size { return false @@ -59,7 +59,7 @@ func splitMetrics(size int, src pdata.Metrics) pdata.Metrics { destIlm := destRs.ScopeMetrics().AppendEmpty() srcIlm.Scope().CopyTo(destIlm.Scope()) - srcIlm.Metrics().RemoveIf(func(srcMetric pdata.Metric) bool { + srcIlm.Metrics().RemoveIf(func(srcMetric metrics.Metric) bool { // If we are done skip everything else. if totalCopiedDataPoints == size { return false @@ -86,8 +86,8 @@ func splitMetrics(size int, src pdata.Metrics) pdata.Metrics { return dest } -// resourceMetricsDPC calculates the total number of data points in the pdata.ResourceMetrics. -func resourceMetricsDPC(rs pdata.ResourceMetrics) int { +// resourceMetricsDPC calculates the total number of data points in the metrics.ResourceMetrics. +func resourceMetricsDPC(rs metrics.ResourceMetrics) int { dataPointCount := 0 ilms := rs.ScopeMetrics() for k := 0; k < ilms.Len(); k++ { @@ -96,8 +96,8 @@ func resourceMetricsDPC(rs pdata.ResourceMetrics) int { return dataPointCount } -// scopeMetricsDPC calculates the total number of data points in the pdata.ScopeMetrics. -func scopeMetricsDPC(ilm pdata.ScopeMetrics) int { +// scopeMetricsDPC calculates the total number of data points in the metrics.ScopeMetrics. +func scopeMetricsDPC(ilm metrics.ScopeMetrics) int { dataPointCount := 0 ms := ilm.Metrics() for k := 0; k < ms.Len(); k++ { @@ -106,18 +106,18 @@ func scopeMetricsDPC(ilm pdata.ScopeMetrics) int { return dataPointCount } -// metricDPC calculates the total number of data points in the pdata.Metric. -func metricDPC(ms pdata.Metric) int { +// metricDPC calculates the total number of data points in the metrics.Metric. +func metricDPC(ms metrics.Metric) int { switch ms.DataType() { - case pdata.MetricDataTypeGauge: + case metrics.MetricDataTypeGauge: return ms.Gauge().DataPoints().Len() - case pdata.MetricDataTypeSum: + case metrics.MetricDataTypeSum: return ms.Sum().DataPoints().Len() - case pdata.MetricDataTypeHistogram: + case metrics.MetricDataTypeHistogram: return ms.Histogram().DataPoints().Len() - case pdata.MetricDataTypeExponentialHistogram: + case metrics.MetricDataTypeExponentialHistogram: return ms.ExponentialHistogram().DataPoints().Len() - case pdata.MetricDataTypeSummary: + case metrics.MetricDataTypeSummary: return ms.Summary().DataPoints().Len() } return 0 @@ -125,35 +125,35 @@ func metricDPC(ms pdata.Metric) int { // splitMetric removes metric points from the input data and moves data of the specified size to destination. // Returns size of moved data and boolean describing, whether the metric should be removed from original slice. -func splitMetric(ms, dest pdata.Metric, size int) (int, bool) { +func splitMetric(ms, dest metrics.Metric, size int) (int, bool) { dest.SetDataType(ms.DataType()) dest.SetName(ms.Name()) dest.SetDescription(ms.Description()) dest.SetUnit(ms.Unit()) switch ms.DataType() { - case pdata.MetricDataTypeGauge: + case metrics.MetricDataTypeGauge: return splitNumberDataPoints(ms.Gauge().DataPoints(), dest.Gauge().DataPoints(), size) - case pdata.MetricDataTypeSum: + case metrics.MetricDataTypeSum: dest.Sum().SetAggregationTemporality(ms.Sum().AggregationTemporality()) dest.Sum().SetIsMonotonic(ms.Sum().IsMonotonic()) return splitNumberDataPoints(ms.Sum().DataPoints(), dest.Sum().DataPoints(), size) - case pdata.MetricDataTypeHistogram: + case metrics.MetricDataTypeHistogram: dest.Histogram().SetAggregationTemporality(ms.Histogram().AggregationTemporality()) return splitHistogramDataPoints(ms.Histogram().DataPoints(), dest.Histogram().DataPoints(), size) - case pdata.MetricDataTypeExponentialHistogram: + case metrics.MetricDataTypeExponentialHistogram: dest.ExponentialHistogram().SetAggregationTemporality(ms.ExponentialHistogram().AggregationTemporality()) return splitExponentialHistogramDataPoints(ms.ExponentialHistogram().DataPoints(), dest.ExponentialHistogram().DataPoints(), size) - case pdata.MetricDataTypeSummary: + case metrics.MetricDataTypeSummary: return splitSummaryDataPoints(ms.Summary().DataPoints(), dest.Summary().DataPoints(), size) } return size, false } -func splitNumberDataPoints(src, dst pdata.NumberDataPointSlice, size int) (int, bool) { +func splitNumberDataPoints(src, dst metrics.NumberDataPointSlice, size int) (int, bool) { dst.EnsureCapacity(size) i := 0 - src.RemoveIf(func(dp pdata.NumberDataPoint) bool { + src.RemoveIf(func(dp metrics.NumberDataPoint) bool { if i < size { dp.MoveTo(dst.AppendEmpty()) i++ @@ -164,10 +164,10 @@ func splitNumberDataPoints(src, dst pdata.NumberDataPointSlice, size int) (int, return size, false } -func splitHistogramDataPoints(src, dst pdata.HistogramDataPointSlice, size int) (int, bool) { +func splitHistogramDataPoints(src, dst metrics.HistogramDataPointSlice, size int) (int, bool) { dst.EnsureCapacity(size) i := 0 - src.RemoveIf(func(dp pdata.HistogramDataPoint) bool { + src.RemoveIf(func(dp metrics.HistogramDataPoint) bool { if i < size { dp.MoveTo(dst.AppendEmpty()) i++ @@ -178,10 +178,10 @@ func splitHistogramDataPoints(src, dst pdata.HistogramDataPointSlice, size int) return size, false } -func splitExponentialHistogramDataPoints(src, dst pdata.ExponentialHistogramDataPointSlice, size int) (int, bool) { +func splitExponentialHistogramDataPoints(src, dst metrics.ExponentialHistogramDataPointSlice, size int) (int, bool) { dst.EnsureCapacity(size) i := 0 - src.RemoveIf(func(dp pdata.ExponentialHistogramDataPoint) bool { + src.RemoveIf(func(dp metrics.ExponentialHistogramDataPoint) bool { if i < size { dp.MoveTo(dst.AppendEmpty()) i++ @@ -192,10 +192,10 @@ func splitExponentialHistogramDataPoints(src, dst pdata.ExponentialHistogramData return size, false } -func splitSummaryDataPoints(src, dst pdata.SummaryDataPointSlice, size int) (int, bool) { +func splitSummaryDataPoints(src, dst metrics.SummaryDataPointSlice, size int) (int, bool) { dst.EnsureCapacity(size) i := 0 - src.RemoveIf(func(dp pdata.SummaryDataPoint) bool { + src.RemoveIf(func(dp metrics.SummaryDataPoint) bool { if i < size { dp.MoveTo(dst.AppendEmpty()) i++ diff --git a/processor/batchprocessor/splitmetrics_test.go b/processor/batchprocessor/splitmetrics_test.go index 2ba9fa2cd65..dcf82fa076c 100644 --- a/processor/batchprocessor/splitmetrics_test.go +++ b/processor/batchprocessor/splitmetrics_test.go @@ -20,7 +20,7 @@ import ( "github.com/stretchr/testify/assert" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) func TestSplitMetrics_noop(t *testing.T) { @@ -30,7 +30,7 @@ func TestSplitMetrics_noop(t *testing.T) { assert.Equal(t, td, split) i := 0 - td.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().RemoveIf(func(_ pdata.Metric) bool { + td.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().RemoveIf(func(_ metrics.Metric) bool { i++ return i > 5 }) @@ -39,24 +39,24 @@ func TestSplitMetrics_noop(t *testing.T) { func TestSplitMetrics(t *testing.T) { md := testdata.GenerateMetricsManyMetricsSameResource(20) - metrics := md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics() - dataPointCount := metricDPC(metrics.At(0)) - for i := 0; i < metrics.Len(); i++ { - metrics.At(i).SetName(getTestMetricName(0, i)) - assert.Equal(t, dataPointCount, metricDPC(metrics.At(i))) + m := md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics() + dataPointCount := metricDPC(m.At(0)) + for i := 0; i < m.Len(); i++ { + m.At(i).SetName(getTestMetricName(0, i)) + assert.Equal(t, dataPointCount, metricDPC(m.At(i))) } - cp := pdata.NewMetrics() + cp := metrics.New() cpMetrics := cp.ResourceMetrics().AppendEmpty().ScopeMetrics().AppendEmpty().Metrics() cpMetrics.EnsureCapacity(5) md.ResourceMetrics().At(0).ScopeMetrics().At(0).Scope().CopyTo( cp.ResourceMetrics().At(0).ScopeMetrics().At(0).Scope()) md.ResourceMetrics().At(0).Resource().CopyTo( cp.ResourceMetrics().At(0).Resource()) - metrics.At(0).CopyTo(cpMetrics.AppendEmpty()) - metrics.At(1).CopyTo(cpMetrics.AppendEmpty()) - metrics.At(2).CopyTo(cpMetrics.AppendEmpty()) - metrics.At(3).CopyTo(cpMetrics.AppendEmpty()) - metrics.At(4).CopyTo(cpMetrics.AppendEmpty()) + m.At(0).CopyTo(cpMetrics.AppendEmpty()) + m.At(1).CopyTo(cpMetrics.AppendEmpty()) + m.At(2).CopyTo(cpMetrics.AppendEmpty()) + m.At(3).CopyTo(cpMetrics.AppendEmpty()) + m.At(4).CopyTo(cpMetrics.AppendEmpty()) splitMetricCount := 5 splitSize := splitMetricCount * dataPointCount @@ -166,10 +166,10 @@ func TestSplitMetricsUneven(t *testing.T) { func TestSplitMetricsAllTypes(t *testing.T) { md := testdata.GeneratMetricsAllTypesWithSampleDatapoints() dataPointCount := 2 - metrics := md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics() - for i := 0; i < metrics.Len(); i++ { - metrics.At(i).SetName(getTestMetricName(0, i)) - assert.Equal(t, dataPointCount, metricDPC(metrics.At(i))) + m := md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics() + for i := 0; i < m.Len(); i++ { + m.At(i).SetName(getTestMetricName(0, i)) + assert.Equal(t, dataPointCount, metricDPC(m.At(i))) } splitSize := 2 @@ -202,7 +202,7 @@ func TestSplitMetricsAllTypes(t *testing.T) { assert.Equal(t, 1, gaugeDouble.Gauge().DataPoints().Len()) assert.Equal(t, "test-metric-int-0-1", gaugeDouble.Name()) assert.Equal(t, 1, sumInt.Sum().DataPoints().Len()) - assert.Equal(t, pdata.MetricAggregationTemporalityCumulative, sumInt.Sum().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityCumulative, sumInt.Sum().AggregationTemporality()) assert.Equal(t, true, sumInt.Sum().IsMonotonic()) assert.Equal(t, "test-metric-int-0-2", sumInt.Name()) @@ -212,11 +212,11 @@ func TestSplitMetricsAllTypes(t *testing.T) { sumInt = split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0) sumDouble := split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(1) assert.Equal(t, 1, sumInt.Sum().DataPoints().Len()) - assert.Equal(t, pdata.MetricAggregationTemporalityCumulative, sumInt.Sum().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityCumulative, sumInt.Sum().AggregationTemporality()) assert.Equal(t, true, sumInt.Sum().IsMonotonic()) assert.Equal(t, "test-metric-int-0-2", sumInt.Name()) assert.Equal(t, 1, sumDouble.Sum().DataPoints().Len()) - assert.Equal(t, pdata.MetricAggregationTemporalityCumulative, sumDouble.Sum().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityCumulative, sumDouble.Sum().AggregationTemporality()) assert.Equal(t, true, sumDouble.Sum().IsMonotonic()) assert.Equal(t, "test-metric-int-0-3", sumDouble.Name()) @@ -226,11 +226,11 @@ func TestSplitMetricsAllTypes(t *testing.T) { sumDouble = split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0) histogram := split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(1) assert.Equal(t, 1, sumDouble.Sum().DataPoints().Len()) - assert.Equal(t, pdata.MetricAggregationTemporalityCumulative, sumDouble.Sum().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityCumulative, sumDouble.Sum().AggregationTemporality()) assert.Equal(t, true, sumDouble.Sum().IsMonotonic()) assert.Equal(t, "test-metric-int-0-3", sumDouble.Name()) assert.Equal(t, 1, histogram.Histogram().DataPoints().Len()) - assert.Equal(t, pdata.MetricAggregationTemporalityCumulative, histogram.Histogram().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityCumulative, histogram.Histogram().AggregationTemporality()) assert.Equal(t, "test-metric-int-0-4", histogram.Name()) split = splitMetrics(splitSize, md) @@ -239,10 +239,10 @@ func TestSplitMetricsAllTypes(t *testing.T) { histogram = split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0) exponentialHistogram := split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(1) assert.Equal(t, 1, histogram.Histogram().DataPoints().Len()) - assert.Equal(t, pdata.MetricAggregationTemporalityCumulative, histogram.Histogram().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityCumulative, histogram.Histogram().AggregationTemporality()) assert.Equal(t, "test-metric-int-0-4", histogram.Name()) assert.Equal(t, 1, exponentialHistogram.ExponentialHistogram().DataPoints().Len()) - assert.Equal(t, pdata.MetricAggregationTemporalityDelta, exponentialHistogram.ExponentialHistogram().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityDelta, exponentialHistogram.ExponentialHistogram().AggregationTemporality()) assert.Equal(t, "test-metric-int-0-5", exponentialHistogram.Name()) split = splitMetrics(splitSize, md) @@ -251,7 +251,7 @@ func TestSplitMetricsAllTypes(t *testing.T) { exponentialHistogram = split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0) summary := split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(1) assert.Equal(t, 1, exponentialHistogram.ExponentialHistogram().DataPoints().Len()) - assert.Equal(t, pdata.MetricAggregationTemporalityDelta, exponentialHistogram.ExponentialHistogram().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityDelta, exponentialHistogram.ExponentialHistogram().AggregationTemporality()) assert.Equal(t, "test-metric-int-0-5", exponentialHistogram.Name()) assert.Equal(t, 1, summary.Summary().DataPoints().Len()) assert.Equal(t, "test-metric-int-0-6", summary.Name()) @@ -264,11 +264,11 @@ func TestSplitMetricsAllTypes(t *testing.T) { func TestSplitMetricsBatchSizeSmallerThanDataPointCount(t *testing.T) { md := testdata.GenerateMetricsManyMetricsSameResource(2) - metrics := md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics() + m := md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics() dataPointCount := 2 - for i := 0; i < metrics.Len(); i++ { - metrics.At(i).SetName(getTestMetricName(0, i)) - assert.Equal(t, dataPointCount, metricDPC(metrics.At(i))) + for i := 0; i < m.Len(); i++ { + m.At(i).SetName(getTestMetricName(0, i)) + assert.Equal(t, dataPointCount, metricDPC(m.At(i))) } splitSize := 1 @@ -276,7 +276,7 @@ func TestSplitMetricsBatchSizeSmallerThanDataPointCount(t *testing.T) { splitMetric := split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0) assert.Equal(t, 1, split.MetricCount()) assert.Equal(t, 2, md.MetricCount()) - assert.Equal(t, pdata.MetricAggregationTemporalityCumulative, splitMetric.Sum().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityCumulative, splitMetric.Sum().AggregationTemporality()) assert.Equal(t, true, splitMetric.Sum().IsMonotonic()) assert.Equal(t, "test-metric-int-0-0", splitMetric.Name()) @@ -284,7 +284,7 @@ func TestSplitMetricsBatchSizeSmallerThanDataPointCount(t *testing.T) { splitMetric = split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0) assert.Equal(t, 1, split.MetricCount()) assert.Equal(t, 1, md.MetricCount()) - assert.Equal(t, pdata.MetricAggregationTemporalityCumulative, splitMetric.Sum().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityCumulative, splitMetric.Sum().AggregationTemporality()) assert.Equal(t, true, splitMetric.Sum().IsMonotonic()) assert.Equal(t, "test-metric-int-0-0", splitMetric.Name()) @@ -292,7 +292,7 @@ func TestSplitMetricsBatchSizeSmallerThanDataPointCount(t *testing.T) { splitMetric = split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0) assert.Equal(t, 1, split.MetricCount()) assert.Equal(t, 1, md.MetricCount()) - assert.Equal(t, pdata.MetricAggregationTemporalityCumulative, splitMetric.Sum().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityCumulative, splitMetric.Sum().AggregationTemporality()) assert.Equal(t, true, splitMetric.Sum().IsMonotonic()) assert.Equal(t, "test-metric-int-0-1", splitMetric.Name()) @@ -300,7 +300,7 @@ func TestSplitMetricsBatchSizeSmallerThanDataPointCount(t *testing.T) { splitMetric = split.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0) assert.Equal(t, 1, split.MetricCount()) assert.Equal(t, 1, md.MetricCount()) - assert.Equal(t, pdata.MetricAggregationTemporalityCumulative, splitMetric.Sum().AggregationTemporality()) + assert.Equal(t, metrics.MetricAggregationTemporalityCumulative, splitMetric.Sum().AggregationTemporality()) assert.Equal(t, true, splitMetric.Sum().IsMonotonic()) assert.Equal(t, "test-metric-int-0-1", splitMetric.Name()) } @@ -335,7 +335,7 @@ func TestSplitMetricsMultipleILM(t *testing.T) { } func BenchmarkSplitMetrics(b *testing.B) { - md := pdata.NewMetrics() + md := metrics.New() rms := md.ResourceMetrics() for i := 0; i < 20; i++ { testdata.GenerateMetricsManyMetricsSameResource(20).ResourceMetrics().MoveAndAppendTo(md.ResourceMetrics()) @@ -350,7 +350,7 @@ func BenchmarkSplitMetrics(b *testing.B) { } dataPointCount := metricDPC(md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0)) - clones := make([]pdata.Metrics, b.N) + clones := make([]metrics.Metrics, b.N) for n := 0; n < b.N; n++ { clones[n] = md.Clone() } diff --git a/processor/batchprocessor/splittraces.go b/processor/batchprocessor/splittraces.go index e8fbf779b7b..7b0930bedb1 100644 --- a/processor/batchprocessor/splittraces.go +++ b/processor/batchprocessor/splittraces.go @@ -15,18 +15,18 @@ package batchprocessor // import "go.opentelemetry.io/collector/processor/batchprocessor" import ( - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) // splitTraces removes spans from the input trace and returns a new trace of the specified size. -func splitTraces(size int, src pdata.Traces) pdata.Traces { +func splitTraces(size int, src traces.Traces) traces.Traces { if src.SpanCount() <= size { return src } totalCopiedSpans := 0 - dest := pdata.NewTraces() + dest := traces.New() - src.ResourceSpans().RemoveIf(func(srcRs pdata.ResourceSpans) bool { + src.ResourceSpans().RemoveIf(func(srcRs traces.ResourceSpans) bool { // If we are done skip everything else. if totalCopiedSpans == size { return false @@ -42,7 +42,7 @@ func splitTraces(size int, src pdata.Traces) pdata.Traces { destRs := dest.ResourceSpans().AppendEmpty() srcRs.Resource().CopyTo(destRs.Resource()) - srcRs.ScopeSpans().RemoveIf(func(srcIls pdata.ScopeSpans) bool { + srcRs.ScopeSpans().RemoveIf(func(srcIls traces.ScopeSpans) bool { // If we are done skip everything else. if totalCopiedSpans == size { return false @@ -58,7 +58,7 @@ func splitTraces(size int, src pdata.Traces) pdata.Traces { destIls := destRs.ScopeSpans().AppendEmpty() srcIls.Scope().CopyTo(destIls.Scope()) - srcIls.Spans().RemoveIf(func(srcSpan pdata.Span) bool { + srcIls.Spans().RemoveIf(func(srcSpan traces.Span) bool { // If we are done skip everything else. if totalCopiedSpans == size { return false @@ -75,8 +75,8 @@ func splitTraces(size int, src pdata.Traces) pdata.Traces { return dest } -// resourceSC calculates the total number of spans in the pdata.ResourceSpans. -func resourceSC(rs pdata.ResourceSpans) (count int) { +// resourceSC calculates the total number of spans in the traces.ResourceSpans. +func resourceSC(rs traces.ResourceSpans) (count int) { for k := 0; k < rs.ScopeSpans().Len(); k++ { count += rs.ScopeSpans().At(k).Spans().Len() } diff --git a/processor/batchprocessor/splittraces_test.go b/processor/batchprocessor/splittraces_test.go index 863054ad544..ea69a9b8904 100644 --- a/processor/batchprocessor/splittraces_test.go +++ b/processor/batchprocessor/splittraces_test.go @@ -20,7 +20,7 @@ import ( "github.com/stretchr/testify/assert" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) func TestSplitTraces_noop(t *testing.T) { @@ -30,7 +30,7 @@ func TestSplitTraces_noop(t *testing.T) { assert.Equal(t, td, split) i := 0 - td.ResourceSpans().At(0).ScopeSpans().At(0).Spans().RemoveIf(func(_ pdata.Span) bool { + td.ResourceSpans().At(0).ScopeSpans().At(0).Spans().RemoveIf(func(_ traces.Span) bool { i++ return i > 5 }) @@ -43,7 +43,7 @@ func TestSplitTraces(t *testing.T) { for i := 0; i < spans.Len(); i++ { spans.At(i).SetName(getTestSpanName(0, i)) } - cp := pdata.NewTraces() + cp := traces.New() cpSpans := cp.ResourceSpans().AppendEmpty().ScopeSpans().AppendEmpty().Spans() cpSpans.EnsureCapacity(5) td.ResourceSpans().At(0).Resource().CopyTo( @@ -128,7 +128,7 @@ func TestSplitTracesMultipleResourceSpans_SplitSizeGreaterThanSpanSize(t *testin } func BenchmarkCloneSpans(b *testing.B) { - td := pdata.NewTraces() + td := traces.New() rms := td.ResourceSpans() for i := 0; i < 20; i++ { testdata.GenerateTracesManySpansSameResource(20).ResourceSpans().MoveAndAppendTo(td.ResourceSpans()) @@ -179,7 +179,7 @@ func TestSplitTracesMultipleILS(t *testing.T) { } func BenchmarkSplitTraces(b *testing.B) { - td := pdata.NewTraces() + td := traces.New() rms := td.ResourceSpans() for i := 0; i < 20; i++ { testdata.GenerateTracesManySpansSameResource(20).ResourceSpans().MoveAndAppendTo(td.ResourceSpans()) @@ -193,7 +193,7 @@ func BenchmarkSplitTraces(b *testing.B) { b.Skipf("SKIP: b.N too high, set -benchtime=x with n < 100000") } - clones := make([]pdata.Traces, b.N) + clones := make([]traces.Traces, b.N) for n := 0; n < b.N; n++ { clones[n] = td.Clone() } diff --git a/processor/memorylimiterprocessor/memorylimiter.go b/processor/memorylimiterprocessor/memorylimiter.go index 93cfe0dbad8..604aac674a4 100644 --- a/processor/memorylimiterprocessor/memorylimiter.go +++ b/processor/memorylimiterprocessor/memorylimiter.go @@ -28,7 +28,9 @@ import ( "go.opentelemetry.io/collector/component" "go.opentelemetry.io/collector/extension/ballastextension" "go.opentelemetry.io/collector/internal/iruntime" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" "go.opentelemetry.io/collector/obsreport" ) @@ -169,7 +171,7 @@ func (ml *memoryLimiter) shutdown(context.Context) error { return nil } -func (ml *memoryLimiter) processTraces(ctx context.Context, td pdata.Traces) (pdata.Traces, error) { +func (ml *memoryLimiter) processTraces(ctx context.Context, td traces.Traces) (traces.Traces, error) { numSpans := td.SpanCount() if ml.forcingDrop() { // TODO: actually to be 100% sure that this is "refused" and not "dropped" @@ -188,7 +190,7 @@ func (ml *memoryLimiter) processTraces(ctx context.Context, td pdata.Traces) (pd return td, nil } -func (ml *memoryLimiter) processMetrics(ctx context.Context, md pdata.Metrics) (pdata.Metrics, error) { +func (ml *memoryLimiter) processMetrics(ctx context.Context, md metrics.Metrics) (metrics.Metrics, error) { numDataPoints := md.DataPointCount() if ml.forcingDrop() { // TODO: actually to be 100% sure that this is "refused" and not "dropped" @@ -206,7 +208,7 @@ func (ml *memoryLimiter) processMetrics(ctx context.Context, md pdata.Metrics) ( return md, nil } -func (ml *memoryLimiter) processLogs(ctx context.Context, ld pdata.Logs) (pdata.Logs, error) { +func (ml *memoryLimiter) processLogs(ctx context.Context, ld logs.Logs) (logs.Logs, error) { numRecords := ld.LogRecordCount() if ml.forcingDrop() { // TODO: actually to be 100% sure that this is "refused" and not "dropped" diff --git a/processor/memorylimiterprocessor/memorylimiter_test.go b/processor/memorylimiterprocessor/memorylimiter_test.go index 33f2add071b..de38495e547 100644 --- a/processor/memorylimiterprocessor/memorylimiter_test.go +++ b/processor/memorylimiterprocessor/memorylimiter_test.go @@ -31,7 +31,9 @@ import ( "go.opentelemetry.io/collector/consumer/consumertest" "go.opentelemetry.io/collector/extension/ballastextension" "go.opentelemetry.io/collector/internal/iruntime" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" + "go.opentelemetry.io/collector/model/pdata/metrics" + "go.opentelemetry.io/collector/model/pdata/traces" "go.opentelemetry.io/collector/obsreport" "go.opentelemetry.io/collector/processor/processorhelper" ) @@ -131,7 +133,7 @@ func TestMetricsMemoryPressureResponse(t *testing.T) { require.NoError(t, err) ctx := context.Background() - md := pdata.NewMetrics() + md := metrics.New() // Below memAllocLimit. currentMemAlloc = 800 @@ -202,7 +204,7 @@ func TestTraceMemoryPressureResponse(t *testing.T) { require.NoError(t, err) ctx := context.Background() - td := pdata.NewTraces() + td := traces.New() // Below memAllocLimit. currentMemAlloc = 800 @@ -273,7 +275,7 @@ func TestLogMemoryPressureResponse(t *testing.T) { require.NoError(t, err) ctx := context.Background() - ld := pdata.NewLogs() + ld := logs.New() // Below memAllocLimit. currentMemAlloc = 800 diff --git a/processor/processorhelper/logs.go b/processor/processorhelper/logs.go index 822a0c99a4b..4d44515352c 100644 --- a/processor/processorhelper/logs.go +++ b/processor/processorhelper/logs.go @@ -24,12 +24,12 @@ import ( "go.opentelemetry.io/collector/component/componenterror" "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/consumer" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) // ProcessLogsFunc is a helper function that processes the incoming data and returns the data to be sent to the next component. // If error is returned then returned data are ignored. It MUST not call the next component. -type ProcessLogsFunc func(context.Context, pdata.Logs) (pdata.Logs, error) +type ProcessLogsFunc func(context.Context, logs.Logs) (logs.Logs, error) type logProcessor struct { component.StartFunc @@ -55,7 +55,7 @@ func NewLogsProcessor( eventOptions := spanAttributes(cfg.ID()) bs := fromOptions(options) - logsConsumer, err := consumer.NewLogs(func(ctx context.Context, ld pdata.Logs) error { + logsConsumer, err := consumer.NewLogs(func(ctx context.Context, ld logs.Logs) error { span := trace.SpanFromContext(ctx) span.AddEvent("Start processing.", eventOptions) var err error diff --git a/processor/processorhelper/logs_test.go b/processor/processorhelper/logs_test.go index efe04e07fb5..e7bfc5554ac 100644 --- a/processor/processorhelper/logs_test.go +++ b/processor/processorhelper/logs_test.go @@ -28,7 +28,7 @@ import ( "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/consumer" "go.opentelemetry.io/collector/consumer/consumertest" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) var testLogsCfg = config.NewProcessorSettings(config.NewComponentID("test")) @@ -39,7 +39,7 @@ func TestNewLogsProcessor(t *testing.T) { assert.True(t, lp.Capabilities().MutatesData) assert.NoError(t, lp.Start(context.Background(), componenttest.NewNopHost())) - assert.NoError(t, lp.ConsumeLogs(context.Background(), pdata.NewLogs())) + assert.NoError(t, lp.ConsumeLogs(context.Background(), logs.New())) assert.NoError(t, lp.Shutdown(context.Background())) } @@ -68,17 +68,17 @@ func TestNewLogsProcessor_ProcessLogError(t *testing.T) { want := errors.New("my_error") lp, err := NewLogsProcessor(&testLogsCfg, consumertest.NewNop(), newTestLProcessor(want)) require.NoError(t, err) - assert.Equal(t, want, lp.ConsumeLogs(context.Background(), pdata.NewLogs())) + assert.Equal(t, want, lp.ConsumeLogs(context.Background(), logs.New())) } func TestNewLogsProcessor_ProcessLogsErrSkipProcessingData(t *testing.T) { lp, err := NewLogsProcessor(&testLogsCfg, consumertest.NewNop(), newTestLProcessor(ErrSkipProcessingData)) require.NoError(t, err) - assert.Equal(t, nil, lp.ConsumeLogs(context.Background(), pdata.NewLogs())) + assert.Equal(t, nil, lp.ConsumeLogs(context.Background(), logs.New())) } func newTestLProcessor(retError error) ProcessLogsFunc { - return func(_ context.Context, ld pdata.Logs) (pdata.Logs, error) { + return func(_ context.Context, ld logs.Logs) (logs.Logs, error) { return ld, retError } } diff --git a/processor/processorhelper/metrics.go b/processor/processorhelper/metrics.go index 4585e51fda5..b810b7c92c5 100644 --- a/processor/processorhelper/metrics.go +++ b/processor/processorhelper/metrics.go @@ -24,12 +24,12 @@ import ( "go.opentelemetry.io/collector/component/componenterror" "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/consumer" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) // ProcessMetricsFunc is a helper function that processes the incoming data and returns the data to be sent to the next component. // If error is returned then returned data are ignored. It MUST not call the next component. -type ProcessMetricsFunc func(context.Context, pdata.Metrics) (pdata.Metrics, error) +type ProcessMetricsFunc func(context.Context, metrics.Metrics) (metrics.Metrics, error) type metricsProcessor struct { component.StartFunc @@ -55,7 +55,7 @@ func NewMetricsProcessor( eventOptions := spanAttributes(cfg.ID()) bs := fromOptions(options) - metricsConsumer, err := consumer.NewMetrics(func(ctx context.Context, md pdata.Metrics) error { + metricsConsumer, err := consumer.NewMetrics(func(ctx context.Context, md metrics.Metrics) error { span := trace.SpanFromContext(ctx) span.AddEvent("Start processing.", eventOptions) var err error diff --git a/processor/processorhelper/metrics_test.go b/processor/processorhelper/metrics_test.go index 5e568037546..65e61b450d0 100644 --- a/processor/processorhelper/metrics_test.go +++ b/processor/processorhelper/metrics_test.go @@ -28,7 +28,7 @@ import ( "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/consumer" "go.opentelemetry.io/collector/consumer/consumertest" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) var testMetricsCfg = config.NewProcessorSettings(config.NewComponentID("test")) @@ -39,7 +39,7 @@ func TestNewMetricsProcessor(t *testing.T) { assert.True(t, mp.Capabilities().MutatesData) assert.NoError(t, mp.Start(context.Background(), componenttest.NewNopHost())) - assert.NoError(t, mp.ConsumeMetrics(context.Background(), pdata.NewMetrics())) + assert.NoError(t, mp.ConsumeMetrics(context.Background(), metrics.New())) assert.NoError(t, mp.Shutdown(context.Background())) } @@ -68,17 +68,17 @@ func TestNewMetricsProcessor_ProcessMetricsError(t *testing.T) { want := errors.New("my_error") mp, err := NewMetricsProcessor(&testMetricsCfg, consumertest.NewNop(), newTestMProcessor(want)) require.NoError(t, err) - assert.Equal(t, want, mp.ConsumeMetrics(context.Background(), pdata.NewMetrics())) + assert.Equal(t, want, mp.ConsumeMetrics(context.Background(), metrics.New())) } func TestNewMetricsProcessor_ProcessMetricsErrSkipProcessingData(t *testing.T) { mp, err := NewMetricsProcessor(&testMetricsCfg, consumertest.NewNop(), newTestMProcessor(ErrSkipProcessingData)) require.NoError(t, err) - assert.Equal(t, nil, mp.ConsumeMetrics(context.Background(), pdata.NewMetrics())) + assert.Equal(t, nil, mp.ConsumeMetrics(context.Background(), metrics.New())) } func newTestMProcessor(retError error) ProcessMetricsFunc { - return func(_ context.Context, md pdata.Metrics) (pdata.Metrics, error) { + return func(_ context.Context, md metrics.Metrics) (metrics.Metrics, error) { return md, retError } } diff --git a/processor/processorhelper/traces.go b/processor/processorhelper/traces.go index b802c539ea7..4b54e260555 100644 --- a/processor/processorhelper/traces.go +++ b/processor/processorhelper/traces.go @@ -24,12 +24,12 @@ import ( "go.opentelemetry.io/collector/component/componenterror" "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/consumer" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) // ProcessTracesFunc is a helper function that processes the incoming data and returns the data to be sent to the next component. // If error is returned then returned data are ignored. It MUST not call the next component. -type ProcessTracesFunc func(context.Context, pdata.Traces) (pdata.Traces, error) +type ProcessTracesFunc func(context.Context, traces.Traces) (traces.Traces, error) type tracesProcessor struct { component.StartFunc @@ -55,7 +55,7 @@ func NewTracesProcessor( eventOptions := spanAttributes(cfg.ID()) bs := fromOptions(options) - traceConsumer, err := consumer.NewTraces(func(ctx context.Context, td pdata.Traces) error { + traceConsumer, err := consumer.NewTraces(func(ctx context.Context, td traces.Traces) error { span := trace.SpanFromContext(ctx) span.AddEvent("Start processing.", eventOptions) var err error diff --git a/processor/processorhelper/traces_test.go b/processor/processorhelper/traces_test.go index de2cc9209ac..817708fe2aa 100644 --- a/processor/processorhelper/traces_test.go +++ b/processor/processorhelper/traces_test.go @@ -28,7 +28,7 @@ import ( "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/consumer" "go.opentelemetry.io/collector/consumer/consumertest" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) var testTracesCfg = config.NewProcessorSettings(config.NewComponentID("test")) @@ -39,7 +39,7 @@ func TestNewTracesProcessor(t *testing.T) { assert.True(t, tp.Capabilities().MutatesData) assert.NoError(t, tp.Start(context.Background(), componenttest.NewNopHost())) - assert.NoError(t, tp.ConsumeTraces(context.Background(), pdata.NewTraces())) + assert.NoError(t, tp.ConsumeTraces(context.Background(), traces.New())) assert.NoError(t, tp.Shutdown(context.Background())) } @@ -68,17 +68,17 @@ func TestNewTracesProcessor_ProcessTraceError(t *testing.T) { want := errors.New("my_error") tp, err := NewTracesProcessor(&testTracesCfg, consumertest.NewNop(), newTestTProcessor(want)) require.NoError(t, err) - assert.Equal(t, want, tp.ConsumeTraces(context.Background(), pdata.NewTraces())) + assert.Equal(t, want, tp.ConsumeTraces(context.Background(), traces.New())) } func TestNewTracesProcessor_ProcessTracesErrSkipProcessingData(t *testing.T) { tp, err := NewTracesProcessor(&testTracesCfg, consumertest.NewNop(), newTestTProcessor(ErrSkipProcessingData)) require.NoError(t, err) - assert.Equal(t, nil, tp.ConsumeTraces(context.Background(), pdata.NewTraces())) + assert.Equal(t, nil, tp.ConsumeTraces(context.Background(), traces.New())) } func newTestTProcessor(retError error) ProcessTracesFunc { - return func(_ context.Context, td pdata.Traces) (pdata.Traces, error) { + return func(_ context.Context, td traces.Traces) (traces.Traces, error) { return td, retError } } diff --git a/receiver/otlpreceiver/otlp_test.go b/receiver/otlpreceiver/otlp_test.go index 9a45e47d9fc..510f0c29190 100644 --- a/receiver/otlpreceiver/otlp_test.go +++ b/receiver/otlpreceiver/otlp_test.go @@ -51,6 +51,7 @@ import ( "go.opentelemetry.io/collector/model/otlp" "go.opentelemetry.io/collector/model/otlpgrpc" "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" semconv "go.opentelemetry.io/collector/model/semconv/v1.5.0" "go.opentelemetry.io/collector/obsreport/obsreporttest" ) @@ -108,8 +109,8 @@ var traceJSON = []byte(` ] }`) -var traceOtlp = func() pdata.Traces { - td := pdata.NewTraces() +var traceOtlp = func() traces.Traces { + td := traces.New() rs := td.ResourceSpans().AppendEmpty() rs.Resource().Attributes().UpsertString(semconv.AttributeHostName, "testHost") spans := rs.ScopeSpans().AppendEmpty().Spans() @@ -120,7 +121,7 @@ var traceOtlp = func() pdata.Traces { span1.SetName("testSpan") span1.SetStartTimestamp(1544712660300000000) span1.SetEndTimestamp(1544712660600000000) - span1.SetKind(pdata.SpanKindServer) + span1.SetKind(traces.SpanKindServer) span1.Attributes().UpsertInt("attr1", 55) span2 := spans.AppendEmpty() span2.SetTraceID(pdata.NewTraceID([16]byte{0x5B, 0x8E, 0xFF, 0xF7, 0x98, 0x3, 0x81, 0x3, 0xD2, 0x69, 0xB6, 0x33, 0x81, 0x3F, 0xC6, 0xC})) @@ -128,7 +129,7 @@ var traceOtlp = func() pdata.Traces { span2.SetName("testSpan") span2.SetStartTimestamp(1544712660000000000) span2.SetEndTimestamp(1544712661000000000) - span2.SetKind(pdata.SpanKindClient) + span2.SetKind(traces.SpanKindClient) span2.Attributes().UpsertInt("attr1", 55) return td }() @@ -466,7 +467,7 @@ func testHTTPProtobufRequest( encoding string, traceBytes []byte, expectedErr error, - wantData pdata.Traces, + wantData traces.Traces, ) { tSink.SetConsumeError(expectedErr) @@ -651,7 +652,7 @@ func TestOTLPReceiverTrace_HandleNextConsumerResponse(t *testing.T) { receiverTag string exportFn func( cc *grpc.ClientConn, - td pdata.Traces) error + td traces.Traces) error }{ { receiverTag: "trace", @@ -885,7 +886,7 @@ func compressGzip(body []byte) (*bytes.Buffer, error) { return &buf, nil } -type senderFunc func(td pdata.Traces) +type senderFunc func(td traces.Traces) func TestShutdown(t *testing.T) { endpointGrpc := testutil.GetAvailableLocalAddress(t) @@ -915,11 +916,11 @@ func TestShutdown(t *testing.T) { doneSignalGrpc := make(chan bool) doneSignalHTTP := make(chan bool) - senderGrpc := func(td pdata.Traces) { + senderGrpc := func(td traces.Traces) { // Ignore error, may be executed after the receiver shutdown. _ = exportTraces(conn, td) } - senderHTTP := func(td pdata.Traces) { + senderHTTP := func(td traces.Traces) { // Send request via OTLP/HTTP. traceBytes, err2 := otlp.NewProtobufTracesMarshaler().MarshalTraces(td) if err2 != nil { @@ -989,7 +990,7 @@ loop: close(doneSignal) } -func exportTraces(cc *grpc.ClientConn, td pdata.Traces) error { +func exportTraces(cc *grpc.ClientConn, td traces.Traces) error { acc := otlpgrpc.NewTracesClient(cc) req := otlpgrpc.NewTracesRequest() req.SetTraces(td) diff --git a/receiver/scraperhelper/scraper.go b/receiver/scraperhelper/scraper.go index 2c6c75296c6..31a90390e7a 100644 --- a/receiver/scraperhelper/scraper.go +++ b/receiver/scraperhelper/scraper.go @@ -20,15 +20,15 @@ import ( "go.opentelemetry.io/collector/component" "go.opentelemetry.io/collector/config" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) var errNilFunc = errors.New("nil scrape func") // ScrapeFunc scrapes metrics. -type ScrapeFunc func(context.Context) (pdata.Metrics, error) +type ScrapeFunc func(context.Context) (metrics.Metrics, error) -func (sf ScrapeFunc) Scrape(ctx context.Context) (pdata.Metrics, error) { +func (sf ScrapeFunc) Scrape(ctx context.Context) (metrics.Metrics, error) { return sf(ctx) } @@ -38,7 +38,7 @@ type Scraper interface { // ID returns the scraper id. ID() config.ComponentID - Scrape(context.Context) (pdata.Metrics, error) + Scrape(context.Context) (metrics.Metrics, error) } // ScraperOption apply changes to internal options. diff --git a/receiver/scraperhelper/scrapercontroller.go b/receiver/scraperhelper/scrapercontroller.go index 8b96c379d87..e56393e88c5 100644 --- a/receiver/scraperhelper/scrapercontroller.go +++ b/receiver/scraperhelper/scrapercontroller.go @@ -26,7 +26,7 @@ import ( "go.opentelemetry.io/collector/component/componenterror" "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/consumer" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" "go.opentelemetry.io/collector/obsreport" "go.opentelemetry.io/collector/receiver/scrapererror" ) @@ -183,7 +183,7 @@ func (sc *controller) startScraping() { // Scrapers, records observability information, and passes the scraped metrics // to the next component. func (sc *controller) scrapeMetricsAndReport(ctx context.Context) { - metrics := pdata.NewMetrics() + metrics := metrics.New() for _, scraper := range sc.scrapers { scrp := obsreport.NewScraper(obsreport.ScraperSettings{ diff --git a/receiver/scraperhelper/scrapercontroller_test.go b/receiver/scraperhelper/scrapercontroller_test.go index 0adff240e60..e32bd931325 100644 --- a/receiver/scraperhelper/scrapercontroller_test.go +++ b/receiver/scraperhelper/scrapercontroller_test.go @@ -31,7 +31,7 @@ import ( "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/consumer" "go.opentelemetry.io/collector/consumer/consumertest" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" "go.opentelemetry.io/collector/obsreport/obsreporttest" "go.opentelemetry.io/collector/receiver/scrapererror" ) @@ -62,17 +62,17 @@ type testScrapeMetrics struct { err error } -func (ts *testScrapeMetrics) scrape(_ context.Context) (pdata.Metrics, error) { +func (ts *testScrapeMetrics) scrape(_ context.Context) (metrics.Metrics, error) { ts.timesScrapeCalled++ ts.ch <- ts.timesScrapeCalled if ts.err != nil { - return pdata.Metrics{}, ts.err + return metrics.Metrics{}, ts.err } - md := pdata.NewMetrics() + md := metrics.New() metric := md.ResourceMetrics().AppendEmpty().ScopeMetrics().AppendEmpty().Metrics().AppendEmpty() - metric.SetDataType(pdata.MetricDataTypeGauge) + metric.SetDataType(metrics.MetricDataTypeGauge) metric.Gauge().DataPoints().AppendEmpty() return md, nil } diff --git a/service/internal/builder/pipelines_builder_test.go b/service/internal/builder/pipelines_builder_test.go index e67c1ce9487..40de1842f73 100644 --- a/service/internal/builder/pipelines_builder_test.go +++ b/service/internal/builder/pipelines_builder_test.go @@ -27,7 +27,7 @@ import ( "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/internal/testcomponents" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" "go.opentelemetry.io/collector/service/servicetest" ) @@ -154,7 +154,7 @@ func TestBuildPipelines_BuildVarious(t *testing.T) { } // Send one custom data. - log := pdata.Logs{} + log := logs.Logs{} require.NoError(t, processor.firstLC.ConsumeLogs(context.Background(), log)) // Now verify received data. diff --git a/service/internal/builder/receivers_builder_test.go b/service/internal/builder/receivers_builder_test.go index 0aa6d43cd09..c9f4fb9aa74 100644 --- a/service/internal/builder/receivers_builder_test.go +++ b/service/internal/builder/receivers_builder_test.go @@ -28,7 +28,7 @@ import ( "go.opentelemetry.io/collector/config" "go.opentelemetry.io/collector/internal/testcomponents" "go.opentelemetry.io/collector/internal/testdata" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" "go.opentelemetry.io/collector/service/servicetest" ) @@ -235,7 +235,7 @@ func TestBuildReceivers_BuildCustom(t *testing.T) { } // Send one data. - log := pdata.Logs{} + log := logs.Logs{} producer := receiver.receiver.(*testcomponents.ExampleReceiverProducer) require.NoError(t, producer.ConsumeLogs(context.Background(), log)) diff --git a/service/internal/fanoutconsumer/logs.go b/service/internal/fanoutconsumer/logs.go index 9dde97673a1..d452a3918eb 100644 --- a/service/internal/fanoutconsumer/logs.go +++ b/service/internal/fanoutconsumer/logs.go @@ -22,7 +22,7 @@ import ( "go.uber.org/multierr" "go.opentelemetry.io/collector/consumer" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/logs" ) // NewLogs wraps multiple log consumers in a single one. @@ -64,8 +64,8 @@ func (lsc *logsConsumer) Capabilities() consumer.Capabilities { return consumer.Capabilities{MutatesData: false} } -// ConsumeLogs exports the pdata.Logs to all consumers wrapped by the current one. -func (lsc *logsConsumer) ConsumeLogs(ctx context.Context, ld pdata.Logs) error { +// ConsumeLogs exports the logs.Logs to all consumers wrapped by the current one. +func (lsc *logsConsumer) ConsumeLogs(ctx context.Context, ld logs.Logs) error { var errs error // Initially pass to clone exporter to avoid the case where the optimization of sending // the incoming data to a mutating consumer is used that may change the incoming data before diff --git a/service/internal/fanoutconsumer/metrics.go b/service/internal/fanoutconsumer/metrics.go index 371643252b5..4145adbfcaa 100644 --- a/service/internal/fanoutconsumer/metrics.go +++ b/service/internal/fanoutconsumer/metrics.go @@ -20,7 +20,7 @@ import ( "go.uber.org/multierr" "go.opentelemetry.io/collector/consumer" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/metrics" ) // NewMetrics wraps multiple metrics consumers in a single one. @@ -62,8 +62,8 @@ func (msc *metricsConsumer) Capabilities() consumer.Capabilities { return consumer.Capabilities{MutatesData: false} } -// ConsumeMetrics exports the pdata.Metrics to all consumers wrapped by the current one. -func (msc *metricsConsumer) ConsumeMetrics(ctx context.Context, md pdata.Metrics) error { +// ConsumeMetrics exports the metrics.Metrics to all consumers wrapped by the current one. +func (msc *metricsConsumer) ConsumeMetrics(ctx context.Context, md metrics.Metrics) error { var errs error // Initially pass to clone exporter to avoid the case where the optimization of sending // the incoming data to a mutating consumer is used that may change the incoming data before diff --git a/service/internal/fanoutconsumer/traces.go b/service/internal/fanoutconsumer/traces.go index 04dcd9fb5e8..4214158d36c 100644 --- a/service/internal/fanoutconsumer/traces.go +++ b/service/internal/fanoutconsumer/traces.go @@ -20,7 +20,7 @@ import ( "go.uber.org/multierr" "go.opentelemetry.io/collector/consumer" - "go.opentelemetry.io/collector/model/pdata" + "go.opentelemetry.io/collector/model/pdata/traces" ) // NewTraces wraps multiple trace consumers in a single one. @@ -62,8 +62,8 @@ func (tsc *tracesConsumer) Capabilities() consumer.Capabilities { return consumer.Capabilities{MutatesData: false} } -// ConsumeTraces exports the pdata.Traces to all consumers wrapped by the current one. -func (tsc *tracesConsumer) ConsumeTraces(ctx context.Context, td pdata.Traces) error { +// ConsumeTraces exports the traces.Traces to all consumers wrapped by the current one. +func (tsc *tracesConsumer) ConsumeTraces(ctx context.Context, td traces.Traces) error { var errs error // Initially pass to clone exporter to avoid the case where the optimization of sending // the incoming data to a mutating consumer is used that may change the incoming data before