agent

Documentation

Index

• Constants
• func Run(ctx context.Context)
• func Truncate(s *pb.Span)
• type Agent
  • func NewAgent(ctx context.Context, conf *config.AgentConfig) *Agent
  • func (a *Agent) Process(t pb.Trace)
  • func (a *Agent) Run()
• type ProcessedTrace
  • func (pt *ProcessedTrace) GetSamplingPriority() (sampler.SamplingPriority, bool)
  • func (pt *ProcessedTrace) Weight() float64
• type Sampler
  • func NewErrorsSampler(conf *config.AgentConfig) *Sampler
  • func NewPrioritySampler(conf *config.AgentConfig, dynConf *sampler.DynamicConfig) *Sampler
  • func NewScoreSampler(conf *config.AgentConfig) *Sampler
  • func (s *Sampler) Add(t ProcessedTrace) (sampled bool, rate float64)
  • func (s *Sampler) Start()
  • func (s *Sampler) Stop()
• type ServiceMapper
  • func NewServiceMapper(in <-chan pb.ServicesMetadata, out chan<- pb.ServicesMetadata) *ServiceMapper
  • func (s *ServiceMapper) Run()
  • func (s *ServiceMapper) Start()
  • func (s *ServiceMapper) Stop()
• type TraceServiceExtractor
  • func NewTraceServiceExtractor(out chan pb.ServicesMetadata) *TraceServiceExtractor
  • func (ts *TraceServiceExtractor) Process(t stats.WeightedTrace)

Constants

const (
	// MaxResourceLen the maximum length the resource can have
	MaxResourceLen = 5000
	// MaxMetaKeyLen the maximum length of metadata key
	MaxMetaKeyLen = 100
	// MaxMetaValLen the maximum length of metadata value
	MaxMetaValLen = 5000
	// MaxMetricsKeyLen the maximum length of a metric name key
	MaxMetricsKeyLen = MaxMetaKeyLen
)

Functions

func Run

func Run(ctx context.Context)

Run is the entrypoint of our code, which starts the agent.

func Truncate

func Truncate(s *pb.Span)

Truncate checks that the span resource, meta and metrics are within the max length and modifies them if they are not

Types

type Agent

type Agent struct {
	Receiver           *api.HTTPReceiver
	Concentrator       *stats.Concentrator
	Blacklister        *filters.Blacklister
	Replacer           *filters.Replacer
	ScoreSampler       *Sampler
	ErrorsScoreSampler *Sampler
	PrioritySampler    *Sampler
	EventProcessor     *event.Processor
	TraceWriter        *writer.TraceWriter
	ServiceWriter      *writer.ServiceWriter
	StatsWriter        *writer.StatsWriter
	ServiceExtractor   *TraceServiceExtractor
	ServiceMapper      *ServiceMapper
	// contains filtered or unexported fields
}

Agent struct holds all the sub-routines structs and make the data flow between them

func NewAgent

func NewAgent(ctx context.Context, conf *config.AgentConfig) *Agent

NewAgent returns a new Agent object, ready to be started. It takes a context which may be cancelled in order to gracefully stop the agent.

func (*Agent) Process

func (a *Agent) Process(t pb.Trace)

Process is the default work unit that receives a trace, transforms it and passes it downstream.

func (*Agent) Run

func (a *Agent) Run()

Run starts routers routines and individual pieces then stop them when the exit order is received

type ProcessedTrace

type ProcessedTrace struct {
	Trace         pb.Trace
	WeightedTrace stats.WeightedTrace
	Root          *pb.Span
	Env           string
	Sublayers     stats.SublayerMap
	Sampled       bool
}

ProcessedTrace represents a trace being processed in the agent.

func (*ProcessedTrace) GetSamplingPriority

func (pt *ProcessedTrace) GetSamplingPriority() (sampler.SamplingPriority, bool)

GetSamplingPriority returns the sampling priority of the root span.

func (*ProcessedTrace) Weight

func (pt *ProcessedTrace) Weight() float64

Weight returns the weight at the root span.

type Sampler

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

Sampler chooses which spans to write to the API

func NewErrorsSampler

func NewErrorsSampler(conf *config.AgentConfig) *Sampler

NewErrorsSampler creates a new sampler dedicated to traces containing errors to isolate them from the global max tps. It behaves exactly like the normal ScoreSampler except that its statistics are reported under a different name.

func NewPrioritySampler

func NewPrioritySampler(conf *config.AgentConfig, dynConf *sampler.DynamicConfig) *Sampler

NewPrioritySampler creates a new empty distributed sampler ready to be started

func NewScoreSampler

func NewScoreSampler(conf *config.AgentConfig) *Sampler

NewScoreSampler creates a new empty sampler ready to be started

func (*Sampler) Add

func (s *Sampler) Add(t ProcessedTrace) (sampled bool, rate float64)

Add samples a trace and returns true if trace was sampled (should be kept), false otherwise

func (*Sampler) Start

func (s *Sampler) Start()

Start starts sampling traces

func (*Sampler) Stop

func (s *Sampler) Stop()

Stop stops the sampler

type ServiceMapper

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

ServiceMapper provides a cache layer over model.ServicesMetadata pipeline Used in conjunction with ServiceWriter: in-> ServiceMapper out-> ServiceWriter

func NewServiceMapper

func NewServiceMapper(in <-chan pb.ServicesMetadata, out chan<- pb.ServicesMetadata) *ServiceMapper

NewServiceMapper returns an instance of ServiceMapper with the provided channels

func (*ServiceMapper) Run

func (s *ServiceMapper) Run()

Run triggers the event-loop that consumes model.ServicesMeta

func (*ServiceMapper) Start

func (s *ServiceMapper) Start()

Start runs the event loop in a non-blocking way

func (*ServiceMapper) Stop

func (s *ServiceMapper) Stop()

Stop gracefully terminates the event-loop

type TraceServiceExtractor

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

TraceServiceExtractor extracts service metadata from top-level spans

func NewTraceServiceExtractor

func NewTraceServiceExtractor(out chan pb.ServicesMetadata) *TraceServiceExtractor

NewTraceServiceExtractor returns a new TraceServiceExtractor

func (*TraceServiceExtractor) Process

func (ts *TraceServiceExtractor) Process(t stats.WeightedTrace)

Process extracts service metadata from top-level spans and sends it downstream