core

type Buffer struct {
	bytes.Buffer
}

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{}) (opentracing.SpanContext, error)
}

type HTTPHeadersCarrier opentracing.HTTPHeadersCarrier

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 opentracing.SpanContext, carrier interface{})
}

type Span interface {
	opentracing.Span
	RawContext() SpanContext
	RawTracer() Tracer
}

type SpanContext interface {
	opentracing.SpanContext
	TraceID() string
	SpanID() string
	BaggageItem(key string) string
}

type SpanEncoder interface {

	// Return the encoder to the appropriate sync.Pool. Unpooled encoder
	// implementations can no-op this method.
	Encode(opentracing.Span) []byte
}

type SpanModel struct {
	TraceID   string                     `json:"traceId"`
	SpanID    string                     `json:"spanId"`
	ParentID  string                     `json:"parentId"`
	Operation string                     `json:"operation"`
	Start     int64                      `json:"start"`
	Finish    int64                      `json:"finish"`
	Duration  int64                      `json:"duration"`
	Tags      map[string]interface{}     `json:"tags"`
	Logs      [](map[string]interface{}) `json:"logs"`
	Baggage   map[string]string          `json:"baggage"`
}

type SpanReporter interface {
	Report(opentracing.Span)
}

type TextMapCarrier opentracing.TextMapCarrier

type TextMapWriter opentracing.TextMapWriter

type Tracer interface {
	opentracing.Tracer
	StartSpanWithOptions(string, opentracing.StartSpanOptions) opentracing.Span
}

type TracerOptions struct {
	// MultiEvent tells whether the tracer outputs in Single-Event or Multi-Event Mode.
	// See [Canonical Events](https://github.com/Nordstrom/ctrace/tree/new#canonical-events).
	// If MultiEvent=true, the tracer is using Multi-Event Mode which means Start-Span, Log,
	// and Finish-Span events are output with each containing a single log.
	// If MultiEvent=false (default), the tracer is using Single-Event Mode which
	// means only Finish-Span events are output with a collectionn of all logs for that Span.
	MultiEvent bool

	// Writer is used to write serialized trace events.  It defaults to os.Stdout.
	Writer io.Writer

	// ServiceName allows the configuration of the "service" tag for the entire Tracer.
	// If not specified here, it can also be specified using environment variable "CTRACE_SERVICE"
	ServiceName string

	// DebugAssertSingleGoroutine internally records the ID of the goroutine
	// creating each Span and verifies that no operation is carried out on
	// it on a different goroutine.
	// Provided strictly for development purposes.
	// Passing Spans between goroutine without proper synchronization often
	// results in use-after-Finish() errors. For a simple example, consider the
	// following pseudocode:
	//
	//  func (s *Server) Handle(req http.Request) error {
	//    sp := s.StartSpan("server")
	//    defer sp.Finish()
	//    wait := s.queueProcessing(opentracing.ContextWithSpan(context.Background(), sp), req)
	//    select {
	//    case resp := <-wait:
	//      return resp.Error
	//    case <-time.After(10*time.Second):
	//      sp.LogEvent("timed out waiting for processing")
	//      return ErrTimedOut
	//    }
	//  }
	//
	// This looks reasonable at first, but a request which spends more than ten
	// seconds in the queue is abandoned by the main goroutine and its trace
	// finished, leading to use-after-finish when the request is finally
	// processed. Note also that even joining on to a finished Span via
	// StartSpanWithOptions constitutes an illegal operation.
	//
	// Code bases which do not require (or decide they do not want) Spans to
	// be passed across goroutine boundaries can run with this flag enabled in
	// tests to increase their chances of spotting wrong-doers.
	DebugAssertSingleGoroutine bool
	// DebugAssertUseAfterFinish is provided strictly for development purposes.
	// When set, it attempts to exacerbate issues emanating from use of Spans
	// after calling Finish by running additional assertions.
	DebugAssertUseAfterFinish bool
}