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

package stdout

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

Package stdout contains an OpenTelemetry exporter for both tracing and metric telemetry to be written to an output destination as JSON.

Code:

package main

import (
    "context"
    "log"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/stdout"
    "go.opentelemetry.io/otel/global"
    "go.opentelemetry.io/otel/label"
)

const (
    instrumentationName    = "github.com/instrumentron"
    instrumentationVersion = "v0.1.0"
)

var (
    tracer = global.TracerProvider().Tracer(
        instrumentationName,
        otel.WithInstrumentationVersion(instrumentationVersion),
    )

    meter = global.MeterProvider().Meter(
        instrumentationName,
        otel.WithInstrumentationVersion(instrumentationVersion),
    )

    loopCounter = otel.Must(meter).NewInt64Counter("function.loops")
    paramValue  = otel.Must(meter).NewInt64ValueRecorder("function.param")

    nameKey = label.Key("function.name")
)

func add(ctx context.Context, x, y int64) int64 {
    nameKV := nameKey.String("add")

    var span otel.Span
    ctx, span = tracer.Start(ctx, "Addition")
    defer span.End()

    loopCounter.Add(ctx, 1, nameKV)
    paramValue.Record(ctx, x, nameKV)
    paramValue.Record(ctx, y, nameKV)

    return x + y
}

func multiply(ctx context.Context, x, y int64) int64 {
    nameKV := nameKey.String("multiply")

    var span otel.Span
    ctx, span = tracer.Start(ctx, "Multiplication")
    defer span.End()

    loopCounter.Add(ctx, 1, nameKV)
    paramValue.Record(ctx, x, nameKV)
    paramValue.Record(ctx, y, nameKV)

    return x * y
}

func main() {
    exportOpts := []stdout.Option{
        stdout.WithQuantiles([]float64{0.5}),
        stdout.WithPrettyPrint(),
    }
    // Registers both a trace and meter Provider globally.
    pusher, err := stdout.InstallNewPipeline(exportOpts, nil)
    if err != nil {
        log.Fatal("Could not initialize stdout exporter:", err)
    }
    defer pusher.Stop()

    ctx := context.Background()
    log.Println("the answer is", add(ctx, multiply(ctx, multiply(ctx, 2, 2), 10), 2))
}

Index

Examples

Package Files

config.go doc.go exporter.go metric.go trace.go

func InstallNewPipeline Uses

func InstallNewPipeline(exportOpts []Option, pushOpts []push.Option) (*push.Controller, error)

InstallNewPipeline creates a complete export pipelines with defaults and registers it globally. It is the responsibility of the caller to stop the returned push Controller.

Typically this is called as:

pipeline, err := stdout.InstallNewPipeline(stdout.Config{...})
if err != nil {
	...
}
defer pipeline.Stop()
... Done

func NewExportPipeline Uses

func NewExportPipeline(exportOpts []Option, pushOpts []push.Option) (otel.TracerProvider, *push.Controller, error)

NewExportPipeline creates a complete export pipeline with the default selectors, processors, and trace registration. It is the responsibility of the caller to stop the returned push Controller.

type Config Uses

type Config struct {
    // Writer is the destination.  If not set, os.Stdout is used.
    Writer io.Writer

    // PrettyPrint will encode the output into readable JSON. Default is
    // false.
    PrettyPrint bool

    // Timestamps specifies if timestamps should be pritted. Default is
    // true.
    Timestamps bool

    // Quantiles are the desired aggregation quantiles for distribution
    // summaries, used when the configured aggregator supports
    // quantiles.
    //
    // Note: this exporter is meant as a demonstration; a real
    // exporter may wish to configure quantiles on a per-metric
    // basis.
    Quantiles []float64

    // LabelEncoder encodes the labels.
    LabelEncoder label.Encoder

    // DisableTraceExport prevents any export of trace telemetry.
    DisableTraceExport bool

    // DisableMetricExport prevents any export of metric telemetry.
    DisableMetricExport bool
}

Config contains options for the STDOUT exporter.

func NewConfig Uses

func NewConfig(options ...Option) (Config, error)

NewConfig creates a validated Config configured with options.

type Exporter Uses

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

func NewExporter Uses

func NewExporter(options ...Option) (*Exporter, error)

NewExporter creates an Exporter with the passed options.

func (*Exporter) Export Uses

func (e *Exporter) Export(_ context.Context, checkpointSet exportmetric.CheckpointSet) error

func (*Exporter) ExportKindFor Uses

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

func (*Exporter) ExportSpans Uses

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

ExportSpans writes SpanData in json format to stdout.

func (*Exporter) Shutdown Uses

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

Shutdown is called to stop the exporter, it preforms no action.

type Option Uses

type Option interface {
    // Apply option value to Config.
    Apply(*Config)
}

Option sets the value of an option for a Config.

func WithLabelEncoder Uses

func WithLabelEncoder(enc label.Encoder) Option

WithLabelEncoder sets the label encoder used in export.

func WithPrettyPrint Uses

func WithPrettyPrint() Option

WithPrettyPrint sets the export stream format to use JSON.

func WithQuantiles Uses

func WithQuantiles(quantiles []float64) Option

WithQuantiles sets the quantile values to export.

func WithWriter Uses

func WithWriter(w io.Writer) Option

WithWriter sets the export stream destination.

func WithoutMetricExport Uses

func WithoutMetricExport() Option

WithoutMetricExport disables all metric exporting.

func WithoutTimestamps Uses

func WithoutTimestamps() Option

WithoutTimestamps sets the export stream to not include timestamps.

func WithoutTraceExport Uses

func WithoutTraceExport() Option

WithoutTraceExport disables all trace exporting.

Package stdout imports 18 packages (graph) and is imported by 5 packages. Updated 2020-10-17. Refresh now. Tools for package owners.