feat: new chart repo recorder

Author: York Chen

internal/helm/repository/chart_repository.go

@@ -76,6 +76,11 @@ type ChartRepository struct {
 	*sync.RWMutex
 
 	cacheInfo
+
+	// namespace of the ChartRepository of the helm/oci chart repository object
+	Namespace string
+
+	*Recorder
 }
 
 type cacheInfo struct {
@@ -119,7 +124,7 @@ func WithMemoryCache(key string, c *cache.Cache, ttl time.Duration, rec RecordMe
 // the ChartRepository.Client configured to the getter.Getter for the
 // repository URL scheme. It returns an error on URL parsing failures,
 // or if there is no getter available for the scheme.
-func NewChartRepository(repositoryURL, cachePath string, providers getter.Providers, tlsConfig *tls.Config, getterOpts []getter.Option, chartRepoOpts ...ChartRepositoryOption) (*ChartRepository, error) {
+func NewChartRepository(repositoryURL, cachePath string, providers getter.Providers, tlsConfig *tls.Config, getterOpts []getter.Option, namespace string, repoRecorder *Recorder, chartRepoOpts ...ChartRepositoryOption) (*ChartRepository, error) {
 	u, err := url.Parse(repositoryURL)
 	if err != nil {
 		return nil, err
@@ -135,6 +140,8 @@ func NewChartRepository(repositoryURL, cachePath string, providers getter.Provid
 	r.Client = c
 	r.Options = getterOpts
 	r.tlsConfig = tlsConfig
+	r.Namespace = namespace
+	r.Recorder = repoRecorder
 
 	for _, opt := range chartRepoOpts {
 		if err := opt(r); err != nil {
@@ -275,8 +282,15 @@ func (r *ChartRepository) DownloadChart(chart *repo.ChartVersion) (*bytes.Buffer
 	t := transport.NewOrIdle(r.tlsConfig)
 	clientOpts := append(r.Options, getter.WithTransport(t))
 	defer transport.Release(t)
-
-	return r.Client.Get(u.String(), clientOpts...)
+	start := time.Now()
+	buffer, err := r.Client.Get(u.String(), clientOpts...)
+	r.Recorder.RecordChartRepoEventDuration(
+		ChartRepoTypeHelm,
+		ChartRepoEventTypeDownloadChart,
+		r.Namespace,
+		r.URL,
+		start)
+	return buffer, err
 }
 
 // LoadIndexFromBytes loads Index from the given bytes.
@@ -428,6 +442,7 @@ func (r *ChartRepository) LoadFromCache() error {
 // the Client and set Options, and writes the index to the given io.Writer.
 // It returns an url.Error if the URL failed to parse.
 func (r *ChartRepository) DownloadIndex(w io.Writer) (err error) {
+	start := time.Now()
 	u, err := url.Parse(r.URL)
 	if err != nil {
 		return err
@@ -444,6 +459,12 @@ func (r *ChartRepository) DownloadIndex(w io.Writer) (err error) {
 	if err != nil {
 		return err
 	}
+	r.Recorder.RecordChartRepoEventDuration(
+		ChartRepoTypeHelm,
+		ChartRepoEventTypeDownloadIndex,
+		r.Namespace,
+		r.URL,
+		start)
 	if _, err = io.Copy(w, res); err != nil {
 		return err
 	}

internal/helm/repository/chart_repository_test.go

@@ -63,12 +63,13 @@ func TestNewChartRepository(t *testing.T) {
 			New:     helmgetter.NewHTTPGetter,
 		},
 	}
+	repoRecorder := MustMakeMetrics()
 	options := []helmgetter.Option{helmgetter.WithBasicAuth("username", "password")}
 
 	t.Run("should construct chart repository", func(t *testing.T) {
 		g := NewWithT(t)
 
-		r, err := NewChartRepository(repositoryURL, "", providers, nil, options)
+		r, err := NewChartRepository(repositoryURL, "", providers, nil, options, "fake-namespace", repoRecorder)
 		g.Expect(err).ToNot(HaveOccurred())
 		g.Expect(r).ToNot(BeNil())
 		g.Expect(r.URL).To(Equal(repositoryURL))
@@ -78,7 +79,7 @@ func TestNewChartRepository(t *testing.T) {
 
 	t.Run("should error on URL parsing failure", func(t *testing.T) {
 		g := NewWithT(t)
-		r, err := NewChartRepository("https://ex ample.com", "", nil, nil, nil)
+		r, err := NewChartRepository("https://ex ample.com", "", nil, nil, nil, "fake-namespace", repoRecorder)
 		g.Expect(err).To(HaveOccurred())
 		g.Expect(err).To(BeAssignableToTypeOf(&url.Error{}))
 		g.Expect(r).To(BeNil())
@@ -88,7 +89,7 @@ func TestNewChartRepository(t *testing.T) {
 	t.Run("should error on unsupported scheme", func(t *testing.T) {
 		g := NewWithT(t)
 
-		r, err := NewChartRepository("http://example.com", "", providers, nil, nil)
+		r, err := NewChartRepository("http://example.com", "", providers, nil, nil, "fake-namespace", repoRecorder)
 		g.Expect(err).To(HaveOccurred())
 		g.Expect(err.Error()).To(Equal("scheme \"http\" not supported"))
 		g.Expect(r).To(BeNil())

internal/helm/repository/metrics.go

@@ -0,0 +1,90 @@
+/*
+Copyright 2022 The Flux authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package repository
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"sigs.k8s.io/controller-runtime/pkg/metrics"
+	"time"
+)
+
+const (
+	ChartRepoTypeHelm = "helm"
+	//ChartRepoTypeOCI                = "oci"
+	ChartRepoEventTypeDownloadIndex = "chart_repository_download"
+	ChartRepoEventTypeDownloadChart = "chart_download"
+)
+
+// Recorder is a recorder for chart repository events.
+type Recorder struct {
+	// TODO: type up the metrics and talk to aryan9600
+	// TODO: split this counter??
+	chartRepoEventsCounter *prometheus.CounterVec
+	durationHistogram      *prometheus.HistogramVec
+}
+
+// NewRepositoryRecorder returns a new Recorder.
+// The configured labels are: event_type, name, namespace.
+// The event_type is one of:
+//   - "chart_repository_download"
+//   - "chart_download"
+// The url is the url of the helm chart repository
+func NewRepositoryRecorder() *Recorder {
+	return &Recorder{
+		chartRepoEventsCounter: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "gotk_chart_repository_events_total",
+				Help: "Total number of events for a Helm Chart Repository.",
+			},
+			[]string{"name", "repo_type", "namespace", "url", "checksum"},
+		),
+		durationHistogram: prometheus.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Name:    "gotk_chart_repository_event_duration_seconds",
+				Help:    "The duration in seconds of an event for a Helm Chart Repository.",
+				Buckets: prometheus.ExponentialBuckets(10e-9, 10, 10),
+			},
+			[]string{"name", "repo_type", "namespace", "url", "checksum"},
+		),
+	}
+}
+
+// ChartRepoCollectors returns the metrics.Collector objects for the Recorder.
+func (r *Recorder) ChartRepoCollectors() []prometheus.Collector {
+	return []prometheus.Collector{
+		r.chartRepoEventsCounter,
+		r.durationHistogram,
+	}
+}
+
+// IncChartRepoEvents increment by 1 the chart repo event count for the given event type, url and checksum.
+func (r *Recorder) IncChartRepoEvents(event, repoType, url, checksum, namespace string) {
+	r.chartRepoEventsCounter.WithLabelValues(event, repoType, url, checksum, namespace).Inc()
+}
+
+// RecordChartRepoEventDuration records the duration since start for the given ref.
+func (r *Recorder) RecordChartRepoEventDuration(event, repoType, namespace, url string, start time.Time) {
+	r.durationHistogram.WithLabelValues(event, repoType, namespace, url).Observe(time.Since(start).Seconds())
+}
+
+// MustMakeMetrics creates a new Recorder, and registers the metrics collectors in the controller-runtime metrics registry.
+func MustMakeMetrics() *Recorder {
+	r := NewRepositoryRecorder()
+	metrics.Registry.MustRegister(r.ChartRepoCollectors()...)
+
+	return r
+}