trace

Documentation

Index

• Constants
• type BufferedDirectTraceExporter
  • func NewBufferedDirectTraceExporter(log *logrus.Logger, consumer consumer.Traces, bufferSize int) *BufferedDirectTraceExporter
  • func (s *BufferedDirectTraceExporter) Export(ctx context.Context, flows <-chan protoreflect.Message) error
• type BufferedTraceExporter
  • func NewBufferedTraceExporter(otlpConn *grpc.ClientConn, bufferSize int, headers map[string]string, ...) *BufferedTraceExporter
  • func (s *BufferedTraceExporter) Export(ctx context.Context, flows <-chan protoreflect.Message) error
• type FlowConverter
  • func NewFlowConverter(log *logrus.Logger, dir string, options *common.EncodingOptions, ...) (*FlowConverter, error)
  • func (c *FlowConverter) CloseCache() error
  • func (c *FlowConverter) Convert(hubbleResp *hubbleObserver.GetFlowsResponse) (protoreflect.Message, error)
  • func (c *FlowConverter) DeleteCache()
• type IDTuple
• type TraceCache
  • func NewTraceCache(opt badger.Options, traceCacheWindow time.Duration) (*TraceCache, error)
  • func (tc *TraceCache) Close() error
  • func (tc *TraceCache) Delete()
  • func (tc *TraceCache) GetSpanContext(f *flow.Flow, parseHeaders bool) (*trace.SpanContext, *trace.SpanContext, error)

Constants

const (
	DefaultTraceCacheWindow = 20 * time.Minute
)

Types

type BufferedDirectTraceExporter

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

func NewBufferedDirectTraceExporter

func NewBufferedDirectTraceExporter(log *logrus.Logger, consumer consumer.Traces, bufferSize int) *BufferedDirectTraceExporter

func (*BufferedDirectTraceExporter) Export

func (s *BufferedDirectTraceExporter) Export(ctx context.Context, flows <-chan protoreflect.Message) error

type BufferedTraceExporter

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

func NewBufferedTraceExporter

func NewBufferedTraceExporter(otlpConn *grpc.ClientConn, bufferSize int, headers map[string]string, callOptions ...grpc.CallOption) *BufferedTraceExporter

func (*BufferedTraceExporter) Export

func (s *BufferedTraceExporter) Export(ctx context.Context, flows <-chan protoreflect.Message) error

type FlowConverter

type FlowConverter struct {
	*common.FlowEncoder
	// contains filtered or unexported fields
}

func NewFlowConverter

func NewFlowConverter(
	log *logrus.Logger,
	dir string,
	options *common.EncodingOptions,
	includeFlowTypes *common.IncludeFlowTypes,
	fallbackServiceNamePrefix string,
	traceCacheWindow time.Duration,
	parseHeaders bool,
) (*FlowConverter, error)

func (*FlowConverter) CloseCache

func (c *FlowConverter) CloseCache() error

func (*FlowConverter) Convert

func (c *FlowConverter) Convert(hubbleResp *hubbleObserver.GetFlowsResponse) (protoreflect.Message, error)

func (*FlowConverter) DeleteCache

func (c *FlowConverter) DeleteCache()

type IDTuple

type IDTuple struct {
	TraceID trace.TraceID
	SpanID  trace.SpanID
}

type TraceCache

type TraceCache struct {
	// MaxTraceLen defins the length of the time window during which
	// reconstruction of long-lived sessions is permitted.
	// This is used as a Badger value TTL that is set when trace ID is
	// stored for the first time, and gets updated each time a trace ID
	// is retreived. In other words, trace ID will only be tracked for
	// this duration after last matching flow was seen.
	TraceCacheWindow time.Duration
	Strict           bool
	StoreFlowData    bool
	// contains filtered or unexported fields
}

TraceCache holds an instance of Badger database that is used to track a limited number of observed flows and associated trace IDs.

func NewTraceCache

func NewTraceCache(opt badger.Options, traceCacheWindow time.Duration) (*TraceCache, error)

func (*TraceCache) Close

func (tc *TraceCache) Close() error

func (*TraceCache) Delete

func (tc *TraceCache) Delete()

func (*TraceCache) GetSpanContext

func (tc *TraceCache) GetSpanContext(f *flow.Flow, parseHeaders bool) (*trace.SpanContext, *trace.SpanContext, error)