feat(system-metrics): Change gc.get_count with gc.get_stats with corresponding metrics.

Signed-off-by: Cagri Yonca <cagri@ibm.com>

Author: CagriYonca

src/instana/agent/host.py

@@ -99,13 +99,24 @@ def reset(self) -> None:
 
     def is_timed_out(self) -> bool:
         """
-        If we haven't heard from the Instana host agent in 60 seconds, this
-        method will return True.
+        If we haven't heard from the Instana host agent within the timeout
+        window, this method will return True.  The window is the larger of
+        60 seconds or twice the configured poll_rate so that high poll_rate
+        values (e.g. 120 s) do not cause spurious resets.
+
+        Note: We intentionally read the FSM state directly instead of calling
+        can_send(), because can_send() has a fork-detection side-effect that
+        triggers handle_fork() → reset() and would cause a spurious restart
+        loop on frameworks (e.g. Twisted) that spawn threads with different
+        perceived PIDs.  total_seconds() is used instead of .seconds to
+        correctly handle gaps longer than 24 hours.
         @return: Boolean
         """
-        if self.last_seen and self.can_send:
+        if self.last_seen and self.machine.fsm.current in ["wait4init", "good2go"]:
+            poll_rate = getattr(getattr(self, "options", None), "poll_rate", 1)
+            timeout_threshold = max(60, poll_rate * 2)
             diff = datetime.now() - self.last_seen
-            if diff.seconds > 60:
+            if diff.total_seconds() > timeout_threshold:
                 return True
         return False
 
@@ -276,31 +287,40 @@ def report_data_payload(
     ) -> Optional[Response]:
         """
         Used to report collection payload to the host agent.  This can be metrics, spans and snapshot data.
+        When there is nothing to send (no spans, profiles, or metrics), a lightweight HEAD heartbeat
+        is sent instead so that the host-agent timeout detection continues to work correctly even
+        when poll_rate is larger than the 60-second timeout window.
         """
         response = None
+        data_was_sent = False
         try:
             # Report spans (if any)
             response = self.report_spans(payload)
-
             if response is not None and 200 <= response.status_code <= 204:
                 self.last_seen = datetime.now()
+                data_was_sent = True
 
             # Report profiles (if any)
             response = self.report_profiles(payload)
-
             if response is not None and 200 <= response.status_code <= 204:
                 self.last_seen = datetime.now()
+                data_was_sent = True
 
             # Report metrics
             response = self.report_metrics(payload)
-
             if response is not None and 200 <= response.status_code <= 204:
                 self.last_seen = datetime.now()
+                data_was_sent = True
 
                 if response.status_code == 200 and len(response.content) > 2:
-                    # The host agent returned something indicating that is has a request for us that we
-                    # need to process.
+                    # The host agent returned something indicating that it has a request for us
+                    # that we need to process.
                     self.handle_agent_tasks(json.loads(response.content)[0])
+
+            # Nothing was sent this cycle — send a heartbeat HEAD request so that
+            # is_timed_out() keeps working correctly at high poll_rate values.
+            if not data_was_sent:
+                self._send_heartbeat()
         except requests.exceptions.ConnectionError:
             pass
         except urllib3.exceptions.MaxRetryError:
@@ -312,6 +332,34 @@ def report_data_payload(
             )
         return response
 
+    def _send_heartbeat(self) -> None:
+        """
+        Updates last_seen via a HEAD request when no payload was sent this cycle.
+
+        Critical when metric collection is disabled (INSTANA_DISABLE_METRICS_COLLECTION)
+        and no spans arrive — last_seen would never be updated, causing is_timed_out()
+        to fire spuriously. Only runs in "good2go" state; wait4init already polls via
+        is_agent_ready().
+        """
+        try:
+            announce_data = self.announce_data  # local copy — avoids race with reset()
+            if announce_data is None:
+                return
+            if self.machine.fsm.current != "good2go":
+                return
+            response = self.client.head(self.__data_url(), timeout=0.8)
+            if response is not None and 200 <= response.status_code <= 204:
+                self.last_seen = datetime.now()
+        except requests.exceptions.ConnectionError:
+            pass
+        except urllib3.exceptions.MaxRetryError:
+            pass
+        except Exception as exc:
+            logger.debug(
+                f"_send_heartbeat: connection error ({type(exc)})",
+                exc_info=True,
+            )
+
     def report_metrics(self, payload: dict[str, Any]) -> Optional[Response]:
         metrics = payload.get("metrics", [])
         if len(metrics) > 0 and len(metrics.get("plugins", [])) > 0:

src/instana/collector/helpers/runtime.py

@@ -83,6 +83,7 @@ def _collect_runtime_metrics(
             return
 
         """ Collect up and return the runtime metrics """
+        rusage = self.previous_rusage
         try:
             rusage = get_resource_usage()
             if gc.isenabled():

tests/agent/test_host.py

@@ -334,8 +334,8 @@ def test_is_timed_out(
         assert not agent.is_timed_out()
 
         agent.last_seen = datetime.datetime.now() - datetime.timedelta(minutes=5)
-        agent.can_send = True
-        assert agent.is_timed_out()
+        with patch.object(agent.machine.fsm, "current", "good2go"):
+            assert agent.is_timed_out()
 
     def test_can_send_test_env(
         self,

tests/collector/helpers/test_collector_runtime.py

@@ -1,6 +1,6 @@
 # (c) Copyright IBM Corp. 2024
 
-from typing import Generator
+from collections.abc import Generator
 from unittest.mock import patch
 
 import pytest
@@ -27,7 +27,7 @@ def test_default_while_gc_disabled(self) -> None:
 
         gc.disable()
         helper = RuntimeHelper(collector=HostCollector(HostAgent()))
-        assert helper.previous_gc_count is None
+        assert helper.previous_gc_stats is None
 
     def test_collect_metrics(self) -> None:
         response = self.helper.collect_metrics()
@@ -68,8 +68,71 @@ def test_collect_runtime_snapshot_webhook(self) -> None:
     def test_collect_gc_metrics(self) -> None:
         plugin_data = self.helper.collect_metrics()
 
+        # First call establishes the baseline (previous_gc_stats was None); no
+        # data is written yet.
         self.helper._collect_gc_metrics(plugin_data[0], True)
-        assert len(self.helper.previous["data"]["metrics"]["gc"]) == 6
+        assert self.helper.previous_gc_stats is not None
+
+        # Second call computes deltas from the baseline and writes them.
+        self.helper._collect_gc_metrics(plugin_data[0], True)
+        gc_metrics = self.helper.previous["data"]["metrics"]["gc"]
+        for i in range(3):
+            for key in ("collections", "collected", "uncollectable"):
+                assert f"{key}{i}" in gc_metrics
+
+    def test_collect_gc_metrics_reports_delta_between_polls(self) -> None:
+        """GC metrics must be deltas between successive polls, not kumulatif values."""
+        # Simulate first poll: previous_gc_stats set to known baseline
+        baseline = [
+            {"collections": 100, "collected": 200, "uncollectable": 0},
+            {"collections": 10, "collected": 50, "uncollectable": 0},
+            {"collections": 1, "collected": 5, "uncollectable": 0},
+        ]
+        self.helper.previous_gc_stats = baseline
+
+        # Simulate gc.get_stats() returning incremented counts
+        after = [
+            {"collections": 103, "collected": 206, "uncollectable": 0},
+            {"collections": 11, "collected": 53, "uncollectable": 0},
+            {"collections": 1, "collected": 5, "uncollectable": 0},
+        ]
+
+        plugin_data = [{"data": {"metrics": {"gc": {}}}}]
+
+        with patch("gc.get_stats", return_value=after):
+            self.helper._collect_gc_metrics(plugin_data[0], True)
+
+        gc_metrics = plugin_data[0]["data"]["metrics"]["gc"]
+        # Gen 0: collections delta = 3, collected delta = 6
+        assert gc_metrics["collections0"] == 3
+        assert gc_metrics["collected0"] == 6
+        assert gc_metrics["uncollectable0"] == 0
+        # Gen 1: collections delta = 1, collected delta = 3
+        assert gc_metrics["collections1"] == 1
+        assert gc_metrics["collected1"] == 3
+        # Gen 2: no change — delta = 0, still reported because with_snapshot=True
+        assert gc_metrics["collections2"] == 0
+        assert gc_metrics["collected2"] == 0
+
+        # previous_gc_stats must be updated to the latest snapshot
+        assert self.helper.previous_gc_stats == after
+
+    def test_collect_gc_metrics_no_change_not_sent_without_snapshot(self) -> None:
+        """When nothing changed and with_snapshot=False, gc metrics must be empty."""
+        same = [
+            {"collections": 50, "collected": 100, "uncollectable": 0},
+            {"collections": 5, "collected": 20, "uncollectable": 0},
+            {"collections": 0, "collected": 0, "uncollectable": 0},
+        ]
+        self.helper.previous_gc_stats = same
+
+        plugin_data = [{"data": {"metrics": {"gc": {}}}}]
+
+        with patch("gc.get_stats", return_value=same):
+            self.helper._collect_gc_metrics(plugin_data[0], False)
+
+        # All deltas are 0 and with_snapshot=False → nothing written
+        assert plugin_data[0]["data"]["metrics"]["gc"] == {}
 
     def test_collect_runtime_metrics(self) -> None:
         """Test that _collect_runtime_metrics properly collects metrics"""