feat(go): expose gateway async sink metrics

go/vehicle-gateway/internal/eventbus/async_sink.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"lingniu-vehicle-ingest/go/vehicle-gateway/internal/envelope"
+	"lingniu-vehicle-ingest/go/vehicle-gateway/internal/metrics"
 )
 
 type AsyncConfig struct {
@@ -14,6 +15,8 @@ type AsyncConfig struct {
 	Workers          int
 	OperationTimeout time.Duration
 	OnError          func(error)
+	Metrics          *metrics.Registry
+	Name             string
 }
 
 type AsyncSink struct {
@@ -21,6 +24,8 @@ type AsyncSink struct {
 	jobs     chan asyncJob
 	timeout  time.Duration
 	onError  func(error)
+	metrics  *metrics.Registry
+	name     string
 
 	closeOnce sync.Once
 	closed    chan struct{}
@@ -48,11 +53,16 @@ func NewAsyncSink(delegate Sink, cfg AsyncConfig) *AsyncSink {
 	if cfg.OperationTimeout <= 0 {
 		cfg.OperationTimeout = 30 * time.Second
 	}
+	if cfg.Name == "" {
+		cfg.Name = "async"
+	}
 	s := &AsyncSink{
 		delegate: delegate,
 		jobs:     make(chan asyncJob, cfg.QueueSize),
 		timeout:  cfg.OperationTimeout,
 		onError:  cfg.OnError,
+		metrics:  cfg.Metrics,
+		name:     cfg.Name,
 		closed:   make(chan struct{}),
 		done:     make(chan struct{}),
 	}
@@ -91,15 +101,21 @@ func (s *AsyncSink) Close() error {
 func (s *AsyncSink) enqueue(ctx context.Context, job asyncJob) error {
 	select {
 	case <-s.closed:
+		s.recordEnqueue(job.kind, "closed")
 		return ErrAsyncSinkClosed
 	default:
 	}
 	select {
 	case s.jobs <- job:
+		s.recordEnqueue(job.kind, "queued")
+		s.recordQueueDepth()
 		return nil
 	case <-s.closed:
+		s.recordEnqueue(job.kind, "closed")
 		return ErrAsyncSinkClosed
 	case <-ctx.Done():
+		s.recordEnqueue(job.kind, "timeout")
+		s.recordQueueDepth()
 		return ctx.Err()
 	}
 }
@@ -107,7 +123,9 @@ func (s *AsyncSink) enqueue(ctx context.Context, job asyncJob) error {
 func (s *AsyncSink) worker() {
 	defer s.wg.Done()
 	for job := range s.jobs {
+		s.recordQueueDepth()
 		ctx, cancel := context.WithTimeout(context.Background(), s.timeout)
+		started := time.Now()
 		var err error
 		switch job.kind {
 		case "raw":
@@ -118,8 +136,47 @@ func (s *AsyncSink) worker() {
 			err = s.delegate.PublishFields(ctx, job.env)
 		}
 		cancel()
+		status := "ok"
+		if err != nil {
+			status = "error"
+		}
+		s.recordPublish(job.kind, status, time.Since(started))
 		if err != nil && s.onError != nil {
 			s.onError(err)
 		}
+		s.recordQueueDepth()
 	}
 }
+
+func (s *AsyncSink) recordEnqueue(kind string, status string) {
+	if s.metrics == nil {
+		return
+	}
+	s.metrics.IncCounter("vehicle_async_sink_enqueue_total", metrics.Labels{
+		"sink":   s.name,
+		"kind":   kind,
+		"status": status,
+	})
+}
+
+func (s *AsyncSink) recordPublish(kind string, status string, elapsed time.Duration) {
+	if s.metrics == nil {
+		return
+	}
+	labels := metrics.Labels{
+		"sink":   s.name,
+		"kind":   kind,
+		"status": status,
+	}
+	s.metrics.IncCounter("vehicle_async_sink_publish_total", labels)
+	s.metrics.SetGauge("vehicle_async_sink_publish_duration_ms", labels, float64(elapsed.Milliseconds()))
+}
+
+func (s *AsyncSink) recordQueueDepth() {
+	if s.metrics == nil {
+		return
+	}
+	s.metrics.SetGauge("vehicle_async_sink_queue_depth", metrics.Labels{
+		"sink": s.name,
+	}, float64(len(s.jobs)))
+}