chore: import upstream snapshot with attribution

pkg/observability/metrics/metrics.go

@@ -0,0 +1,13 @@
+package metrics
+
+import "time"
+
+// Metrics is a backend-agnostic interface for emitting metrics.
+// Implementations can route to DataDog, log to slog, or discard (noop).
+type Metrics interface {
+	Increment(key string, tags map[string]string)
+	Counter(key string, tags map[string]string, value int64)
+	Distribution(key string, tags map[string]string, value float64)
+	DistributionMs(key string, tags map[string]string, value time.Duration)
+	WithTags(tags map[string]string) Metrics
+}

pkg/observability/metrics/noop_sink.go

@@ -0,0 +1,19 @@
+package metrics
+
+import "time"
+
+// NoopMetrics is a no-op implementation of the Metrics interface.
+type NoopMetrics struct{}
+
+var _ Metrics = (*NoopMetrics)(nil)
+
+// NewNoopMetrics returns a new NoopMetrics.
+func NewNoopMetrics() *NoopMetrics {
+	return &NoopMetrics{}
+}
+
+func (n *NoopMetrics) Increment(_ string, _ map[string]string)                       {}
+func (n *NoopMetrics) Counter(_ string, _ map[string]string, _ int64)                {}
+func (n *NoopMetrics) Distribution(_ string, _ map[string]string, _ float64)         {}
+func (n *NoopMetrics) DistributionMs(_ string, _ map[string]string, _ time.Duration) {}
+func (n *NoopMetrics) WithTags(_ map[string]string) Metrics                          { return n }

pkg/observability/metrics/noop_sink_test.go

@@ -0,0 +1,42 @@
+package metrics
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNoopMetrics_ImplementsInterface(_ *testing.T) {
+	var _ Metrics = (*NoopMetrics)(nil)
+}
+
+func TestNoopMetrics_NoPanics(t *testing.T) {
+	m := NewNoopMetrics()
+
+	assert.NotPanics(t, func() {
+		m.Increment("key", map[string]string{"a": "b"})
+		m.Counter("key", map[string]string{"a": "b"}, 1)
+		m.Distribution("key", map[string]string{"a": "b"}, 1.5)
+		m.DistributionMs("key", map[string]string{"a": "b"}, time.Second)
+	})
+}
+
+func TestNoopMetrics_NilTags(t *testing.T) {
+	m := NewNoopMetrics()
+
+	assert.NotPanics(t, func() {
+		m.Increment("key", nil)
+		m.Counter("key", nil, 1)
+		m.Distribution("key", nil, 1.5)
+		m.DistributionMs("key", nil, time.Second)
+	})
+}
+
+func TestNoopMetrics_WithTags(t *testing.T) {
+	m := NewNoopMetrics()
+	tagged := m.WithTags(map[string]string{"env": "prod"})
+
+	assert.NotNil(t, tagged)
+	assert.Equal(t, m, tagged)
+}

pkg/observability/observability.go

@@ -0,0 +1,46 @@
+package observability
+
+import (
+	"context"
+	"errors"
+	"log/slog"
+
+	"github.com/github/github-mcp-server/pkg/observability/metrics"
+)
+
+// Exporters bundles observability primitives (logger + metrics) for dependency injection.
+// The logger is Go's stdlib *slog.Logger — integrators provide their own slog.Handler.
+type Exporters interface {
+	Logger() *slog.Logger
+	Metrics(context.Context) metrics.Metrics
+}
+
+type exporters struct {
+	logger  *slog.Logger
+	metrics metrics.Metrics
+}
+
+// NewExporters creates an Exporters bundle. Pass a configured *slog.Logger
+// (with whatever slog.Handler you need) and a Metrics implementation.
+// Neither may be nil; use slog.New(slog.DiscardHandler) and metrics.NewNoopMetrics()
+// if logging or metrics are unwanted.
+func NewExporters(logger *slog.Logger, m metrics.Metrics) (Exporters, error) {
+	if logger == nil {
+		return nil, errors.New("logger must not be nil: use slog.New(slog.DiscardHandler) to discard logs")
+	}
+	if m == nil {
+		return nil, errors.New("metrics must not be nil: use metrics.NewNoopMetrics() to discard metrics")
+	}
+	return &exporters{
+		logger:  logger,
+		metrics: m,
+	}, nil
+}
+
+func (e *exporters) Logger() *slog.Logger {
+	return e.logger
+}
+
+func (e *exporters) Metrics(_ context.Context) metrics.Metrics {
+	return e.metrics
+}

pkg/observability/observability_test.go

@@ -0,0 +1,46 @@
+package observability
+
+import (
+	"context"
+	"log/slog"
+	"testing"
+
+	"github.com/github/github-mcp-server/pkg/observability/metrics"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewExporters(t *testing.T) {
+	logger := slog.Default()
+	m := metrics.NewNoopMetrics()
+	exp, err := NewExporters(logger, m)
+	ctx := context.Background()
+
+	require.NoError(t, err)
+	assert.NotNil(t, exp)
+	assert.Equal(t, logger, exp.Logger())
+	assert.Equal(t, m, exp.Metrics(ctx))
+}
+
+func TestNewExporters_WithNilLogger(t *testing.T) {
+	_, err := NewExporters(nil, metrics.NewNoopMetrics())
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "logger must not be nil")
+}
+
+func TestNewExporters_WithNilMetrics(t *testing.T) {
+	_, err := NewExporters(slog.New(slog.DiscardHandler), nil)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "metrics must not be nil")
+}
+
+func TestNewExporters_WithDiscardLogger(t *testing.T) {
+	logger := slog.New(slog.DiscardHandler)
+	m := metrics.NewNoopMetrics()
+	exp, err := NewExporters(logger, m)
+
+	require.NoError(t, err)
+	assert.NotNil(t, exp)
+	assert.Equal(t, logger, exp.Logger())
+	assert.Equal(t, m, exp.Metrics(context.Background()))
+}