otel: go.opentelemetry.io/otel Index | Files | Directories

package otel

import "go.opentelemetry.io/otel"

Package otel provides global access to the OpenTelemetry API. The subpackages of the otel package provide an implementation of the OpenTelemetry API.

This package is currently in a pre-GA phase. Backwards incompatible changes may be introduced in subsequent minor version releases as we work to track the evolving OpenTelemetry specification and user feedback.

The provided API is used to instrument code and measure data about that code's performance and operation. The measured data, by default, is not processed or transmitted anywhere. An implementation of the OpenTelemetry SDK, like the default SDK implementation (go.opentelemetry.io/otel/sdk), and associated exporters are used to process and transport this data.

To read more about tracing, see go.opentelemetry.io/otel/trace.

To read more about metrics, see go.opentelemetry.io/otel/metric.

To read more about propagation, see go.opentelemetry.io/otel/propagation and go.opentelemetry.io/otel/baggage.

Index

Package Files

doc.go error_handler.go handler.go metric.go propagation.go trace.go version.go

func GetMeterProvider Uses

func GetMeterProvider() metric.MeterProvider

GetMeterProvider returns the registered global meter provider. If none is registered then a default meter provider is returned that forwards the Meter interface to the first registered Meter.

Use the meter provider to create a named meter. E.g.

meter := global.MeterProvider().Meter("example.com/foo")

or

meter := global.Meter("example.com/foo")

func GetTextMapPropagator Uses

func GetTextMapPropagator() propagation.TextMapPropagator

GetTextMapPropagator returns the global TextMapPropagator. If none has been set, a No-Op TextMapPropagator is returned.

func GetTracerProvider Uses

func GetTracerProvider() trace.TracerProvider

TracerProvider returns the registered global trace provider. If none is registered then an instance of NoopTracerProvider is returned.

Use the trace provider to create a named tracer. E.g.

tracer := global.GetTracerProvider().Tracer("example.com/foo")

or

tracer := global.Tracer("example.com/foo")

func Handle Uses

func Handle(err error)

Handle is a convience function for ErrorHandler().Handle(err)

func Meter Uses

func Meter(instrumentationName string, opts ...metric.MeterOption) metric.Meter

Meter creates an implementation of the Meter interface from the global MeterProvider. The instrumentationName must be the name of the library providing instrumentation. This name may be the same as the instrumented code only if that code provides built-in instrumentation. If the instrumentationName is empty, then a implementation defined default name will be used instead.

This is short for MeterProvider().Meter(name)

func SetErrorHandler Uses

func SetErrorHandler(h ErrorHandler)

SetErrorHandler sets the global ErrorHandler to be h.

func SetMeterProvider Uses

func SetMeterProvider(mp metric.MeterProvider)

SetMeterProvider registers `mp` as the global meter provider.

func SetTextMapPropagator Uses

func SetTextMapPropagator(propagator propagation.TextMapPropagator)

SetTextMapPropagator sets propagator as the global TSetTextMapPropagator.

func SetTracerProvider Uses

func SetTracerProvider(tp trace.TracerProvider)

SetTracerProvider registers `tp` as the global trace provider.

func Tracer Uses

func Tracer(name string) trace.Tracer

Tracer creates a named tracer that implements Tracer interface. If the name is an empty string then provider uses default name.

This is short for TracerProvider().Tracer(name)

func Version Uses

func Version() string

Version is the current release version of OpenTelemetry in use.

type ErrorHandler Uses

type ErrorHandler interface {
    // Handle handles any error deemed irremediable by an OpenTelemetry
    // component.
    Handle(error)
}

ErrorHandler handles irremediable events.

func GetErrorHandler Uses

func GetErrorHandler() ErrorHandler

GetErrorHandler returns the global ErrorHandler instance. If no ErrorHandler instance has been set (`SetErrorHandler`), the default ErrorHandler which logs errors to STDERR is returned.

Directories

PathSynopsis
baggagePackage baggage provides functionality for storing and retrieving baggage items in Go context.
bridge/opencensusPackage opencensus provides a migration bridge forwarding the OpenCensus API to the OpenTelemetry SDK.
bridge/opencensus/binary
bridge/opencensus/utils
bridge/opentracingThis package implements a bridge that forwards OpenTracing API calls to the OpenTelemetry SDK.
bridge/opentracing/internal
bridge/opentracing/migrationThis package provides interfaces and functions that are useful for providing a cooperation of the OpenTelemetry tracers with the OpenTracing API.
codesPackage codes defines the canonical error codes used by OpenTelemetry.
example/basic
example/jaegerCommand jaeger is an example program that creates spans and uploads to Jaeger.
example/namedtracer
example/namedtracer/foo
example/otel-collectorExample using the OTLP exporter + collector + third-party backends.
example/prometheus
example/zipkinCommand zipkin is an example program that creates spans and uploads to openzipkin collector.
exporters/metric/prometheus
exporters/otlpPackage otlp contains an exporter for the OpenTelemetry protocol buffers.
exporters/otlp/internal/opentelemetry-proto-gen/collector/metrics/v1
exporters/otlp/internal/opentelemetry-proto-gen/collector/trace/v1
exporters/otlp/internal/opentelemetry-proto-gen/common/v1
exporters/otlp/internal/opentelemetry-proto-gen/metrics/v1
exporters/otlp/internal/opentelemetry-proto-gen/resource/v1
exporters/otlp/internal/opentelemetry-proto-gen/trace/v1
exporters/otlp/internal/transformPackage transform provides translations for opentelemetry-go concepts and structures to otlp structures.
exporters/stdoutPackage stdout contains an OpenTelemetry exporter for both tracing and metric telemetry to be written to an output destination as JSON.
exporters/trace/jaegerPackage jaeger contains an OpenTelemetry tracing exporter for Jaeger.
exporters/trace/jaeger/internal/gen-go/jaeger
exporters/trace/jaeger/internal/gen-go/jaeger/collector-remote
exporters/trace/zipkinPackage zipkin contains an OpenTelemetry tracing exporter for Zipkin.
internal
internal/baggagePackage baggage provides types and functions to manage W3C Baggage.
internal/global
internal/matchers
internal/metric
internal/testing
internal/trace/noopPackage noop provides noop tracing implementations for tracer and span.
internal/trace/parent
labelPackage label provides key and value labels.
metricPackage metric provides an implementation of the metrics part of the OpenTelemetry API.
metric/numberPackage number provides a number abstraction for instruments that either support int64 or float64 input values.
metric/registryPackage registry provides a non-standalone implementation of MeterProvider that adds uniqueness checking for instrument descriptors on top of other MeterProvider it wraps.
oteltestPackage oteltest provides testing utilities for the otel package.
propagationPackage propagation contains OpenTelemetry context propagators.
sdk/export/metric
sdk/export/metric/aggregation
sdk/export/metric/metrictest
sdk/export/trace
sdk/export/trace/tracetesttracetest is a testing helper package for the SDK.
sdk/instrumentationPackage instrumentation provides an instrumentation library structure to be passed to both the OpenTelemetry Tracer and Meter components.
sdk/internal
sdk/metricPackage metric implements the OpenTelemetry metric API.
sdk/metric/aggregator
sdk/metric/aggregator/aggregatortest
sdk/metric/aggregator/array
sdk/metric/aggregator/ddsketch
sdk/metric/aggregator/histogram
sdk/metric/aggregator/lastvalue
sdk/metric/aggregator/minmaxsumcount
sdk/metric/aggregator/sum
sdk/metric/controller/controllertest
sdk/metric/controller/pull
sdk/metric/controller/push
sdk/metric/controller/time
sdk/metric/processor/basic
sdk/metric/processor/processortest
sdk/metric/processor/reducerPackage reducer implements a metrics Processor component to reduce labels.
sdk/metric/selector/simple
sdk/resourcePackage resource provides detecting and representing resources.
sdk/tracePackage trace contains support for OpenTelemetry distributed tracing.
sdk/trace/internalPackage internal provides trace internals.
semconvPackage semconv implements OpenTelemetry semantic conventions.
tracePackage trace provides an implementation of the tracing part of the OpenTelemetry API.
unitPackage unit provides units.

Package otel imports 8 packages (graph) and is imported by 37 packages. Updated 2020-12-01. Refresh now. Tools for package owners.