feat(metrics): route prometheus export through the bridge; drop forge runtime collector

Author: juicycleff

internal/metrics/collector.go

@@ -101,6 +101,7 @@ type collector struct {
 	errors             []error
 	httpCollector      *collectors.HTTPCollector
 	tsStorage          *storage.TimeSeriesStorage
+	promBridge         *exporters.PrometheusBridge
 }
 
 // CollectorConfig contains configuration for the metrics collector.
@@ -154,6 +155,13 @@ func New(config *CollectorConfig, logger logger.Logger) Metrics {
 	// Initialize exporters
 	c.initializeExporters()
 
+	// Prometheus bridge: reads the merged snapshot fresh on each scrape.
+	c.promBridge = exporters.NewPrometheusBridge(c.GetMetrics, exporters.PrometheusConfig{
+		Namespace:              c.config.Collection.Namespace,
+		EnableGoCollector:      true,
+		EnableProcessCollector: true,
+	})
+
 	// Initialize time-series storage for historical metric queries.
 	c.tsStorage = storage.NewTimeSeriesStorageWithConfig(&storage.TimeSeriesStorageConfig{
 		Retention:          time.Hour,
@@ -582,7 +590,10 @@ func (c *collector) GetMetricsByTag(tagKey, tagValue string) map[string]any {
 
 // Export exports metrics in the specified format.
 func (c *collector) Export(format metrics.ExportFormat) ([]byte, error) {
-	// Snapshot exporter without holding lock during export operation
+	if format == metrics.ExportFormatPrometheus && c.promBridge != nil {
+		return c.promBridge.GatherText()
+	}
+
 	c.mu.RLock()
 	exporter, exists := c.exporters[format]
 	c.mu.RUnlock()
@@ -593,9 +604,15 @@ func (c *collector) Export(format metrics.ExportFormat) ([]byte, error) {
 
 	// Get metrics without holding the collector lock
 	// This prevents deadlock with other systems (health checks, etc.) that may need locks
-	metrics := c.GetMetrics()
+	allMetrics := c.GetMetrics()
 
-	return exporter.Export(metrics)
+	return exporter.Export(allMetrics)
+}
+
+// PrometheusHandler returns an http.Handler that serves the Prometheus scrape
+// endpoint. Implements shared.PrometheusProvider.
+func (c *collector) PrometheusHandler() http.Handler {
+	return c.promBridge.Handler()
 }
 
 // ExportToFile exports metrics to a file.
@@ -739,14 +756,6 @@ func (c *collector) initializeBuiltinCollectors() error {
 		}
 	}
 
-	// Register runtime metrics collector
-	if c.config.Features.RuntimeMetrics {
-		runtimeCollector := collectors.NewRuntimeCollector()
-		if err := c.registerCollectorLocked(runtimeCollector); err != nil {
-			return fmt.Errorf("failed to register runtime collector: %w", err)
-		}
-	}
-
 	// Register HTTP collector
 	if c.config.Features.HTTPMetrics {
 		httpCollector := collectors.NewHTTPCollector()

internal/metrics/collector_prometheus_test.go

@@ -0,0 +1,36 @@
+package metrics
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/prometheus/common/expfmt"
+	"github.com/xraph/forge/internal/shared"
+)
+
+func TestCollector_ExportPrometheusParses(t *testing.T) {
+	c := New(DefaultCollectorConfig(), nil)
+
+	c.Counter("widget_built_total").Inc()
+	c.Gauge("widget_pending").Set(4)
+
+	out, err := c.Export(shared.ExportFormatPrometheus)
+	if err != nil {
+		t.Fatalf("Export: %v", err)
+	}
+
+	var parser expfmt.TextParser
+	if _, err := parser.TextToMetricFamilies(strings.NewReader(string(out))); err != nil {
+		t.Fatalf("output is not valid prometheus text: %v", err)
+	}
+	if !strings.Contains(string(out), "widget_built_total") {
+		t.Fatalf("expected widget_built_total in output, got:\n%s", out)
+	}
+}
+
+func TestCollector_ImplementsPrometheusProvider(t *testing.T) {
+	c := New(DefaultCollectorConfig(), nil)
+	if _, ok := c.(shared.PrometheusProvider); !ok {
+		t.Fatal("collector does not implement shared.PrometheusProvider")
+	}
+}

internal/shared/metrics.go

@@ -1,6 +1,8 @@
 package shared
 
 import (
+	"net/http"
+
 	"github.com/xraph/go-utils/metrics"
 )
 
@@ -72,3 +74,9 @@ type Exporter = metrics.Exporter
 
 // CollectorStats contains statistics about the metrics collector.
 type CollectorStats = metrics.CollectorStats
+
+// PrometheusProvider is implemented by metrics collectors that can serve a
+// Prometheus scrape endpoint via an http.Handler.
+type PrometheusProvider interface {
+	PrometheusHandler() http.Handler
+}