houyi

type AdaptiveSampler struct {
	ProbabilitySampler
}

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

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

type DynamicSampler struct {
	ProbabilitySampler
}

type Extractor interface {
	// Extract decodes a SpanContext instance from the given `carrier`,
	// or (nil, opentracing.ErrSpanContextNotFound) if no context could
	// be found in the `carrier`.
	Extract(carrier interface{}) (SpanContext, error)
}

type Factory interface {
	InitFromViper(*viper.Viper)
	CreateTracer(serviceName string, logger *zap.Logger) (opentracing.Tracer, io.Closer)
}

type HttpHeadersPropagator struct{}

type Injector interface {
	// Inject takes `SpanContext` and injects it into `carrier`. The actual type
	// of `carrier` depends on the `format` passed to `Tracer.Inject()`.
	//
	// Implementations may return opentracing.ErrInvalidCarrier or any other
	// implementation-specific error if injection fails.
	Inject(ctx SpanContext, carrier interface{}) error
}

type Operation struct {
	Service string  `json:"service"`
	Name    string  `json:"name"`
	Qps     float64 `json:"qpsStat"`
}

type Options struct {
	PullStrategiesInterval time.Duration
	ReporterType           string
	AgentAddr              string
	AgentPort              int
	BufferRefreshInterval  time.Duration
	MaxBufferedSize        int
	QueueSize              int
}

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

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

type Process struct {
	Service string
	UUID    string
	Tags    []opentracing.Tag
}

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

type RemoteReporterParams struct {
	Logger    *zap.Logger
	QueueSize int
	Interval  time.Duration
	Transport Transport
}

type RemoteSampler struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type RemoteSamplerParams struct {
	Logger        *zap.Logger
	ServiceName   string
	PullInterval  time.Duration
	AgentEndpoint routing.Endpoint
}

type Reporter interface {
	Report(span *Span)
	io.Closer
}

type Sampler interface {
	OnCreateSpan(span *Span) SamplingDecision
	IsSampled(span *Span) (bool, []opentracing.Tag)

	fmt.Stringer
	io.Closer
}

type SamplerUpdater interface {
	Update(sampler *RemoteSampler, strategies *api_v1.StrategiesResponse) error
}

type SamplingDecision struct {
	Sampled bool
	Tag     []opentracing.Tag
}

type SamplingStrategyFetcher interface {
	Fetch(service string, operations []Operation) (*api_v1.StrategiesResponse, error)
}

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

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

type SpanID uint64

type Throughput struct {
	Since      time.Time
	Throughput int64
}

type TraceID struct {
	Low  uint64
	High uint64
}

type Tracer interface {
	opentracing.Tracer
	io.Closer

	Sampler() Sampler
	Tags() []opentracing.Tag
}

type TracerParams struct {
	Logger   *zap.Logger
	Reporter Reporter
	Sampler  Sampler
}

type Transport interface {
	// Append appends a span into transport but the span would not be reported to agent until
	// cache is full.
	Append(span *Span) (int, error)

	// Flush would immediately transport all spans in cache to agent.
	Flush() (int, error)

	io.Closer
}

type TransportParams struct {
	Logger          *zap.Logger
	MaxBufferedSize int
	AgentEndpoint   routing.Endpoint
}