pipeline

type Component interface {
	// Use registers new usage of this component. Use should be called whenever this component is
	// added downstream of some other component. When no longer used, Release should be called.
	Use()

	// Release is called when the caller is no longer using this component. If the component's usage
	// count reaches 0 due to this release, it should perform the following steps in order:
	// 1. Decrement the usage counter. If the usage counter is still greater than 0, return nil.
	// 2. Gracefully shutdown background processes and wait for completion. Following this step,
	//    no data shall be sent from this component to downstream components.
	// 3. Call Release on all downstream components, waiting for their release operations to
	//    complete.
	//
	// As a result, calling Release on all of the pipeline Input components should result in a graceful
	// shutdown of all Components in the correct order.
	//
	// Release returns an error if it or any of its downstream components generate one.
	Release() error
}

type Endpoint interface {
	// Endpoint is a Component.
	Component

	// Name returns the name of this endpoint. The name must be unique across all endpoints in the
	// system, and should be constant across restarts of the agent. There can be multiple instances
	// of the same type of endpoint with different names.
	Name() string

	// Send sends the given EndpointReport - previously built by this endpoint - to the reporting
	// service.
	Send(EndpointReport) error

	// BuildReport builds an EndpointReport from the given StampedMetricReport, optionally attaching
	// context.
	BuildReport(report metrics.StampedMetricReport) (EndpointReport, error)

	// IsTransient returns true if the given error indicates that the operation failed due to some
	// transient error and can be retried.
	IsTransient(error) bool
}

type EndpointReport struct {
	metrics.StampedMetricReport `json:",inline"`
	Context                     json.RawMessage
}

type Input interface {
	// Input is also a Component.
	Component

	// AddReport adds a report to the pipeline. It returns an error if one is known immediately,
	// such as a report that refers to unknown metrics. See aggregator.Aggregator.
	AddReport(metrics.MetricReport) error
}

type InputAdapter struct {
	Sender Sender
}

type Sender interface {
	// Sender is a Component.
	Component

	// Send sends the report downstream. The behavior of the Send operation depends on the type of
	// sender. Some implementations - the Dispatcher, for instance - simply forward the Send to
	// subsequent Senders. Others - like the RetryingSender - may queue the report and attempt to
	// send it at a later time.
	//
	// An error indicates that something failed quickly, but it does not
	// indicate that the operation failed completely (i.e., some senders behind a Dispatcher may have
	// succeeded). Likewise, the lack of an error response does not indicate that the Send operation
	// succeeded, due to the asynchronous nature of a RetryingSender.
	Send(report metrics.StampedMetricReport) error

	// Endpoints returns the transitive list of endpoints that this sender will ultimately send to.
	Endpoints() []string
}

type Source interface {

	// Shutdown instructs the source to stop sending metric data, release any held components, and
	// clean up resources.
	Shutdown() error
}

type UsageTracker struct {
	// contains filtered or unexported fields
}