agent

Documentation

Index

• Constants
• Variables
• func Run(ctx context.Context)
• func Truncate(s *pb.Span)
• type Agent
  • func NewAgent(ctx context.Context, conf *config.AgentConfig) *Agent
  • func (a *Agent) FlushSync()
  • func (a *Agent) Process(p *api.Payload)
  • func (a *Agent) ProcessStats(in pb.ClientStatsPayload, lang, tracerVersion string)
  • func (a *Agent) Run()
  • func (a *Agent) SetGlobalTagsUnsafe(tags map[string]string)
• type ProcessedTrace

Constants

const (
	// MaxTypeLen the maximum length a span type can have
	MaxTypeLen = 100
)

Variables

var (
	// Year2000NanosecTS is an arbitrary cutoff to spot weird-looking values
	Year2000NanosecTS = time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC).UnixNano()
)

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
	OTLPReceiver          *api.OTLPReceiver
	Concentrator          *stats.Concentrator
	ClientStatsAggregator *stats.ClientStatsAggregator
	Blacklister           *filters.Blacklister
	Replacer              *filters.Replacer
	PrioritySampler       *sampler.PrioritySampler
	ErrorsSampler         *sampler.ErrorsSampler
	RareSampler           *sampler.RareSampler
	NoPrioritySampler     *sampler.NoPrioritySampler
	EventProcessor        *event.Processor
	TraceWriter           *writer.TraceWriter
	StatsWriter           *writer.StatsWriter
	SpanInterpreterEngine *interpreter.SpanInterpreterEngine //sts

	// In takes incoming payloads to be processed by the agent.
	In chan *api.Payload
	// 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) FlushSync

func (a *Agent) FlushSync()

FlushSync flushes traces sychronously. This method only works when the agent is configured in synchronous flushing mode via the apm_config.sync_flush option.

func (*Agent) Process

func (a *Agent) Process(p *api.Payload)

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

func (*Agent) ProcessStats

func (a *Agent) ProcessStats(in pb.ClientStatsPayload, lang, tracerVersion string)

ProcessStats processes incoming client stats in from the given tracer.

func (*Agent) Run

func (a *Agent) Run()

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

func (*Agent) SetGlobalTagsUnsafe

func (a *Agent) SetGlobalTagsUnsafe(tags map[string]string)

SetGlobalTagsUnsafe sets global tags to the agent configuration. Unsafe for concurrent use.

type ProcessedTrace

type ProcessedTrace struct {
	TraceChunk       *pb.TraceChunk
	WeightedTrace    stats.WeightedTrace
	Root             *pb.Span
	Env              string
	ClientDroppedP0s bool
}

ProcessedTrace represents a trace being processed in the agent.