refactor: remove tracemalloc/python_heap_bytes per review feedback

tracemalloc.start() has ~10-30% runtime overhead and was being activated
silently for all production connectors. The cgroup-based metrics already
provide container memory pressure visibility. tracemalloc-based heap
metrics will be added separately behind an explicit opt-in env var flag.

Co-Authored-By: bot_apk <apk@cognition.ai>

Author: devin-ai-integration[bot]

airbyte_cdk/metrics/__init__.py

@@ -14,15 +14,14 @@
 import time
 from typing import Any, Optional
 
-from airbyte_cdk.metrics.memory import MemoryInfo, get_memory_info, get_python_heap_bytes
+from airbyte_cdk.metrics.memory import MemoryInfo, get_memory_info
 
 logger = logging.getLogger(__name__)
 
 # Metric names
 METRIC_MEMORY_USAGE_BYTES = "cdk.memory.usage_bytes"
 METRIC_MEMORY_LIMIT_BYTES = "cdk.memory.limit_bytes"
 METRIC_MEMORY_USAGE_PERCENT = "cdk.memory.usage_percent"
-METRIC_MEMORY_PYTHON_HEAP_BYTES = "cdk.memory.python_heap_bytes"
 
 # Default emission interval in seconds
 DEFAULT_EMISSION_INTERVAL_SECONDS = 30.0
@@ -140,7 +139,6 @@ def emit_memory_metrics(self) -> None:
         - cdk.memory.usage_bytes: Current container memory usage
         - cdk.memory.limit_bytes: Container memory limit (if known)
         - cdk.memory.usage_percent: Usage/limit ratio (if limit is known)
-        - cdk.memory.python_heap_bytes: Python-specific heap via tracemalloc
         """
         if not self.enabled:
             return
@@ -156,10 +154,6 @@ def emit_memory_metrics(self) -> None:
             if info.usage_percent is not None:
                 self.gauge(METRIC_MEMORY_USAGE_PERCENT, info.usage_percent)
 
-            python_heap = get_python_heap_bytes()
-            if python_heap is not None:
-                self.gauge(METRIC_MEMORY_PYTHON_HEAP_BYTES, float(python_heap))
-
         except Exception:
             # Never let metric collection failures affect the sync
             logger.debug("Failed to collect memory metrics", exc_info=True)

airbyte_cdk/metrics/memory.py

@@ -149,23 +149,3 @@ def get_memory_info() -> MemoryInfo:
 
     # Fallback to rusage
     return _read_rusage_memory()
-
-
-def get_python_heap_bytes() -> Optional[int]:
-    """
-    Get Python-specific heap memory usage via tracemalloc.
-
-    Returns the current traced memory size in bytes, or None if tracemalloc
-    is not active. Tracemalloc is started lazily on first call.
-    """
-    import tracemalloc
-
-    if not tracemalloc.is_tracing():
-        try:
-            tracemalloc.start()
-        except RuntimeError:
-            # tracemalloc may fail to start in some environments
-            return None
-
-    current, _ = tracemalloc.get_traced_memory()
-    return current

unit_tests/metrics/test_memory.py

@@ -15,7 +15,6 @@
     _read_cgroup_v2_memory,
     _read_rusage_memory,
     get_memory_info,
-    get_python_heap_bytes,
 )
 
 
@@ -177,11 +176,3 @@ def test_falls_back_to_rusage(self) -> None:
 
         assert info.usage_bytes > 0
         assert info.limit_bytes is None
-
-
-class TestGetPythonHeapBytes:
-    def test_returns_integer(self) -> None:
-        result = get_python_heap_bytes()
-        assert result is not None
-        assert isinstance(result, int)
-        assert result >= 0

unit_tests/metrics/test_metrics_client.py

@@ -130,33 +130,25 @@ def test_emits_all_metrics_when_enabled(self) -> None:
         client, mock_instance = _make_enabled_client()
 
         mock_info = MemoryInfo(usage_bytes=100_000_000, limit_bytes=200_000_000)
-        with (
-            patch("airbyte_cdk.metrics.get_memory_info", return_value=mock_info),
-            patch("airbyte_cdk.metrics.get_python_heap_bytes", return_value=50_000_000),
-        ):
+        with patch("airbyte_cdk.metrics.get_memory_info", return_value=mock_info):
             client.emit_memory_metrics()
 
         gauge_calls = {call[0][0]: call[0][1] for call in mock_instance.gauge.call_args_list}
         assert gauge_calls["cdk.memory.usage_bytes"] == 100_000_000.0
         assert gauge_calls["cdk.memory.limit_bytes"] == 200_000_000.0
         assert gauge_calls["cdk.memory.usage_percent"] == pytest.approx(0.5)
-        assert gauge_calls["cdk.memory.python_heap_bytes"] == 50_000_000.0
 
     def test_skips_limit_when_unknown(self) -> None:
         client, mock_instance = _make_enabled_client()
 
         mock_info = MemoryInfo(usage_bytes=100_000_000, limit_bytes=None)
-        with (
-            patch("airbyte_cdk.metrics.get_memory_info", return_value=mock_info),
-            patch("airbyte_cdk.metrics.get_python_heap_bytes", return_value=None),
-        ):
+        with patch("airbyte_cdk.metrics.get_memory_info", return_value=mock_info):
             client.emit_memory_metrics()
 
         metric_names = [call[0][0] for call in mock_instance.gauge.call_args_list]
         assert "cdk.memory.usage_bytes" in metric_names
         assert "cdk.memory.limit_bytes" not in metric_names
         assert "cdk.memory.usage_percent" not in metric_names
-        assert "cdk.memory.python_heap_bytes" not in metric_names
 
     def test_noop_when_disabled(self) -> None:
         client = MetricsClient()
@@ -186,10 +178,7 @@ def test_emits_on_interval(self) -> None:
         client, mock_instance = _make_enabled_client()
 
         mock_info = MemoryInfo(usage_bytes=100, limit_bytes=200)
-        with (
-            patch("airbyte_cdk.metrics.get_memory_info", return_value=mock_info),
-            patch("airbyte_cdk.metrics.get_python_heap_bytes", return_value=50),
-        ):
+        with patch("airbyte_cdk.metrics.get_memory_info", return_value=mock_info):
             client.maybe_emit_memory_metrics(interval_seconds=0.0)
             first_call_count = mock_instance.gauge.call_count