trace

package
v0.7.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 4, 2018 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Overview

Package trace contains types for representing trace information, and functions for global configuration of tracing.

The following assumes a basic familiarity with OpenCensus concepts. See http://opencensus.io

Enabling Tracing for a Program

To use OpenCensus tracing, register at least one Exporter. You can use one of the provided exporters or write your own. 

trace.RegisterExporter(anExporter)

By default, traces will be sampled relatively rarely. To change the sampling frequency for your entire program, call ApplyConfig. Use a ProbabilitySampler to sample a subset of traces, or use AlwaysSample to collect a trace on every run: 

trace.ApplyConfig(trace.Config{DefaultSampler: trace.AlwaysSample()})

Adding Spans to a Trace

A trace consists of a tree of spans. In Go, the current span is carried in a context.Context.

It is common to want to capture all the activity of a function call in a span. For this to work, the function must take a context.Context as a parameter. Add these two lines to the top of the function: 

ctx, span := trace.StartSpan(ctx, "your choice of name")
defer span.End()

StartSpan will create a new top-level span if the context doesn't contain another span, otherwise it will create a child span.

As a suggestion, use the fully-qualified function name as the span name, e.g. "github.com/me/mypackage.Run".

Index

Examples

Constants

View Source 
const (
	SpanKindUnspecified = iota
	SpanKindServer
	SpanKindClient
)

All available span kinds. Span kind must be either one of these values.

Variables

This section is empty.

Functions

func ApplyConfig added in v0.7.0 

func ApplyConfig(cfg Config)

ApplyConfig applies changes to the global tracing configuration.

Fields not provided in the given config are going to be preserved.

func RegisterExporter 

func RegisterExporter(e Exporter)

RegisterExporter adds to the list of Exporters that will receive sampled trace spans.

func UnregisterExporter 

func UnregisterExporter(e Exporter)

UnregisterExporter removes from the list of Exporters the Exporter that was registered with the given name.

func WithSpan 

func WithSpan(parent context.Context, s *Span) context.Context

WithSpan returns a new context with the given Span attached.

Types

type Annotation 

type Annotation struct {
	Time       time.Time
	Message    string
	Attributes map[string]interface{}
}

Annotation represents a text annotation with a set of attributes and a timestamp.

type Attribute 

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

Attribute represents a key-value pair on a span, link or annotation. Construct with one of: BoolAttribute, Int64Attribute, or StringAttribute.

func BoolAttribute 

func BoolAttribute(key string, value bool) Attribute

BoolAttribute returns a bool-valued attribute.

func Int64Attribute 

func Int64Attribute(key string, value int64) Attribute

Int64Attribute returns an int64-valued attribute.

func StringAttribute 

func StringAttribute(key string, value string) Attribute

StringAttribute returns a string-valued attribute.

type Config added in v0.7.0 

type Config struct {
	// DefaultSampler is the default sampler used when creating new spans.
	DefaultSampler Sampler
}

Config represents the global tracing configuration.

type Exporter 

type Exporter interface {
	ExportSpan(s *SpanData)
}

Exporter is a type for functions that receive sampled trace spans.

The ExportSpan method should be safe for concurrent use and should return quickly; if an Exporter takes a significant amount of time to process a SpanData, that work should be done on another goroutine.

The SpanData should not be modified, but a pointer to it can be kept. 

type Link struct {
	TraceID TraceID
	SpanID  SpanID
	Type    LinkType
	// Attributes is a set of attributes on the link.
	Attributes map[string]interface{}
}

Link represents a reference from one span to another span.

type LinkType 

type LinkType int32

LinkType specifies the relationship between the span that had the link added, and the linked span. 

const (
	LinkTypeUnspecified LinkType = iota // The relationship of the two spans is unknown.
	LinkTypeChild                       // The current span is a child of the linked span.
	LinkTypeParent                      // The current span is the parent of the linked span.
)

LinkType values.

type MessageEvent 

type MessageEvent struct {
	Time                 time.Time
	EventType            MessageEventType
	MessageID            int64
	UncompressedByteSize int64
	CompressedByteSize   int64
}

MessageEvent represents an event describing a message sent or received on the network.

type MessageEventType 

type MessageEventType int32

MessageEventType specifies the type of message event. 

const (
	MessageEventTypeUnspecified MessageEventType = iota // Unknown event type.
	MessageEventTypeSent                                // Indicates a sent RPC message.
	MessageEventTypeRecv                                // Indicates a received RPC message.
)

MessageEventType values.

type Sampler 

type Sampler func(SamplingParameters) SamplingDecision

Sampler decides whether a trace should be sampled and exported.

func AlwaysSample 

func AlwaysSample() Sampler

AlwaysSample returns a Sampler that samples every trace.

func NeverSample 

func NeverSample() Sampler

NeverSample returns a Sampler that samples no traces.

func ProbabilitySampler 

func ProbabilitySampler(fraction float64) Sampler

ProbabilitySampler returns a Sampler that samples a given fraction of traces.

It also samples spans whose parents are sampled.

type SamplingDecision 

type SamplingDecision struct {
	Sample bool
}

SamplingDecision is the value returned by a Sampler.

type SamplingParameters 

type SamplingParameters struct {
	ParentContext   SpanContext
	TraceID         TraceID
	SpanID          SpanID
	Name            string
	HasRemoteParent bool
}

SamplingParameters contains the values passed to a Sampler.

type Span 

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

Span represents a span of a trace. It has an associated SpanContext, and stores data accumulated while the span is active.

Ideally users should interact with Spans by calling the functions in this package that take a Context parameter.

func FromContext 

func FromContext(ctx context.Context) *Span

FromContext returns the Span stored in a context, or nil if there isn't one.

func NewSpan 

func NewSpan(name string, parent *Span, o StartOptions) *Span

NewSpan returns a new span.

If parent is not nil, created span will be a child of the parent.

func NewSpanWithRemoteParent 

func NewSpanWithRemoteParent(name string, parent SpanContext, o StartOptions) *Span

NewSpanWithRemoteParent returns a new span with the given parent SpanContext.

func StartSpan 

func StartSpan(ctx context.Context, name string) (context.Context, *Span)

StartSpan starts a new child span of the current span in the context. If there is no span in the context, creates a new trace and span.

This is provided as a convenience for WithSpan(ctx, NewSpan(...)). Use it if you require custom spans in addition to the default spans provided by ocgrpc, ochttp or similar framework integration.

Example

This example shows how to use StartSpan and (*Span).End to capture a function execution in a Span. It assumes that the function has a context.Context argument. 

package main

import (
	"fmt"

	"go.opencensus.io/trace"
	"golang.org/x/net/context"
)

func main() {
	printEvens := func(ctx context.Context) {
		ctx, span := trace.StartSpan(ctx, "my/package.Function")
		defer span.End()

		for i := 0; i < 10; i++ {
			if i%2 == 0 {
				fmt.Printf("Even!\n")
			}
		}
	}

	ctx := context.Background()
	printEvens(ctx)
}

Output:

func (*Span) AddAttributes added in v0.5.0 

func (s *Span) AddAttributes(attributes ...Attribute)

AddAttributes sets attributes in the span.

Existing attributes whose keys appear in the attributes parameter are overwritten. 

func (s *Span) AddLink(l Link)

AddLink adds a link to the span.

func (*Span) AddMessageReceiveEvent 

func (s *Span) AddMessageReceiveEvent(messageID, uncompressedByteSize, compressedByteSize int64)

AddMessageReceiveEvent adds a message receive event to the span.

messageID is an identifier for the message, which is recommended to be unique in this span and the same between the send event and the receive event (this allows to identify a message between the sender and receiver). For example, this could be a sequence id.

func (*Span) AddMessageSendEvent 

func (s *Span) AddMessageSendEvent(messageID, uncompressedByteSize, compressedByteSize int64)

AddMessageSendEvent adds a message send event to the span.

messageID is an identifier for the message, which is recommended to be unique in this span and the same between the send event and the receive event (this allows to identify a message between the sender and receiver). For example, this could be a sequence id.

func (*Span) Annotate added in v0.2.0 

func (s *Span) Annotate(attributes []Attribute, str string)

Annotate adds an annotation with attributes. Attributes can be nil.

func (*Span) Annotatef added in v0.2.0 

func (s *Span) Annotatef(attributes []Attribute, format string, a ...interface{})

Annotatef adds an annotation with attributes.

func (*Span) End 

func (s *Span) End()

End ends the span.

func (*Span) IsRecordingEvents 

func (s *Span) IsRecordingEvents() bool

IsRecordingEvents returns true if events are being recorded for this span. Use this check to avoid computing expensive annotations when they will never be used.

func (*Span) SetStatus 

func (s *Span) SetStatus(status Status)

SetStatus sets the status of the span, if it is recording events.

func (*Span) SpanContext 

func (s *Span) SpanContext() SpanContext

SpanContext returns the SpanContext of the span.

func (*Span) String 

func (s *Span) String() string

type SpanContext 

type SpanContext struct {
	TraceID      TraceID
	SpanID       SpanID
	TraceOptions TraceOptions
}

SpanContext contains the state that must propagate across process boundaries.

SpanContext is not an implementation of context.Context. TODO: add reference to external Census docs for SpanContext.

func (SpanContext) IsSampled 

func (sc SpanContext) IsSampled() bool

IsSampled returns true if the span will be exported.

type SpanData 

type SpanData struct {
	SpanContext
	ParentSpanID SpanID
	SpanKind     int
	Name         string
	StartTime    time.Time
	// The wall clock time of EndTime will be adjusted to always be offset
	// from StartTime by the duration of the span.
	EndTime time.Time
	// The values of Attributes each have type string, bool, or int64.
	Attributes    map[string]interface{}
	Annotations   []Annotation
	MessageEvents []MessageEvent
	Status
	Links           []Link
	HasRemoteParent bool
}

SpanData contains all the information collected by a Span.

type SpanID 

type SpanID [8]byte

SpanID is an 8-byte identifier for a single span.

func (SpanID) String 

func (s SpanID) String() string

type StartOptions added in v0.2.0 

type StartOptions struct {
	// Sampler to consult for this Span. If provided, it is always consulted.
	//
	// If not provided, then the behavior differs based on whether
	// the parent of this Span is remote, local, or there is no parent.
	// In the case of a remote parent or no parent, the
	// default sampler (see Config) will be consulted. Otherwise,
	// when there is a non-remote parent, no new sampling decision will be made:
	// we will preserve the sampling of the parent.
	Sampler Sampler

	// SpanKind represents the kind of a span. If none is set,
	// SpanKindUnspecified is used.
	SpanKind int
}

StartOptions contains options concerning how a span is started.

type Status 

type Status struct {
	// Code is a status code.  Zero indicates success.
	//
	// If Code will be propagated to Google APIs, it ideally should be a value from
	// https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto .
	Code    int32
	Message string
}

Status is the status of a Span.

type TraceID 

type TraceID [16]byte

TraceID is a 16-byte identifier for a set of spans.

func (TraceID) String 

func (t TraceID) String() string

type TraceOptions 

type TraceOptions uint32

TraceOptions contains options associated with a trace span.

func (TraceOptions) IsSampled 

func (t TraceOptions) IsSampled() bool

IsSampled returns true if the span will be exported.

Source Files

View all Source files

Directories

Path Synopsis
Package propagation implements the binary trace context format.
 Package propagation implements the binary trace context format.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.