otelcol

type AttrActionKeyValue struct {
	// Key specifies the attribute to act upon.
	// This is a required field.
	Key string `river:"key,attr"`

	// Value specifies the value to populate for the key.
	// The type of the value is inferred from the configuration.
	Value interface{} `river:"value,attr,optional"`

	// A regex pattern  must be specified for the action EXTRACT.
	// It uses the attribute specified by `key' to extract values from
	// The target keys are inferred based on the names of the matcher groups
	// provided and the names will be inferred based on the values of the
	// matcher group.
	// Note: All subexpressions must have a name.
	// Note: The value type of the source key must be a string. If it isn't,
	// no extraction will occur.
	RegexPattern string `river:"pattern,attr,optional"`

	// FromAttribute specifies the attribute to use to populate
	// the value. If the attribute doesn't exist, no action is performed.
	FromAttribute string `river:"from_attribute,attr,optional"`

	// FromContext specifies the context value to use to populate
	// the value. The values would be searched in client.Info.Metadata.
	// If the key doesn't exist, no action is performed.
	// If the key has multiple values the values will be joined with `;` separator.
	FromContext string `river:"from_context,attr,optional"`

	// ConvertedType specifies the target type of an attribute to be converted
	// If the key doesn't exist, no action is performed.
	// If the value cannot be converted, the original value will be left as-is
	ConvertedType string `river:"converted_type,attr,optional"`

	// Action specifies the type of action to perform.
	// The set of values are {INSERT, UPDATE, UPSERT, DELETE, HASH}.
	// Both lower case and upper case are supported.
	// INSERT -  Inserts the key/value to attributes when the key does not exist.
	//           No action is applied to attributes where the key already exists.
	//           Either Value, FromAttribute or FromContext must be set.
	// UPDATE -  Updates an existing key with a value. No action is applied
	//           to attributes where the key does not exist.
	//           Either Value, FromAttribute or FromContext must be set.
	// UPSERT -  Performs insert or update action depending on the attributes
	//           containing the key. The key/value is inserted to attributes
	//           that did not originally have the key. The key/value is updated
	//           for attributes where the key already existed.
	//           Either Value, FromAttribute or FromContext must be set.
	// DELETE  - Deletes the attribute. If the key doesn't exist,
	//           no action is performed.
	// HASH    - Calculates the SHA-1 hash of an existing value and overwrites the
	//           value with it's SHA-1 hash result.
	// EXTRACT - Extracts values using a regular expression rule from the input
	//           'key' to target keys specified in the 'rule'. If a target key
	//           already exists, it will be overridden.
	// CONVERT  - converts the type of an existing attribute, if convertable
	// This is a required field.
	Action string `river:"action,attr"`
}

type AttrActionKeyValueSlice []AttrActionKeyValue

type Attribute struct {
	// Key specifies the attribute key.
	Key string `river:"key,attr"`

	// Values specifies the value to match against.
	// If it is not set, any value will match.
	Value interface{} `river:"value,attr,optional"`
}

type CORSArguments struct {
	AllowedOrigins []string `river:"allowed_origins,attr,optional"`
	AllowedHeaders []string `river:"allowed_headers,attr,optional"`

	MaxAge int `river:"max_age,attr,optional"`
}

type CompressionType string

type Consumer interface {
	otelconsumer.Traces
	otelconsumer.Metrics
	otelconsumer.Logs
}

type ConsumerArguments struct {
	Metrics []Consumer `river:"metrics,attr,optional"`
	Logs    []Consumer `river:"logs,attr,optional"`
	Traces  []Consumer `river:"traces,attr,optional"`
}

type ConsumerExports struct {
	Input Consumer `river:"input,attr"`
}

type DebugMetricsArguments struct {
	DisableHighCardinalityMetrics bool `river:"disable_high_cardinality_metrics,attr,optional"`
}

type GRPCClientArguments struct {
	Endpoint string `river:"endpoint,attr"`

	Compression CompressionType `river:"compression,attr,optional"`

	TLS       TLSClientArguments        `river:"tls,block,optional"`
	Keepalive *KeepaliveClientArguments `river:"keepalive,block,optional"`

	ReadBufferSize  units.Base2Bytes  `river:"read_buffer_size,attr,optional"`
	WriteBufferSize units.Base2Bytes  `river:"write_buffer_size,attr,optional"`
	WaitForReady    bool              `river:"wait_for_ready,attr,optional"`
	Headers         map[string]string `river:"headers,attr,optional"`
	BalancerName    string            `river:"balancer_name,attr,optional"`
	Authority       string            `river:"authority,attr,optional"`

	// Auth is a binding to an otelcol.auth.* component extension which handles
	// authentication.
	Auth *auth.Handler `river:"auth,attr,optional"`
}

type GRPCServerArguments struct {
	Endpoint  string `river:"endpoint,attr,optional"`
	Transport string `river:"transport,attr,optional"`

	TLS *TLSServerArguments `river:"tls,block,optional"`

	MaxRecvMsgSize       units.Base2Bytes `river:"max_recv_msg_size,attr,optional"`
	MaxConcurrentStreams uint32           `river:"max_concurrent_streams,attr,optional"`
	ReadBufferSize       units.Base2Bytes `river:"read_buffer_size,attr,optional"`
	WriteBufferSize      units.Base2Bytes `river:"write_buffer_size,attr,optional"`

	Keepalive *KeepaliveServerArguments `river:"keepalive,block,optional"`

	IncludeMetadata bool `river:"include_metadata,attr,optional"`
}

type HTTPClientArguments struct {
	Endpoint string `river:"endpoint,attr"`

	Compression CompressionType `river:"compression,attr,optional"`

	TLS TLSClientArguments `river:"tls,block,optional"`

	ReadBufferSize  units.Base2Bytes  `river:"read_buffer_size,attr,optional"`
	WriteBufferSize units.Base2Bytes  `river:"write_buffer_size,attr,optional"`
	Timeout         time.Duration     `river:"timeout,attr,optional"`
	Headers         map[string]string `river:"headers,attr,optional"`
	// CustomRoundTripper  func(next http.RoundTripper) (http.RoundTripper, error) TODO (@tpaschalis)
	MaxIdleConns        *int           `river:"max_idle_conns,attr,optional"`
	MaxIdleConnsPerHost *int           `river:"max_idle_conns_per_host,attr,optional"`
	MaxConnsPerHost     *int           `river:"max_conns_per_host,attr,optional"`
	IdleConnTimeout     *time.Duration `river:"idle_conn_timeout,attr,optional"`
	DisableKeepAlives   bool           `river:"disable_keep_alives,attr,optional"`

	// Auth is a binding to an otelcol.auth.* component extension which handles
	// authentication.
	Auth *auth.Handler `river:"auth,attr,optional"`
}

type HTTPServerArguments struct {
	Endpoint string `river:"endpoint,attr,optional"`

	TLS *TLSServerArguments `river:"tls,block,optional"`

	CORS *CORSArguments `river:"cors,block,optional"`

	MaxRequestBodySize units.Base2Bytes `river:"max_request_body_size,attr,optional"`
	IncludeMetadata    bool             `river:"include_metadata,attr,optional"`
}

type InstrumentationLibrary struct {
	Name string `river:"name,attr"`
	// version match
	//  expected actual  match
	//  nil      <blank> yes
	//  nil      1       yes
	//  <blank>  <blank> yes
	//  <blank>  1       no
	//  1        <blank> no
	//  1        1       yes
	Version *string `river:"version,attr,optional"`
}

type KeepaliveClientArguments struct {
	PingWait            time.Duration `river:"ping_wait,attr,optional"`
	PingResponseTimeout time.Duration `river:"ping_response_timeout,attr,optional"`
	PingWithoutStream   bool          `river:"ping_without_stream,attr,optional"`
}

type KeepaliveEnforcementPolicy struct {
	MinTime             time.Duration `river:"min_time,attr,optional"`
	PermitWithoutStream bool          `river:"permit_without_stream,attr,optional"`
}

type KeepaliveServerArguments struct {
	ServerParameters  *KeepaliveServerParamaters  `river:"server_parameters,block,optional"`
	EnforcementPolicy *KeepaliveEnforcementPolicy `river:"enforcement_policy,block,optional"`
}

type KeepaliveServerParamaters struct {
	MaxConnectionIdle     time.Duration `river:"max_connection_idle,attr,optional"`
	MaxConnectionAge      time.Duration `river:"max_connection_age,attr,optional"`
	MaxConnectionAgeGrace time.Duration `river:"max_connection_age_grace,attr,optional"`
	Time                  time.Duration `river:"time,attr,optional"`
	Timeout               time.Duration `river:"timeout,attr,optional"`
}

type LogSeverityNumberMatchProperties struct {
	// Min is the lowest severity that may be matched.
	// e.g. if this is plog.SeverityNumberInfo, INFO, WARN, ERROR, and FATAL logs will match.
	Min SeverityLevel `river:"min,attr"`

	// MatchUndefined controls whether logs with "undefined" severity matches.
	// If this is true, entries with undefined severity will match.
	MatchUndefined bool `river:"match_undefined,attr"`
}

type MatchConfig struct {
	Include *MatchProperties `river:"include,block,optional"`
	Exclude *MatchProperties `river:"exclude,block,optional"`
}

type MatchProperties struct {
	MatchType    string        `river:"match_type,attr"`
	RegexpConfig *RegexpConfig `river:"regexp,block,optional"`

	// Services specify the list of items to match service name against.
	// A match occurs if the span's service name matches at least one item in this list.
	Services []string `river:"services,attr,optional"`

	// SpanNames specify the list of items to match span name against.
	// A match occurs if the span name matches at least one item in this list.
	SpanNames []string `river:"span_names,attr,optional"`

	// LogBodies is a list of strings that the LogRecord's body field must match against.
	LogBodies []string `river:"log_bodies,attr,optional"`

	// LogSeverityTexts is a list of strings that the LogRecord's severity text field must match against.
	LogSeverityTexts []string `river:"log_severity_texts,attr,optional"`

	// LogSeverity defines how to match against a log record's SeverityNumber, if defined.
	LogSeverity *LogSeverityNumberMatchProperties `river:"log_severity,block,optional"`

	// MetricNames is a list of strings to match metric name against.
	// A match occurs if metric name matches at least one item in the list.
	MetricNames []string `river:"metric_names,attr,optional"`

	// Attributes specifies the list of attributes to match against.
	// All of these attributes must match exactly for a match to occur.
	// Only match_type=strict is allowed if "attributes" are specified.
	Attributes []Attribute `river:"attribute,block,optional"`

	// Resources specify the list of items to match the resources against.
	// A match occurs if the data's resources match at least one item in this list.
	Resources []Attribute `river:"resource,block,optional"`

	// Libraries specify the list of items to match the implementation library against.
	// A match occurs if the span's implementation library matches at least one item in this list.
	Libraries []InstrumentationLibrary `river:"library,block,optional"`

	// SpanKinds specify the list of items to match the span kind against.
	// A match occurs if the span's span kind matches at least one item in this list.
	SpanKinds []string `river:"span_kinds,attr,optional"`
}

type QueueArguments struct {
	Enabled      bool `river:"enabled,attr,optional"`
	NumConsumers int  `river:"num_consumers,attr,optional"`
	QueueSize    int  `river:"queue_size,attr,optional"`
}

type RegexpConfig struct {
	// CacheEnabled determines whether match results are LRU cached to make subsequent matches faster.
	// Cache size is unlimited unless CacheMaxNumEntries is also specified.
	CacheEnabled bool `river:"cache_enabled,attr,optional"`
	// CacheMaxNumEntries is the max number of entries of the LRU cache that stores match results.
	// CacheMaxNumEntries is ignored if CacheEnabled is false.
	CacheMaxNumEntries int `river:"cache_max_num_entries,attr,optional"`
}

type RetryArguments struct {
	Enabled             bool          `river:"enabled,attr,optional"`
	InitialInterval     time.Duration `river:"initial_interval,attr,optional"`
	RandomizationFactor float64       `river:"randomization_factor,attr,optional"`
	Multiplier          float64       `river:"multiplier,attr,optional"`
	MaxInterval         time.Duration `river:"max_interval,attr,optional"`
	MaxElapsedTime      time.Duration `river:"max_elapsed_time,attr,optional"`
}

type ScraperControllerArguments struct {
	CollectionInterval time.Duration `river:"collection_interval,attr,optional"`
	InitialDelay       time.Duration `river:"initial_delay,attr,optional"`
	Timeout            time.Duration `river:"timeout,attr,optional"`
}

type SeverityLevel string

type TLSClientArguments struct {
	TLSSetting TLSSetting `river:",squash"`

	Insecure           bool   `river:"insecure,attr,optional"`
	InsecureSkipVerify bool   `river:"insecure_skip_verify,attr,optional"`
	ServerName         string `river:"server_name,attr,optional"`
}

type TLSServerArguments struct {
	TLSSetting TLSSetting `river:",squash"`

	ClientCAFile string `river:"client_ca_file,attr,optional"`
}

type TLSSetting struct {
	CA             string            `river:"ca_pem,attr,optional"`
	CAFile         string            `river:"ca_file,attr,optional"`
	Cert           string            `river:"cert_pem,attr,optional"`
	CertFile       string            `river:"cert_file,attr,optional"`
	Key            rivertypes.Secret `river:"key_pem,attr,optional"`
	KeyFile        string            `river:"key_file,attr,optional"`
	MinVersion     string            `river:"min_version,attr,optional"`
	MaxVersion     string            `river:"max_version,attr,optional"`
	ReloadInterval time.Duration     `river:"reload_interval,attr,optional"`
}