comment

Signed-off-by: Kenny Leung <kleung@chainguard.dev>

Author: k4leung4

pkg/metrics/server.go

@@ -10,6 +10,7 @@ import (
 	"log"
 	"net/http"
 	"net/http/pprof"
+	"sync"
 	"time"
 
 	"github.com/chainguard-dev/clog"
@@ -25,7 +26,26 @@ import (
 	"google.golang.org/grpc"
 )
 
-var serverMetrics *grpc_prometheus.ServerMetrics
+type initStuff struct {
+	serverMetrics *grpc_prometheus.ServerMetrics
+}
+
+var (
+	state = sync.OnceValue(func() initStuff {
+		init := initStuff{}
+
+		init.serverMetrics = grpc_prometheus.NewServerMetrics(
+			grpc_prometheus.WithServerHandlingTimeHistogram(
+				grpc_prometheus.WithHistogramBuckets(
+					[]float64{0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60, 120, 300, 600, 1200, 2400, 3666},
+				),
+			),
+		)
+		prometheus.MustRegister(init.serverMetrics)
+
+		return init
+	})
+)
 
 // Fractions >= 1 will always sample. Fractions < 0 are treated as zero. To
 // respect the parent trace's `SampledFlag`, the `TraceIDRatioBased` sampler
@@ -65,15 +85,7 @@ func SetupTracer(ctx context.Context) func() {
 }
 
 func RegisterListenAndServe(server *grpc.Server, listenAddr string, enablePprof bool) {
-	serverMetrics = grpc_prometheus.NewServerMetrics(
-		grpc_prometheus.WithServerHandlingTimeHistogram(
-			grpc_prometheus.WithHistogramBuckets(
-				[]float64{0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60, 120, 300, 600, 1200, 2400, 3666},
-			),
-		),
-	)
-	prometheus.MustRegister(serverMetrics)
-	serverMetrics.InitializeMetrics(server)
+	state().serverMetrics.InitializeMetrics(server)
 
 	go func(addr string) {
 		mux := http.NewServeMux()
@@ -109,9 +121,9 @@ func RegisterListenAndServe(server *grpc.Server, listenAddr string, enablePprof
 }
 
 func UnaryServerInterceptor() grpc.UnaryServerInterceptor {
-	return serverMetrics.UnaryServerInterceptor()
+	return state().serverMetrics.UnaryServerInterceptor()
 }
 
 func StreamServerInterceptor() grpc.StreamServerInterceptor {
-	return serverMetrics.StreamServerInterceptor()
+	return state().serverMetrics.StreamServerInterceptor()
 }

pkg/options/options.go

@@ -19,8 +19,8 @@ import (
 
 	"chainguard.dev/go-grpc-kit/pkg/trace"
 	"github.com/chainguard-dev/clog"
+	grpc_prometheus "github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus"
 	grpc_retry "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/retry"
-	grpc_prometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
 	"github.com/kelseyhightower/envconfig"
 	"github.com/prometheus/client_golang/prometheus"
 	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
@@ -37,18 +37,17 @@ type envStruct struct {
 	GrpcClientMaxRetry                     uint `envconfig:"GRPC_CLIENT_MAX_RETRY" default:"0"`
 }
 
-var (
-	envOnce sync.Once
-
+type initStuff struct {
 	env           envStruct
 	clientMetrics *grpc_prometheus.ClientMetrics
-)
+}
+
+var (
+	state = sync.OnceValue(func() initStuff {
+		init := initStuff{}
 
-// Parse these lazily, to allow clients to set their own in their main() or init().
-func getEnv() *envStruct {
-	envOnce.Do(func() {
 		logger := clog.FromContext(context.Background())
-		if err := envconfig.Process("", &env); err != nil {
+		if err := envconfig.Process("", &init.env); err != nil {
 			logger.Warn("Failed to process environment variables", "error", err)
 		}
 
@@ -58,21 +57,22 @@ func getEnv() *envStruct {
 
 		cmOpts := []grpc_prometheus.ClientMetricsOption{}
 
-		if env.EnableClientHandlingTimeHistogram {
+		if init.env.EnableClientHandlingTimeHistogram {
 			cmOpts = append(cmOpts, grpc_prometheus.WithClientHandlingTimeHistogram(hopt))
 		}
-		if env.EnableClientStreamReceiveTimeHistogram {
+		if init.env.EnableClientStreamReceiveTimeHistogram {
 			cmOpts = append(cmOpts, grpc_prometheus.WithClientStreamRecvHistogram(hopt))
 		}
-		if env.EnableClientStreamSendTimeHistogram {
+		if init.env.EnableClientStreamSendTimeHistogram {
 			cmOpts = append(cmOpts, grpc_prometheus.WithClientStreamSendHistogram(hopt))
 		}
 
-		clientMetrics = grpc_prometheus.NewClientMetrics(cmOpts...)
-		prometheus.MustRegister(clientMetrics)
+		init.clientMetrics = grpc_prometheus.NewClientMetrics(cmOpts...)
+		prometheus.MustRegister(init.clientMetrics)
+
+		return init
 	})
-	return &env
-}
+)
 
 // ListenerForTest is to support bufnet in our testing.
 var ListenerForTest DialableListener
@@ -132,14 +132,14 @@ func ClientOptions() []option.ClientOption {
 func GRPCDialOptions() []grpc.DialOption {
 	retryOpts := []grpc_retry.CallOption{
 		grpc_retry.WithBackoff(grpc_retry.BackoffExponential(100 * time.Millisecond)),
-		grpc_retry.WithMax(getEnv().GrpcClientMaxRetry),
+		grpc_retry.WithMax(state().env.GrpcClientMaxRetry),
 	}
 
 	return []grpc.DialOption{
 		grpc.WithStatsHandler(otelgrpc.NewClientHandler()),
 		grpc.WithStatsHandler(trace.PreserveTraceParentHandler),
-		grpc.WithChainUnaryInterceptor(clientMetrics.UnaryClientInterceptor(), grpc_retry.UnaryClientInterceptor(retryOpts...)),
-		grpc.WithChainStreamInterceptor(clientMetrics.StreamClientInterceptor(), grpc_retry.StreamClientInterceptor(retryOpts...)),
+		grpc.WithChainUnaryInterceptor(state().clientMetrics.UnaryClientInterceptor(), grpc_retry.UnaryClientInterceptor(retryOpts...)),
+		grpc.WithChainStreamInterceptor(state().clientMetrics.StreamClientInterceptor(), grpc_retry.StreamClientInterceptor(retryOpts...)),
 	}
 }
 

pkg/options/options_test.go

@@ -17,21 +17,21 @@ func TestGetEnv(t *testing.T) {
 	old := os.Getenv("GRPC_CLIENT_MAX_RETRY")
 	defer os.Setenv("GRPC_CLIENT_MAX_RETRY", old)
 
-	want := &envStruct{
+	want := envStruct{
 		EnableClientHandlingTimeHistogram:      true,
 		EnableClientStreamReceiveTimeHistogram: true,
 		EnableClientStreamSendTimeHistogram:    true,
 		GrpcClientMaxRetry:                     42,
 	}
 	t.Run("can change env right before usage", func(t *testing.T) {
 		os.Setenv("GRPC_CLIENT_MAX_RETRY", strconv.Itoa(int(want.GrpcClientMaxRetry)))
-		if diff := cmp.Diff(want, getEnv()); diff != "" {
+		if diff := cmp.Diff(want, state().env); diff != "" {
 			t.Errorf("getEnv() -want,+got: %s", diff)
 		}
 	})
 	t.Run("but cannot change after usage", func(t *testing.T) {
 		os.Setenv("GRPC_CLIENT_MAX_RETRY", strconv.Itoa(int(want.GrpcClientMaxRetry+10)))
-		if diff := cmp.Diff(want, getEnv()); diff != "" {
+		if diff := cmp.Diff(want, state().env); diff != "" {
 			t.Errorf("getEnv() -want,+got: %s", diff)
 		}
 	})