agent

Documentation

Overview

Package agent implements the trace-agent.

Index

• Constants
• Variables
• 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)
  • func (a *Agent) Truncate(s *pb.Span)
  • func (a *Agent) TruncateResource(r string) (string, bool)
  • func (a *Agent) UpdateAPIKey(oldKey, newKey string)
• type Concentrator
• type SpanModifier
• type TraceWriter

Constants

const (
	// MaxMetaKeyLen the maximum length of metadata key
	MaxMetaKeyLen = 200
	// MaxMetaValLen the maximum length of metadata value
	MaxMetaValLen = 25000
	// MaxMetricsKeyLen the maximum length of a metric name key
	MaxMetricsKeyLen = MaxMetaKeyLen
)

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()
)

Types

type Agent

type Agent struct {
	Receiver              *api.HTTPReceiver
	OTLPReceiver          *api.OTLPReceiver
	Concentrator          Concentrator
	ClientStatsAggregator *stats.ClientStatsAggregator
	Blacklister           *filters.Blacklister
	Replacer              *filters.Replacer
	PrioritySampler       *sampler.PrioritySampler
	ErrorsSampler         *sampler.ErrorsSampler
	RareSampler           *sampler.RareSampler
	NoPrioritySampler     *sampler.NoPrioritySampler
	ProbabilisticSampler  *sampler.ProbabilisticSampler
	EventProcessor        *event.Processor
	TraceWriter           TraceWriter
	StatsWriter           *writer.DatadogStatsWriter
	RemoteConfigHandler   *remoteconfighandler.RemoteConfigHandler
	TelemetryCollector    telemetry.TelemetryCollector
	DebugServer           *api.DebugServer
	Statsd                statsd.ClientInterface
	Timing                timing.Reporter

	// DiscardSpan will be called on all spans, if non-nil. If it returns true, the span will be deleted before processing.
	DiscardSpan func(*pb.Span) bool

	// SpanModifier will be called on all non-nil spans of received trace chunks.
	// Note that any modification of the trace chunk could be overwritten by
	// subsequent SpanModifier calls.
	SpanModifier SpanModifier

	// 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, telemetryCollector telemetry.TelemetryCollector, statsd statsd.ClientInterface, comp compression.Component) *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 synchronously. 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.

func (*Agent) Truncate

func (a *Agent) 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

func (*Agent) TruncateResource

func (a *Agent) TruncateResource(r string) (string, bool)

TruncateResource truncates a span's resource to the maximum allowed length. It returns true if the input was below the max size.

func (*Agent) UpdateAPIKey

func (a *Agent) UpdateAPIKey(oldKey, newKey string)

UpdateAPIKey receives the API Key update signal and propagates it across all internal components that rely on API Key configuration: - HTTP Receiver (used in reverse proxies) - Trace Writer senders - Stats Writer senders

type Concentrator

type Concentrator interface {
	// Start starts the Concentrator
	Start()
	// Stop stops the Concentrator and attempts to flush whatever is left in the buffers
	Stop()
	// Add a stats Input to be concentrated and flushed
	Add(t stats.Input)
}

Concentrator accepts stats input, 'concentrating' them together into buckets before flushing them

type SpanModifier

type SpanModifier interface {
	ModifySpan(*pb.TraceChunk, *pb.Span)
}

SpanModifier is an interface that allows to modify spans while they are processed by the agent.

type TraceWriter

type TraceWriter interface {
	// Stop stops the TraceWriter and attempts to flush whatever is left in the senders buffers.
	Stop()

	// WriteChunks to be written
	WriteChunks(pkg *writer.SampledChunks)

	// FlushSync blocks and sends pending payloads when syncMode is true
	FlushSync() error

	// UpdateAPIKey signals the TraceWriter to update the API Keys stored in its senders config.
	UpdateAPIKey(oldKey, newKey string)
}

TraceWriter provides a way to write trace chunks