change naming and combine metricsLogic

Signed-off-by: Tim Li <ltim@uber.com>

Author: timl3136

.cursorrules

@@ -35,7 +35,15 @@ pip install -e ".[dev]"
 - Use `uv run python scripts/dev.py` for development tasks
 
 ## Code Quality
+- **ALWAYS run linter and type checker after making code changes**
 - Run linter with auto-fix: `uv tool run ruff check --fix`
 - Run type checking: `uv tool run mypy cadence/`
-- Always run both commands before committing code changes
 - Use `uv tool run ruff check --fix && uv tool run mypy cadence/` to run both together
+- **Standard workflow**: Make changes → Run linter → Run type checker → Commit
+
+## Development Workflow
+1. Make code changes
+2. Run `uv tool run ruff check --fix` (fixes formatting and linting issues)
+3. Run `uv tool run mypy cadence/` (checks type safety)
+4. Run `uv run python -m pytest` (run tests)
+5. Commit changes

cadence/_internal/visibility/__init__.py

@@ -1,11 +1,12 @@
 """Visibility and metrics collection components for Cadence client."""
 
-from .metrics import MetricsRegistry, get_default_registry
+from .metrics import MetricsHandler, NoOpMetricsHandler, get_default_handler
 from .prometheus import PrometheusMetrics, PrometheusConfig
 
 __all__ = [
-    "MetricsRegistry",
-    "get_default_registry",
+    "MetricsHandler",
+    "NoOpMetricsHandler", 
+    "get_default_handler",
     "PrometheusMetrics", 
     "PrometheusConfig",
 ]

cadence/_internal/visibility/metrics.py

@@ -2,7 +2,7 @@
 
 import logging
 from enum import Enum
-from typing import Dict, Optional, Protocol, Set
+from typing import Dict, Optional, Protocol
 
 logger = logging.getLogger(__name__)
 
@@ -16,7 +16,7 @@ class MetricType(Enum):
     SUMMARY = "summary"
 
 
-class MetricsCollector(Protocol):
+class MetricsHandler(Protocol):
     """Protocol for metrics collection backends."""
 
     def counter(
@@ -44,8 +44,8 @@ def histogram(
         ...
 
 
-class NoOpMetricsCollector:
-    """No-op metrics collector that discards all metrics."""
+class NoOpMetricsHandler:
+    """No-op metrics handler that discards all metrics."""
 
     def counter(
         self, key: str, n: int = 1, tags: Optional[Dict[str, str]] = None
@@ -68,77 +68,19 @@ def histogram(
         pass
 
 
-class MetricsRegistry:
-    """Registry for managing metrics collection in the Cadence client."""
+# Global default handler
+_default_handler: Optional[MetricsHandler] = None
 
-    def __init__(self, collector: Optional[MetricsCollector] = None):
-        self._collector = collector or NoOpMetricsCollector()
-        self._registered_metrics: Set[str] = set()
 
-    def set_collector(self, collector: MetricsCollector) -> None:
-        """Set the metrics collector backend."""
-        self._collector = collector
-        logger.info(f"Metrics collector set to {type(collector).__name__}")
+def get_default_handler() -> MetricsHandler:
+    """Get the default global metrics handler."""
+    global _default_handler
+    if _default_handler is None:
+        _default_handler = NoOpMetricsHandler()
+    return _default_handler
 
-    def register_metric(self, name: str, metric_type: MetricType) -> None:
-        """Register a metric with the registry."""
-        if name in self._registered_metrics:
-            logger.warning(f"Metric {name} already registered")
-            return
 
-        self._registered_metrics.add(name)
-        logger.debug(f"Registered {metric_type.value} metric: {name}")
-
-    def counter(
-        self, key: str, n: int = 1, tags: Optional[Dict[str, str]] = None
-    ) -> None:
-        """Send a counter metric."""
-        try:
-            self._collector.counter(key, n, tags)
-        except Exception as e:
-            logger.error(f"Failed to send counter {key}: {e}")
-
-    def gauge(
-        self, key: str, value: float, tags: Optional[Dict[str, str]] = None
-    ) -> None:
-        """Send a gauge metric."""
-        try:
-            self._collector.gauge(key, value, tags)
-        except Exception as e:
-            logger.error(f"Failed to send gauge {key}: {e}")
-
-    def timer(
-        self, key: str, duration: float, tags: Optional[Dict[str, str]] = None
-    ) -> None:
-        """Send a timer metric."""
-        try:
-            self._collector.timer(key, duration, tags)
-        except Exception as e:
-            logger.error(f"Failed to send timer {key}: {e}")
-
-    def histogram(
-        self, key: str, value: float, tags: Optional[Dict[str, str]] = None
-    ) -> None:
-        """Send a histogram metric."""
-        try:
-            self._collector.histogram(key, value, tags)
-        except Exception as e:
-            logger.error(f"Failed to send histogram {key}: {e}")
-
-
-# Global default registry
-_default_registry: Optional[MetricsRegistry] = None
-
-
-def get_default_registry() -> MetricsRegistry:
-    """Get the default global metrics registry."""
-    global _default_registry
-    if _default_registry is None:
-        _default_registry = MetricsRegistry()
-    return _default_registry
-
-
-def set_default_registry(registry: MetricsRegistry) -> None:
-    """Set the default global metrics registry."""
-    global _default_registry
-    _default_registry = registry
+def set_default_handler(handler: MetricsHandler) -> None:
+    """Set the default global metrics handler."""
+    global _default_handler
+    _default_handler = handler

cadence/_internal/visibility/prometheus.py

@@ -146,10 +146,10 @@ def _get_or_create_summary(
 
         return self._summaries[metric_name]
 
-    def count(
+    def counter(
         self, key: str, n: int = 1, tags: Optional[Dict[str, str]] = None
     ) -> None:
-        """Send a count metric (aligned with M3.count)."""
+        """Send a counter metric."""
         try:
             counter = self._get_or_create_counter(key, tags)
             merged_tags = self._merge_labels(tags)
@@ -160,12 +160,12 @@ def count(
                 counter.inc(n)
 
         except Exception as e:
-            logger.error(f"Failed to send count {key}: {e}")
+            logger.error(f"Failed to send counter {key}: {e}")
 
     def gauge(
         self, key: str, value: float, tags: Optional[Dict[str, str]] = None
     ) -> None:
-        """Send a gauge metric (aligned with M3.gauge)."""
+        """Send a gauge metric."""
         try:
             gauge = self._get_or_create_gauge(key, tags)
             merged_tags = self._merge_labels(tags)
@@ -178,10 +178,10 @@ def gauge(
         except Exception as e:
             logger.error(f"Failed to send gauge {key}: {e}")
 
-    def timing(
+    def timer(
         self, key: str, duration: float, tags: Optional[Dict[str, str]] = None
     ) -> None:
-        """Send a timing metric (aligned with M3.timing) - implemented as histogram."""
+        """Send a timer metric - implemented as histogram."""
         try:
             histogram = self._get_or_create_histogram(key, tags)
             merged_tags = self._merge_labels(tags)
@@ -192,12 +192,12 @@ def timing(
                 histogram.observe(duration)
 
         except Exception as e:
-            logger.error(f"Failed to send timing {key}: {e}")
+            logger.error(f"Failed to send timer {key}: {e}")
 
     def histogram(
         self, key: str, value: float, tags: Optional[Dict[str, str]] = None
     ) -> None:
-        """Send a histogram metric (aligned with M3.histogram)."""
+        """Send a histogram metric."""
         try:
             histogram = self._get_or_create_histogram(key, tags)
             merged_tags = self._merge_labels(tags)

tests/cadence/_internal/visibility/test_metrics.py

@@ -4,126 +4,78 @@
 
 
 from cadence._internal.visibility.metrics import (
-    MetricsRegistry,
-    MetricType,
-    NoOpMetricsCollector,
-    get_default_registry,
-    set_default_registry,
+    MetricsHandler,
+    NoOpMetricsHandler,
+    get_default_handler,
+    set_default_handler,
 )
 
 
-class TestMetricsRegistry:
-    """Test cases for MetricsRegistry."""
+class TestMetricsHandler:
+    """Test cases for MetricsHandler protocol."""
 
-    def test_registry_with_no_collector(self):
-        """Test registry with default no-op collector."""
-        registry = MetricsRegistry()
+    def test_noop_handler(self):
+        """Test no-op handler doesn't raise exceptions."""
+        handler = NoOpMetricsHandler()
 
         # Should not raise any exceptions
-        registry.counter("test_counter", 1)
-        registry.gauge("test_gauge", 42.0)
-        registry.histogram("test_histogram", 0.5)
-        registry.timer("test_timing", 1.5)
+        handler.counter("test_counter", 1)
+        handler.gauge("test_gauge", 42.0)
+        handler.histogram("test_histogram", 0.5)
+        handler.timer("test_timing", 1.5)
 
-    def test_registry_with_mock_collector(self):
-        """Test registry with mock collector."""
-        mock_collector = Mock()
-        registry = MetricsRegistry(mock_collector)
+    def test_mock_handler(self):
+        """Test mock handler implementation."""
+        mock_handler = Mock(spec=MetricsHandler)
 
         # Test counter
-        registry.counter("test_counter", 2, {"label": "value"})
-        mock_collector.counter.assert_called_once_with(
+        mock_handler.counter("test_counter", 2, {"label": "value"})
+        mock_handler.counter.assert_called_once_with(
             "test_counter", 2, {"label": "value"}
         )
 
         # Test gauge
-        registry.gauge("test_gauge", 100.0, {"env": "test"})
-        mock_collector.gauge.assert_called_once_with(
+        mock_handler.gauge("test_gauge", 100.0, {"env": "test"})
+        mock_handler.gauge.assert_called_once_with(
             "test_gauge", 100.0, {"env": "test"}
         )
 
         # Test timer
-        registry.timer("test_timing", 0.75)
-        mock_collector.timer.assert_called_once_with(
-            "test_timing", 0.75, None
+        mock_handler.timer("test_timing", 0.75, {"tag": "value"})
+        mock_handler.timer.assert_called_once_with(
+            "test_timing", 0.75, {"tag": "value"}
         )
 
         # Test histogram
-        registry.histogram("test_histogram", 2.5)
-        mock_collector.histogram.assert_called_once_with(
-            "test_histogram", 2.5, None
+        mock_handler.histogram("test_histogram", 2.5, {"env": "prod"})
+        mock_handler.histogram.assert_called_once_with(
+            "test_histogram", 2.5, {"env": "prod"}
         )
 
-    def test_set_collector(self):
-        """Test setting a new collector."""
-        registry = MetricsRegistry()
-        mock_collector = Mock()
 
-        registry.set_collector(mock_collector)
-        registry.counter("test", 1)
+class TestDefaultHandler:
+    """Test cases for default handler management."""
 
-        mock_collector.counter.assert_called_once_with("test", 1, None)
-
-    def test_register_metric(self):
-        """Test metric registration."""
-        registry = MetricsRegistry()
-
-        registry.register_metric("test_counter", MetricType.COUNTER)
-        registry.register_metric("test_gauge", MetricType.GAUGE)
-
-        # Registering the same metric twice should not raise an error
-        registry.register_metric("test_counter", MetricType.COUNTER)
-
-    def test_collector_exception_handling(self):
-        """Test that collector exceptions are handled gracefully."""
-        mock_collector = Mock()
-        mock_collector.counter.side_effect = Exception("Test exception")
-
-        registry = MetricsRegistry(mock_collector)
-
-        # Should not raise exception, but log error
-        registry.counter("test", 1)
-
-        mock_collector.counter.assert_called_once()
-
-
-class TestNoOpMetricsCollector:
-    """Test cases for NoOpMetricsCollector."""
-
-    def test_no_op_collector(self):
-        """Test that no-op collector doesn't raise exceptions."""
-        collector = NoOpMetricsCollector()
-
-        # Should not raise any exceptions
-        collector.counter("test", 1, {"label": "value"})
-        collector.gauge("test", 42.0)
-        collector.histogram("test", 0.5, {"env": "test"})
-        collector.timer("test", 1.5)
-
-
-class TestDefaultRegistry:
-    """Test cases for default registry management."""
-
-    def test_get_default_registry(self):
-        """Test getting the default registry."""
-        registry = get_default_registry()
-        assert isinstance(registry, MetricsRegistry)
+    def test_get_default_handler(self):
+        """Test getting the default handler."""
+        handler = get_default_handler()
+        assert isinstance(handler, NoOpMetricsHandler)
 
         # Should return the same instance
-        registry2 = get_default_registry()
-        assert registry is registry2
+        handler2 = get_default_handler()
+        assert handler is handler2
 
-    def test_set_default_registry(self):
-        """Test setting a custom default registry."""
-        original_registry = get_default_registry()
-        custom_registry = MetricsRegistry()
+    def test_set_default_handler(self):
+        """Test setting a custom default handler."""
+        original_handler = get_default_handler()
+        custom_handler = NoOpMetricsHandler()
 
-        set_default_registry(custom_registry)
+        set_default_handler(custom_handler)
 
-        # Should return the custom registry
-        current_registry = get_default_registry()
-        assert current_registry is custom_registry
-        assert current_registry is not original_registry
+        # Should return the custom handler
+        current_handler = get_default_handler()
+        assert current_handler is custom_handler
+        assert current_handler is not original_handler
 
         # Restore original for other tests
-        set_default_registry(original_registry)
+        set_default_handler(original_handler)