chore: version gauge code coverage and error improvements (#2379)

Improves error messages and adds some unit tests to bring code coverage
to 100%.

Co-authored-by: Chris Stockton <chris.stockton@supabase.io>

Author: cstockton

internal/utilities/version.go

@@ -23,37 +23,55 @@ func InitVersionMetrics(ctx context.Context) error {
 func initVersionMetrics(ctx context.Context, ver string) error {
 	vi, err := parseSemver(ver)
 	if err != nil {
-		vi = &versionInfo{}
+		const msg = "initVersionMetrics: unable to parse version %q: %w"
+		return fmt.Errorf(msg, ver, err)
 	}
 
 	if err := initMetrics(ctx, vi); err != nil {
-		return err
+		const msg = "initVersionMetrics: unable to initialize version %q: %w"
+		return fmt.Errorf(msg, ver, err)
 	}
 	return nil
 }
 
-func initGauge(ctx context.Context, typ string, val uint64) error {
+func initGauge(
+	ctx context.Context,
+	typ string,
+	val uint64,
+	gaugeFunc initGaugeFunc,
+) error {
 	name := fmt.Sprintf("global_auth_version_%v", typ)
 	desc := fmt.Sprintf("Set to this auth servers %v version number.", typ)
 
-	g, err := otel.Meter("gotrue").Int64Gauge(name, metric.WithDescription(desc))
+	g, err := gaugeFunc(name, metric.WithDescription(desc))
 	if err != nil {
-		return err
+		const msg = "initGauge: part %q (%v) otel error: %w"
+		return fmt.Errorf(msg, typ, val, err)
 	}
 	if val > math.MaxInt64 {
-		return errors.New("value is > math.MaxInt64")
+		const msg = "initGauge: part %q (%v) value > math.MaxInt64"
+		return fmt.Errorf(msg, typ, val)
 	}
 
 	g.Record(ctx, int64(val))
 	return nil
 }
 
+type initGaugeFunc func(
+	name string,
+	options ...metric.Int64GaugeOption,
+) (metric.Int64Gauge, error)
+
+func initGaugeOtel(name string, options ...metric.Int64GaugeOption) (metric.Int64Gauge, error) {
+	return otel.Meter("gotrue").Int64Gauge(name, options...)
+}
+
 func initMetrics(ctx context.Context, vi *versionInfo) error {
 	return errors.Join(
-		initGauge(ctx, "major", vi.Major),
-		initGauge(ctx, "minor", vi.Minor),
-		initGauge(ctx, "patch", vi.Patch),
-		initGauge(ctx, "rc", vi.RC),
+		initGauge(ctx, "major", vi.Major, initGaugeOtel),
+		initGauge(ctx, "minor", vi.Minor, initGaugeOtel),
+		initGauge(ctx, "patch", vi.Patch, initGaugeOtel),
+		initGauge(ctx, "rc", vi.RC, initGaugeOtel),
 	)
 }
 

internal/utilities/version_test.go

@@ -2,14 +2,19 @@ package utilities
 
 import (
 	"context"
+	"errors"
+	"fmt"
+	"math"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/otel/metric"
 )
 
-func TestInitVersionMetrics(t *testing.T) {
+func TestVersionInitVersionMetrics(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 	defer cancel()
 
@@ -28,31 +33,63 @@ func TestInitVersionMetrics(t *testing.T) {
 		}
 	}
 
-	const ver = "rc2.187.3-rc.23-g33b87ae0"
+	const validVer = "rc2.187.3-rc.23-g33b87ae0"
 
 	{
-		vi, err := parseSemver(ver)
+		vi, err := parseSemver(validVer)
 		require.NoError(t, err)
 		check(vi)
 	}
 
 	{
-		err := initVersionMetrics(ctx, ver)
+		err := initVersionMetrics(ctx, validVer)
 		require.NoError(t, err)
 	}
 
+	{
+		err := initVersionMetrics(ctx, "invalid")
+		require.Error(t, err)
+		const exp = "initVersionMetrics: unable to parse version"
+		if got := err.Error(); !strings.Contains(got, exp) {
+			t.Fatalf("exp err %q to contain %q", got, exp)
+		}
+	}
+
+	{
+		max := strconv.AppendUint(nil, math.MaxUint64, 10)
+		ver := fmt.Sprintf("%v.%v.%s", 2, 187, max)
+		err := initVersionMetrics(ctx, ver)
+		require.Error(t, err)
+		if exp, got := "math.MaxInt64", err.Error(); !strings.Contains(got, exp) {
+			t.Fatalf("exp err %q to contain %q", got, exp)
+		}
+	}
+
+	{
+		sentinel := errors.New("otel-sentinel")
+		errFn := func(name string, options ...metric.Int64GaugeOption) (metric.Int64Gauge, error) {
+			return nil, sentinel
+		}
+
+		err := initGauge(ctx, "metric", 1, errFn)
+		require.Error(t, err)
+		if exp, got := sentinel.Error(), err.Error(); !strings.Contains(got, exp) {
+			t.Fatalf("exp err %q to contain %q", got, exp)
+		}
+	}
+
 	func() {
 		prev := Version
 		defer func() { Version = prev }()
-		Version = ver
+		Version = validVer
 
 		err := InitVersionMetrics(ctx)
 		require.NoError(t, err)
 	}()
 
 }
 
-func TestParseSemver(t *testing.T) {
+func TestVersionParseSemver(t *testing.T) {
 	cases := []struct {
 		str, err          string
 		maj, min, pat, rc uint64
@@ -115,6 +152,9 @@ func TestParseSemver(t *testing.T) {
 		{str: "2.165.1-rc.1", maj: 2, min: 165, pat: 1, rc: 1},
 		{str: "2.165.1-rc1", maj: 2, min: 165, pat: 1, rc: 1},
 
+		{str: "2.165.1-rc.1.5", maj: 2, min: 165, pat: 1, rc: 1},
+		{str: "2.165.1-rc1.5", maj: 2, min: 165, pat: 1, rc: 1},
+
 		{str: "", err: "Invalid Semantic Version"},
 		{str: "abc", err: "Invalid Semantic Version"},
 	}
@@ -144,7 +184,7 @@ func TestParseSemver(t *testing.T) {
 				t.Fatal("exp non-nil err")
 			}
 			if exp, got := tc.err, err.Error(); !strings.Contains(got, exp) {
-				t.Fatalf("exp ")
+				t.Fatalf("exp err %q to contain %q", got, exp)
 			}
 			continue
 		}