Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Accumulator ¶
type Accumulator interface {
// AddFields adds a metric to the accumulator with the given measurement
// name, fields, and tags (and timestamp). If a timestamp is not provided,
// then the accumulator sets it to "now".
AddFields(measurement string,
fields map[string]interface{},
tags map[string]string,
t ...time.Time)
// AddGauge is the same as AddFields, but will add the metric as a "Gauge" type
AddGauge(measurement string,
fields map[string]interface{},
tags map[string]string,
t ...time.Time)
// AddCounter is the same as AddFields, but will add the metric as a "Counter" type
AddCounter(measurement string,
fields map[string]interface{},
tags map[string]string,
t ...time.Time)
// AddSummary is the same as AddFields, but will add the metric as a "Summary" type
AddSummary(measurement string,
fields map[string]interface{},
tags map[string]string,
t ...time.Time)
// AddHistogram is the same as AddFields, but will add the metric as a "Histogram" type
AddHistogram(measurement string,
fields map[string]interface{},
tags map[string]string,
t ...time.Time)
// AddCumulativeHistogram is the same as AddFields, but will add the metric as a "CumulativeHistogram" type
AddCumulativeHistogram(measurement string,
fields map[string]interface{},
tags map[string]string,
t ...time.Time)
// AddMetric adds an metric to the accumulator.
AddMetric(Metric)
// SetPrecision sets the timestamp rounding precision. All metrics addeds
// added to the accumulator will have their timestamp rounded to the
// nearest multiple of precision.
SetPrecision(precision time.Duration)
// Report an error.
AddError(err error)
// Upgrade to a TrackingAccumulator with space for maxTracked
// metrics/batches.
WithTracking(maxTracked int) TrackingAccumulator
}
Accumulator allows adding metrics to the processing flow.
type AggregatingOutput ¶
type AggregatingOutput interface {
Output
// Add the metric to the aggregator
Add(in Metric)
// Push returns the aggregated metrics and is called every flush interval.
Push() []Metric
// Reset signals the the aggregator period is completed.
Reset()
}
AggregatingOutput adds aggregating functionality to an Output. May be used if the Output only accepts a fixed set of aggregations over a time period. These functions may be called concurrently to the Write function.
type Aggregator ¶
type Aggregator interface {
PluginDescriber
// Add the metric to the aggregator.
Add(in Metric)
// Push pushes the current aggregates to the accumulator.
Push(acc Accumulator)
// Reset resets the aggregators caches and aggregates.
Reset()
}
Aggregator is an interface for implementing an Aggregator plugin. the RunningAggregator wraps this interface and guarantees that Add, Push, and Reset can not be called concurrently, so locking is not required when implementing an Aggregator plugin.
type DeliveryInfo ¶
type DeliveryInfo interface {
// ID is the TrackingID
ID() TrackingID
// Delivered returns true if the metric was processed successfully.
Delivered() bool
}
DeliveryInfo provides the results of a delivered metric group.
type Field ¶
type Field struct {
Value interface{}
Key string
}
Field represents a single field key and value.
type Initializer ¶
type Initializer interface {
// Init performs one time setup of the plugin and returns an error if the
// configuration is invalid.
Init() error
}
Initializer is an interface that all plugin types: Inputs, Outputs, Processors, and Aggregators can optionally implement to initialize the plugin.
type Input ¶
type Input interface {
PluginDescriber
// Gather takes in an accumulator and adds the metrics that the Input
// gathers. This is called every agent.interval
Gather(context.Context, Accumulator) error
}
type Logger ¶
type Logger interface {
// Errorf logs an error message, patterned after log.Printf.
Errorf(format string, args ...interface{})
// Error logs an error message, patterned after log.Print.
Error(args ...interface{})
// Debugf logs a debug message, patterned after log.Printf.
Debugf(format string, args ...interface{})
// Debug logs a debug message, patterned after log.Print.
Debug(args ...interface{})
// Warnf logs a warning message, patterned after log.Printf.
Warnf(format string, args ...interface{})
// Warn logs a warning message, patterned after log.Print.
Warn(args ...interface{})
// Infof logs an information message, patterned after log.Printf.
Infof(format string, args ...interface{})
// Info logs an information message, patterned after log.Print.
Info(args ...interface{})
}
Logger defines an interface for logging.
type Metric ¶
type Metric interface {
// Name is the primary identifier for the Metric and corresponds to the
// measurement in the InfluxDB data model.
Name() string
// Tags returns the tags as a map. This method is deprecated, use TagList instead.
Tags() map[string]string
// TagList returns the tags as a slice ordered by the tag key in lexical
// bytewise ascending order. The returned value should not be modified,
// use the AddTag or RemoveTag methods instead.
TagList() []*Tag
// Fields returns the fields as a map. This method is deprecated, use FieldList instead.
Fields() map[string]interface{}
// FieldList returns the fields as a slice in an undefined order. The
// returned value should not be modified, use the AddField or RemoveField
// methods instead.
FieldList() []*Field
// Time returns the timestamp of the metric.
Time() time.Time
// Type returns a general type for the entire metric that describes how you
// might interpret, aggregate the values.
//
// This method may be removed in the future and its use is discouraged.
Type() ValueType
// SetName sets the metric name.
SetName(name string)
// AddPrefix adds a string to the front of the metric name. It is
// equivalent to m.SetName(prefix + m.Name()).
//
// This method is deprecated, use SetName instead.
AddPrefix(prefix string)
// AddSuffix appends a string to the back of the metric name. It is
// equivalent to m.SetName(m.Name() + suffix).
//
// This method is deprecated, use SetName instead.
AddSuffix(suffix string)
// GetTag returns the value of a tag and a boolean to indicate if it was set.
GetTag(key string) (string, bool)
// HasTag returns true if the tag is set on the Metric.
HasTag(key string) bool
// AddTag sets the tag on the Metric. If the Metric already has the tag
// set then the current value is replaced.
AddTag(key, value string)
// RemoveTag removes the tag if it is set.
RemoveTag(key string)
// GetField returns the value of a field and a boolean to indicate if it was set.
GetField(key string) (interface{}, bool)
// HasField returns true if the field is set on the Metric.
HasField(key string) bool
// AddField sets the field on the Metric. If the Metric already has the field
// set then the current value is replaced.
AddField(key string, value interface{})
// RemoveField removes the tag if it is set.
RemoveField(key string)
// SetTime sets the timestamp of the Metric.
SetTime(t time.Time)
// HashID returns an unique identifier for the series.
HashID() uint64
// Copy returns a deep copy of the Metric.
Copy() Metric
// Accept marks the metric as processed successfully and written to an
// output.
Accept()
// Reject marks the metric as processed unsuccessfully.
Reject()
// Drop marks the metric as processed successfully without being written
// to any output.
Drop()
// SetAggregate indicates the metric is an aggregated value.
//
// This method may be removed in the future and its use is discouraged.
SetAggregate(bool)
// IsAggregate returns true if the Metric is an aggregate.
//
// This method may be removed in the future and its use is discouraged.
IsAggregate() bool
// Origin gets the origin of the metric
Origin() string
// SetOrigin sets the origin of the metric
SetOrigin(string)
// OriginInstance gets the origin instance id
OriginInstance() string
// SetOriginInstance sets the origin instance id
SetOriginInstance(string)
// OriginCheckTags gets the origin check tags
OriginCheckTags() map[string]string
// SetOriginCheckTags sets the origin check tags
SetOriginCheckTags(map[string]string)
// OriginCheckTarget gets the origin check target
OriginCheckTarget() string
// SetOriginCheckTarget sets the origin check target
SetOriginCheckTarget(string)
// OriginCheckDisplayName gets the origin check display name
OriginCheckDisplayName() string
// SetOriginCheckDisplayName sets the origin check display name
SetOriginCheckDisplayName(string)
}
Metric is the type of data that is processed by the agent. Input plugins, and to a lesser degree, Processor and Aggregator plugins create new Metrics and Output plugins write them.
type Output ¶
type Output interface {
PluginDescriber
// Connect to the Output; connect is only called once when the plugin starts
Connect() error
// Close any connections to the Output. Close is called once when the output
// is shutting down. Close will not be called until all writes have finished,
// and Write() will not be called once Close() has been, so locking is not
// necessary.
Close() error
// Write takes in group of points to be written to the Output
Write(metrics []Metric) (int, error)
}
type PluginDescriber ¶
type PluginDescriber interface {
// SampleConfig returns the default configuration of the Processor
SampleConfig() string
// Description returns a one-sentence description on the Processor
Description() string
}
PluginDescriber contains the functions all plugins must implement to describe themselves to the agent. Note that all plugins may define a logger that is not part of the interface, but will receive an injected logger if it's set. eg: Log cua.Logger `toml:"-"`
type Processor ¶
type Processor interface {
PluginDescriber
// Apply the filter to the given metric.
Apply(in ...Metric) []Metric
}
Processor is a processor plugin interface for defining new inline processors. these are extremely efficient and should be used over StreamingProcessor if you do not need asynchronous metric writes.
type ServiceInput ¶
type ServiceInput interface {
Input
// Start the ServiceInput. The Accumulator may be retained and used until
// Stop returns.
Start(context.Context, Accumulator) error
// Stop stops the services and closes any necessary channels and connections.
// Metrics should not be written out to the accumulator once stop returns, so
// Stop() should stop reading and wait for any in-flight metrics to write out
// to the accumulator before returning.
Stop()
}
type StreamingProcessor ¶
type StreamingProcessor interface {
PluginDescriber
// Start is called once when the plugin starts; it is only called once per
// plugin instance, and never in parallel.
// Start should return once it is ready to receive metrics.
// The passed in accumulator is the same as the one passed to Add(), so you
// can choose to save it in the plugin, or use the one received from Add().
Start(acc Accumulator) error
// Add is called for each metric to be processed. The Add() function does not
// need to wait for the metric to be processed before returning, and it may
// be acceptable to let background goroutine(s) handle the processing if you
// have slow processing you need to do in parallel.
// Keep in mind Add() should not spawn unbounded goroutines, so you may need
// to use a semaphore or pool of workers (eg: reverse_dns plugin does this)
// Metrics you don't want to pass downstream should have metric.Drop() called,
// rather than simply omitting the acc.AddMetric() call
Add(metric Metric, acc Accumulator) error
// Stop gives you an opportunity to gracefully shut down the processor.
// Once Stop() is called, Add() will not be called any more. If you are using
// goroutines, you should wait for any in-progress metrics to be processed
// before returning from Stop().
// When stop returns, you should no longer be writing metrics to the
// accumulator.
Stop() error
}
StreamingProcessor is a processor that can take in a stream of messages
type TrackingAccumulator ¶
type TrackingAccumulator interface {
Accumulator
// Add the Metric and arrange for tracking feedback after processing..
AddTrackingMetric(m Metric) TrackingID
// Add a group of Metrics and arrange for a signal when the group has been
// processed.
AddTrackingMetricGroup(group []Metric) TrackingID
// Delivered returns a channel that will contain the tracking results.
Delivered() <-chan DeliveryInfo
}
TrackingAccumulator is an Accumulator that provides a signal when the metric has been fully processed. Sending more metrics than the accumulator has been allocated for without reading status from the Accepted or Rejected channels is an error.
Source Files
Click to show internal directories.
Click to hide internal directories.