zipkintracer

type CollectionError interface {
	Error() string
	GetErrors() []error
}

type Collector interface {
	Collect(*zipkincore.Span) error
	Close() error
}

type Context struct {
	// A probabilistically unique identifier for a [multi-span] trace.
	TraceID uint64

	// A probabilistically unique identifier for a span.
	SpanID uint64

	// The SpanID of this Context's parent, or 0 if there is no parent.
	ParentSpanID uint64

	// Whether the trace is sampled.
	Sampled bool
}

type DelegatingCarrier interface {
	SetState(traceID, spanID, parentSpanID uint64, sampled bool)
	State() (traceID, spanID, parentSpanID uint64, sampled bool)
	SetBaggageItem(key, value string)
	GetBaggage(func(key, value string))
}

type EventBaggage struct {
	Key, Value string
}

type EventCreate struct{ OperationName string }

type EventFinish RawSpan

type EventLog opentracing.LogData

type EventTag struct {
	Key   string
	Value interface{}
}

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

type KafkaOption func(c *KafkaCollector)

type Logger interface {
	Log(keyvals ...interface{}) error
}

type LoggerFunc func(...interface{}) error

type MultiCollector []Collector

type NopCollector struct{}

type RawSpan struct {
	// The RawSpan embeds its Context. Those recording the RawSpan
	// should also record the contents of its Context.
	Context

	// The name of the "operation" this span is an instance of. (Called a "span
	// name" in some implementations)
	Operation string

	// We store <start, duration> rather than <start, end> so that only
	// one of the timestamps has global clock uncertainty issues.
	Start    time.Time
	Duration time.Duration

	// Essentially an extension mechanism. Can be used for many purposes,
	// not to be enumerated here.
	Tags opentracing.Tags

	// The span's "microlog".
	Logs []opentracing.LogData

	// The span's associated baggage.
	Baggage map[string]string // initialized on first use
}

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

type Sampler func(id uint64) bool

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

type ScribeOption func(s *ScribeCollector)

type Span interface {
	opentracing.Span

	// Context contains trace identifiers
	Context() Context

	// Operation names the work done by this span instance
	Operation() string

	// Start indicates when the span began
	Start() time.Time
}

type SpanEvent interface{}

type SpanRecorder interface {
	// Implementations must determine whether and where to store `span`.
	RecordSpan(span RawSpan)
}

type Tracer interface {
	opentracing.Tracer

	// Options gets the Options used in New() or NewWithOptions().
	Options() TracerOptions
}

type TracerOption func(opts *TracerOptions) error

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