test(observability): add tests for previously-uncovered helpers

internal/observability had 17.7% statement coverage. Most production
helpers were untested, including the pprof handler, the chi-aware
tracing helpers, the intercepting response writer, the request-logger
helpers, the cleanup wrapper, and the disabled-config and error
branches of the configure-* setup functions.

Adds focused, infra-free unit tests across cleanup, profiler, metrics,
tracing, request-tracing, and request-logger files. The metrics,
tracing, and metrics-config tests intentionally cover only the
disabled and protocol-unsupported branches; the success branches
require a real prometheus or OTLP endpoint and are out of scope for
a coverage PR.

Coverage for the package goes from 17.7% to 53.4% with no behaviour
changes. The remaining gap is in functions that actually start
listeners or connect to exporters; those need integration-style
fixtures that this PR deliberately doesn't introduce.

Signed-off-by: Manas Srivastava <mastermanas805@gmail.com>

Author: mastermanas805

internal/observability/cleanup_test.go

@@ -0,0 +1,24 @@
+package observability
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestWaitForCleanup(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		WaitForCleanup(ctx)
+	}()
+
+	select {
+	case <-done:
+	case <-time.After(time.Second):
+		t.Fatal("WaitForCleanup did not return after context cancellation")
+	}
+}

internal/observability/metrics_test.go

@@ -0,0 +1,38 @@
+package observability
+
+import (
+	"context"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/supabase/auth/internal/conf"
+)
+
+func TestMeter(t *testing.T) {
+	require.NotNil(t, Meter("test-meter"))
+}
+
+func TestObtainMetricCounter(t *testing.T) {
+	require.NotNil(t, ObtainMetricCounter("test_counter", "a counter for tests"))
+}
+
+func TestConfigureMetricsNilContextPanics(t *testing.T) {
+	require.PanicsWithValue(t, "context must not be nil", func() {
+		_ = ConfigureMetrics(nil, &conf.MetricsConfig{})
+	})
+}
+
+func TestConfigureMetricsDisabled(t *testing.T) {
+	// metricsOnce is a package-level *sync.Once used to ensure ConfigureMetrics
+	// runs exactly once per process. Reset it for this isolated test so we can
+	// exercise the disabled-config branch without coupling to other tests.
+	metricsOnce = &sync.Once{}
+	require.NoError(t, ConfigureMetrics(context.Background(), &conf.MetricsConfig{Enabled: false}))
+}
+
+func TestEnableOpenTelemetryMetricsRejectsUnsupportedExporter(t *testing.T) {
+	err := enableOpenTelemetryMetrics(context.Background(), &conf.MetricsConfig{ExporterProtocol: "http/json"})
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "unsupported OpenTelemetry exporter protocol")
+}

internal/observability/profiler_test.go

@@ -0,0 +1,45 @@
+package observability
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/supabase/auth/internal/conf"
+)
+
+func TestConfigureProfilerDisabled(t *testing.T) {
+	require.NoError(t, ConfigureProfiler(context.Background(), &conf.ProfilerConfig{Enabled: false}))
+}
+
+func TestProfilerHandlerServeHTTP(t *testing.T) {
+	tests := []struct {
+		name           string
+		path           string
+		expectedStatus int
+	}{
+		{name: "pprof index", path: "/debug/pprof/", expectedStatus: http.StatusOK},
+		{name: "pprof cmdline", path: "/debug/pprof/cmdline", expectedStatus: http.StatusOK},
+		{name: "pprof symbol", path: "/debug/pprof/symbol", expectedStatus: http.StatusOK},
+		{name: "pprof goroutine", path: "/debug/pprof/goroutine", expectedStatus: http.StatusOK},
+		{name: "pprof heap", path: "/debug/pprof/heap", expectedStatus: http.StatusOK},
+		{name: "pprof allocs", path: "/debug/pprof/allocs", expectedStatus: http.StatusOK},
+		{name: "pprof threadcreate", path: "/debug/pprof/threadcreate", expectedStatus: http.StatusOK},
+		{name: "pprof block", path: "/debug/pprof/block", expectedStatus: http.StatusOK},
+		{name: "pprof mutex", path: "/debug/pprof/mutex", expectedStatus: http.StatusOK},
+		{name: "unknown path returns 404", path: "/debug/pprof/unknown", expectedStatus: http.StatusNotFound},
+		{name: "non-pprof path returns 404", path: "/something/else", expectedStatus: http.StatusNotFound},
+	}
+
+	handler := &ProfilerHandler{}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := httptest.NewRequest(http.MethodGet, tt.path, nil)
+			w := httptest.NewRecorder()
+			handler.ServeHTTP(w, req)
+			require.Equal(t, tt.expectedStatus, w.Code)
+		})
+	}
+}

internal/observability/request-logger_test.go

@@ -93,3 +93,77 @@ func TestContext(t *testing.T) {
 		}
 	}
 }
+
+func TestNewLogEntry(t *testing.T) {
+	le := NewLogEntry(logrus.NewEntry(logrus.StandardLogger()))
+	require.NotNil(t, le)
+	// NewLogEntry returns a chimiddleware.LogEntry; verify the underlying type
+	// is the package's *logEntry so downstream casts in GetLogEntry work.
+	_, ok := le.(*logEntry)
+	require.True(t, ok, "expected NewLogEntry to return *logEntry")
+}
+
+func TestGetLogEntryFallback(t *testing.T) {
+	// No log entry is attached to this request's context, so GetLogEntry
+	// should return a fresh fallback entry rather than panic or nil.
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	got := GetLogEntry(req)
+	require.NotNil(t, got)
+	require.NotNil(t, got.Entry)
+}
+
+func TestGetLogEntryReturnsAttachedEntry(t *testing.T) {
+	want := &logEntry{Entry: logrus.NewEntry(logrus.StandardLogger())}
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	ctx := SetLogEntryWithContext(req.Context(), want)
+	req = req.WithContext(ctx)
+
+	got := GetLogEntry(req)
+	require.Same(t, want, got)
+}
+
+func TestLogEntrySetField(t *testing.T) {
+	le := &logEntry{Entry: logrus.NewEntry(logrus.StandardLogger())}
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	req = req.WithContext(SetLogEntryWithContext(req.Context(), le))
+
+	LogEntrySetField(req, "user_id", "abc-123")
+	require.Equal(t, "abc-123", le.Entry.Data["user_id"])
+}
+
+func TestLogEntrySetFieldsMerges(t *testing.T) {
+	le := &logEntry{Entry: logrus.NewEntry(logrus.StandardLogger())}
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	req = req.WithContext(SetLogEntryWithContext(req.Context(), le))
+
+	LogEntrySetFields(req, logrus.Fields{
+		"session": "s1",
+		"trace":   "t1",
+	})
+	require.Equal(t, "s1", le.Entry.Data["session"])
+	require.Equal(t, "t1", le.Entry.Data["trace"])
+}
+
+func TestLogEntrySetFieldNoLogEntryInContextIsNoop(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	require.NotPanics(t, func() {
+		LogEntrySetField(req, "k", "v")
+		LogEntrySetFields(req, logrus.Fields{"k": "v"})
+	})
+}
+
+func TestLogEntryPanicWritesPanicAndStackFields(t *testing.T) {
+	var buf bytes.Buffer
+	logger := logrus.New()
+	logger.SetOutput(&buf)
+	logger.SetFormatter(&logrus.JSONFormatter{})
+
+	le := &logEntry{Entry: logrus.NewEntry(logger)}
+	le.Panic("boom", []byte("fake-stack-trace"))
+
+	var out map[string]interface{}
+	require.NoError(t, json.Unmarshal(buf.Bytes(), &out))
+	require.Equal(t, "request panicked", out["msg"])
+	require.Equal(t, "fake-stack-trace", out["stack"])
+	require.Contains(t, out["panic"], "boom")
+}

internal/observability/request-tracing_test.go

@@ -0,0 +1,90 @@
+package observability
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetChiRoutePatternNoRouteContext(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/anything", nil)
+	require.Equal(t, "noroute", getChiRoutePattern(req))
+}
+
+func TestGetChiRoutePatternWithRouter(t *testing.T) {
+	r := chi.NewRouter()
+	var captured string
+	r.Get("/users/{id}", func(w http.ResponseWriter, r *http.Request) {
+		captured = getChiRoutePattern(r)
+		w.WriteHeader(http.StatusOK)
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/users/42", nil)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	require.Equal(t, http.StatusOK, w.Code)
+	require.Equal(t, "/users/{id}", captured)
+}
+
+func TestTraceChiRoutesSafelyDoesNotPanicWithoutRouteContext(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/no/route/context", nil)
+	require.NotPanics(t, func() { traceChiRoutesSafely(req) })
+}
+
+func TestTraceChiRouteURLParamsSafelyDoesNotPanicWithoutRouteContext(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/no/route/context", nil)
+	require.NotPanics(t, func() { traceChiRouteURLParamsSafely(req) })
+}
+
+func TestAddMetricAttributesIncludesRoutePattern(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/something", nil)
+	attrs := addMetricAttributes(req)
+	require.NotEmpty(t, attrs)
+	// The first attribute should be the route key. Without a chi RouteContext
+	// the value falls back to "noroute".
+	require.Equal(t, "noroute", attrs[0].Value.AsString())
+}
+
+func TestInterceptingResponseWriterDelegates(t *testing.T) {
+	inner := httptest.NewRecorder()
+	w := &interceptingResponseWriter{writer: inner}
+
+	w.Header().Set("X-Test", "value")
+	require.Equal(t, "value", inner.Header().Get("X-Test"))
+
+	w.WriteHeader(http.StatusTeapot)
+	require.Equal(t, http.StatusTeapot, inner.Code)
+	require.Equal(t, http.StatusTeapot, w.statusCode)
+
+	n, err := w.Write([]byte("hello"))
+	require.NoError(t, err)
+	require.Equal(t, 5, n)
+	require.Equal(t, "hello", inner.Body.String())
+}
+
+func TestCountStatusCodesSafelyNilCounterIsNoop(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/path", nil)
+	writer := &interceptingResponseWriter{statusCode: http.StatusOK}
+	require.NotPanics(t, func() { countStatusCodesSafely(writer, req, nil) })
+}
+
+func TestRequestTracingMiddlewareInvokesNext(t *testing.T) {
+	called := false
+	next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		called = true
+		w.WriteHeader(http.StatusOK)
+	})
+
+	handler := RequestTracing()(next)
+	req := httptest.NewRequest(http.MethodGet, "/ping", nil)
+	req.Header.Set("User-Agent", "agent-under-test")
+	w := httptest.NewRecorder()
+	handler.ServeHTTP(w, req)
+
+	require.True(t, called, "next handler should have been invoked")
+	require.Equal(t, http.StatusOK, w.Code)
+}

internal/observability/tracing_test.go

@@ -0,0 +1,38 @@
+package observability
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/supabase/auth/internal/conf"
+)
+
+func TestTracer(t *testing.T) {
+	require.NotNil(t, Tracer("test-tracer"))
+}
+
+func TestOpenTelemetryResource(t *testing.T) {
+	resource := openTelemetryResource()
+	require.NotNil(t, resource)
+	// The resource should at minimum carry the gotrue.version attribute that
+	// openTelemetryResource merges in. We don't assert the exact value because
+	// utilities.Version is a build-time string; presence is enough.
+	require.NotEmpty(t, resource.Attributes())
+}
+
+func TestConfigureTracingNilContextPanics(t *testing.T) {
+	require.PanicsWithValue(t, "context must not be nil", func() {
+		_ = ConfigureTracing(nil, &conf.TracingConfig{})
+	})
+}
+
+func TestConfigureTracingDisabled(t *testing.T) {
+	require.NoError(t, ConfigureTracing(context.Background(), &conf.TracingConfig{Enabled: false}))
+}
+
+func TestEnableOpenTelemetryTracingRejectsUnsupportedExporter(t *testing.T) {
+	err := enableOpenTelemetryTracing(context.Background(), &conf.TracingConfig{ExporterProtocol: "http/json"})
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "unsupported OpenTelemetry exporter protocol")
+}