confgenerator

type AgentSelfMetrics struct {
	MetricsVersionLabel string
	LoggingVersionLabel string
	FluentBitPort       int
	OtelPort            int
	OtelRuntimeDir      string
	OtelLogging         bool
}

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

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

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

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

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 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
}

type CustomProcessorValidator interface {
	AllowCustomProcessors() bool
}

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
}

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

type InternalLoggingProcessor interface {
	// 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 InternalLoggingProcessorMerger interface {
	// MergeInternalLoggingProcessor attempts to merge p into the current receiver.
	// It returns the new receiver; and a potentially modified processor or nil.
	MergeInternalLoggingProcessor(p InternalLoggingProcessor) (InternalLoggingReceiver, InternalLoggingProcessor)
}

type InternalLoggingReceiver interface {
	// Components returns fluentbit components that implement this receiver.
	// tag is the log tag that is assigned to the collected logs.
	Components(ctx context.Context, tag string) []fluentbit.Component
}

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

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

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"`
}

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 interface {
	LoggingReceiver
	GetListenPort() uint16
}

type LoggingProcessor interface {
	Component
	InternalLoggingProcessor
}

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

type LoggingProcessorMacro interface {
	Type() string
	// Expand returns a slice of logging processors that implement this processor. This is an intermediate step for processors that can be implemented in a subagent-agnostic way.
	Expand(ctx context.Context) []InternalLoggingProcessor
}

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:"-"`
}

type LoggingProcessorNestWildcard struct {
	Wildcard     string
	NestUnder    string
	RemovePrefix string
}

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

type LoggingProcessorParseMultilineRegex struct {
	LoggingProcessorParseRegexComplex
	Rules []MultilineRule
}

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"`
}

type LoggingProcessorParseRegexComplex struct {
	Field   string
	Parsers []RegexParser
}

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

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

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

type LoggingReceiver interface {
	Component
	InternalLoggingReceiver
}

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"`
}

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"`
	// In transformation test mode, the file is read exactly once from the beginning, and then the process exits.
	TransformationTest bool `yaml:"-" tracking:"-"`
}

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

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

type LoggingReceiverMacro interface {
	Type() string
	// Expand returns a receiver and slice of logging processors that implement this receivers. This is an intermediate step for receivers that can be implemented in a subagent-agnostic way.
	Expand(ctx context.Context) (InternalLoggingReceiver, []InternalLoggingProcessor)
}

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"`
}

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

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"`
}

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:""`
}

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 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 interface {
	OTelProcessor
}

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 interface {
	OTelReceiver
}

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

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

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

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"`
}

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"`
}

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 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 = fluentbit.MultilineRule

type OTelProcessor interface {
	Component
	InternalOTelProcessor
}

type OTelReceiver interface {
	Component
	InternalOTelReceiver
}

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"`
}

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

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"`
}

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 PipelineInstance struct {
	PID, RID     string
	PipelineType string
	Receiver     Component
	Processors   []struct {
		ID string
		Component
	}
	Backend pipelineBackend
}

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"`
}

type RegexParser struct {
	Regex  string
	Parser ParserShared
}

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

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

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

type TrackingOverrideMapError struct {
	FieldName string
}

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"`
}

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