otelcol

package
v1.1.1 Latest Latest
Warning

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

 Go to latest Published: May 30, 2024 License: Apache-2.0 Imports: 23 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	KubernetesAPIConfig_AuthType_None           = "none"
	KubernetesAPIConfig_AuthType_ServiceAccount = "serviceAccount"
	KubernetesAPIConfig_AuthType_KubeConfig     = "kubeConfig"
	KubernetesAPIConfig_AuthType_TLS            = "tls"
)
View Source 
const DefaultBalancerName = "pick_first"

Variables

View Source 
var DefaultScraperControllerArguments = ScraperControllerArguments{
	CollectionInterval: time.Minute,
	InitialDelay:       time.Second,
	Timeout:            0 * time.Second,
}

DefaultScraperControllerArguments holds default settings for ScraperControllerArguments.

View Source 
var DefaultTimeout = 5 * time.Second

DefaultTimeout holds the default timeout used for components which can time out from requests.

Functions

This section is empty.

Types

type AttrActionKeyValue 

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

	// Value specifies the value to populate for the key.
	// The type of the value is inferred from the configuration.
	Value interface{} `alloy:"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 `alloy:"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 `alloy:"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 `alloy:"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 `alloy:"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 `alloy:"action,attr"`
}

type AttrActionKeyValueSlice 

type AttrActionKeyValueSlice []AttrActionKeyValue

func (AttrActionKeyValueSlice) Convert 

func (actions AttrActionKeyValueSlice) Convert() []interface{}

type Attribute 

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

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

Attribute specifies the attribute key and optional value to match against.

type CORSArguments 

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

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

CORSArguments holds shared CORS settings for components which launch HTTP servers.

func (*CORSArguments) Convert 

func (args *CORSArguments) Convert() *otelconfighttp.CORSConfig

Convert converts args into the upstream type.

type CompressionType 

type CompressionType string

CompressionType represents a mechanism used to compress data. 

const (
	CompressionTypeGzip    CompressionType = "gzip"
	CompressionTypeZlib    CompressionType = "zlib"
	CompressionTypeDeflate CompressionType = "deflate"
	CompressionTypeSnappy  CompressionType = "snappy"
	CompressionTypeZstd    CompressionType = "zstd"
	CompressionTypeNone    CompressionType = "none"
	CompressionTypeEmpty   CompressionType = ""
)

Supported values for compression

func (CompressionType) Convert 

func (ct CompressionType) Convert() configcompression.Type

Convert converts ct into the upstream type.

func (*CompressionType) UnmarshalText 

func (ct *CompressionType) UnmarshalText(in []byte) error

UnmarshalText converts a string into a CompressionType. Returns an error if the string is invalid.

type Consumer 

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

Consumer is a combined OpenTelemetry Collector consumer which can consume any telemetry signal.

type ConsumerArguments 

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

ConsumerArguments is a common Arguments type for Alloy components which can send data to otelcol consumers.

It is expected to use ConsumerArguments as a block within the top-level arguments block for a component.

type ConsumerExports 

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

ConsumerExports is a common Exports type for Alloy components which are otelcol processors or otelcol exporters.

type ControllerArguments added in v1.1.0 

type ControllerArguments struct {
	// CollectionInterval sets how frequently the scraper should be called and
	// used as the context timeout to ensure that scrapers don't exceed the
	// interval.
	CollectionInterval time.Duration `alloy:"collection_interval,attr,optional"`
	// InitialDelay sets the initial start delay for the scraper, any non
	// positive value is assumed to be immediately.
	InitialDelay time.Duration `alloy:"initial_delay,attr,optional"`
	// Timeout is an optional value used to set scraper's context deadline.
	Timeout time.Duration `alloy:"timeout,attr,optional"`
}

ControllerArguments defines common settings for a scraper controller configuration. Scraper controller receivers can squash this struct, instead of receiver.Settings, and extend it with more fields if needed.

func (*ControllerArguments) Convert added in v1.1.0 

func (args *ControllerArguments) Convert() *scraperhelper.ControllerConfig

Convert converts args to the upstream type.

func (*ControllerArguments) SetToDefault added in v1.1.0 

func (args *ControllerArguments) SetToDefault()

SetToDefault implements syntax.Defaulter.

func (*ControllerArguments) Validate added in v1.1.0 

func (args *ControllerArguments) Validate() error

Validate implements syntax.Validator.

type DebugMetricsArguments 

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

DebugMetricsArguments configures internal metrics of the components

func (*DebugMetricsArguments) SetToDefault 

func (args *DebugMetricsArguments) SetToDefault()

SetToDefault implements syntax.Defaulter.

type GRPCClientArguments 

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

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

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

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

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

GRPCClientArguments holds shared gRPC settings for components which launch gRPC clients. NOTE: When changing this structure, note that similar structures such as loadbalancing.GRPCClientArguments may also need to be changed.

func (*GRPCClientArguments) Convert 

func (args *GRPCClientArguments) Convert() *otelconfiggrpc.ClientConfig

Convert converts args into the upstream type.

func (*GRPCClientArguments) Extensions 

func (args *GRPCClientArguments) Extensions() map[otelcomponent.ID]otelextension.Extension

Extensions exposes extensions used by args.

type GRPCServerArguments 

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

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

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

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

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

GRPCServerArguments holds shared gRPC settings for components which launch gRPC servers.

func (*GRPCServerArguments) Convert 

func (args *GRPCServerArguments) Convert() *otelconfiggrpc.ServerConfig

Convert converts args into the upstream type.

type HTTPClientArguments 

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

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

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

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

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

HTTPClientArguments holds shared HTTP settings for components which launch HTTP clients.

func (*HTTPClientArguments) Convert 

func (args *HTTPClientArguments) Convert() *otelconfighttp.ClientConfig

Convert converts args into the upstream type.

func (*HTTPClientArguments) Extensions 

func (args *HTTPClientArguments) Extensions() map[otelcomponent.ID]otelextension.Extension

Extensions exposes extensions used by args.

type HTTPServerArguments 

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

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

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

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

HTTPServerArguments holds shared settings for components which launch HTTP servers.

func (*HTTPServerArguments) Convert 

func (args *HTTPServerArguments) Convert() *otelconfighttp.ServerConfig

Convert converts args into the upstream type.

type InstrumentationLibrary 

type InstrumentationLibrary struct {
	Name string `alloy:"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 `alloy:"version,attr,optional"`
}

InstrumentationLibrary specifies the instrumentation library and optional version to match against.

type KeepaliveClientArguments 

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

KeepaliveClientArguments holds shared keepalive settings for components which launch clients.

func (*KeepaliveClientArguments) Convert 

func (args *KeepaliveClientArguments) Convert() *otelconfiggrpc.KeepaliveClientConfig

Convert converts args into the upstream type.

type KeepaliveEnforcementPolicy 

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

KeepaliveEnforcementPolicy holds shared keepalive settings for components which launch servers.

func (*KeepaliveEnforcementPolicy) Convert 

func (args *KeepaliveEnforcementPolicy) Convert() *otelconfiggrpc.KeepaliveEnforcementPolicy

Convert converts args into the upstream type.

type KeepaliveServerArguments 

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

KeepaliveServerArguments holds shared keepalive settings for components which launch servers.

func (*KeepaliveServerArguments) Convert 

func (args *KeepaliveServerArguments) Convert() *otelconfiggrpc.KeepaliveServerConfig

Convert converts args into the upstream type.

type KeepaliveServerParamaters 

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

KeepaliveServerParamaters holds shared keepalive settings for components which launch servers.

func (*KeepaliveServerParamaters) Convert 

func (args *KeepaliveServerParamaters) Convert() *otelconfiggrpc.KeepaliveServerParameters

Convert converts args into the upstream type.

type KubernetesAPIConfig 

type KubernetesAPIConfig struct {
	// How to authenticate to the K8s API server.  This can be one of `none`
	// (for no auth), `serviceAccount` (to use the standard service account
	// token provided to the Alloy pod), or `kubeConfig` to use credentials
	// from `~/.kube/config`.
	AuthType string `alloy:"auth_type,attr,optional"`

	// When using auth_type `kubeConfig`, override the current context.
	Context string `alloy:"context,attr,optional"`
}

KubernetesAPIConfig contains options relevant to connecting to the K8s API

func (*KubernetesAPIConfig) Validate 

func (c *KubernetesAPIConfig) Validate() error

Validate returns an error if the config is invalid.

type LogSeverityNumberMatchProperties 

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 `alloy:"min,attr"`

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

LogSeverityNumberMatchProperties defines how to match based on a log record's SeverityNumber field.

type MatchConfig 

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

MatchConfig has two optional MatchProperties:

  1. 'include': to define what is processed by the processor.
  2. 'exclude': to define what is excluded from the processor.

If both 'include' and 'exclude' are specified, the 'include' properties are checked before the 'exclude' properties.

type MatchProperties 

type MatchProperties struct {
	MatchType    string        `alloy:"match_type,attr"`
	RegexpConfig *RegexpConfig `alloy:"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 `alloy:"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 `alloy:"span_names,attr,optional"`

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

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

	// LogSeverity defines how to match against a log record's SeverityNumber, if defined.
	LogSeverity *LogSeverityNumberMatchProperties `alloy:"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 `alloy:"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 `alloy:"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 `alloy:"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 `alloy:"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 `alloy:"span_kinds,attr,optional"`
}

MatchProperties specifies the set of properties in a spans/log/metric to match against and if the input data should be included or excluded from the processor.

func (*MatchProperties) Convert 

func (args *MatchProperties) Convert() (map[string]interface{}, error)

Convert converts args into the upstream type.

type QueueArguments 

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

QueueArguments holds shared settings for components which can queue requests.

func (*QueueArguments) Convert 

func (args *QueueArguments) Convert() *otelexporterhelper.QueueSettings

Convert converts args into the upstream type.

func (*QueueArguments) SetToDefault 

func (args *QueueArguments) SetToDefault()

SetToDefault implements syntax.Defaulter.

func (*QueueArguments) Validate 

func (args *QueueArguments) Validate() error

Validate returns an error if args is invalid.

type RegexpConfig 

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 `alloy:"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 `alloy:"cache_max_num_entries,attr,optional"`
}

type RetryArguments 

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

RetryArguments holds shared settings for components which can retry requests.

func (*RetryArguments) Convert 

func (args *RetryArguments) Convert() *configretry.BackOffConfig

Convert converts args into the upstream type.

func (*RetryArguments) SetToDefault 

func (args *RetryArguments) SetToDefault()

SetToDefault implements syntax.Defaulter.

func (*RetryArguments) Validate 

func (args *RetryArguments) Validate() error

Validate returns an error if args is invalid.

type ScraperControllerArguments 

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

ScraperControllerArguments defines common settings for a scraper controller configuration.

func (*ScraperControllerArguments) Convert 

func (args *ScraperControllerArguments) Convert() *scraperhelper.ControllerConfig

Convert converts args into the upstream type.

func (*ScraperControllerArguments) SetToDefault 

func (args *ScraperControllerArguments) SetToDefault()

SetToDefault implements syntax.Defaulter.

func (*ScraperControllerArguments) Validate 

func (args *ScraperControllerArguments) Validate() error

Validate returns an error if args is invalid.

type SeverityLevel 

type SeverityLevel string

func LookupSeverityNumber 

func LookupSeverityNumber(num plog.SeverityNumber) (SeverityLevel, error)

func (*SeverityLevel) UnmarshalText 

func (sl *SeverityLevel) UnmarshalText(text []byte) error

UnmarshalText implements encoding.TextUnmarshaler for SeverityLevel.

type TLSClientArguments 

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

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

TLSClientArguments holds shared TLS settings for components which launch TLS clients.

func (*TLSClientArguments) Convert 

func (args *TLSClientArguments) Convert() *otelconfigtls.ClientConfig

Convert converts args into the upstream type.

type TLSServerArguments 

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

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

TLSServerArguments holds shared TLS settings for components which launch servers with TLS.

func (*TLSServerArguments) Convert 

func (args *TLSServerArguments) Convert() *otelconfigtls.ServerConfig

Convert converts args into the upstream type.

type TLSSetting 

type TLSSetting struct {
	CA                       string            `alloy:"ca_pem,attr,optional"`
	CAFile                   string            `alloy:"ca_file,attr,optional"`
	Cert                     string            `alloy:"cert_pem,attr,optional"`
	CertFile                 string            `alloy:"cert_file,attr,optional"`
	Key                      alloytypes.Secret `alloy:"key_pem,attr,optional"`
	KeyFile                  string            `alloy:"key_file,attr,optional"`
	MinVersion               string            `alloy:"min_version,attr,optional"`
	MaxVersion               string            `alloy:"max_version,attr,optional"`
	ReloadInterval           time.Duration     `alloy:"reload_interval,attr,optional"`
	CipherSuites             []string          `alloy:"cipher_suites,attr,optional"`
	IncludeSystemCACertsPool bool              `alloy:"include_system_ca_certs_pool,attr,optional"`
}

func (*TLSSetting) Convert 

func (args *TLSSetting) Convert() *otelconfigtls.Config

func (*TLSSetting) Validate 

func (t *TLSSetting) Validate() error

Validate implements syntax.Validator.

Source Files

View all Source files

Directories

Path Synopsis
Package auth provides utilities to create an Alloy component from OpenTelemetry Collector authentication extensions.
 Package auth provides utilities to create an Alloy component from OpenTelemetry Collector authentication extensions.
basic
Package basic provides an otelcol.auth.basic component.
 Package basic provides an otelcol.auth.basic component.
bearer
Package bearer provides an otelcol.auth.bearer component.
 Package bearer provides an otelcol.auth.bearer component.
headers
Package headers provides an otelcol.auth.headers component.
 Package headers provides an otelcol.auth.headers component.
oauth2
sigv4
Package connector exposes utilities to create an Alloy component from OpenTelemetry Collector connectors.
 Package connector exposes utilities to create an Alloy component from OpenTelemetry Collector connectors.
host_info
Package host_info provides an otelcol.connector.host_info component.
 Package host_info provides an otelcol.connector.host_info component.
servicegraph
spanlogs
Package spanlogs provides an otelcol.connector.spanlogs component.
 Package spanlogs provides an otelcol.connector.spanlogs component.
spanmetrics
Package spanmetrics provides an otelcol.connector.spanmetrics component.
 Package spanmetrics provides an otelcol.connector.spanmetrics component.
Package exporter exposes utilities to create an Alloy component from OpenTelemetry Collector exporters.
 Package exporter exposes utilities to create an Alloy component from OpenTelemetry Collector exporters.
loadbalancing
Package loadbalancing provides an otelcol.exporter.loadbalancing component.
 Package loadbalancing provides an otelcol.exporter.loadbalancing component.
logging
Package logging provides an otelcol.exporter.logging component.
 Package logging provides an otelcol.exporter.logging component.
loki
Package loki provides an otelcol.exporter.loki component.
 Package loki provides an otelcol.exporter.loki component.
loki/internal/convert
Package convert implements conversion utilities to convert between OpenTelemetry Collector and Loki data.
 Package convert implements conversion utilities to convert between OpenTelemetry Collector and Loki data.
otlp
Package otlp provides an otelcol.exporter.otlp component.
 Package otlp provides an otelcol.exporter.otlp component.
otlphttp
Package otlphttp provides an otelcol.exporter.otlphttp component.
 Package otlphttp provides an otelcol.exporter.otlphttp component.
prometheus
Package prometheus provides an otelcol.exporter.prometheus component.
 Package prometheus provides an otelcol.exporter.prometheus component.
prometheus/internal/convert
Package convert implements conversion utilities to convert between OpenTelemetry Collector data and Prometheus data.
 Package convert implements conversion utilities to convert between OpenTelemetry Collector data and Prometheus data.
Package extension provides utilities to create an Alloy component from OpenTelemetry Collector extensions.
 Package extension provides utilities to create an Alloy component from OpenTelemetry Collector extensions.
jaeger_remote_sampling
jaeger_remote_sampling/internal/jaegerremotesampling
jaeger_remote_sampling/internal/jaegerremotesampling/internal
jaeger_remote_sampling/internal/jaegerremotesampling/internal/metadata
jaeger_remote_sampling/internal/strategy_store
internal
fakeconsumer
fanoutconsumer
lazycollector
lazyconsumer
Package lazyconsumer implements a lazy OpenTelemetry Collector consumer which can lazily forward request to another consumer implementation.
 Package lazyconsumer implements a lazy OpenTelemetry Collector consumer which can lazily forward request to another consumer implementation.
scheduler
Package scheduler exposes utilities for scheduling and running OpenTelemetry Collector components.
 Package scheduler exposes utilities for scheduling and running OpenTelemetry Collector components.
views
Package processor exposes utilities to create an Alloy component from OpenTelemetry Collector processors.
 Package processor exposes utilities to create an Alloy component from OpenTelemetry Collector processors.
attributes
Package attributes provides an otelcol.processor.attributes component.
 Package attributes provides an otelcol.processor.attributes component.
batch
Package batch provides an otelcol.processor.batch component.
 Package batch provides an otelcol.processor.batch component.
discovery
Package discovery provides an otelcol.processor.discovery component.
 Package discovery provides an otelcol.processor.discovery component.
filter
k8sattributes
Package attributes provides an otelcol.processor.k8sattributes component.
 Package attributes provides an otelcol.processor.k8sattributes component.
memorylimiter
Package memorylimiter provides an otelcol.processor.memory_limiter component.
 Package memorylimiter provides an otelcol.processor.memory_limiter component.
probabilistic_sampler
Package probabilistic_sampler provides an otelcol.processor.probabilistic_sampler component.
 Package probabilistic_sampler provides an otelcol.processor.probabilistic_sampler component.
processortest
resourcedetection
resourcedetection/internal/aws/ec2
resourcedetection/internal/aws/ecs
resourcedetection/internal/aws/eks
resourcedetection/internal/aws/elasticbeanstalk
resourcedetection/internal/aws/lambda
resourcedetection/internal/azure
resourcedetection/internal/azure/aks
resourcedetection/internal/consul
resourcedetection/internal/docker
resourcedetection/internal/gcp
resourcedetection/internal/heroku
resourcedetection/internal/k8snode
resourcedetection/internal/openshift
resourcedetection/internal/resource_attribute_config
resourcedetection/internal/system
span
Package span provides an otelcol.processor.span component.
 Package span provides an otelcol.processor.span component.
tail_sampling
Package tail_sampling provides an otelcol.processor.tail_sampling component.
 Package tail_sampling provides an otelcol.processor.tail_sampling component.
transform
Package transform provides an otelcol.processor.transform component.
 Package transform provides an otelcol.processor.transform component.
Package receiver utilities to create an Alloy component from OpenTelemetry Collector receivers.
 Package receiver utilities to create an Alloy component from OpenTelemetry Collector receivers.
file_stats
Package file_stats provides an otelcol.receiver.file_stats component.
 Package file_stats provides an otelcol.receiver.file_stats component.
jaeger
Package jaeger provides an otelcol.receiver.jaeger component.
 Package jaeger provides an otelcol.receiver.jaeger component.
kafka
Package kafka provides an otelcol.receiver.kafka component.
 Package kafka provides an otelcol.receiver.kafka component.
loki
Package loki provides an otelcol.receiver.loki component.
 Package loki provides an otelcol.receiver.loki component.
opencensus
Package opencensus provides an otelcol.receiver.opencensus component.
 Package opencensus provides an otelcol.receiver.opencensus component.
otlp
Package otlp provides an otelcol.receiver.otlp component.
 Package otlp provides an otelcol.receiver.otlp component.
prometheus
Package prometheus provides an otelcol.receiver.prometheus component.
 Package prometheus provides an otelcol.receiver.prometheus component.
prometheus/internal
Package internal is a near copy of https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/v0.87.0/receiver/prometheusreceiver/internal A copy was made because the upstream package is internal.
 Package internal is a near copy of https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/v0.87.0/receiver/prometheusreceiver/internal A copy was made because the upstream package is internal.
vcenter
Package vcenter provides an otelcol.receiver.vcenter component.
 Package vcenter provides an otelcol.receiver.vcenter component.
zipkin
Package zipkin provides an otelcol.receiver.zipkin component.
 Package zipkin provides an otelcol.receiver.zipkin component.

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.