config

Documentation

Overview

Package config defines the data models for entities. This file defines the models for configuration format. The defined entities are: Config (the top-level structure), Receivers, Exporters, Processors, Pipelines.

Receivers, Exporters and Processors typically have common configuration settings, however sometimes specific implementations will have extra configuration settings. This requires the configuration data for these entities to be polymorphic.

To satisfy these requirements we declare interfaces Receiver, Exporter, Processor, which define the behavior. We also provide helper structs ReceiverSettings, ExporterSettings, ProcessorSettings, which define the common settings and un-marshaling from config files.

Specific Receivers/Exporters/Processors are expected to at the minimum implement the corresponding interface and if they have additional settings they must also extend the corresponding common settings struct (the easiest approach is to embed the common struct).

Index

• Constants
• func NewViper() *viper.Viper
• type Config
  • func (cfg *Config) Validate() error
• type DataType
• type Exporter
• type ExporterSettings
  • func NewExporterSettings(typeVal Type) *ExporterSettings
  • func (es *ExporterSettings) Name() string
  • func (es *ExporterSettings) SetName(name string)
  • func (es *ExporterSettings) Type() Type
• type Exporters
• type Extension
• type ExtensionSettings
  • func NewExtensionSettings(typeVal Type) *ExtensionSettings
  • func (ext *ExtensionSettings) Name() string
  • func (ext *ExtensionSettings) SetName(name string)
  • func (ext *ExtensionSettings) Type() Type
• type Extensions
• type NamedEntity
• type Parser
  • func NewParser() *Parser
  • func NewParserFromFile(fileName string) (*Parser, error)
  • func NewParserFromStringMap(data map[string]interface{}) *Parser
  • func ParserFromViper(v *viper.Viper) *Parser
  • func (l *Parser) AllKeys() []string
  • func (l *Parser) Get(key string) interface{}
  • func (l *Parser) Set(key string, value interface{})
  • func (l *Parser) Sub(key string) (*Parser, error)
  • func (l *Parser) ToStringMap() map[string]interface{}
  • func (l *Parser) Unmarshal(rawVal interface{}) error
  • func (l *Parser) UnmarshalExact(intoCfg interface{}) error
  • func (l *Parser) Viper() *viper.Viper
• type Pipeline
• type Pipelines
• type Processor
• type ProcessorSettings
  • func NewProcessorSettings(typeVal Type) *ProcessorSettings
  • func (proc *ProcessorSettings) Name() string
  • func (proc *ProcessorSettings) SetName(name string)
  • func (proc *ProcessorSettings) Type() Type
• type Processors
• type Receiver
• type ReceiverSettings
  • func (rs *ReceiverSettings) Name() string
  • func (rs *ReceiverSettings) SetName(name string)
  • func (rs *ReceiverSettings) Type() Type
  • func (rs *ReceiverSettings) Validate() error
• type Receivers
• type Service
• type Type

Constants

const (
	// KeyDelimiter is used as the default key delimiter in the default viper instance.
	KeyDelimiter = "::"
)

Functions

func NewViper

func NewViper() *viper.Viper

NewViper creates a new Viper instance with key delimiter KeyDelimiter instead of the default ".". This way configs can have keys that contain ".".

Types

type Config

type Config struct {
	Receivers
	Exporters
	Processors
	Extensions
	Service
}

Config defines the configuration for the various elements of collector or agent.

func (*Config) Validate

func (cfg *Config) Validate() error

Validate returns an error if the config is invalid.

This function performs basic validation of configuration. There may be more subtle invalid cases that we currently don't check for but which we may want to add in the future (e.g. disallowing receiving and exporting on the same endpoint).

type DataType

type DataType string

DataType is the data type that is supported for collection. We currently support collecting metrics, traces and logs, this can expand in the future.

const (
	// TracesDataType is the data type tag for traces.
	TracesDataType DataType = "traces"

	// MetricsDataType is the data type tag for metrics.
	MetricsDataType DataType = "metrics"

	// LogsDataType is the data type tag for logs.
	LogsDataType DataType = "logs"
)

Currently supported data types. Add new data types here when new types are supported in the future.

type Exporter

type Exporter interface {
	NamedEntity
}

Exporter is the configuration of an exporter.

type ExporterSettings

type ExporterSettings struct {
	TypeVal Type   `mapstructure:"-"`
	NameVal string `mapstructure:"-"`
}

ExporterSettings defines common settings for an exporter configuration. Specific exporters can embed this struct and extend it with more fields if needed. When embedded in the exporter config it must be with `mapstructure:"-"` tag.

func NewExporterSettings

func NewExporterSettings(typeVal Type) *ExporterSettings

NewExporterSettings return a new ExporterSettings with the given type.

func (*ExporterSettings) Name

func (es *ExporterSettings) Name() string

Name gets the exporter name.

func (*ExporterSettings) SetName

func (es *ExporterSettings) SetName(name string)

SetName sets the exporter name.

func (*ExporterSettings) Type

func (es *ExporterSettings) Type() Type

Type sets the exporter type.

type Exporters

type Exporters map[string]Exporter

Exporters is a map of names to Exporters.

type Extension

type Extension interface {
	NamedEntity
}

Extension is the configuration of a service extension. Specific extensions must implement this interface and will typically embed ExtensionSettings struct or a struct that extends it.

type ExtensionSettings

type ExtensionSettings struct {
	TypeVal Type   `mapstructure:"-"`
	NameVal string `mapstructure:"-"`
}

ExtensionSettings defines common settings for a extension configuration. Specific extensions can embed this struct and extend it with more fields if needed. When embedded in the extension config it must be with `mapstructure:"-"` tag.

func NewExtensionSettings

func NewExtensionSettings(typeVal Type) *ExtensionSettings

NewExtensionSettings return a new ExtensionSettings with the given type.

func (*ExtensionSettings) Name

func (ext *ExtensionSettings) Name() string

Name gets the extension name.

func (*ExtensionSettings) SetName

func (ext *ExtensionSettings) SetName(name string)

SetName sets the extension name.

func (*ExtensionSettings) Type

func (ext *ExtensionSettings) Type() Type

Type sets the extension type.

type Extensions

type Extensions map[string]Extension

Extensions is a map of names to extensions.

type NamedEntity

type NamedEntity interface {
	Type() Type
	Name() string
	SetName(name string)
}

NamedEntity is a configuration entity that has a type and a name.

type Parser

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

Parser loads configuration.

func NewParser

func NewParser() *Parser

NewParser creates a new Parser instance.

func NewParserFromFile

func NewParserFromFile(fileName string) (*Parser, error)

NewParserFromFile creates a new Parser by reading the given file.

func NewParserFromStringMap

func NewParserFromStringMap(data map[string]interface{}) *Parser

NewParserFromStringMap creates a parser from a map[string]interface{}.

func ParserFromViper

func ParserFromViper(v *viper.Viper) *Parser

ParserFromViper creates a Parser from a Viper instance.

func (*Parser) AllKeys

func (l *Parser) AllKeys() []string

AllKeys returns all keys holding a value, regardless of where they are set. Nested keys are returned with a KeyDelimiter separator

func (*Parser) Get

func (l *Parser) Get(key string) interface{}

Get can retrieve any value given the key to use.

func (*Parser) Set

func (l *Parser) Set(key string, value interface{})

Set sets the value for the key.

func (*Parser) Sub

func (l *Parser) Sub(key string) (*Parser, error)

Sub returns new Parser instance representing a sub tree of this instance.

func (*Parser) ToStringMap

func (l *Parser) ToStringMap() map[string]interface{}

ToStringMap creates a map[string]interface{} from a Parser.

func (*Parser) Unmarshal

func (l *Parser) Unmarshal(rawVal interface{}) error

Unmarshal unmarshals the config into a struct. Make sure that the tags on the fields of the structure are properly set.

func (*Parser) UnmarshalExact

func (l *Parser) UnmarshalExact(intoCfg interface{}) error

UnmarshalExact unmarshals the config into a struct, erroring if a field is nonexistent.

func (*Parser) Viper

func (l *Parser) Viper() *viper.Viper

Viper returns the viper.Viper implementation of this Parser.

type Pipeline

type Pipeline struct {
	Name       string
	InputType  DataType
	Receivers  []string
	Processors []string
	Exporters  []string
}

Pipeline defines a single pipeline.

type Pipelines

type Pipelines map[string]*Pipeline

Pipelines is a map of names to Pipelines.

type Processor

type Processor interface {
	NamedEntity
}

Processor is the configuration of a processor. Specific processors must implement this interface and will typically embed ProcessorSettings struct or a struct that extends it.

type ProcessorSettings

type ProcessorSettings struct {
	TypeVal Type   `mapstructure:"-"`
	NameVal string `mapstructure:"-"`
}

ProcessorSettings defines common settings for a processor configuration. Specific processors can embed this struct and extend it with more fields if needed. When embedded in the processor config it must be with `mapstructure:"-"` tag.

func NewProcessorSettings

func NewProcessorSettings(typeVal Type) *ProcessorSettings

NewProcessorSettings return a new ProcessorSettings with the given type.

func (*ProcessorSettings) Name

func (proc *ProcessorSettings) Name() string

Name gets the processor name.

func (*ProcessorSettings) SetName

func (proc *ProcessorSettings) SetName(name string)

SetName sets the processor name.

func (*ProcessorSettings) Type

func (proc *ProcessorSettings) Type() Type

Type sets the processor type.

type Processors

type Processors map[string]Processor

Processors is a map of names to Processors.

type Receiver

type Receiver interface {
	NamedEntity
	// contains filtered or unexported methods
}

Receiver is the configuration of a receiver. Specific receivers must implement this interface and will typically embed ReceiverSettings struct or a struct that extends it. Embedded validatable will force each receiver to implement Validate() function

type ReceiverSettings

type ReceiverSettings struct {
	TypeVal Type   `mapstructure:"-"`
	NameVal string `mapstructure:"-"`
}

ReceiverSettings defines common settings for a receiver configuration. Specific receivers can embed this struct and extend it with more fields if needed. It is highly recommended to "override" the Validate() function. When embedded in the processor config it must be with `mapstructure:"-"` tag.

func (*ReceiverSettings) Name

func (rs *ReceiverSettings) Name() string

Name gets the receiver name.

func (*ReceiverSettings) SetName

func (rs *ReceiverSettings) SetName(name string)

SetName sets the receiver name.

func (*ReceiverSettings) Type

func (rs *ReceiverSettings) Type() Type

Type sets the receiver type.

func (*ReceiverSettings) Validate

func (rs *ReceiverSettings) Validate() error

Validate validates the configuration and returns an error if invalid.

type Receivers

type Receivers map[string]Receiver

Receivers is a map of names to Receivers.

type Service

type Service struct {
	// Extensions is the ordered list of extensions configured for the service.
	Extensions []string

	// Pipelines is the set of data pipelines configured for the service.
	Pipelines Pipelines
}

Service defines the configurable components of the service.

type Type

type Type string

Type is the component type as it is used in the config.