otel: go.opentelemetry.io/otel/exporters/otlp Index | Examples | Files | Directories

package otlp

import "go.opentelemetry.io/otel/exporters/otlp"

Package otlp contains an exporter for the OpenTelemetry protocol buffers.

Code:

exp, err := otlp.NewExporter(otlp.WithInsecure())
if err != nil {
    log.Fatalf("Failed to create the collector exporter: %v", err)
}
defer func() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    if err := exp.Shutdown(ctx); err != nil {
        global.Handle(err)
    }
}()

tp := sdktrace.NewTracerProvider(
    sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()}),
    sdktrace.WithBatcher(
        exp,
        // add following two options to ensure flush
        sdktrace.WithBatchTimeout(5),
        sdktrace.WithMaxExportBatchSize(10),
    ),
)
global.SetTracerProvider(tp)

tracer := global.Tracer("test-tracer")

// Then use the OpenTelemetry tracing library, like we normally would.
ctx, span := tracer.Start(context.Background(), "CollectorExporter-Example")
defer span.End()

for i := 0; i < 10; i++ {
    _, iSpan := tracer.Start(ctx, fmt.Sprintf("Sample-%d", i))
    <-time.After(6 * time.Millisecond)
    iSpan.End()
}

Code:

// Please take at look at https://pkg.go.dev/google.golang.org/grpc/credentials#TransportCredentials
// for ways on how to initialize gRPC TransportCredentials.
creds, err := credentials.NewClientTLSFromFile("my-cert.pem", "")
if err != nil {
    log.Fatalf("failed to create gRPC client TLS credentials: %v", err)
}

exp, err := otlp.NewExporter(otlp.WithTLSCredentials(creds))
if err != nil {
    log.Fatalf("failed to create the collector exporter: %v", err)
}
defer func() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    if err := exp.Shutdown(ctx); err != nil {
        global.Handle(err)
    }
}()

tp := sdktrace.NewTracerProvider(
    sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()}),
    sdktrace.WithBatcher(
        exp,
        // add following two options to ensure flush
        sdktrace.WithBatchTimeout(5),
        sdktrace.WithMaxExportBatchSize(10),
    ),
)
global.SetTracerProvider(tp)

tracer := global.Tracer("test-tracer")

// Then use the OpenTelemetry tracing library, like we normally would.
ctx, span := tracer.Start(context.Background(), "Securely-Talking-To-Collector-Span")
defer span.End()

for i := 0; i < 10; i++ {
    _, iSpan := tracer.Start(ctx, fmt.Sprintf("Sample-%d", i))
    <-time.After(6 * time.Millisecond)
    iSpan.End()
}

Index

Examples

Package Files

connection.go doc.go options.go otlp.go

Constants

const (
    DefaultCollectorPort uint16 = 55680

    DefaultCollectorHost string = "localhost"

    DefaultNumWorkers uint = 1

    DefaultGRPCServiceConfig = "" /* 499 byte string literal not displayed */

)

type Exporter Uses

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

Exporter is an OpenTelemetry exporter. It exports both traces and metrics from OpenTelemetry instrumented to code using OpenTelemetry protocol buffers to a configurable receiver.

func NewExporter Uses

func NewExporter(opts ...ExporterOption) (*Exporter, error)

NewExporter constructs a new Exporter and starts it.

func NewUnstartedExporter Uses

func NewUnstartedExporter(opts ...ExporterOption) *Exporter

NewUnstartedExporter constructs a new Exporter and does not start it.

func (*Exporter) Export Uses

func (e *Exporter) Export(parent context.Context, cps metricsdk.CheckpointSet) error

Export implements the "go.opentelemetry.io/otel/sdk/export/metric".Exporter interface. It transforms and batches metric Records into OTLP Metrics and transmits them to the configured collector.

func (*Exporter) ExportKindFor Uses

func (e *Exporter) ExportKindFor(*otel.Descriptor, aggregation.Kind) metricsdk.ExportKind

ExportKindFor reports back to the OpenTelemetry SDK sending this Exporter metric telemetry that it needs to be provided in a pass-through format.

func (*Exporter) ExportSpans Uses

func (e *Exporter) ExportSpans(ctx context.Context, sds []*tracesdk.SpanData) error

ExportSpans exports a batch of SpanData.

func (*Exporter) Shutdown Uses

func (e *Exporter) Shutdown(ctx context.Context) error

Shutdown closes all connections and releases resources currently being used by the exporter. If the exporter is not started this does nothing.

func (*Exporter) Start Uses

func (e *Exporter) Start() error

Start dials to the collector, establishing a connection to it. It also initiates the Config and Trace services by sending over the initial messages that consist of the node identifier. Start invokes a background connector that will reattempt connections to the collector periodically if the connection dies.

type ExporterOption Uses

type ExporterOption func(*config)

ExporterOption are setting options passed to an Exporter on creation.

func WithAddress Uses

func WithAddress(addr string) ExporterOption

WithAddress allows one to set the address that the exporter will connect to the collector on. If unset, it will instead try to use connect to DefaultCollectorHost:DefaultCollectorPort.

func WithCompressor Uses

func WithCompressor(compressor string) ExporterOption

WithCompressor will set the compressor for the gRPC client to use when sending requests. It is the responsibility of the caller to ensure that the compressor set has been registered with google.golang.org/grpc/encoding. This can be done by encoding.RegisterCompressor. Some compressors auto-register on import, such as gzip, which can be registered by calling `import _ "google.golang.org/grpc/encoding/gzip"`

func WithGRPCDialOption Uses

func WithGRPCDialOption(opts ...grpc.DialOption) ExporterOption

WithGRPCDialOption opens support to any grpc.DialOption to be used. If it conflicts with some other configuration the GRPC specified via the collector the ones here will take preference since they are set last.

func WithGRPCServiceConfig Uses

func WithGRPCServiceConfig(serviceConfig string) ExporterOption

WithGRPCServiceConfig defines the default gRPC service config used.

func WithHeaders Uses

func WithHeaders(headers map[string]string) ExporterOption

WithHeaders will send the provided headers with gRPC requests

func WithInsecure Uses

func WithInsecure() ExporterOption

WithInsecure disables client transport security for the exporter's gRPC connection just like grpc.WithInsecure() https://pkg.go.dev/google.golang.org/grpc#WithInsecure does. Note, by default, client security is required unless WithInsecure is used.

func WithReconnectionPeriod Uses

func WithReconnectionPeriod(rp time.Duration) ExporterOption

WithReconnectionPeriod allows one to set the delay between next connection attempt after failing to connect with the collector.

func WithTLSCredentials Uses

func WithTLSCredentials(creds credentials.TransportCredentials) ExporterOption

WithTLSCredentials allows the connection to use TLS credentials when talking to the server. It takes in grpc.TransportCredentials instead of say a Certificate file or a tls.Certificate, because the retrieving these credentials can be done in many ways e.g. plain file, in code tls.Config or by certificate rotation, so it is up to the caller to decide what to use.

func WorkerCount Uses

func WorkerCount(n uint) ExporterOption

WorkerCount sets the number of Goroutines to use when processing telemetry.

Directories

PathSynopsis
internal/opentelemetry-proto-gen/collector/metrics/v1
internal/opentelemetry-proto-gen/collector/trace/v1
internal/opentelemetry-proto-gen/common/v1
internal/opentelemetry-proto-gen/metrics/v1
internal/opentelemetry-proto-gen/resource/v1
internal/opentelemetry-proto-gen/trace/v1
internal/transformPackage transform provides translations for opentelemetry-go concepts and structures to otlp structures.

Package otlp imports 18 packages (graph) and is imported by 2 packages. Updated 2020-10-19. Refresh now. Tools for package owners.