README

Exporter Helper

This is a helper exporter that other exporters can depend on. Today, it primarily offers queued retries and resource attributes to metric labels conversion.

⚠️ This exporter should not be added to a service pipeline.

Configuration

The following configuration options can be modified:

  • retry_on_failure
    • enabled (default = true)
    • initial_interval (default = 5s): Time to wait after the first failure before retrying; ignored if enabled is false
    • max_interval (default = 30s): Is the upper bound on backoff; ignored if enabled is false
    • max_elapsed_time (default = 120s): Is the maximum amount of time spent trying to send a batch; ignored if enabled is false
  • sending_queue
    • enabled (default = true)
    • num_consumers (default = 10): Number of consumers that dequeue batches; ignored if enabled is false
    • queue_size (default = 5000): Maximum number of batches kept in memory before data; ignored if enabled is false; User should calculate this as num_seconds * requests_per_second where:
      • num_seconds is the number of seconds to buffer in case of a backend outage
      • requests_per_second is the average number of requests per seconds.
  • resource_to_telemetry_conversion
    • enabled (default = false): If enabled is true, all the resource attributes will be converted to metric labels by default.
  • timeout (default = 5s): Time to wait per individual attempt to send data to a backend.

The full list of settings exposed for this helper exporter are documented here.

Expand ▾ Collapse ▴

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NewFactory

func NewFactory(
	cfgType config.Type,
	createDefaultConfig CreateDefaultConfig,
	options ...FactoryOption) component.ExporterFactory

    NewFactory returns a component.ExporterFactory.

    func NewLogsExporter

    func NewLogsExporter(
    	cfg config.Exporter,
    	logger *zap.Logger,
    	pusher PushLogs,
    	options ...Option,
    ) (component.LogsExporter, error)

      NewLogsExporter creates an LogsExporter that records observability metrics and wraps every request with a Span.

      func NewMetricsExporter

      func NewMetricsExporter(
      	cfg config.Exporter,
      	logger *zap.Logger,
      	pusher PushMetrics,
      	options ...Option,
      ) (component.MetricsExporter, error)

        NewMetricsExporter creates an MetricsExporter that records observability metrics and wraps every request with a Span.

        func NewThrottleRetry

        func NewThrottleRetry(err error, delay time.Duration) error

          NewThrottleRetry creates a new throttle retry error.

          func NewTraceExporter

          func NewTraceExporter(
          	cfg config.Exporter,
          	logger *zap.Logger,
          	pusher PushTraces,
          	options ...Option,
          ) (component.TracesExporter, error)

            NewTraceExporter creates a TracesExporter that records observability metrics and wraps every request with a Span.

            Types

            type CreateDefaultConfig

            type CreateDefaultConfig func() config.Exporter

              CreateDefaultConfig is the equivalent of component.ExporterFactory.CreateDefaultConfig()

              type CreateLogsExporter

                CreateLogsExporter is the equivalent of component.ExporterFactory.CreateLogsExporter()

                type CreateMetricsExporter

                  CreateMetricsExporter is the equivalent of component.ExporterFactory.CreateMetricsExporter()

                  type CreateTracesExporter

                    CreateTracesExporter is the equivalent of component.ExporterFactory.CreateTracesExporter()

                    type FactoryOption

                    type FactoryOption func(o *factory)

                      FactoryOption apply changes to ExporterOptions.

                      func WithCustomUnmarshaler

                      func WithCustomUnmarshaler(customUnmarshaler component.CustomUnmarshaler) FactoryOption

                        WithCustomUnmarshaler implements component.ConfigUnmarshaler.

                        func WithLogs

                        func WithLogs(createLogsExporter CreateLogsExporter) FactoryOption

                          WithLogs overrides the default "error not supported" implementation for CreateLogsReceiver.

                          func WithMetrics

                          func WithMetrics(createMetricsExporter CreateMetricsExporter) FactoryOption

                            WithMetrics overrides the default "error not supported" implementation for CreateMetricsReceiver.

                            func WithTraces

                            func WithTraces(createTraceExporter CreateTracesExporter) FactoryOption

                              WithTraces overrides the default "error not supported" implementation for CreateTracesReceiver.

                              type Option

                              type Option func(*baseSettings)

                                Option apply changes to baseSettings.

                                func WithQueue

                                func WithQueue(queueSettings QueueSettings) Option

                                  WithQueue overrides the default QueueSettings for an exporter. The default QueueSettings is to disable queueing.

                                  func WithResourceToTelemetryConversion

                                  func WithResourceToTelemetryConversion(resourceToTelemetrySettings ResourceToTelemetrySettings) Option

                                    WithResourceToTelemetryConversion overrides the default ResourceToTelemetrySettings for an exporter. The default ResourceToTelemetrySettings is to disable resource attributes to metric labels conversion.

                                    func WithRetry

                                    func WithRetry(retrySettings RetrySettings) Option

                                      WithRetry overrides the default RetrySettings for an exporter. The default RetrySettings is to disable retries.

                                      func WithShutdown

                                      func WithShutdown(shutdown componenthelper.Shutdown) Option

                                        WithShutdown overrides the default Shutdown function for an exporter. The default shutdown function does nothing and always returns nil.

                                        func WithStart

                                        func WithStart(start componenthelper.Start) Option

                                          WithStart overrides the default Start function for an exporter. The default shutdown function does nothing and always returns nil.

                                          func WithTimeout

                                          func WithTimeout(timeoutSettings TimeoutSettings) Option

                                            WithTimeout overrides the default TimeoutSettings for an exporter. The default TimeoutSettings is 5 seconds.

                                            type PushLogs

                                            type PushLogs func(ctx context.Context, md pdata.Logs) error

                                              PushLogs is a helper function that is similar to ConsumeLogs but also returns the number of dropped logs.

                                              type PushMetrics

                                              type PushMetrics func(ctx context.Context, md pdata.Metrics) error

                                                PushMetrics is a helper function that is similar to ConsumeMetrics but also returns the number of dropped metrics.

                                                type PushTraces

                                                type PushTraces func(ctx context.Context, td pdata.Traces) error

                                                  PushTraces is a helper function that is similar to ConsumeTraces but also returns the number of dropped spans.

                                                  type QueueSettings

                                                  type QueueSettings struct {
                                                  	// Enabled indicates whether to not enqueue batches before sending to the consumerSender.
                                                  	Enabled bool `mapstructure:"enabled"`
                                                  	// NumConsumers is the number of consumers from the queue.
                                                  	NumConsumers int `mapstructure:"num_consumers"`
                                                  	// QueueSize is the maximum number of batches allowed in queue at a given time.
                                                  	QueueSize int `mapstructure:"queue_size"`
                                                  }

                                                    QueueSettings defines configuration for queueing batches before sending to the consumerSender.

                                                    func DefaultQueueSettings

                                                    func DefaultQueueSettings() QueueSettings

                                                      DefaultQueueSettings returns the default settings for QueueSettings.

                                                      type ResourceToTelemetrySettings

                                                      type ResourceToTelemetrySettings struct {
                                                      	// Enabled indicates whether to not convert resource attributes to metric labels
                                                      	Enabled bool `mapstructure:"enabled"`
                                                      }

                                                        ResourceToTelemetrySettings defines configuration for converting resource attributes to metric labels.

                                                        type RetrySettings

                                                        type RetrySettings struct {
                                                        	// Enabled indicates whether to not retry sending batches in case of export failure.
                                                        	Enabled bool `mapstructure:"enabled"`
                                                        	// InitialInterval the time to wait after the first failure before retrying.
                                                        	InitialInterval time.Duration `mapstructure:"initial_interval"`
                                                        	// MaxInterval is the upper bound on backoff interval. Once this value is reached the delay between
                                                        	// consecutive retries will always be `MaxInterval`.
                                                        	MaxInterval time.Duration `mapstructure:"max_interval"`
                                                        	// MaxElapsedTime is the maximum amount of time (including retries) spent trying to send a request/batch.
                                                        	// Once this value is reached, the data is discarded.
                                                        	MaxElapsedTime time.Duration `mapstructure:"max_elapsed_time"`
                                                        }

                                                          RetrySettings defines configuration for retrying batches in case of export failure. The current supported strategy is exponential backoff.

                                                          func DefaultRetrySettings

                                                          func DefaultRetrySettings() RetrySettings

                                                            DefaultRetrySettings returns the default settings for RetrySettings.

                                                            type TimeoutSettings

                                                            type TimeoutSettings struct {
                                                            	// Timeout is the timeout for every attempt to send data to the backend.
                                                            	Timeout time.Duration `mapstructure:"timeout"`
                                                            }

                                                              TimeoutSettings for timeout. The timeout applies to individual attempts to send data to the backend.

                                                              func DefaultTimeoutSettings

                                                              func DefaultTimeoutSettings() TimeoutSettings

                                                                DefaultTimeoutSettings returns the default settings for TimeoutSettings.