Use static "Snapshot" label in DAP stopped event description

Summary:
The dynamic `Snapshot {N}/{M} — {HH:MM:SS.fff} ({ExceptionType})` description that `_snapshot_display_name` builds for the `stopped` event looks correct on the initial launch but stays stale on subsequent `tintypeJumpToSnapshot` requests. VS Code does not consistently re-render the CALL STACK description on every `stopped` event after the first one, so the label drifts out of sync with the actual cursor — and a stale `1/3` label next to snapshot 2 is more misleading than no detail at all. The bootstrap-then-real pair in `handle_launch` is also affected: in practice the bootstrap event's plain `"Snapshot"` is what users see on launch, hiding the dynamic format entirely.

Collapse `_snapshot_display_name` to always return `"Snapshot"`. The snapshot index and timestamp the user actually needs are already visible in the Tintype Snapshots panel — the CALL STACK description doesn't need to duplicate them. The bootstrap-then-real `_send_stopped_event` pair in `handle_launch` is kept intact so any future re-introduction of a dynamic label (e.g. once we have a reliable way to push description updates to VS Code) can use it without code changes.

Drops the now-unused `import datetime`.

Reviewed By: bvu405

Differential Revision: D106092777

fbshipit-source-id: d0e3cb034883423dde01b50a3f1d001f730ea7d9

Author: pdepetro

dap/session.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import datetime
 import logging
 import os
 import re
@@ -1223,58 +1222,23 @@ def _require_snapshot(self) -> Snapshot:
     # Display-name helpers
     # ---------------------------------------------------------------
 
-    def _snapshot_display_name(self, snapshot: Snapshot) -> str | None:
+    def _snapshot_display_name(self, _snapshot: Snapshot) -> str | None:
         """One-line description of the current snapshot.
 
         Surfaced via the ``stopped`` event's ``description`` field, which
-        VS Code renders next to the session row in CALL STACK. Keep it
-        short — the field is a single-line label and VS Code truncates.
-
-        Default format::
-
-            Snapshot {N}/{M} — {HH:MM:SS.fff} ({ExceptionType})
-
-        Returns ``None`` to suppress the description entirely.
+        VS Code renders next to the session row in CALL STACK.
+
+        Currently always returns the static label ``"Snapshot"`` rather
+        than a dynamic ``N/M — timestamp`` format. The dynamic format
+        looks correct on the initial launch but stays stale on
+        subsequent ``tintypeJumpToSnapshot`` requests because VS Code
+        does not consistently re-render the CALL STACK description on
+        every ``stopped`` event after the first one. A stale dynamic
+        label is more misleading than a static one — the snapshot
+        index / timestamp the user actually needs is already visible
+        in the snapshots panel.
         """
-        parts: list[str] = []
-        try:
-            total = self._require_reader().snapshot_count()
-        except DispatchError:
-            total = 1
-        if total > 1:
-            parts.append(f"Snapshot {self._snapshot_index + 1}/{total}")
-        else:
-            parts.append("Snapshot")
-
-        try:
-            # ``snapshot.timestamp`` is microseconds since the Unix epoch.
-            # Format using UTC so cross-timezone teams opening the same
-            # ``.pytb`` see identical labels in CALL STACK (the label
-            # otherwise depends on the viewer's local wall clock, which
-            # is confusing when correlating snapshots with server-side
-            # timestamps).
-            ts_seconds = int(snapshot.timestamp) / 1_000_000.0
-            dt = datetime.datetime.fromtimestamp(ts_seconds, tz=datetime.timezone.utc)
-            parts.append("— " + dt.strftime("%H:%M:%S.%f")[:-3] + " UTC")
-        except (ValueError, OSError, OverflowError, TypeError) as e:
-            # Concrete failure modes of ``int()`` (TypeError / ValueError),
-            # ``fromtimestamp()`` (OverflowError / OSError on Windows for
-            # out-of-range timestamps), and attribute access on a
-            # malformed Snapshot (AttributeError is intentionally NOT
-            # caught — it signals a real bug, not a bad timestamp). Log
-            # at warning so bug reports can surface the real cause; the
-            # description field just loses the timestamp decoration.
-            logger.warning(
-                "failed to format timestamp for snapshot display name: %s", e
-            )
-
-        for st in snapshot.stacktraces.values():
-            exc = st.exception_object
-            if exc is not None:
-                parts.append(f"({type(exc).__name__})")
-                break
-
-        return " ".join(parts) if parts else None
+        return "Snapshot"
 
 
 # ---------------------------------------------------------------

dap/tests/test_session.py

@@ -167,28 +167,23 @@ def test_launch_emits_initial_events(self) -> None:
 
         messages = _drain_messages(self.stream)
         # We expect: launch response, initialized, thread(s), two
-        # stopped events (bootstrap + real). The bootstrap carries a
-        # generic ``"Snapshot"`` description so VS Code has something to
-        # overwrite on its initial-launch race; the real event that
-        # follows sets the actual display name the user sees in the
-        # CALL STACK panel. We still emit NO ``process`` event — that
-        # surface is owned by the Tintype Snapshots sidebar.
+        # stopped events (bootstrap + real). Both currently carry the
+        # static ``"Snapshot"`` description; the bootstrap-then-real
+        # pattern is retained because VS Code overwrites the
+        # description on the first event of a launch, and any future
+        # reintroduction of a dynamic display name needs the second
+        # event to settle the real value. We still emit NO ``process``
+        # event — that surface is owned by the Tintype Snapshots
+        # sidebar.
         event_names = [m.get("event") for m in messages if m["type"] == "event"]
         self.assertIn("initialized", event_names)
         self.assertNotIn("process", event_names)
         self.assertIn("thread", event_names)
         self.assertEqual(event_names.count("stopped"), 2)
 
         stopped_events = [m for m in messages if m.get("event") == "stopped"]
-        # First is bootstrap — generic "Snapshot" label.
         self.assertEqual(stopped_events[0]["body"]["description"], "Snapshot")
-        # Second is the real one — must include a richer description.
-        self.assertIn("description", stopped_events[1]["body"])
-        self.assertIn("Snapshot", stopped_events[1]["body"]["description"])
-        self.assertNotEqual(
-            stopped_events[0]["body"]["description"],
-            stopped_events[1]["body"]["description"],
-        )
+        self.assertEqual(stopped_events[1]["body"]["description"], "Snapshot")
 
     def test_launch_succeeds_on_empty_snapshot_file(self) -> None:
         """An empty ``.pytb`` is a valid launch state.
@@ -1774,9 +1769,13 @@ def test_exception_info_on_virtual_chain_thread_returns_innermost_cause(
 
 class StoppedEventDescriptionTest(unittest.TestCase):
     """``stopped`` events carry a ``description`` field with the snapshot's
-    display name. On launch we send a bootstrap ``"Snapshot"`` event first so
-    VS Code has something to overwrite on its initial-launch race, followed
-    by the real description event the user actually sees."""
+    display name. The label is currently the static string ``"Snapshot"`` —
+    a dynamic ``N/M — timestamp`` form looked correct on launch but went
+    stale on subsequent ``tintypeJumpToSnapshot`` calls because VS Code
+    does not consistently re-render CALL STACK descriptions on every
+    ``stopped`` event after the first. A stale dynamic label is more
+    misleading than a static one — the snapshot index / timestamp the
+    user needs is already visible in the snapshots panel."""
 
     def setUp(self) -> None:
         self.stream = RecordingStream()
@@ -1805,38 +1804,9 @@ def _launch_with_snapshots(self, snapshots: list[Any]) -> MagicMock:
             )
         return reader
 
-    def test_launch_description_includes_timestamp_and_index(self) -> None:
-        st = _make_stacktrace(
-            100, [_make_frame("/a/b.py", "foo", 1, {})], thread_name="MainThread"
-        )
-        snap = _make_snapshot([st], ts=1_700_000_000_000_000)
-        self._launch_with_snapshots([snap])
-
-        stopped_events = [
-            m for m in _drain_messages(self.stream) if m.get("event") == "stopped"
-        ]
-        real = stopped_events[-1]["body"]
-        self.assertIn("description", real)
-        self.assertIn("Snapshot", real["description"])
-        # HH:MM:SS.fff pattern must show up in the real-stop description.
-        self.assertRegex(real["description"], r"\d{2}:\d{2}:\d{2}\.\d{3}")
-
-    def test_description_mentions_exception_type(self) -> None:
-        st = _make_stacktrace(
-            100,
-            [_make_frame("/a/b.py", "foo", 1, {})],
-            thread_name="MainThread",
-            exception=KeyError("missing"),
-        )
-        snap = _make_snapshot([st])
-        self._launch_with_snapshots([snap])
-
-        real = [m for m in _drain_messages(self.stream) if m.get("event") == "stopped"][
-            -1
-        ]["body"]
-        self.assertIn("KeyError", real["description"])
-
-    def test_description_updates_across_snapshot_jumps(self) -> None:
+    def test_description_is_static_snapshot_label(self) -> None:
+        """Every ``stopped`` event — launch, jump, and exception — uses
+        the static ``"Snapshot"`` description."""
         snap1 = _make_snapshot(
             [
                 _make_stacktrace(
@@ -1853,16 +1823,18 @@ def test_description_updates_across_snapshot_jumps(self) -> None:
                     100,
                     [_make_frame("/a/b.py", "foo", 2, {})],
                     thread_name="MainThread",
+                    exception=KeyError("missing"),
                 )
             ],
             ts=1_700_000_005_000_000,
         )
         self._launch_with_snapshots([snap1, snap2])
 
-        launch_desc = [
+        launch_stops = [
             m for m in _drain_messages(self.stream) if m.get("event") == "stopped"
-        ][-1]["body"]["description"]
-        self.assertIn("1/2", launch_desc)
+        ]
+        for evt in launch_stops:
+            self.assertEqual(evt["body"]["description"], "Snapshot")
 
         self.stream.seek(0)
         self.stream.truncate()
@@ -1878,9 +1850,11 @@ def test_description_updates_across_snapshot_jumps(self) -> None:
         ]
         # Jump emits exactly one stopped event (no bootstrap).
         self.assertEqual(len(jump_events), 1)
-        jump_desc = jump_events[0]["body"]["description"]
-        self.assertIn("2/2", jump_desc)
-        self.assertNotEqual(launch_desc, jump_desc)
+        # Even though snap2 carries an exception, the static label
+        # does not mention the exception type. CALL STACK shows the
+        # exception via the thread name + stop reason; the description
+        # is intentionally minimal.
+        self.assertEqual(jump_events[0]["body"]["description"], "Snapshot")
 
 
 if __name__ == "__main__":