collex

README

collex

Use OpenTelemetry Collector Exporters with OpenTelemetry Go

⚠ This project is a work in progress 🚧. Breaking changes may be introduced. ⚠

Getting Started

OpenTelemetry Collector exporters are generated from ExporterFactorys. First wrap this facotry with collex.

factory, err := collex.NewFactory(your.NewFactory(), nil)
if err != nil {
    // Handle error appropiately.
}

Tracing

Generate a SpanExporter from your collex.Factory.

exp, err := factory.SpanExporter(context.Background(), nil)
if err != nil {
    // Handle error appropiately.
}
provider := trace.NewTracerProvider(trace.WithBatcher(exp))

Use provider as any other OpenTelemetry Go TracerProvider to generate tracing telemetry.

Documentation

Overview

Package collex provides OpenTelemetry Go Exporters that wrap OpenTelemetry Collector Exporters. This allows any collector exporter to be used with opentelemetry-go.

Example

package main

import (
	"context"
	"log"

	"github.com/MrAlias/collex"
	"go.opentelemetry.io/collector/component"
	"go.opentelemetry.io/collector/config/configtelemetry"
	"go.opentelemetry.io/collector/exporter"
	"go.opentelemetry.io/collector/exporter/debugexporter"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/metric"
	"go.opentelemetry.io/otel/metric/noop"
	"go.opentelemetry.io/otel/sdk/trace"
	"go.uber.org/zap"
)

func main() {
	settings := &exporter.Settings{
		TelemetrySettings: component.TelemetrySettings{
			Logger:         zap.NewExample(), // Log to STDOUT for example.
			TracerProvider: otel.GetTracerProvider(),
			MeterProvider:  otel.GetMeterProvider(),
			LeveledMeterProvider: func(configtelemetry.Level) metric.MeterProvider {
				return noop.NewMeterProvider()
			},
		},
	}
	factory, err := collex.NewFactory(debugexporter.NewFactory(), settings)
	if err != nil {
		log.Fatal(err)
	}

	ctx := context.Background()
	exp, err := factory.SpanExporter(ctx, nil)
	if err != nil {
		log.Fatal(err)
	}

	provider := trace.NewTracerProvider(trace.WithSyncer(exp))
	tracer := provider.Tracer("github.com/MrAlias/collex")
	_, s := tracer.Start(ctx, "ExampleTracesExporter")
	s.End()
	if err := provider.Shutdown(ctx); err != nil {
		log.Fatal(err)
	}

}

Output:
{"level":"info","msg":"Traces","resource spans":1,"spans":1}

Index

• type Factory
  • func NewFactory(f exporter.Factory, set *exporter.Settings) (*Factory, error)
  • func (f *Factory) SpanExporter(ctx context.Context, cfg component.Config) (trace.SpanExporter, error)

Examples

• Package

Types

type Factory

type Factory struct {
	// contains filtered or unexported fields
}

Factory wraps an OpenTelemetry collector ExporterFactory and initializes new OpenTelemetry Go exporters from it.

func NewFactory

func NewFactory(f exporter.Factory, set *exporter.Settings) (*Factory, error)

NewFactory returns a new configured *Factory. If set is nil, a default Settings will be used. These settings use a production ready Zap logger and a global OpenTelemetry Go TracerProvider.

func (*Factory) SpanExporter

func (f *Factory) SpanExporter(ctx context.Context, cfg component.Config) (trace.SpanExporter, error)

SpanExporter returns an OpenTelemetry Go SpanExporter that can be registered with a TracerProvider. If cfg is nil the factory default configuration for the ExporterFactory is used.