add NewExportPipeline and InstallNewPipeline for otlp

CHANGELOG.md

@@ -8,6 +8,8 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+- The OTLP exporter now has two new convenience functions, `NewExportPipeline` and `InstallNewPipeline`, setup and install the exporter in tracing and metrics pipelines. (#1348)
+
 ### Added
 
 - Added `Marshaler` config option to `otlphttp` to enable otlp over json or protobufs. (#1586)

exporters/otlp/otlp.go

@@ -19,10 +19,16 @@ import (
 	"errors"
 	"sync"
 
+	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/metric"
 	metricsdk "go.opentelemetry.io/otel/sdk/export/metric"
 	"go.opentelemetry.io/otel/sdk/export/metric/aggregation"
 	tracesdk "go.opentelemetry.io/otel/sdk/export/trace"
+	"go.opentelemetry.io/otel/sdk/metric/selector/simple"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+
+	"go.opentelemetry.io/otel/sdk/metric/controller/basic"
+	processor "go.opentelemetry.io/otel/sdk/metric/processor/basic"
 )
 
 // Exporter is an OpenTelemetry exporter. It exports both traces and metrics
@@ -131,3 +137,46 @@ func (e *Exporter) ExportKindFor(desc *metric.Descriptor, kind aggregation.Kind)
 func (e *Exporter) ExportSpans(ctx context.Context, ss []*tracesdk.SpanSnapshot) error {
 	return e.driver.ExportTraces(ctx, ss)
 }
+
+// NewExportPipeline sets up a complete export pipeline
+// with the recommended setup for trace provider.
+func NewExportPipeline(ctx context.Context, driver ProtocolDriver, exporterOpts ...ExporterOption) (*Exporter,
+	*sdktrace.TracerProvider, *basic.Controller, error) {
+
+	exp, err := NewExporter(ctx, driver, exporterOpts...)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	tracerProvider := sdktrace.NewTracerProvider(
+		sdktrace.WithBatcher(exp),
+	)
+
+	cntr := basic.New(
+		processor.New(
+			simple.NewWithInexpensiveDistribution(),
+			exp,
+		),
+	)
+
+	return exp, tracerProvider, cntr, nil
+}
+
+// InstallNewPipeline instantiates a NewExportPipeline with the
+// recommended configuration and registers it globally.
+func InstallNewPipeline(ctx context.Context, driver ProtocolDriver, exporterOpts ...ExporterOption) (*Exporter,
+	*sdktrace.TracerProvider, *basic.Controller, error) {
+
+	exp, tp, cntr, err := NewExportPipeline(ctx, driver, exporterOpts...)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	otel.SetTracerProvider(tp)
+	err = cntr.Start(ctx)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	return exp, tp, cntr, err
+}

exporters/otlp/otlp_test.go

@@ -24,12 +24,14 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/exporters/otlp"
 	metricpb "go.opentelemetry.io/otel/exporters/otlp/internal/opentelemetry-proto-gen/metrics/v1"
 	tracepb "go.opentelemetry.io/otel/exporters/otlp/internal/opentelemetry-proto-gen/trace/v1"
 	"go.opentelemetry.io/otel/exporters/otlp/internal/transform"
 	metricsdk "go.opentelemetry.io/otel/sdk/export/metric"
 	tracesdk "go.opentelemetry.io/otel/sdk/export/trace"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
 )
 
 func stubSpanSnapshot(count int) []*tracesdk.SpanSnapshot {
@@ -244,6 +246,43 @@ func TestExporterShutdownManyTimes(t *testing.T) {
 	}
 }
 
+func TestInstallNewPipeline(t *testing.T) {
+	ctx := context.Background()
+	_, _, _, err := otlp.InstallNewPipeline(ctx, &stubProtocolDriver{})
+	assert.NoError(t, err)
+	assert.IsType(t, &sdktrace.TracerProvider{}, otel.GetTracerProvider())
+}
+
+func TestNewExportPipeline(t *testing.T) {
+	testCases := []struct {
+		name             string
+		expOpts          []otlp.ExporterOption
+		testSpanSampling bool
+	}{
+		{
+			name: "simple pipeline",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			_, tp, _, err := otlp.NewExportPipeline(
+				context.Background(),
+				&stubProtocolDriver{},
+				tc.expOpts...,
+			)
+
+			assert.NoError(t, err)
+			assert.NotEqual(t, tp, otel.GetTracerProvider())
+
+			_, span := tp.Tracer("otlp test").Start(context.Background(), tc.name)
+			spanCtx := span.SpanContext()
+			assert.Equal(t, true, spanCtx.IsSampled())
+			span.End()
+		})
+	}
+}
+
 func TestSplitDriver(t *testing.T) {
 	driverTraces := &stubProtocolDriver{}
 	driverMetrics := &stubProtocolDriver{}