confgenerator

package
v0.0.0-...-5ad0212 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 18, 2024 License: Apache-2.0 Imports: 41 Imported by: 0

Documentation

Overview

Package confgenerator represents the Ops Agent configuration and provides functions to generate subagents configuration from unified agent.

Package confgenerator provides functions to generate subagents configuration from unified agent.

Index

Constants

View Source 
const HttpRequestKey = "logging.googleapis.com/httpRequest"
View Source 
const InstrumentationSourceLabel = `labels."logging.googleapis.com/instrumentation_source"`

Variables

View Source 
var (
	ErrTrackingInlineStruct   = errors.New("cannot have tracking on inline struct")
	ErrTrackingOverrideStruct = errors.New("struct that has tracking tag must not be empty")
)
View Source 
var CombinedReceiverTypes = &componentTypeRegistry[CombinedReceiver, combinedReceiverMap]{
	Subagent: "generic", Kind: "receiver",
}
View Source 
var FindJarPath = func() (string, error) {
	jarName := "opentelemetry-java-contrib-jmx-metrics.jar"

	executableDir, err := osext.ExecutableFolder()
	if err != nil {
		return jarName, fmt.Errorf("could not determine binary path for jvm receiver: %w", err)
	}

	if runtime.GOOS != "windows" {
		return filepath.Join(executableDir, "../subagents/opentelemetry-collector/", jarName), nil
	}
	return filepath.Join(executableDir, jarName), nil
}
View Source 
var LegacyBuiltinProcessors = map[string]LoggingProcessor{
	"lib:default_message_parser": &LoggingProcessorParseRegex{
		Regex: `^(?<message>.*)$`,
	},
	"lib:apache": &LoggingProcessorParseRegex{
		Regex: `^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^\"]*?)(?: +\S*)?)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>[^\"]*)")?$`,
		ParserShared: ParserShared{
			TimeKey:    "time",
			TimeFormat: "%d/%b/%Y:%H:%M:%S %z",
		},
	},
	"lib:apache2": &LoggingProcessorParseRegex{
		Regex: `^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>.*)")?$`,
		ParserShared: ParserShared{
			TimeKey:    "time",
			TimeFormat: "%d/%b/%Y:%H:%M:%S %z",
		},
	},
	"lib:apache_error": &LoggingProcessorParseRegex{
		Regex: `^\[[^ ]* (?<time>[^\]]*)\] \[(?<level>[^\]]*)\](?: \[pid (?<pid>[^\]]*)\])?( \[client (?<client>[^\]]*)\])? (?<message>.*)$`,
	},
	"lib:mongodb": &LoggingProcessorParseRegex{
		Regex: `^(?<time>[^ ]*)\s+(?<severity>\w)\s+(?<component>[^ ]+)\s+\[(?<context>[^\]]+)]\s+(?<message>.*?) *(?<ms>(\d+))?(:?ms)?$`,
		ParserShared: ParserShared{
			TimeKey:    "time",
			TimeFormat: "%Y-%m-%dT%H:%M:%S.%L",
		},
	},
	"lib:nginx": &LoggingProcessorParseRegex{
		Regex: `^(?<remote>[^ ]*) (?<host>[^ ]*) (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^\"]*?)(?: +\S*)?)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>[^\"]*)")`,
		ParserShared: ParserShared{
			TimeKey:    "time",
			TimeFormat: "%d/%b/%Y:%H:%M:%S %z",
		},
	},
	"lib:syslog-rfc5424": &LoggingProcessorParseRegex{
		Regex: `^\<(?<pri>[0-9]{1,5})\>1 (?<time>[^ ]+) (?<host>[^ ]+) (?<ident>[^ ]+) (?<pid>[-0-9]+) (?<msgid>[^ ]+) (?<extradata>(\[(.*?)\]|-)) (?<message>.+)$`,
		ParserShared: ParserShared{
			TimeKey:    "time",
			TimeFormat: "%Y-%m-%dT%H:%M:%S.%L%Z",
		},
	},
	"lib:syslog-rfc3164": &LoggingProcessorParseRegex{
		Regex: `/^\<(?<pri>[0-9]+)\>(?<time>[^ ]* {1,2}[^ ]* [^ ]*) (?<host>[^ ]*) (?<ident>[a-zA-Z0-9_\/\.\-]*)(?:\[(?<pid>[0-9]+)\])?(?:[^\:]*\:)? *(?<message>.*)$/`,
		ParserShared: ParserShared{
			TimeKey:    "time",
			TimeFormat: "%b %d %H:%M:%S",
		},
	},
}
View Source 
var LoggingProcessorTypes = &componentTypeRegistry[LoggingProcessor, loggingProcessorMap]{
	Subagent: "logging", Kind: "processor",
}
View Source 
var LoggingReceiverTypes = &componentTypeRegistry[LoggingReceiver, loggingReceiverMap]{
	Subagent: "logging", Kind: "receiver",
}
View Source 
var MetricsProcessorTypes = &componentTypeRegistry[MetricsProcessor, metricsProcessorMap]{
	Subagent: "metrics", Kind: "processor",
}
View Source 
var MetricsReceiverTypes = &componentTypeRegistry[MetricsReceiver, metricsReceiverMap]{
	Subagent: "metrics", Kind: "receiver",
}

Functions

func ContextWithExperiments 

func ContextWithExperiments(ctx context.Context, experiments map[string]bool) context.Context

func DBPath 

func DBPath(tag string) string

DBPath returns the database path for the given log tag

func ParseExperimentalFeatures 

func ParseExperimentalFeatures(features string) map[string]bool

func WriteConfigFile 

func WriteConfigFile(content []byte, path string) error

Types

type AgentSelfMetrics 

type AgentSelfMetrics struct {
	Version string
	Port    int
}

AgentSelfMetrics provides the agent.googleapis.com/agent/ metrics. It is never referenced in the config file, and instead is forcibly added in confgenerator.go. Therefore, it does not need to implement any interfaces.

func (AgentSelfMetrics) LoggingSubmodulePipeline 

func (r AgentSelfMetrics) LoggingSubmodulePipeline() otel.ReceiverPipeline

func (AgentSelfMetrics) MetricsSubmodulePipeline 

func (r AgentSelfMetrics) MetricsSubmodulePipeline() otel.ReceiverPipeline

type Combined 

type Combined struct {
	Receivers combinedReceiverMap `yaml:"receivers,omitempty" validate:"dive,keys,startsnotwith=lib:"`
}

type CombinedReceiver 

type CombinedReceiver interface {
	// TODO: Add more types of signals
	MetricsReceiver
}

type Component 

type Component interface {
	// Type returns the component type string as used in the configuration file (e.g. "hostmetrics")
	Type() string
}

type ConfigComponent 

type ConfigComponent struct {
	Type string `yaml:"type" validate:"required" tracking:""`
}

ConfigComponent holds the shared configuration fields that all components have. It is also used by itself when unmarshaling a component's configuration.

type CustomFeature 

type CustomFeature struct {
	// Key: set of keys that will be joined together for feature tracking metrics
	Key []string
	// Value defined from fields of UnifiedConfig.
	Value string
}

type CustomFeatures 

type CustomFeatures interface {
	// ExtractFeatures returns a list of features that will be tracked for this component.
	ExtractFeatures() ([]CustomFeature, error)

	// ListAllFeatures returns a list of all features that could be tracked for this component.
	// This lists all the possible features that could be tracked for this component, but some of these
	// features may not be tracked when not used by the component.
	ListAllFeatures() []string
}

CustomFeatures is the interface that components must implement to be able to track features not captured by the `tracking` struct tag.

type Feature 

type Feature struct {
	// Module defines the sub-agent: metrics or logging
	Module string
	// Kind defines the kind: receivers or processors
	Kind string
	// Type from Component.Type()
	Type string
	// Key: set of keys that will be joined together for feature tracking metrics
	Key []string
	// Value defined from fields of UnifiedConfig.
	Value string
}

func ExtractFeatures 

func ExtractFeatures(uc *UnifiedConfig) ([]Feature, error)

ExtractFeatures fields that containing a tracking tag will be tracked. Automatic collection of bool or int fields. Any value that exists on tracking tag will be used instead of value from UnifiedConfig.

type Global 

type Global struct {
	DefaultSelfLogFileCollection *bool            `yaml:"default_self_log_file_collection,omitempty"`
	DefaultLogFileRotation       *LogFileRotation `yaml:"default_self_log_file_rotation,omitempty"`
}

func (*Global) GetDefaultSelfLogFileCollection 

func (g *Global) GetDefaultSelfLogFileCollection() bool

Get whether self log collection should be enabled. Defaults to true if unset.

type LogFileRotation 

type LogFileRotation struct {
	Enabled     *bool `yaml:"enabled"`
	MaxFileSize *int  `yaml:"max_file_size_megabytes" validate:"omitempty,gte=1"`
	BackupCount *int  `yaml:"backup_count" validate:"omitempty,gte=1"`
}

func (*LogFileRotation) GetBackupCount 

func (c *LogFileRotation) GetBackupCount() int

Get the maximum number of backups for logs. If not set or negative, defaults to 1 backup (2 files including the file that is being logged to).

func (*LogFileRotation) GetEnabled 

func (c *LogFileRotation) GetEnabled() bool

Get whether log rotation should be enabled. Defaults to true if unset.

func (*LogFileRotation) GetMaxFileSize 

func (c *LogFileRotation) GetMaxFileSize() int

Get the maximum file size for logs in megabytes. If not set or non-positive, defaults to 400 MB.

type Logging 

type Logging struct {
	Receivers  loggingReceiverMap  `yaml:"receivers,omitempty" validate:"dive,keys,startsnotwith=lib:"`
	Processors loggingProcessorMap `yaml:"processors,omitempty" validate:"dive,keys,startsnotwith=lib:"`
	// Exporters are deprecated and ignored, so do not have any validation.
	Exporters map[string]interface{} `yaml:"exporters,omitempty"`
	Service   *LoggingService        `yaml:"service"`
}

type LoggingNetworkReceiver 

type LoggingNetworkReceiver interface {
	LoggingReceiver
	GetListenPort() uint16
}

Logging receivers that listen on a port of the host

type LoggingProcessor 

type LoggingProcessor interface {
	Component
	// Components returns fluentbit components that implement this processor.
	// tag is the log tag that should be matched by those components, and uid is a string which should be used when needed to generate unique names.
	Components(ctx context.Context, tag string, uid string) []fluentbit.Component
}

type LoggingProcessorExcludeLogs 

type LoggingProcessorExcludeLogs struct {
	ConfigComponent `yaml:",inline"`
	MatchAny        []string `yaml:"match_any" validate:"required,dive,filter"`
}

A LoggingProcessorExcludeLogs filters out logs according to a pattern.

func (LoggingProcessorExcludeLogs) Components 

func (p LoggingProcessorExcludeLogs) Components(ctx context.Context, tag, uid string) []fluentbit.Component

func (LoggingProcessorExcludeLogs) Processors 

func (p LoggingProcessorExcludeLogs) Processors(ctx context.Context) ([]otel.Component, error)

func (LoggingProcessorExcludeLogs) Type 

func (p LoggingProcessorExcludeLogs) Type() string

type LoggingProcessorModifyFields 

type LoggingProcessorModifyFields struct {
	ConfigComponent `yaml:",inline"`
	Fields          map[string]*ModifyField `yaml:"fields" validate:"dive,keys,field,distinctfield,writablefield,endkeys" tracking:"-"`

	// For use by other processors, if set this will clear out `jsonPayload`, leaving only the fields set above.
	// Only supported in OTel.
	EmptyBody bool `yaml:"-" tracking:"-"`
}

func (LoggingProcessorModifyFields) Components 

func (p LoggingProcessorModifyFields) Components(ctx context.Context, tag, uid string) []fluentbit.Component

func (LoggingProcessorModifyFields) Processors 

func (p LoggingProcessorModifyFields) Processors(ctx context.Context) ([]otel.Component, error)

func (LoggingProcessorModifyFields) Type 

func (p LoggingProcessorModifyFields) Type() string

type LoggingProcessorNestWildcard 

type LoggingProcessorNestWildcard struct {
	Wildcard     string
	NestUnder    string
	RemovePrefix string
}

func (LoggingProcessorNestWildcard) Components 

func (p LoggingProcessorNestWildcard) Components(ctx context.Context, tag, uid string) []fluentbit.Component

type LoggingProcessorParseJson 

type LoggingProcessorParseJson struct {
	ConfigComponent `yaml:",inline"`
	ParserShared    `yaml:",inline"`
	Field           string `yaml:"field,omitempty" validate:"omitempty,fieldlegacy"`
}

A LoggingProcessorParseJson parses the specified field as JSON.

func (LoggingProcessorParseJson) Components 

func (p LoggingProcessorParseJson) Components(ctx context.Context, tag, uid string) []fluentbit.Component

func (LoggingProcessorParseJson) Processors 

func (p LoggingProcessorParseJson) Processors(ctx context.Context) ([]otel.Component, error)

func (LoggingProcessorParseJson) Type 

func (r LoggingProcessorParseJson) Type() string

type LoggingProcessorParseMultilineRegex 

type LoggingProcessorParseMultilineRegex struct {
	LoggingProcessorParseRegexComplex
	Rules []MultilineRule
}

A LoggingProcessorParseMultiline applies a set of regex rules to the specified lines, storing the named capture groups as keys in the log record. 

#
# Regex rules for multiline parsing
# ---------------------------------
#
# configuration hints:
#
#  - first state always has the name: start_state
#  - every field in the rule must be inside double quotes
#
# rules |   state name  | regex pattern                  | next state
# ------|---------------|--------------------------------------------
rule      "start_state"   "/(Dec \d+ \d+\:\d+\:\d+)(.*)/"  "cont"
rule      "cont"          "/^\s+at.*/"                     "cont"

func (LoggingProcessorParseMultilineRegex) Components 

func (p LoggingProcessorParseMultilineRegex) Components(ctx context.Context, tag, uid string) []fluentbit.Component

type LoggingProcessorParseRegex 

type LoggingProcessorParseRegex struct {
	ConfigComponent `yaml:",inline"`
	ParserShared    `yaml:",inline"`
	Field           string `yaml:"field,omitempty" validate:"omitempty,fieldlegacy"`
	PreserveKey     bool   `yaml:"-"`

	Regex string `yaml:"regex,omitempty" validate:"required"`
}

A LoggingProcessorParseRegex applies a regex to the specified field, storing the named capture groups as keys in the log record. This was maintained in addition to the parse_regex_complex to ensure backward compatibility with any existing configurations

func (LoggingProcessorParseRegex) Components 

func (p LoggingProcessorParseRegex) Components(ctx context.Context, tag, uid string) []fluentbit.Component

func (LoggingProcessorParseRegex) Type 

func (r LoggingProcessorParseRegex) Type() string

type LoggingProcessorParseRegexComplex 

type LoggingProcessorParseRegexComplex struct {
	Field   string
	Parsers []RegexParser
}

A LoggingProcessorParseRegexComplex applies a set of regexes to the specified field, storing the named capture groups as keys in the log record.

func (LoggingProcessorParseRegexComplex) Components 

func (p LoggingProcessorParseRegexComplex) Components(ctx context.Context, tag, uid string) []fluentbit.Component

type LoggingReceiver 

type LoggingReceiver interface {
	Component
	Components(ctx context.Context, tag string) []fluentbit.Component
}

type LoggingReceiverFiles 

type LoggingReceiverFiles struct {
	ConfigComponent `yaml:",inline"`
	// TODO: Use LoggingReceiverFilesMixin after figuring out the validation story.
	IncludePaths            []string       `yaml:"include_paths" validate:"required,min=1"`
	ExcludePaths            []string       `yaml:"exclude_paths,omitempty"`
	WildcardRefreshInterval *time.Duration `yaml:"wildcard_refresh_interval,omitempty" validate:"omitempty,min=1s,multipleof_time=1s"`
	RecordLogFilePath       *bool          `yaml:"record_log_file_path,omitempty"`
}

A LoggingReceiverFiles represents the user configuration for a file receiver (fluentbit's tail plugin).

func (LoggingReceiverFiles) Components 

func (r LoggingReceiverFiles) Components(ctx context.Context, tag string) []fluentbit.Component

func (LoggingReceiverFiles) Pipelines 

func (r LoggingReceiverFiles) Pipelines(ctx context.Context) ([]otel.ReceiverPipeline, error)

func (LoggingReceiverFiles) Type 

func (r LoggingReceiverFiles) Type() string

type LoggingReceiverFilesMixin 

type LoggingReceiverFilesMixin struct {
	IncludePaths            []string        `yaml:"include_paths,omitempty"`
	ExcludePaths            []string        `yaml:"exclude_paths,omitempty"`
	WildcardRefreshInterval *time.Duration  `yaml:"wildcard_refresh_interval,omitempty" validate:"omitempty,min=1s,multipleof_time=1s"`
	MultilineRules          []MultilineRule `yaml:"-"`
	BufferInMemory          bool            `yaml:"-"`
	RecordLogFilePath       *bool           `yaml:"record_log_file_path,omitempty"`
}

func (LoggingReceiverFilesMixin) Components 

func (r LoggingReceiverFilesMixin) Components(ctx context.Context, tag string) []fluentbit.Component

func (LoggingReceiverFilesMixin) Pipelines 

func (r LoggingReceiverFilesMixin) Pipelines(ctx context.Context) ([]otel.ReceiverPipeline, error)

type LoggingReceiverFluentForward 

type LoggingReceiverFluentForward struct {
	ConfigComponent `yaml:",inline"`

	ListenHost string `yaml:"listen_host,omitempty" validate:"omitempty,ip"`
	ListenPort uint16 `yaml:"listen_port,omitempty"`
}

A LoggingReceiverFluentForward represents the configuration for a Forward Protocol receiver.

func (LoggingReceiverFluentForward) Components 

func (r LoggingReceiverFluentForward) Components(ctx context.Context, tag string) []fluentbit.Component

func (LoggingReceiverFluentForward) GetListenPort 

func (r LoggingReceiverFluentForward) GetListenPort() uint16

func (LoggingReceiverFluentForward) Type 

func (r LoggingReceiverFluentForward) Type() string

type LoggingReceiverSyslog 

type LoggingReceiverSyslog struct {
	ConfigComponent `yaml:",inline"`

	TransportProtocol string `yaml:"transport_protocol,omitempty" validate:"oneof=tcp udp"`
	ListenHost        string `yaml:"listen_host,omitempty" validate:"required,ip"`
	ListenPort        uint16 `yaml:"listen_port,omitempty" validate:"required"`
}

A LoggingReceiverSyslog represents the configuration for a syslog protocol receiver.

func (LoggingReceiverSyslog) Components 

func (r LoggingReceiverSyslog) Components(ctx context.Context, tag string) []fluentbit.Component

func (LoggingReceiverSyslog) GetListenPort 

func (r LoggingReceiverSyslog) GetListenPort() uint16

func (LoggingReceiverSyslog) Type 

func (r LoggingReceiverSyslog) Type() string

type LoggingReceiverSystemd 

type LoggingReceiverSystemd struct {
	ConfigComponent `yaml:",inline"`
}

A LoggingReceiverSystemd represents the user configuration for a Systemd/journald receiver.

func (LoggingReceiverSystemd) Components 

func (r LoggingReceiverSystemd) Components(ctx context.Context, tag string) []fluentbit.Component

func (LoggingReceiverSystemd) Type 

func (r LoggingReceiverSystemd) Type() string

type LoggingReceiverTCP 

type LoggingReceiverTCP struct {
	ConfigComponent `yaml:",inline"`

	Format     string `yaml:"format,omitempty" validate:"required,oneof=json"`
	ListenHost string `yaml:"listen_host,omitempty" validate:"omitempty,ip"`
	ListenPort uint16 `yaml:"listen_port,omitempty"`
}

A LoggingReceiverTCP represents the configuration for a TCP receiver.

func (LoggingReceiverTCP) Components 

func (r LoggingReceiverTCP) Components(ctx context.Context, tag string) []fluentbit.Component

func (LoggingReceiverTCP) GetListenPort 

func (r LoggingReceiverTCP) GetListenPort() uint16

func (LoggingReceiverTCP) Type 

func (r LoggingReceiverTCP) Type() string

type LoggingReceiverWindowsEventLog 

type LoggingReceiverWindowsEventLog struct {
	ConfigComponent `yaml:",inline"`

	Channels        []string `yaml:"channels,omitempty,flow" validate:"required,winlogchannels"`
	ReceiverVersion string   `yaml:"receiver_version,omitempty" validate:"omitempty,oneof=1 2" tracking:""`
	RenderAsXML     bool     `yaml:"render_as_xml,omitempty" tracking:""`
}

A LoggingReceiverWindowsEventLog represents the user configuration for a Windows event log receiver.

func (LoggingReceiverWindowsEventLog) Components 

func (r LoggingReceiverWindowsEventLog) Components(ctx context.Context, tag string) []fluentbit.Component

func (LoggingReceiverWindowsEventLog) IsDefaultVersion 

func (r LoggingReceiverWindowsEventLog) IsDefaultVersion() bool

func (LoggingReceiverWindowsEventLog) Pipelines 

func (r LoggingReceiverWindowsEventLog) Pipelines(ctx context.Context) ([]otel.ReceiverPipeline, error)

func (LoggingReceiverWindowsEventLog) Type 

func (r LoggingReceiverWindowsEventLog) Type() string

type LoggingService 

type LoggingService struct {
	Compress    string               `yaml:"compress,omitempty" validate:"omitempty,oneof=gzip,experimental=log_compression"`
	LogLevel    string               `yaml:"log_level,omitempty" validate:"omitempty,oneof=error warn info debug trace"`
	Pipelines   map[string]*Pipeline `validate:"dive,keys,startsnotwith=lib:"`
	OTelLogging bool                 `yaml:"experimental_otel_logging,omitempty" validate:"omitempty,experimental=otel_logging"`
}

type Metrics 

type Metrics struct {
	Receivers  metricsReceiverMap  `yaml:"receivers" validate:"dive,keys,startsnotwith=lib:"`
	Processors metricsProcessorMap `yaml:"processors" validate:"dive,keys,startsnotwith=lib:"`
	// Exporters are deprecated and ignored, so do not have any validation.
	Exporters map[string]interface{} `yaml:"exporters,omitempty"`
	Service   *MetricsService        `yaml:"service"`
}

type MetricsProcessor 

type MetricsProcessor interface {
	OTelProcessor
}

type MetricsProcessorMerger 

type MetricsProcessorMerger interface {
	// MergeMetricsProcessor attempts to merge p into the current receiver.
	// It returns the new receiver; and true if the processor has been merged
	// into the receiver completely
	MergeMetricsProcessor(p MetricsProcessor) (MetricsReceiver, bool)
}

type MetricsReceiver 

type MetricsReceiver interface {
	OTelReceiver
}

type MetricsReceiverShared 

type MetricsReceiverShared struct {
	CollectionInterval string `yaml:"collection_interval" validate:"duration=10s"` // time.Duration format
}

func (MetricsReceiverShared) CollectionIntervalString 

func (m MetricsReceiverShared) CollectionIntervalString() string

type MetricsReceiverSharedCluster 

type MetricsReceiverSharedCluster struct {
	CollectClusterMetrics *bool `yaml:"collect_cluster_metrics" validate:"omitempty"`
}

func (MetricsReceiverSharedCluster) ShouldCollectClusterMetrics 

func (m MetricsReceiverSharedCluster) ShouldCollectClusterMetrics() bool

type MetricsReceiverSharedCollectJVM 

type MetricsReceiverSharedCollectJVM struct {
	CollectJVMMetrics *bool `yaml:"collect_jvm_metrics"`
}

func (MetricsReceiverSharedCollectJVM) ShouldCollectJVMMetrics 

func (m MetricsReceiverSharedCollectJVM) ShouldCollectJVMMetrics() bool

func (MetricsReceiverSharedCollectJVM) TargetSystemString 

func (m MetricsReceiverSharedCollectJVM) TargetSystemString(targetSystem string) string

type MetricsReceiverSharedJVM 

type MetricsReceiverSharedJVM struct {
	MetricsReceiverShared `yaml:",inline"`

	Endpoint       string        `yaml:"endpoint" validate:"omitempty,hostname_port|startswith=service:jmx:"`
	Username       string        `yaml:"username" validate:"required_with=Password"`
	Password       secret.String `yaml:"password" validate:"required_with=Username"`
	AdditionalJars []string      `yaml:"additional_jars" validate:"omitempty,dive,file"`
}

func (MetricsReceiverSharedJVM) ConfigurePipelines 

func (m MetricsReceiverSharedJVM) ConfigurePipelines(targetSystem string, processors []otel.Component) ([]otel.ReceiverPipeline, error)

ConfigurePipelines sets up a Receiver using the MetricsReceiverSharedJVM and the targetSystem. This is used alongside the passed in processors to return a single Pipeline in an array.

func (MetricsReceiverSharedJVM) WithDefaultAdditionalJars 

func (m MetricsReceiverSharedJVM) WithDefaultAdditionalJars(defaultAdditionalJars ...string) MetricsReceiverSharedJVM

WithDefaultAdditionalJars overrides the MetricReceiverSharedJVM's AdditionalJars if it is empty. It then returns a new MetricReceiverSharedJVM with this change.

func (MetricsReceiverSharedJVM) WithDefaultEndpoint 

func (m MetricsReceiverSharedJVM) WithDefaultEndpoint(defaultEndpoint string) MetricsReceiverSharedJVM

WithDefaultEndpoint overrides the MetricReceiverSharedJVM's Endpoint if it is empty. It then returns a new MetricReceiverSharedJVM with this change.

type MetricsReceiverSharedTLS 

type MetricsReceiverSharedTLS struct {
	Insecure           *bool  `yaml:"insecure" validate:"omitempty"`
	InsecureSkipVerify *bool  `yaml:"insecure_skip_verify" validate:"omitempty"`
	CertFile           string `yaml:"cert_file" validate:"required_with=KeyFile"`
	KeyFile            string `yaml:"key_file" validate:"required_with=CertFile"`
	CAFile             string `yaml:"ca_file" validate:"omitempty"`
}

func (MetricsReceiverSharedTLS) TLSConfig 

func (m MetricsReceiverSharedTLS) TLSConfig(defaultInsecure bool) map[string]interface{}

type MetricsService 

type MetricsService struct {
	LogLevel  string               `yaml:"log_level,omitempty" validate:"omitempty,oneof=error warn info debug"`
	Pipelines map[string]*Pipeline `yaml:"pipelines" validate:"dive,keys,startsnotwith=lib:"`
}

type ModifyField 

type ModifyField struct {
	// Source of value for this field
	MoveFrom     string  `yaml:"move_from" validate:"omitempty,field,excluded_with=CopyFrom StaticValue"`
	CopyFrom     string  `yaml:"copy_from" validate:"omitempty,field,excluded_with=MoveFrom StaticValue"`
	StaticValue  *string `yaml:"static_value" validate:"excluded_with=MoveFrom CopyFrom DefaultValue"`
	DefaultValue *string `yaml:"default_value" validate:"excluded_with=StaticValue"`

	// Operations to perform
	Type              string                            `yaml:"type" validate:"omitempty,oneof=integer float"`
	CustomConvertFunc func(ottl.LValue) ottl.Statements `yaml:"-"`
	OmitIf            string                            `yaml:"omit_if" validate:"omitempty,filter"`
	MapValues         map[string]string                 `yaml:"map_values"`
	// In case the source field's value does not match any keys specified in the map_values pairs,
	// the destination field will be forcefully unset if map_values_exclusive is true,
	// or left untouched if map_values_exclusive is false.
	MapValuesExclusive bool `yaml:"map_values_exclusive" validate:"excluded_without=MapValues"`
	// contains filtered or unexported fields
}

type MultilineRule 

type MultilineRule struct {
	StateName string
	Regex     string
	NextState string
}

func (MultilineRule) AsString 

func (r MultilineRule) AsString() string

type OTelProcessor 

type OTelProcessor interface {
	Component
	Processors(context.Context) ([]otel.Component, error)
}

type OTelReceiver 

type OTelReceiver interface {
	Component
	Pipelines(ctx context.Context) ([]otel.ReceiverPipeline, error)
}

type ParseMultiline 

type ParseMultiline struct {
	ConfigComponent `yaml:",inline"`

	// Make this a list so that it's forward compatible to support more `parse_multiline` type other than the build-in language exceptions.
	MultilineGroups []*ParseMultilineGroup `yaml:"match_any" validate:"required,min=1,max=3,unique"`
}

func (ParseMultiline) Components 

func (p ParseMultiline) Components(ctx context.Context, tag, uid string) []fluentbit.Component

func (ParseMultiline) Type 

func (r ParseMultiline) Type() string

type ParseMultilineGroup 

type ParseMultilineGroup struct {
	Type     string `yaml:"type" validate:"required,oneof=language_exceptions"`
	Language string `yaml:"language" validate:"required,oneof=java python go"`
}

TODO: Add a validation check that will allow only one unique language exceptions that focus in one specific language.

type ParserShared 

type ParserShared struct {
	TimeKey    string `yaml:"time_key,omitempty" validate:"required_with=TimeFormat,omitempty,fieldlegacy"` // by default does not parse timestamp
	TimeFormat string `yaml:"time_format,omitempty" validate:"required_with=TimeKey"`                       // must be provided if time_key is present
	// Types allows parsing the extracted fields.
	// Not exposed to users for now, but can be used by app receivers.
	// Documented at https://docs.fluentbit.io/manual/v/1.3/parser
	// According to docs, this is only supported with `ltsv`, `logfmt`, and `regex` parsers.
	Types map[string]string `yaml:"-" validate:"dive,oneof=string integer bool float hex"`
}

ParserShared holds common parameters that are used by all processors that are implemented with fluentbit's "parser" filter.

func (ParserShared) Component 

func (p ParserShared) Component(tag, uid string) (fluentbit.Component, string)

func (ParserShared) FluentBitSpecialFieldsStatements 

func (p ParserShared) FluentBitSpecialFieldsStatements(ctx context.Context) ottl.Statements

Handle special fields documented at https://cloud.google.com/stackdriver/docs/solutions/agents/ops-agent/configuration#special-fields

func (ParserShared) TimestampStatements 

func (p ParserShared) TimestampStatements() (ottl.Statements, error)

func (ParserShared) TypesStatements 

func (p ParserShared) TypesStatements() (ottl.Statements, error)

type Pipeline 

type Pipeline struct {
	ReceiverIDs  []string `yaml:"receivers,omitempty,flow"`
	ProcessorIDs []string `yaml:"processors,omitempty,flow"`
	// ExporterIDs is deprecated and ignored.
	ExporterIDs []string `yaml:"exporters,omitempty,flow"`
}

type PrometheusMetrics 

type PrometheusMetrics struct {
	ConfigComponent `yaml:",inline"`

	// Note that since we use the OTel Prometheus receiver, there is a caveat in the regex
	// capture group syntax. Since the collector configuration supports env variable substitution
	// `$` characters in your prometheus configuration are interpreted as environment
	// variables.  If you want to use $ characters in your prometheus configuration,
	// you must escape them using `$$`.
	PromConfig promconfig.Config `yaml:"config"`
}

func (PrometheusMetrics) ExtractFeatures 

func (r PrometheusMetrics) ExtractFeatures() ([]CustomFeature, error)

ExtractFeatures returns a list of features that are enabled in the receiver config. Must always be a subset of ListAllFeatures().

func (PrometheusMetrics) ListAllFeatures 

func (r PrometheusMetrics) ListAllFeatures() []string

ListAllFeatures returns a list of all features that the receiver supports that we track.

func (PrometheusMetrics) Pipelines 

func (r PrometheusMetrics) Pipelines(ctx context.Context) ([]otel.ReceiverPipeline, error)

func (PrometheusMetrics) Type 

func (r PrometheusMetrics) Type() string

type RegexParser 

type RegexParser struct {
	Regex  string
	Parser ParserShared
}

type Traces 

type Traces struct {
	Service *TracesService `yaml:"service"`
}

type TracesReceiver 

type TracesReceiver interface {
	// TODO: Distinguish from metrics somehow?
	OTelReceiver
}

type TracesService 

type TracesService struct {
	Pipelines map[string]*Pipeline
}

type TrackingOverrideMapError 

type TrackingOverrideMapError struct {
	FieldName string
}

func (*TrackingOverrideMapError) Error 

func (e *TrackingOverrideMapError) Error() string

type UnifiedConfig 

type UnifiedConfig struct {
	Combined *Combined `yaml:"combined,omitempty"`
	Logging  *Logging  `yaml:"logging"`
	Metrics  *Metrics  `yaml:"metrics"`
	// FIXME: OTel uses metrics/logs/traces but we appear to be using metrics/logging/traces
	Traces *Traces `yaml:"traces,omitempty"`
	Global *Global `yaml:"global,omitempty"`
}

Ops Agent config.

func MergeConfFiles 

func MergeConfFiles(ctx context.Context, userConfPath string, builtInConfStructs map[string]*UnifiedConfig) (*UnifiedConfig, error)

MergeConfFiles merges the user provided config with the built-in config struct for the platform.

func ReadUnifiedConfigFromFile 

func ReadUnifiedConfigFromFile(ctx context.Context, path string) (*UnifiedConfig, error)

ReadUnifiedConfigFromFile reads the user config file and returns a UnifiedConfig. If the user config file does not exist, it returns nil.

func UnmarshalYamlToUnifiedConfig 

func UnmarshalYamlToUnifiedConfig(ctx context.Context, input []byte) (*UnifiedConfig, error)

func (*UnifiedConfig) DeepCopy 

func (uc *UnifiedConfig) DeepCopy(ctx context.Context) (*UnifiedConfig, error)

func (*UnifiedConfig) GenerateFilesFromConfig 

func (uc *UnifiedConfig) GenerateFilesFromConfig(ctx context.Context, service, logsDir, stateDir, outDir string) error

func (*UnifiedConfig) GenerateFluentBitConfigs 

func (uc *UnifiedConfig) GenerateFluentBitConfigs(ctx context.Context, logsDir string, stateDir string) (map[string]string, error)

GenerateFluentBitConfigs generates configuration file(s) for Fluent Bit. It returns a map of filenames to file contents.

func (*UnifiedConfig) GenerateOtelConfig 

func (uc *UnifiedConfig) GenerateOtelConfig(ctx context.Context) (string, error)

func (*UnifiedConfig) HasCombined 

func (uc *UnifiedConfig) HasCombined() bool

func (*UnifiedConfig) HasLogging 

func (uc *UnifiedConfig) HasLogging() bool

func (*UnifiedConfig) HasMetrics 

func (uc *UnifiedConfig) HasMetrics() bool

func (*UnifiedConfig) LoggingReceivers 

func (uc *UnifiedConfig) LoggingReceivers(ctx context.Context) (map[string]Component, error)

LoggingReceivers returns a map of potential logging receivers. Each Component may or may not be usable in fluent-bit or otel.

func (*UnifiedConfig) MetricsReceivers 

func (uc *UnifiedConfig) MetricsReceivers() (map[string]MetricsReceiver, error)

func (*UnifiedConfig) OTelLoggingReceivers 

func (uc *UnifiedConfig) OTelLoggingReceivers(ctx context.Context) (map[string]OTelReceiver, error)

func (*UnifiedConfig) Pipelines 

func (uc *UnifiedConfig) Pipelines(ctx context.Context) ([]pipelineInstance, error)

func (*UnifiedConfig) String 

func (uc *UnifiedConfig) String() string

func (*UnifiedConfig) TracesReceivers 

func (uc *UnifiedConfig) TracesReceivers() (map[string]TracesReceiver, error)

func (*UnifiedConfig) Validate 

func (uc *UnifiedConfig) Validate(ctx context.Context) error

func (*UnifiedConfig) ValidateCombined 

func (uc *UnifiedConfig) ValidateCombined() error

func (*UnifiedConfig) ValidateLogging 

func (uc *UnifiedConfig) ValidateLogging() error

func (*UnifiedConfig) ValidateMetrics 

func (uc *UnifiedConfig) ValidateMetrics(ctx context.Context) error

func (*UnifiedConfig) ValidateTraces 

func (uc *UnifiedConfig) ValidateTraces() error

type VersionedReceivers 

type VersionedReceivers struct {
	ReceiverVersion string `yaml:"receiver_version,omitempty" tracking:""`
}

Source Files

View all Source files

Directories

Path Synopsis
internal/ast
internal/generated/errors
internal/generated/lexer
internal/generated/parser
internal/generated/token
internal/generated/util
Package fluentbit provides data structures to represent and generate fluentBit configuration.
 Package fluentbit provides data structures to represent and generate fluentBit configuration.
modify
Package modify provides helpers for generating fluentbit configs
 Package modify provides helpers for generating fluentbit configs
Package otel provides data structures to represent and generate otel configuration.
 Package otel provides data structures to represent and generate otel configuration.
ottl

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.