Add EventBroadcaster metrics for observability and debugging

Implement comprehensive metrics tracking for EventBroadcaster implementations:

- Add BroadcasterMetrics interface for reading metrics per namespace
- Add MetricsCollector interface and DefaultMetricsCollector implementation
- Track events_published and events_received counters per namespace
- Track active_subscriptions gauge per namespace
- Track publish_errors, subscribe_errors, and dropped_events counters
- Add MetricsProvider interface for EventBroadcaster implementations
- Integrate metrics tracking into EventBus and NATSEventBus
- Add optional Prometheus integration via PrometheusMetricsAdapter

Closes #22

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

eventbus.go

@@ -14,12 +14,20 @@ type EventBroadcaster interface {
 	SubscriberCount(namespaceID string) int
 }
 
+// MetricsProvider is an optional interface that EventBroadcaster implementations
+// can implement to expose metrics.
+type MetricsProvider interface {
+	// Metrics returns the metrics collector for this broadcaster.
+	Metrics() BroadcasterMetrics
+}
+
 // EventBus broadcasts events to multiple subscribers within a namespace
 type EventBus struct {
 	subscribers map[string][]chan *Event // namespaceID -> channels
 	mutex       sync.RWMutex
 	ctx         context.Context
 	cancel      context.CancelFunc
+	metrics     *DefaultMetricsCollector
 }
 
 // NewEventBus creates a new event bus
@@ -29,9 +37,15 @@ func NewEventBus() *EventBus {
 		subscribers: make(map[string][]chan *Event),
 		ctx:         ctx,
 		cancel:      cancel,
+		metrics:     NewMetricsCollector(),
 	}
 }
 
+// Metrics returns the metrics collector for this event bus.
+func (eb *EventBus) Metrics() BroadcasterMetrics {
+	return eb.metrics
+}
+
 // Subscribe creates a new subscription channel for a namespace
 func (eb *EventBus) Subscribe(namespaceID string) <-chan *Event {
 	eb.mutex.Lock()
@@ -41,6 +55,9 @@ func (eb *EventBus) Subscribe(namespaceID string) <-chan *Event {
 	ch := make(chan *Event, 100)
 	eb.subscribers[namespaceID] = append(eb.subscribers[namespaceID], ch)
 
+	// Record subscription metric
+	eb.metrics.RecordSubscribe(namespaceID)
+
 	return ch
 }
 
@@ -55,6 +72,9 @@ func (eb *EventBus) Unsubscribe(namespaceID string, ch <-chan *Event) {
 			// Remove channel from slice
 			eb.subscribers[namespaceID] = append(subs[:i], subs[i+1:]...)
 			close(subscriber)
+
+			// Record unsubscription metric
+			eb.metrics.RecordUnsubscribe(namespaceID)
 			break
 		}
 	}
@@ -70,13 +90,18 @@ func (eb *EventBus) Publish(namespaceID string, event *Event) {
 	eb.mutex.RLock()
 	defer eb.mutex.RUnlock()
 
+	// Record publish metric
+	eb.metrics.RecordPublish(namespaceID)
+
 	subscribers := eb.subscribers[namespaceID]
 	for _, ch := range subscribers {
 		select {
 		case ch <- event:
-			// Event delivered
+			// Event delivered - record receive metric
+			eb.metrics.RecordReceive(namespaceID)
 		default:
 			// Channel full, skip this subscriber (non-blocking)
+			eb.metrics.RecordDroppedEvent(namespaceID)
 		}
 	}
 }
@@ -88,8 +113,11 @@ func (eb *EventBus) Stop() {
 
 	eb.cancel()
 
-	// Close all subscriber channels
-	for _, subs := range eb.subscribers {
+	// Close all subscriber channels and update metrics
+	for namespaceID, subs := range eb.subscribers {
+		for range subs {
+			eb.metrics.RecordUnsubscribe(namespaceID)
+		}
 		for _, ch := range subs {
 			close(ch)
 		}