Rename worker to exporter, add more words to doc.go

pkg/consuldp/consul_dataplane.go

@@ -50,7 +50,7 @@ type ConsulDataplane struct {
 	aclToken        string
 	metricsConfig   *metricsConfig
 	lifecycleConfig *lifecycleConfig
-	hcpTelemetry    *telemetry.Worker
+	hcpTelemetry    *telemetry.Exporter
 }
 
 // NewConsulDP creates a new instance of ConsulDataplane

pkg/hcp/telemetry/doc.go

@@ -1,2 +1,27 @@
-// Package telemetry is for pushing Envoy metrics to HCP.
+// Package telemetry is for scraping and sending Envoy metrics to HCP in OTLP format.
+//
+// This exists to let customers send mesh telemetry to HCP without having to deploy
+// a dedicated telemetry collector. Configuration for the collection, filtering, and exporting
+// of Envoy metrics is managed in the hcp.v1.TelemetryState resource in Consul.
+//
+//		                           ┌───────────────────┐
+//	                               │                   │
+//	                               │ HCP telemetry API │
+//	                               │                   │
+//	                               └───────────▲────--─┘
+//	                                           │POST /v1/metrics
+//	          ┌──────────┐WatchList┌────--─────┴─----─┐
+//			  │          │◄────────┤                  │
+//	          │  consul  │         │ consul-dataplane │
+//			  │          ├────────►│                  │
+//	          └──────────┘         └─────────────┬────┘
+//	                 hcp.v1.TelemetryState       │GET /stats/prometheus
+//	                               ┌─────────────▼────┐
+//	                               │                  │
+//	                               │ envoy admin      │
+//	                               │                  │
+//	                               └──────────────────┘
+//
+// A lot of the package is concerned with converting prometheus-format metrics into their
+// OTLP equivalent.
 package telemetry

pkg/hcp/telemetry/worker.go → pkg/hcp/telemetry/exporter.go

@@ -11,23 +11,27 @@ import (
 
 const workerDefaultScrapeInterval = time.Minute
 
-type Worker struct {
+// Exporter is a telemetry exporter that is specific to HCP. If enabled via the hcp.v1.TelemetryState resource,
+// this exporter periodically scrapes Envoy metrics from its admin endpoint and pushes the metrics up to HCP.
+type Exporter struct {
 	logger         hclog.Logger
 	scrapeInterval time.Duration
 	scraper        scraper
 	stateTracker   stateTracker
 }
 
-func New(resourceClient pbresource.ResourceServiceClient, logger hclog.Logger, envoyAdminHostPort string) *Worker {
-	return &Worker{
+// New creates a new HCP telemetry exporter.
+func New(resourceClient pbresource.ResourceServiceClient, logger hclog.Logger, envoyAdminHostPort string) *Exporter {
+	return &Exporter{
 		logger:         logger,
 		scrapeInterval: workerDefaultScrapeInterval,
 		scraper:        newScraper(envoyAdminHostPort, logger.Named("scraper")),
 		stateTracker:   newStateTracker(resourceClient, logger.Named("state_tracker")),
 	}
 }
 
-func (w *Worker) Run(ctx context.Context) {
+// Run starts the exporter's worker goroutine that periodically scrapes Envoy metrics and pushes them to HCP.
+func (w *Exporter) Run(ctx context.Context) {
 	go w.stateTracker.Run(ctx) // start syncing state from consul.
 	ticker := time.NewTicker(w.scrapeInterval)
 
@@ -50,7 +54,7 @@ func (w *Worker) Run(ctx context.Context) {
 				continue
 			}
 
-			if err := state.exporter.ExportMetrics(ctx, metrics); err != nil {
+			if err := state.client.ExportMetrics(ctx, metrics); err != nil {
 				w.logger.Error("failed to export metrics", "error", err)
 			}
 		case <-ctx.Done():

pkg/hcp/telemetry/worker_test.go → pkg/hcp/telemetry/exporter_test.go

@@ -48,12 +48,12 @@ func (s *fakeStateTracker) GetState() (*state, bool) {
 	return nil, false
 }
 
-type fakeExporter struct {
+type fakeClient struct {
 	exportCalled atomic.Bool
 	exportErr    error
 }
 
-func (e *fakeExporter) ExportMetrics(ctx context.Context, metrics pmetric.Metrics) error {
+func (e *fakeClient) ExportMetrics(ctx context.Context, metrics pmetric.Metrics) error {
 	e.exportCalled.Store(true)
 
 	if e.exportErr != nil {
@@ -107,11 +107,11 @@ func Test_Worker(t *testing.T) {
 			worker.scrapeInterval = time.Millisecond * 10
 
 			// Create fake exporter and state.
-			exporter := &fakeExporter{
+			exporter := &fakeClient{
 				exportErr: tc.exportErr,
 			}
 			state := &state{
-				exporter: exporter,
+				client:   exporter,
 				disabled: false,
 				labels: map[string]string{
 					"foo": "bar",

pkg/hcp/telemetry/state.go

@@ -31,7 +31,7 @@ var (
 //
 // All of this is sourced from Consul that, in turn, gets it from HCP.
 type state struct {
-	exporter           otlphttp.Client
+	client             otlphttp.Client
 	labels             map[string]string
 	disabled           bool
 	metricsIncludeList []string
@@ -168,7 +168,7 @@ func (st *stateTrackerImpl) resourceToState(res *pbresource.Resource) (*state, e
 
 	// TODO replace with actual proto conversion from data
 	return &state{
-		exporter:           exporter,
+		client:             exporter,
 		labels:             map[string]string{},
 		disabled:           false,
 		metricsIncludeList: []string{".+"},