package trace

Import Path
	go.opencensus.io/trace (on go.dev)

Dependency Relation
	imports 13 packages, and imported by 15 packages

Involved Source Files

	      basetypes.go
	      config.go
	   d➜ doc.go
		Package trace contains support for OpenCensus distributed tracing.

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

		Exporting Traces

		To export collected tracing data, register at least one exporter. You can use
		one of the provided exporters or write your own.

		    trace.RegisterExporter(exporter)

		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()})

		Be careful about using trace.AlwaysSample in a production application with
		significant traffic: a new trace will be started and exported for every request.

		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, "example.com/Run")
		    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.

	      evictedqueue.go
	      export.go
	      lrumap.go
	      sampling.go
	      spanbucket.go
	      spanstore.go
	      status_codes.go
	      trace.go
	      trace_go11.go
Package-Level Type Names (total 28, in which 20 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Annotation (struct)
		Annotation represents a text annotation with a set of attributes and a timestamp.

		Fields (total 3, all are exported)
			Attributes map[string]interface{}
			Message string
			Time time.Time
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Span).interfaceArrayToAnnotationArray() []Annotation

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

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			key string
			value interface{}
		As Outputs Of (at least 9, in which 4 are exported)
			func BoolAttribute(key string, value bool) Attribute
			func Float64Attribute(key string, value float64) Attribute
			func Int64Attribute(key string, value int64) Attribute
			func StringAttribute(key string, value string) Attribute
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			func go.opencensus.io/plugin/ochttp.requestAttrs(r *http.Request) []Attribute
			func go.opencensus.io/plugin/ochttp.responseAttrs(resp *http.Response) []Attribute
			func contrib.go.opencensus.io/integrations/ocsql.argToAttr(key string, val interface{}) Attribute
			func contrib.go.opencensus.io/integrations/ocsql.namedParamsAttr(args []driver.NamedValue) []Attribute
			func contrib.go.opencensus.io/integrations/ocsql.paramsAttr(args []driver.Value) []Attribute
		As Inputs Of (at least 8, in which 4 are exported)
			func (*Span).AddAttributes(attributes ...Attribute)
			func (*Span).Annotate(attributes []Attribute, str string)
			func (*Span).Annotatef(attributes []Attribute, format string, a ...interface{})
			func contrib.go.opencensus.io/integrations/ocsql.WithDefaultAttributes(attrs ...Attribute) ocsql.TraceOption
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func copyAttributes(m map[string]interface{}, attributes []Attribute)
			func (*Span).copyToCappedAttributes(attributes []Attribute)
			func (*Span).lazyPrintfInternal(attributes []Attribute, format string, a ...interface{})
			func (*Span).printStringInternal(attributes []Attribute, str string)
		As Types Of (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			  var contrib.go.opencensus.io/integrations/ocsql.attrDeprecated
			  var contrib.go.opencensus.io/integrations/ocsql.attrMissingContext

	 type Config (struct)
		Config represents the global tracing configuration.

		Fields (total 6, all are exported)
			DefaultSampler Sampler
				DefaultSampler is the default sampler used when creating new spans.

			IDGenerator internal.IDGenerator
				IDGenerator is for internal use only.

			MaxAnnotationEventsPerSpan int
				MaxAnnotationEventsPerSpan is max number of annotation events per span

			MaxAttributesPerSpan int
				MaxAnnotationEventsPerSpan is max number of attributes per span

			MaxLinksPerSpan int
				MaxLinksPerSpan is max number of links per span

			MaxMessageEventsPerSpan int
				MaxMessageEventsPerSpan is max number of message events per span

		As Inputs Of (at least one exported)
			func ApplyConfig(cfg Config)

	 type Exporter (interface)
		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.

		Methods (only one, which is exported)
			( T) ExportSpan(s *SpanData)
		Implemented By (at least 3, in which 1 are exported)
			*contrib.go.opencensus.io/exporter/stackdriver.Exporter
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*contrib.go.opencensus.io/exporter/stackdriver.traceExporter
			*golang.org/x/pkgsite/internal/dcensus.debugTraceExporter
		As Inputs Of (at least 2, both are exported)
			func RegisterExporter(e Exporter)
			func UnregisterExporter(e Exporter)

	 type Link (struct)
		Link represents a reference from one span to another span.

		Fields (total 4, all are exported)
			Attributes map[string]interface{}
				Attributes is a set of attributes on the link.

			SpanID SpanID
			TraceID TraceID
			Type LinkType
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Span).interfaceArrayToLinksArray() []Link
		As Inputs Of (at least one exported)
			func (*Span).AddLink(l Link)

	 type LinkType int32 (basic type)
		LinkType specifies the relationship between the span that had the link
		added, and the linked span.

		As Types Of (total 3, all are exported)
			const LinkTypeChild
			const LinkTypeParent
			const LinkTypeUnspecified

	 type MessageEvent (struct)
		MessageEvent represents an event describing a message sent or received on the network.

		Fields (total 5, all are exported)
			CompressedByteSize int64
			EventType MessageEventType
			MessageID int64
			Time time.Time
			UncompressedByteSize int64
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Span).interfaceArrayToMessageEventArray() []MessageEvent

	 type MessageEventType int32 (basic type)
		MessageEventType specifies the type of message event.

		As Types Of (total 3, all are exported)
			const MessageEventTypeRecv
			const MessageEventTypeSent
			const MessageEventTypeUnspecified

	 type Sampler (func)
		Sampler decides whether a trace should be sampled and exported.

		As Outputs Of (at least 3, all are exported)
			func AlwaysSample() Sampler
			func NeverSample() Sampler
			func ProbabilitySampler(fraction float64) Sampler
		As Inputs Of (at least one exported)
			func WithSampler(sampler Sampler) StartOption
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var go.opencensus.io/metric/metricexport.defaultSampler

	 type SamplingDecision (struct)
		SamplingDecision is the value returned by a Sampler.

		Fields (only one, which is exported)
			Sample bool

	 type SamplingParameters (struct)
		SamplingParameters contains the values passed to a Sampler.

		Fields (total 5, all are exported)
			HasRemoteParent bool
			Name string
			ParentContext SpanContext
			SpanID SpanID
			TraceID TraceID

	 type Span (struct)
		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.

		Fields (total 14, none are exported)
			/* 14 unexporteds ... *//* 14 unexporteds: */
			annotations *evictedQueue
				annotations are stored in FIFO queue capped by configured limit.

			data *SpanData
				data contains information recorded about the span.

				It will be non-nil if we are exporting the span or recording events for it.
				Otherwise, data is nil, and the Span is simply a carrier for the
				SpanContext, so that the trace ID is propagated.

			endOnce sync.Once
			executionTracerTaskEnd func()
				// ends the execution tracer span

			links *evictedQueue
				links are stored in FIFO queue capped by configured limit.

			lruAttributes *lruMap
				lruAttributes are capped at configured limit. When the capacity is reached an oldest entry
				is removed to create room for a new entry.

			messageEvents *evictedQueue
				messageEvents are stored in FIFO queue capped by configured limit.

			mu sync.Mutex
				// protects the contents of *data (but not the pointer value.)

			spanContext SpanContext
			spanStore *spanStore
				spanStore is the spanStore this span belongs to, if any, otherwise it is nil.

			spanStore.active map[*Span]struct{}
			spanStore.errors map[int32]*bucket
			spanStore.latency []bucket
			spanStore.maxSpansPerErrorBucket int
		Methods (total 24, in which 12 are exported)
			(*T) AddAttributes(attributes ...Attribute)
				AddAttributes sets attributes in the span.

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

			(*T) AddLink(l Link)
				AddLink adds a link to the span.

			(*T) 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.

			(*T) 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.

			(*T) Annotate(attributes []Attribute, str string)
				Annotate adds an annotation with attributes.
				Attributes can be nil.

			(*T) Annotatef(attributes []Attribute, format string, a ...interface{})
				Annotatef adds an annotation with attributes.

			(*T) End()
				End ends the span.

			(*T) 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.

			(*T) SetName(name string)
				SetName sets the name of the span, if it is recording events.

			(*T) SetStatus(status Status)
				SetStatus sets the status of the span, if it is recording events.

			(*T) SpanContext() SpanContext
				SpanContext returns the SpanContext of the span.

			(*T) String() string
			/* 12 unexporteds ... *//* 12 unexporteds: */
			( T) add(span *Span)
				add adds a span to the active bucket of the spanStore.

			(*T) addChild()
			(*T) copyToCappedAttributes(attributes []Attribute)
			( T) finished(span *Span, sd *SpanData)
				finished removes a span from the active set, and adds a corresponding
				SpanData to a latency or error bucket.

			(*T) interfaceArrayToAnnotationArray() []Annotation
			(*T) interfaceArrayToLinksArray() []Link
			(*T) interfaceArrayToMessageEventArray() []MessageEvent
			(*T) lazyPrintfInternal(attributes []Attribute, format string, a ...interface{})
			(*T) lruAttributesToAttributeMap() map[string]interface{}
			(*T) makeSpanData() *SpanData
				makeSpanData produces a SpanData representing the current state of the Span.
				It requires that s.data is non-nil.

			(*T) printStringInternal(attributes []Attribute, str string)
			( T) resize(latencyBucketSize int, errorBucketSize int)
		Implements (at least 4, in which 2 are exported)
			*T : expvar.Var
			*T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*T : context.stringer
			*T : runtime.stringer
		As Outputs Of (at least 4, in which 3 are exported)
			func FromContext(ctx context.Context) *Span
			func StartSpan(ctx context.Context, name string, o ...StartOption) (context.Context, *Span)
			func StartSpanWithRemoteParent(ctx context.Context, name string, parent SpanContext, o ...StartOption) (context.Context, *Span)
			/* at least one unexported ... *//* at least one unexported: */
			func startSpanInternal(name string, hasParent bool, parent SpanContext, remoteParent bool, o StartOptions) *Span
		As Inputs Of (at least 4, in which 3 are exported)
			func NewContext(parent context.Context, s *Span) context.Context
			func go.opencensus.io/plugin/ochttp.NewSpanAnnotatingClientTrace(_ *http.Request, s *Span) *httptrace.ClientTrace
			func go.opencensus.io/plugin/ochttp.NewSpanAnnotator(r *http.Request, s *Span) *httptrace.ClientTrace
			/* at least one unexported ... *//* at least one unexported: */
			func contrib.go.opencensus.io/integrations/ocsql.setSpanStatus(span *Span, err error)

	 type SpanContext (struct)
		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.

		Fields (total 4, all are exported)
			SpanID SpanID
			TraceID TraceID
			TraceOptions TraceOptions
			Tracestate *tracestate.Tracestate
		Methods (total 2, in which 1 are exported)
			( T) IsSampled() bool
				IsSampled returns true if the span will be exported.

			/* one unexported ... *//* one unexported: */
			(*T) setIsSampled(sampled bool)
				setIsSampled sets the TraceOptions bit that determines whether the span will be exported.

		As Outputs Of (at least 6, in which 5 are exported)
			func (*Span).SpanContext() SpanContext
			func go.opencensus.io/trace/propagation.FromBinary(b []byte) (sc SpanContext, ok bool)
			func go.opencensus.io/trace/propagation.HTTPFormat.SpanContextFromRequest(req *http.Request) (sc SpanContext, ok bool)
			func go.opencensus.io/plugin/ochttp/propagation/b3.(*HTTPFormat).SpanContextFromRequest(req *http.Request) (sc SpanContext, ok bool)
			func google.golang.org/api/transport/http/internal/propagation.(*HTTPFormat).SpanContextFromRequest(req *http.Request) (sc SpanContext, ok bool)
			/* at least one unexported ... *//* at least one unexported: */
			func go.opencensus.io/plugin/ochttp.(*Handler).extractSpanContext(r *http.Request) (SpanContext, bool)
		As Inputs Of (at least 7, in which 5 are exported)
			func StartSpanWithRemoteParent(ctx context.Context, name string, parent SpanContext, o ...StartOption) (context.Context, *Span)
			func go.opencensus.io/trace/propagation.Binary(sc SpanContext) []byte
			func go.opencensus.io/trace/propagation.HTTPFormat.SpanContextToRequest(sc SpanContext, req *http.Request)
			func go.opencensus.io/plugin/ochttp/propagation/b3.(*HTTPFormat).SpanContextToRequest(sc SpanContext, req *http.Request)
			func google.golang.org/api/transport/http/internal/propagation.(*HTTPFormat).SpanContextToRequest(sc SpanContext, req *http.Request)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func startSpanInternal(name string, hasParent bool, parent SpanContext, remoteParent bool, o StartOptions) *Span
			func contrib.go.opencensus.io/exporter/stackdriver.toPbSpanCtxAttachment(spanCtx SpanContext, projectID string) *any.Any

	 type SpanData (struct)
		SpanData contains all the information collected by a Span.

		Fields (total 23, all are exported)
			Annotations []Annotation
			Attributes map[string]interface{}
				The values of Attributes each have type string, bool, or int64.

			ChildSpanCount int
				ChildSpanCount holds the number of child span created for this span.

			DroppedAnnotationCount int
			DroppedAttributeCount int
			DroppedLinkCount int
			DroppedMessageEventCount int
			EndTime time.Time
				The wall clock time of EndTime will be adjusted to always be offset
				from StartTime by the duration of the span.

			HasRemoteParent bool
			Links []Link
			MessageEvents []MessageEvent
			Name string
			ParentSpanID SpanID
			SpanContext SpanContext
			SpanContext.SpanID SpanID
			SpanContext.TraceID TraceID
			SpanContext.TraceOptions TraceOptions
			SpanContext.Tracestate *tracestate.Tracestate
			SpanKind int
			StartTime time.Time
			Status Status
			Status.Code int32
				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 .

			Status.Message string
		Methods (total 2, in which 1 are exported)
			( T) IsSampled() bool
				IsSampled returns true if the span will be exported.

			/* one unexported ... *//* one unexported: */
			(*T) setIsSampled(sampled bool)
				setIsSampled sets the TraceOptions bit that determines whether the span will be exported.

		As Outputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func (*Span).makeSpanData() *SpanData
			func go.opencensus.io/zpages.traceSpans(spanName string, spanType, spanSubtype int) []*SpanData
			func contrib.go.opencensus.io/exporter/stackdriver.(*Exporter).sdWithDefaultTraceAttributes(sd *SpanData) *SpanData
		As Inputs Of (at least 8, in which 3 are exported)
			func Exporter.ExportSpan(s *SpanData)
			func contrib.go.opencensus.io/exporter/stackdriver.(*Exporter).ExportSpan(sd *SpanData)
			func contrib.go.opencensus.io/exporter/stackdriver.(*Exporter).PushTraceSpans(ctx context.Context, node *commonpb.Node, rsc *resourcepb.Resource, spans []*SpanData) (int, error)
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			func go.opencensus.io/zpages.traceDataFromSpans(name string, spans []*SpanData) zpages.traceData
			func go.opencensus.io/zpages.traceRows(s *SpanData) []zpages.traceRow
			func contrib.go.opencensus.io/exporter/stackdriver.protoFromSpanData(s *SpanData, projectID string, mr *monitoredrespb.MonitoredResource, userAgent string) *tracepb.Span
			func contrib.go.opencensus.io/exporter/stackdriver.(*Exporter).sdWithDefaultTraceAttributes(sd *SpanData) *SpanData
			func golang.org/x/pkgsite/internal/dcensus.dumpSpanData(s *SpanData) string

	 type SpanID ([...]T)
		SpanID is an 8-byte identifier for a single span.

		Methods (only one, which is exported)
			( T) String() string
		Implements (at least 4, in which 2 are exported)
			 T : expvar.Var
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least one exported)
			func go.opencensus.io/plugin/ochttp/propagation/b3.ParseSpanID(sid string) (spanID SpanID, ok bool)

	 type StartOption (func)
		StartOption apply changes to StartOptions.

		As Outputs Of (at least 2, both are exported)
			func WithSampler(sampler Sampler) StartOption
			func WithSpanKind(spanKind int) StartOption
		As Inputs Of (at least 2, both are exported)
			func StartSpan(ctx context.Context, name string, o ...StartOption) (context.Context, *Span)
			func StartSpanWithRemoteParent(ctx context.Context, name string, parent SpanContext, o ...StartOption) (context.Context, *Span)

	 type StartOptions (struct)
		StartOptions contains options concerning how a span is started.

		Fields (total 2, both are exported)
			Sampler Sampler
				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.

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

		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func startSpanInternal(name string, hasParent bool, parent SpanContext, remoteParent bool, o StartOptions) *Span

	 type Status (struct)
		Status is the status of a Span.

		Fields (total 2, both are exported)
			Code int32
				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 .

			Message string
		As Outputs Of (at least 2, in which 1 are exported)
			func go.opencensus.io/plugin/ochttp.TraceStatus(httpStatusCode int, statusLine string) Status
			/* at least one unexported ... *//* at least one unexported: */
			func cloud.google.com/go/internal/trace.toStatus(err error) Status
		As Inputs Of (at least one exported)
			func (*Span).SetStatus(status Status)

	 type TraceID ([...]T)
		TraceID is a 16-byte identifier for a set of spans.

		Methods (only one, which is exported)
			( T) String() string
		Implements (at least 4, in which 2 are exported)
			 T : expvar.Var
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least one exported)
			func go.opencensus.io/plugin/ochttp/propagation/b3.ParseTraceID(tid string) (TraceID, bool)

	 type TraceOptions uint32 (basic type)
		TraceOptions contains options associated with a trace span.

		Methods (only one, which is exported)
			( T) IsSampled() bool
				IsSampled returns true if the span will be exported.

		As Outputs Of (at least one exported)
			func go.opencensus.io/plugin/ochttp/propagation/b3.ParseSampled(sampled string) (TraceOptions, bool)

	/* 8 unexporteds ... *//* 8 unexporteds: */
	 type bucket (struct)
		bucket is a container for a set of spans for a particular error code or latency range.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			buffer []*SpanData
				// circular buffer of spans

			nextIndex int
				// location next SpanData should be placed in buffer

			nextTime time.Time
				// next time we can accept a span

			overflow bool
				// whether the circular buffer has wrapped around

		Methods (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) add(s *SpanData)
				add adds a span to the bucket, if nextTime has been reached.

			(*T) resize(n int)
				resize changes the size of the bucket to n, keeping up to n existing spans.

			(*T) size() int
				size returns the number of spans in the bucket.

			(*T) span(i int) *SpanData
				span returns the ith span in the bucket.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func makeBucket(bufferSize int) bucket

	 type contextKey (struct)
	 type defaultIDGenerator (struct)

		Fields (total 7, in which 1 are exported)
			Mutex sync.Mutex
			/* 6 unexporteds ... *//* 6 unexporteds: */
			Mutex.sema uint32
			Mutex.state int32
			nextSpanID uint64
				Please keep these as the first fields
				so that these 8 byte fields will be aligned on addresses
				divisible by 8, on both 32-bit and 64-bit machines when
				performing atomic increments and accesses.
				See:
				* https://github.com/census-instrumentation/opencensus-go/issues/587
				* https://github.com/census-instrumentation/opencensus-go/issues/865
				* https://golang.org/pkg/sync/atomic/#pkg-note-BUG

			spanIDInc uint64
			traceIDAdd [2]uint64
			traceIDRand *rand.Rand
		Methods (total 6, in which 4 are exported)
			(*T) Lock()
				Lock locks m.
				If the lock is already in use, the calling goroutine
				blocks until the mutex is available.

			(*T) NewSpanID() [8]byte
				NewSpanID returns a non-zero span ID from a randomly-chosen sequence.

			(*T) NewTraceID() [16]byte
				NewTraceID returns a non-zero trace ID from a randomly-chosen sequence.
				mu should be held while this function is called.

			(*T) Unlock()
				Unlock unlocks m.
				It is a run-time error if m is not locked on entry to Unlock.

				A locked Mutex is not associated with a particular goroutine.
				It is allowed for one goroutine to lock a Mutex and then
				arrange for another goroutine to unlock it.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) lockSlow()
			(*T) unlockSlow(new int32)
		Implements (at least 2, both are exported)
			*T : go.opencensus.io/trace/internal.IDGenerator
			*T : sync.Locker

	 type evictedQueue (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			capacity int
			droppedCount int
			queue []interface{}
		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*T) add(value interface{})
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newEvictedQueue(capacity int) *evictedQueue

	 type exportersMap (map)
	 type internalOnly (struct)
		This exists purely to avoid exposing internal methods used by z-Pages externally.

		Methods (total 5, all are exported)
			( T) ConfigureBucketSizes(bcs []internal.BucketConfiguration)
				ConfigureBucketSizes sets the number of spans to keep per latency and error
				bucket for different span names.

			( T) ReportActiveSpans(name string) []*SpanData
				ReportActiveSpans returns the active spans for the given name.

			( T) ReportSpansByError(name string, code int32) []*SpanData
				ReportSpansByError returns a sample of error spans.

				If code is nonzero, only spans with that status code are returned.

			( T) ReportSpansByLatency(name string, minLatency, maxLatency time.Duration) []*SpanData
				ReportSpansByLatency returns a sample of successful spans.

				minLatency is the minimum latency of spans to be returned.
				maxLatency, if nonzero, is the maximum latency of spans to be returned.

			( T) ReportSpansPerMethod() map[string]internal.PerMethodSummary
				ReportSpansPerMethod returns a summary of what spans are being stored for each span name.


	 type lruMap (struct)
		A simple lru.Cache wrapper that tracks the keys of the current contents and
		the cumulative number of evicted items.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			cache *lru.Cache
			cacheKeys map[lru.Key]bool
			droppedCount int
		Methods (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) add(key, value interface{})
			(*T) get(key interface{}) (interface{}, bool)
			( T) keys() []interface{}
			( T) len() int
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newLruMap(size int) *lruMap

	 type spanStore (struct)
		spanStore keeps track of spans stored for a particular span name.

		It contains all active spans; a sample of spans for failed requests,
		categorized by error code; and a sample of spans for successful requests,
		bucketed by latency.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			active map[*Span]struct{}
			errors map[int32]*bucket
			latency []bucket
			maxSpansPerErrorBucket int
			mu sync.Mutex
				// protects everything below.

		Methods (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) add(span *Span)
				add adds a span to the active bucket of the spanStore.

			(*T) finished(span *Span, sd *SpanData)
				finished removes a span from the active set, and adds a corresponding
				SpanData to a latency or error bucket.

			(*T) resize(latencyBucketSize int, errorBucketSize int)
		As Outputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func newSpanStore(name string, latencyBucketSize int, errorBucketSize int) *spanStore
			func spanStoreForName(name string) *spanStore
			func spanStoreForNameCreateIfNew(name string) *spanStore


Package-Level Functions (total 30, in which 16 are exported)

	 func AlwaysSample() Sampler
		AlwaysSample returns a Sampler that samples every trace.
		Be careful about using this sampler in a production application with
		significant traffic: a new trace will be started and exported for every
		request.

	 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 BoolAttribute(key string, value bool) Attribute
		BoolAttribute returns a bool-valued attribute.

	 func Float64Attribute(key string, value float64) Attribute
		Float64Attribute returns a float64-valued attribute.

	 func FromContext(ctx context.Context) *Span
		FromContext returns the Span stored in a context, or nil if there isn't one.

	 func Int64Attribute(key string, value int64) Attribute
		Int64Attribute returns an int64-valued attribute.

	 func NeverSample() Sampler
		NeverSample returns a Sampler that samples no traces.

	 func NewContext(parent context.Context, s *Span) context.Context
		NewContext returns a new context with the given Span attached.

	 func ProbabilitySampler(fraction float64) Sampler
		ProbabilitySampler returns a Sampler that samples a given fraction of traces.

		It also samples spans whose parents are sampled.

	 func RegisterExporter(e Exporter)
		RegisterExporter adds to the list of Exporters that will receive sampled
		trace spans.

		Binaries can register exporters, libraries shouldn't register exporters.

	 func StartSpan(ctx context.Context, name string, o ...StartOption) (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.

		Returned context contains the newly created span. You can use it to
		propagate the returned span in process.

	 func StartSpanWithRemoteParent(ctx context.Context, name string, parent SpanContext, o ...StartOption) (context.Context, *Span)
		StartSpanWithRemoteParent starts a new child span of the span from the given parent.

		If the incoming context contains a parent, it ignores. StartSpanWithRemoteParent is
		preferred for cases where the parent is propagated via an incoming request.

		Returned context contains the newly created span. You can use it to
		propagate the returned span in process.

	 func StringAttribute(key string, value string) Attribute
		StringAttribute returns a string-valued attribute.

	 func UnregisterExporter(e Exporter)
		UnregisterExporter removes from the list of Exporters the Exporter that was
		registered with the given name.

	 func WithSampler(sampler Sampler) StartOption
		WithSampler makes new spans to be be created with a custom sampler.
		Otherwise, the global sampler is used.

	 func WithSpanKind(spanKind int) StartOption
		WithSpanKind makes new spans to be created with the given kind.

	/* 14 unexporteds ... *//* 14 unexporteds: */
	 func copyAttributes(m map[string]interface{}, attributes []Attribute)
		copyAttributes copies a slice of Attributes into a map.

	 func init()
	 func init()
	 func latencyBucket(latency time.Duration) int
		latencyBucket returns the appropriate bucket number for a given latency.

	 func latencyBucketBounds(index int) (lower time.Duration, upper time.Duration)
		latencyBucketBounds returns the lower and upper bounds for a latency bucket
		number.

		The lower bound is inclusive, the upper bound is exclusive (except for the
		last bucket.)

	 func makeBucket(bufferSize int) bucket
	 func newEvictedQueue(capacity int) *evictedQueue
	 func newLruMap(size int) *lruMap
	 func newSpanStore(name string, latencyBucketSize int, errorBucketSize int) *spanStore
		newSpanStore creates a span store.

	 func spanStoreForName(name string) *spanStore
		spanStoreForName returns the spanStore for the given name.

		It returns nil if it doesn't exist.

	 func spanStoreForNameCreateIfNew(name string) *spanStore
		spanStoreForNameCreateIfNew returns the spanStore for the given name.

		It creates it if it didn't exist.

	 func spanStoreSetSize(name string, latencyBucketSize int, errorBucketSize int)
		spanStoreSetSize resizes the spanStore for the given name.

		It creates it if it didn't exist.

	 func startExecutionTracerTask(ctx context.Context, name string) (context.Context, func())
	 func startSpanInternal(name string, hasParent bool, parent SpanContext, remoteParent bool, o StartOptions) *Span
Package-Level Variables (total 7, none are exported)

	/* 7 unexporteds ... *//* 7 unexporteds: */
	  var config atomic.Value // access atomically
	  var configWriteMu sync.Mutex
	  var defaultLatencies [8]time.Duration
		defaultLatencies contains the default latency bucket bounds.
		TODO: consider defaults, make configurable

	  var exporterMu sync.Mutex
	  var exporters atomic.Value
	  var spanStores map[string]*spanStore
	  var ssmu sync.RWMutex // protects spanStores
Package-Level Constants (total 34, in which 30 are exported)

	const DefaultMaxAnnotationEventsPerSpan = 32
		DefaultMaxAnnotationEventsPerSpan is default max number of annotation events per span

	const DefaultMaxAttributesPerSpan = 32
		DefaultMaxAttributesPerSpan is default max number of attributes per span

	const DefaultMaxLinksPerSpan = 32
		DefaultMaxLinksPerSpan is default max number of links per span

	const DefaultMaxMessageEventsPerSpan = 128
		DefaultMaxMessageEventsPerSpan is default max number of message events per span

	const LinkTypeChild LinkType = 1 // The linked span is a child of the current span.
		LinkType values.

	const LinkTypeParent LinkType = 2 // The linked span is the parent of the current span.
		LinkType values.

	const LinkTypeUnspecified LinkType = 0 // The relationship of the two spans is unknown.
		LinkType values.

	const MessageEventTypeRecv MessageEventType = 2 // Indicates a received RPC message.
		MessageEventType values.

	const MessageEventTypeSent MessageEventType = 1 // Indicates a sent RPC message.
		MessageEventType values.

	const MessageEventTypeUnspecified MessageEventType = 0 // Unknown event type.
		MessageEventType values.

	const SpanKindClient = 2
		All available span kinds. Span kind must be either one of these values.

	const SpanKindServer = 1
		All available span kinds. Span kind must be either one of these values.

	const SpanKindUnspecified = 0
		All available span kinds. Span kind must be either one of these values.

	const StatusCodeAborted = 10
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeAlreadyExists = 6
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeCancelled = 1
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeDataLoss = 15
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeDeadlineExceeded = 4
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeFailedPrecondition = 9
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeInternal = 13
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeInvalidArgument = 3
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeNotFound = 5
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeOK = 0
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeOutOfRange = 11
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodePermissionDenied = 7
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeResourceExhausted = 8
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeUnauthenticated = 16
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeUnavailable = 14
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeUnimplemented = 12
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	const StatusCodeUnknown = 2
		Status codes for use with Span.SetStatus. These correspond to the status
		codes used by gRPC defined here: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

	/* 4 unexporteds ... *//* 4 unexporteds: */
	const defaultBucketSize = 10
	const defaultSamplingProbability = 0.0001
	const maxBucketSize = 100000
	const samplePeriod time.Duration = 1000000000
		samplePeriod is the minimum time between accepting spans in a single bucket.

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.