1

func GetTextMapPropagator() propagation.TextMapPropagator

1

func GetTracerProvider() trace.TracerProvider

1

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

1

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

1

func Handle(err error)

1

func SetErrorHandler(h ErrorHandler)

1

func SetTextMapPropagator(propagator propagation.TextMapPropagator)

1

func SetTracerProvider(tp trace.TracerProvider)

1

func Tracer(name string) trace.Tracer

1

func Version() string

1
2
3
4
5

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

1

func GetErrorHandler() ErrorHandler

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

var tracer trace.Tracer

func init() {
	tracer = otel.Tracer("instrumentation/package/name")
}

func operation(ctx context.Context) {
	var span trace.Span
	ctx, span = tracer.Start(ctx, "operation")
	defer span.End()
	// ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

const (
	name    = "instrumentation/package/name"
	version = "0.1.0"
)

type Instrumentation struct {
	tracer trace.Tracer
}

func NewInstrumentation(tp trace.TracerProvider) *Instrumentation {
	if tp == nil {
		tp = otel.TracerProvider()
	}
	return &Instrumentation{
		tracer: tp.Tracer(name, trace.WithInstrumentationVersion(version)),
	}
}

func operation(ctx context.Context, inst *Instrumentation) {
	var span trace.Span
	ctx, span = inst.tracer.Start(ctx, "operation")
	defer span.End()
	// ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

const (
	// FlagsSampled is a bitmask with the sampled bit set. A SpanContext
	// with the sampling bit set means the span is sampled.
	FlagsSampled = byte(0x01)
	// FlagsDeferred is a bitmask with the deferred bit set. A SpanContext
	// with the deferred bit set means the sampling decision has been
	// defered to the receiver.
	FlagsDeferred = byte(0x02)
	// FlagsDebug is a bitmask with the debug bit set.
	FlagsDebug = byte(0x04)
)

1

func ContextWithRemoteSpanContext(parent context.Context, remote SpanContext) context.Context

1

func ContextWithSpan(parent context.Context, span Span) context.Context

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

type Event struct {
	// Name is the name of this event
	Name string

	// Attributes describe the aspects of the event.
	Attributes []attribute.KeyValue

	// Time at which this event was recorded.
	Time time.Time
}

1
2
3
4

type EventOption interface {
	ApplyEvent(*SpanConfig)
	// contains filtered or unexported methods
}

1
2
3

type InstrumentationOption interface {
	TracerOption
}

1

func WithInstrumentationVersion(version string) InstrumentationOption

1
2
3
4

type LifeCycleOption interface {
	SpanOption
	EventOption
}

1

func WithAttributes(attributes ...attribute.KeyValue) LifeCycleOption

1

func WithTimestamp(t time.Time) LifeCycleOption

1
2
3
4

type Link struct {
	SpanContext
	Attributes []attribute.KeyValue
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

type Span interface {
	// Tracer returns the Tracer that created the Span. Tracer MUST NOT be
	// nil.
	Tracer() Tracer

	// End completes the Span. The Span is considered complete and ready to be
	// delivered through the rest of the telemetry pipeline after this method
	// is called. Therefore, updates to the Span are not allowed after this
	// method has been called.
	End(options ...SpanOption)

	// AddEvent adds an event with the provided name and options.
	AddEvent(name string, options ...EventOption)

	// IsRecording returns the recording state of the Span. It will return
	// true if the Span is active and events can be recorded.
	IsRecording() bool

	// RecordError records an error as a Span event.
	RecordError(err error, options ...EventOption)

	// SpanContext returns the SpanContext of the Span. The returned
	// SpanContext is usable even after the End has been called for the Span.
	SpanContext() SpanContext

	// SetStatus sets the status of the Span in the form of a code and a
	// message. SetStatus overrides the value of previous calls to SetStatus
	// on the Span.
	SetStatus(code codes.Code, msg string)

	// SetName sets the Span name.
	SetName(name string)

	// SetAttributes sets kv as attributes of the Span. If a key from kv
	// already exists for an attribute of the Span it will be overwritten with
	// the value contained in kv.
	SetAttributes(kv ...attribute.KeyValue)
}

1

func SpanFromContext(ctx context.Context) Span

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

type SpanConfig struct {
	// Attributes describe the associated qualities of a Span.
	Attributes []attribute.KeyValue
	// Timestamp is a time in a Span life-cycle.
	Timestamp time.Time
	// Links are the associations a Span has with other Spans.
	Links []Link
	// NewRoot identifies a Span as the root Span for a new trace. This is
	// commonly used when an existing trace crosses trust boundaries and the
	// remote parent span context should be ignored for security.
	NewRoot bool
	// SpanKind is the role a Span has in a trace.
	SpanKind SpanKind
}

1

func NewEventConfig(options ...EventOption) *SpanConfig

1

func NewSpanConfig(options ...SpanOption) *SpanConfig

1
2
3

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

1

func NewSpanContext(config SpanContextConfig) SpanContext

1

func RemoteSpanContextFromContext(ctx context.Context) SpanContext

1

func SpanContextFromContext(ctx context.Context) SpanContext

1

func (sc SpanContext) Equal(other SpanContext) bool

1

func (sc SpanContext) HasSpanID() bool

1

func (sc SpanContext) HasTraceID() bool

1

func (sc SpanContext) IsDebug() bool

1

func (sc SpanContext) IsDeferred() bool

1

func (sc SpanContext) IsRemote() bool

1

func (sc SpanContext) IsSampled() bool

1

func (sc SpanContext) IsValid() bool

1

func (sc SpanContext) MarshalJSON() ([]byte, error)

1

func (sc SpanContext) SpanID() SpanID

1

func (sc SpanContext) TraceFlags() byte

1

func (sc SpanContext) TraceID() TraceID

1

func (sc SpanContext) TraceState() TraceState

1

func (sc SpanContext) WithRemote(remote bool) SpanContext

1

func (sc SpanContext) WithSpanID(spanID SpanID) SpanContext

1

func (sc SpanContext) WithTraceFlags(flags byte) SpanContext

1

func (sc SpanContext) WithTraceID(traceID TraceID) SpanContext

1

func (sc SpanContext) WithTraceState(state TraceState) SpanContext

1
2
3
4
5
6
7

type SpanContextConfig struct {
	TraceID    TraceID
	SpanID     SpanID
	TraceFlags byte
	TraceState TraceState
	Remote     bool
}

1

type SpanID [8]byte

1

func SpanIDFromHex(h string) (SpanID, error)

1

func (s SpanID) IsValid() bool

1

func (s SpanID) MarshalJSON() ([]byte, error)

1

func (s SpanID) String() string

1

type SpanKind int

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

const (
	// SpanKindUnspecified is an unspecified SpanKind and is not a valid
	// SpanKind. SpanKindUnspecified should be replaced with SpanKindInternal
	// if it is received.
	SpanKindUnspecified SpanKind = 0
	// SpanKindInternal is a SpanKind for a Span that represents an internal
	// operation within an application.
	SpanKindInternal SpanKind = 1
	// SpanKindServer is a SpanKind for a Span that represents the operation
	// of handling a request from a client.
	SpanKindServer SpanKind = 2
	// SpanKindClient is a SpanKind for a Span that represents the operation
	// of client making a request to a server.
	SpanKindClient SpanKind = 3
	// SpanKindProducer is a SpanKind for a Span that represents the operation
	// of a producer sending a message to a message broker. Unlike
	// SpanKindClient and SpanKindServer, there is often no direct
	// relationship between this kind of Span and a SpanKindConsumer kind. A
	// SpanKindProducer Span will end once the message is accepted by the
	// message broker which might not overlap with the processing of that
	// message.
	SpanKindProducer SpanKind = 4
	// SpanKindConsumer is a SpanKind for a Span that represents the operation
	// of a consumer receiving a message from a message broker. Like
	// SpanKindProducer Spans, there is often no direct relationship between
	// this Span and the Span that produced the message.
	SpanKindConsumer SpanKind = 5
)

1

func ValidateSpanKind(spanKind SpanKind) SpanKind

1

func (sk SpanKind) String() string

1
2
3
4

type SpanOption interface {
	ApplySpan(*SpanConfig)
	// contains filtered or unexported methods
}

1

func WithLinks(links ...Link) SpanOption

1

func WithNewRoot() SpanOption

1

func WithSpanKind(kind SpanKind) SpanOption

1

type TraceID [16]byte

1

func TraceIDFromHex(h string) (TraceID, error)

1

func (t TraceID) IsValid() bool

1

func (t TraceID) MarshalJSON() ([]byte, error)

1

func (t TraceID) String() string

1
2
3

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

1

func TraceStateFromKeyValues(kvs ...attribute.KeyValue) (TraceState, error)

1

func (ts TraceState) Delete(key attribute.Key) (TraceState, error)

1

func (ts TraceState) Get(key attribute.Key) attribute.Value

1

func (ts TraceState) Insert(entry attribute.KeyValue) (TraceState, error)

1

func (ts TraceState) IsEmpty() bool

1

func (ts TraceState) MarshalJSON() ([]byte, error)

1

func (ts TraceState) String() string

1
2
3
4

type Tracer interface {
	// Start creates a span.
	Start(ctx context.Context, spanName string, opts ...SpanOption) (context.Context, Span)
}

1
2
3
4
5

type TracerConfig struct {
	// InstrumentationVersion is the version of the library providing
	// instrumentation.
	InstrumentationVersion string
}

1

func NewTracerConfig(options ...TracerOption) *TracerConfig

1
2
3
4

type TracerOption interface {
	ApplyTracer(*TracerConfig)
	// contains filtered or unexported methods
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

type TracerProvider interface {
	// Tracer creates an implementation of the Tracer interface.
	// 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 method must be concurrency safe.
	Tracer(instrumentationName string, opts ...TracerOption) Tracer
}

1

func NewNoopTracerProvider() TracerProvider

1

func WithAgentEndpoint(agentEndpoint string) func() (batchUploader, error)

1

func WithBufferMaxCount(bufferMaxCount int) func(o *options)

1

func WithCollectorEndpoint(collectorEndpoint string, options ...CollectorEndpointOption) func() (batchUploader, error)

1

func WithOnError(onError func(err error)) func(o *options)

1

func WithPassword(password string) func(o *CollectorEndpointOptions)

1

func WithProcess(process Process) func(o *options)

1

func WithUsername(username string) func(o *CollectorEndpointOptions)

1

type CollectorEndpointOption func(o *CollectorEndpointOptions)

1
2
3

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

1

type EndpointOption func() (batchUploader, error)

1
2
3

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

1

func NewExporter(endpointOption EndpointOption, opts ...Option) (*Exporter, error)

1

func (e *Exporter) ExportSpan(ctx context.Context, d *export.SpanData)

1

func (e *Exporter) Flush()

1

type Option func(*options)

1
2
3
4
5
6
7

type Process struct {
	// ServiceName is the Jaeger service name.
	ServiceName string

	// Tags are added to Jaeger Process exports
	Tags []core.KeyValue
}