gitpane 1.0.0__py3-none-any.whl

gitpane/controller/commit_timing_controller.py

@@ -0,0 +1,566 @@
+"""Time each commit in the optional --log file, from the click on Commit to the displayed result.
+
+The click line is written when Prepare changes sends its commit request, from Commit or from Commit & push. The result
+line is written once the new commit is painted in the history of every repository window that manages the worktree, and
+no work of that repository is left:
+refreshes and searches of its sessions, preparation reads, processes of the two runners started in one of its folders,
+worktree continuations and file tasks of it, its reservations, repository parsing and callbacks (those queued for the
+next turn of the event loop included), reference continuations
+and shared refreshes of its sessions. The repository's folders are its common Git folder and the worktree of each of its
+open sessions and Prepare changes windows, the submodules inside them included. Work whose repository is not known counts,
+and work of another repository open in GitPane does not, so the time of a commit does not grow with a transfer elsewhere.
+In a measured test, which opens only one repository, these are the bounds of the commit measurement, so a time read in the
+log of a real commit compares with the time the commit measurement of the tests reads; that measurement checks that they agree
+with its own.
+
+A window whose list shows the new commit's row outside its visible part, as after the user scrolled it, has no paint to
+wait for: the published history that holds the commit is what the user sees by scrolling back. A commit not seen
+displayed within COMMIT_TIMING_LIMIT_MS of its click writes an "abandoned" line and is no longer followed, so a window
+whose history never shows it is not watched for the rest of the session.
+
+The push of Commit & push is work of the same repository started by the same click, so the result line comes after it.
+
+A commit refused or failed, or one whose refresh fails, writes a failure line instead, and never a result line after
+it; so does a Commit & push whose request is dropped before the commit service gives a result, as when the reading of
+where to push is refused. Without an open log, nothing is subscribed: the commit goes the same way as without this controller, and a log that
+a disk error closes on the way ends every timing without an error.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QObject, QTimer
+from shiboken6 import isValid
+
+from gitpane.config import COMMIT_TIMING_LIMIT_MS, NANOSECONDS_PER_MILLISECOND
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.process.process_log import local_now
+from gitpane.system.path_identity import canonical_path
+from gitpane.ui.repository.history_model import MESSAGE_COLUMN
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+    from PySide6.QtCore import QRect
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.account.authentication import AuthenticationService
+    from gitpane.commit.commit_write import CommitOutcome, CommitRequest
+    from gitpane.controller.history_read_controller import HistoryReadController
+    from gitpane.controller.reference_read_controller import ReferenceReadController
+    from gitpane.controller.refresh_controller import RefreshController
+    from gitpane.controller.session_registry import RepositorySession, SessionRegistry
+    from gitpane.controller.staging_session_registry import StagingSessionRegistry
+    from gitpane.controller.worktree_state_controller import WorktreeStateController
+    from gitpane.history.repository import GitRepository
+    from gitpane.history.repository_value import RepositoryContext
+    from gitpane.operation.diagnostic import DiagnosticLog, PreparedDiagnostic
+    from gitpane.operation.repository_operation import OperationIntent, RepositoryOperationService
+    from gitpane.process.process_runner import ProcessRunner
+    from gitpane.ui.repository.repository_window import RepositoryWindow
+    from gitpane.worktree.staging import StagingSession
+    from gitpane.worktree.worktree_service import WorktreeService
+    from gitpane.worktree.worktree_snapshot import WorktreeKey
+
+COMMIT_TIMING_LOG_PREFIX = "Commit timing: "
+# The complete shape of a record, in writing order, the same for every event: a reader takes each field without looking
+# for it, like the process lines written next to it.
+COMMIT_TIMING_LOG_KEYS = ("time", "event", "operation_id", "elapsed_ms")
+# The end is checked one turn of the event loop after what may end the commit: the slots of a published history, of a
+# painted row or of a finished process still run their own work after it, and that work must be seen before the result
+# is called displayed.
+FINISH_CHECK_DELAY_MS = 0
+
+
+class CommitTimingEvent(Enum):
+    """The moments of a commit written in the log."""
+
+    CLICKED = "clicked"
+    SHOWN = "shown"
+    FAILED = "failed"
+    # The commit was not seen displayed before the time limit after its click, and is no longer followed.
+    ABANDONED = "abandoned"
+
+
+class PendingWork(Enum):
+    """A kind of repository work still running after a commit; the value names it in a measurement's failure message."""
+
+    REPOSITORY_REFRESH = "repository refresh or search"
+    PREPARATION = "preparation refresh or operation"
+    PROCESS_RUNNER = "process runner"
+    WORKTREE_TASK = "worktree continuation or file task"
+    RESERVATION = "repository reservation"
+    REPOSITORY_PARSING = "repository parsing or callback"
+    REFERENCE_CONTINUATION = "reference continuation"
+    SHARED_REFRESH = "shared refresh"
+
+
+def format_commit_timing_line(event: CommitTimingEvent, operation_id: str, now: datetime, elapsed_ms: int | None) -> str:
+    """Return the one-line record of a commit moment, which never holds the message, a path or a command.
+
+    ``elapsed_ms`` is the time since the click, absent from the click's own line.
+    """
+    value_by_key: dict[str, object] = {
+        "time": now.isoformat(timespec="milliseconds"),
+        "event": event.value,
+        "operation_id": operation_id,
+        "elapsed_ms": elapsed_ms,
+    }
+    # ASCII only, like a process line: a record stays one physical line whatever a reader treats as a line break.
+    return COMMIT_TIMING_LOG_PREFIX + json.dumps(value_by_key, ensure_ascii=True)
+
+
+def commit_row_rectangle(window: RepositoryWindow, oid: str) -> QRect | None:
+    """Return where the message of this commit's row sits in the history list, or nothing when the list has no such row."""
+    model = window.history_model
+    row = model.row_by_oid.get(oid)
+    if row is None:
+        return None
+    return window.commit_list.visualRect(model.index(row, MESSAGE_COLUMN))
+
+
+def commit_row_current(window: RepositoryWindow, session: RepositorySession | None, oid: str | None, published_generation: int | None) -> bool:
+    """Tell whether the window's complete current history, the one this publication made, holds this commit in its list.
+
+    The history must be complete and without error, the generation published equal to the session's and to the shown
+    history's, the list model built on that history and holding every one of its commits.
+    """
+    snapshot = window.snapshot
+    if (session is None or snapshot is None or not snapshot.complete or snapshot.error or oid is None
+            or published_generation != session.generation or snapshot.generation != session.generation
+            or window.history_model.snapshot is not snapshot):
+        return False
+    return window.history_model.rowCount() == len(snapshot.ordered_oids) and oid in snapshot.ordered_oids
+
+
+def commit_row_in_view(window: RepositoryWindow, oid: str) -> bool:
+    """Tell whether this commit's row crosses the visible part of the history list."""
+    rectangle = commit_row_rectangle(window, oid)
+    if rectangle is None:
+        return False
+    viewport = window.commit_list.viewport()
+    return viewport.isVisible() and not rectangle.isEmpty() and viewport.rect().intersects(rectangle)
+
+
+def commit_row_visible(window: RepositoryWindow, session: RepositorySession | None, oid: str | None, published_generation: int | None) -> bool:
+    """Tell whether the window shows this commit in its complete current history, in the visible part of its list."""
+    return commit_row_current(window, session, oid, published_generation) and commit_row_in_view(window, oid)
+
+
+@dataclass
+class CommitTiming:
+    """One commit followed from its click until its result is displayed in the windows that manage its worktree.
+
+    Each followed window is known by its session id: the generation its history had at the click, the generation a
+    refresh published after it, the one whose paint is waiting for confirmation, and the one confirmed painted.
+    ``limit_timer`` ends the timing with an "abandoned" line once the time limit since the click has passed.
+    """
+
+    operation_id: str
+    key: WorktreeKey
+    common_dir: str
+    clicked_ns: int
+    initial_generation_by_session_id: dict[str, int]
+    viewport_by_session_id: dict[str, QWidget]
+    oid: str | None = None
+    published_generation_by_session_id: dict[str, int] = field(default_factory=dict)
+    confirming_generation_by_session_id: dict[str, int] = field(default_factory=dict)
+    painted_generation_by_session_id: dict[str, int] = field(default_factory=dict)
+    limit_timer: QTimer | None = None
+
+
+class CommitTimingController(QObject):
+    """Write the click and the outcome of every commit into the --log file, when there is one.
+
+    The outcome is the displayed result of a commit that succeeded, the failure of a commit refused, failed or whose
+    refresh failed, or the end of a commit not seen displayed within the time limit after its click. The end conditions
+    read here look at the work of the commit's repository only; the commit measurement, which looks at the work of the
+    whole application, checks that they agree with its own.
+    """
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, staging_session_registry_controller: StagingSessionRegistry, worktree_state_controller: WorktreeStateController,
+                 history_read_controller: HistoryReadController, refresh_controller: RefreshController, reference_read_controller: ReferenceReadController, repository: GitRepository,
+                 authentication: AuthenticationService, worktree_service: WorktreeService, repository_operation: RepositoryOperationService, diagnostic_log: DiagnosticLog | None,
+                 parent: QObject | None = None) -> None:
+        """Receive every state the end of a commit is read from; subscribe to nothing unless the log is open.
+
+        The condition is on the open file, like the process lines: without a log, no slot is added to the path every
+        process and every published history goes through.
+        """
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.worktree_state_controller = worktree_state_controller
+        self.history_read_controller = history_read_controller
+        self.refresh_controller = refresh_controller
+        self.reference_read_controller = reference_read_controller
+        self.repository = repository
+        self.authentication = authentication
+        self.worktree_service = worktree_service
+        self.repository_operation = repository_operation
+        self.diagnostic_log = diagnostic_log
+        # The two runners GitPane starts Git with: the repository's, and the one of the operations that use an account.
+        self.runners: list[ProcessRunner] = [repository.runner, authentication.runner]
+        self.timing_by_operation_id: dict[str, CommitTiming] = {}
+        self.finish_check_timer = QTimer(self)
+        self.finish_check_timer.setSingleShot(True)
+        self.finish_check_timer.setInterval(FINISH_CHECK_DELAY_MS)
+        self.finish_check_timer.timeout.connect(self._check_finished)
+        if not self._log_open():
+            return
+        history_read_controller.history_published.connect(self._history_published)
+        history_read_controller.refresh_failed.connect(self._refresh_failed)
+        for runner in self.runners:
+            runner.finished.connect(self._work_finished)
+        # A file task, the last continuation of a read or a queued repository callback can end after the last process:
+        # their end is told by these.
+        worktree_service.idle.connect(self._work_finished)
+        repository_operation.idle.connect(self._work_finished)
+        repository.next_turn_work_done.connect(self._work_finished)
+
+    def _log_open(self) -> bool:
+        """Tell whether a line written now reaches the file; a disk error closes it for good."""
+        return self.diagnostic_log is not None and self.diagnostic_log.stream is not None
+
+    def pending_work(self, common_dir: str) -> list[str]:
+        """Name the work of this repository still running, without mistaking kept histories or generation maps for requests.
+
+        ``common_dir`` is the canonical common Git folder of the repository. Its sessions and Prepare changes windows are
+        known by that folder. A process counts when it runs in one of the repository's folders, a worktree continuation
+        or file task or a reservation when one of its repositories or reserved folders is one of them, and repository
+        parsing, reference continuations and shared refreshes when they serve one of its sessions. Work whose repository
+        is not known here counts: a sequence the worktree service holds between two steps, a read with no session, a
+        session already forgotten. Work of another repository does not. One name is given per kind of running work, per
+        runner and per shared refresh, so the same name can come more than once.
+        """
+        repository_dir_set = self._repository_dir_set(common_dir)
+        reasons: list[str] = []
+        for session in tuple(self.session_registry_controller.session_by_id.values()):
+            if session.is_closed or canonical_path(session.repository_context.common_git_dir) != common_dir:
+                continue
+            if session.refresh_active or session.refresh_queued is not None or session.search_pending:
+                reasons.append(PendingWork.REPOSITORY_REFRESH.value)
+        for staging in tuple(self.staging_session_registry_controller.staging_by_key.values()):
+            if canonical_path(staging.context.common_git_dir) != common_dir:
+                continue
+            if staging.refresh_active or staging.refresh_queued or staging.explicit_refresh or staging.probe_active or staging.busy:
+                reasons.append(PendingWork.PREPARATION.value)
+        for runner in self.runners:
+            requests = [*runner.pending_requests]
+            for active in tuple(runner.active_by_id.values()):
+                requests.append(active.request)
+            for request in requests:
+                if self._inside_repository(request.working_dir, repository_dir_set):
+                    reasons.append(PendingWork.PROCESS_RUNNER.value)
+                    break
+        if self._worktree_task_running(repository_dir_set):
+            reasons.append(PendingWork.WORKTREE_TASK.value)
+        for intent in tuple(self.repository_operation.active_by_id.values()):
+            if self._intent_in_repository(intent, repository_dir_set):
+                reasons.append(PendingWork.RESERVATION.value)
+                break
+        if self._repository_parsing_running(repository_dir_set):
+            reasons.append(PendingWork.REPOSITORY_PARSING.value)
+        for session_id in tuple(self.reference_read_controller.reference_continuation_by_session):
+            if self._session_in_repository(session_id, repository_dir_set):
+                reasons.append(PendingWork.REFERENCE_CONTINUATION.value)
+                break
+        for shared in tuple(self.refresh_controller.full_refresh_read_by_key.values()):
+            for session_id in tuple(shared.session_generation_by_id):
+                if self._session_in_repository(session_id, repository_dir_set):
+                    reasons.append(PendingWork.SHARED_REFRESH.value)
+                    break
+        return reasons
+
+    def _repository_dir_set(self, common_dir: str) -> set[str]:
+        """Return the canonical folders of the repository: its common Git folder and the worktree of each of its open sessions and Prepare changes windows."""
+        repository_dir_set = {common_dir}
+        for session in tuple(self.session_registry_controller.session_by_id.values()):
+            if not session.is_closed and canonical_path(session.repository_context.common_git_dir) == common_dir:
+                repository_dir_set.add(canonical_path(session.repository_context.repository_dir))
+        for staging in tuple(self.staging_session_registry_controller.staging_by_key.values()):
+            if canonical_path(staging.context.common_git_dir) == common_dir:
+                repository_dir_set.add(canonical_path(staging.context.repository_dir))
+        return repository_dir_set
+
+    @staticmethod
+    def _inside_repository(folder: str, repository_dir_set: set[str]) -> bool:
+        """Tell whether a folder is one of the repository's folders or inside one; a folder on another drive is outside."""
+        canonical_folder = canonical_path(folder)
+        for repository_dir in repository_dir_set:
+            try:
+                if os.path.commonpath((canonical_folder, repository_dir)) == repository_dir:
+                    return True
+            except ValueError:
+                continue
+        return False
+
+    def _context_in_repository(self, context: RepositoryContext, repository_dir_set: set[str]) -> bool:
+        """Tell whether a repository location is the repository's own, one of its linked worktrees, or one of its submodules."""
+        return self._inside_repository(context.common_git_dir, repository_dir_set) or self._inside_repository(context.repository_dir, repository_dir_set)
+
+    def _session_in_repository(self, session_id: str, repository_dir_set: set[str]) -> bool:
+        """Tell whether work done for a session may be the repository's; a session no longer known counts, its repository being unknown."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None:
+            return True
+        return self._context_in_repository(session.repository_context, repository_dir_set)
+
+    def _intent_in_repository(self, intent: OperationIntent, repository_dir_set: set[str]) -> bool:
+        """Tell whether a reservation holds the repository, by its repository, the other repositories it reserves or its reserved folders."""
+        for context in (intent.context, *intent.reserved_contexts):
+            if self._context_in_repository(context, repository_dir_set):
+                return True
+        for reserved_dir in intent.reserved_repository_dirs:
+            if self._inside_repository(reserved_dir, repository_dir_set):
+                return True
+        return False
+
+    def _worktree_task_running(self, repository_dir_set: set[str]) -> bool:
+        """Tell whether a worktree continuation or file task of the repository runs, or a sequence is held between two steps.
+
+        A sequence the service holds with no continuation or file task running is between two of its steps, where its
+        repository is not known: it counts.
+        """
+        worktree = self.worktree_service
+        running_sequence_set: set[object] = set()
+        found = False
+        for sequence, _callback, context, *_rest in (*worktree.continuation_by_id.values(), *worktree.file_task_by_id.values()):
+            running_sequence_set.add(sequence)
+            if self._context_in_repository(context, repository_dir_set):
+                found = True
+        if found:
+            return True
+        for sequence in tuple(worktree.operation_id_by_sequence):
+            if sequence not in running_sequence_set:
+                return True
+        return False
+
+    def _repository_parsing_running(self, repository_dir_set: set[str]) -> bool:
+        """Tell whether a read of the repository is parsed or waits for its callback, by the session its request was made for.
+
+        A request with no identity has no known session: it counts. A callback the repository queued for the next turn
+        of the event loop, such as a cached commit or diff about to be published, is held by no request: it is judged by
+        the session it was queued for, and counts when that session is unknown. Without it the result line could be
+        written one turn before the commit's details are shown; the one service serves every open window, so a callback
+        queued for a window of another repository does not count.
+        """
+        repository = self.repository
+        for session_id in tuple(repository.next_turn_session_id_by_token.values()):
+            if session_id is None or self._session_in_repository(session_id, repository_dir_set):
+                return True
+        request_id_set = {*repository.stream_by_id, *repository.batch_read_by_request_id, *repository.callback_by_id, *repository.result_callback_by_id}
+        for request_id in request_id_set:
+            identity = repository.identity_by_id.get(request_id)
+            if identity is None or self._session_in_repository(identity.session_id, repository_dir_set):
+                return True
+        return False
+
+    def commit_clicked(self, staging: StagingSession, request: CommitRequest) -> None:
+        """Start the clock of a commit Prepare changes has just sent, and watch the history of each window of its worktree.
+
+        Commit and Commit & push both come here. The end is checked once the click's own slots have run, in case the
+        request was already dropped by then.
+        """
+        if not self._log_open():
+            return
+        clicked_ns = time.monotonic_ns()
+        initial_generation_by_session_id: dict[str, int] = {}
+        viewport_by_session_id: dict[str, QWidget] = {}
+        for session_id, window in self.worktree_state_controller.managed_windows_of_worktree(staging.key):
+            initial_generation_by_session_id[session_id] = self.session_registry_controller.session_by_id[session_id].generation
+            viewport = window.commit_list.viewport()
+            viewport.installEventFilter(self)
+            viewport_by_session_id[session_id] = viewport
+        timing = CommitTiming(request.operation_id, staging.key, canonical_path(staging.context.common_git_dir), clicked_ns, initial_generation_by_session_id, viewport_by_session_id)
+        timing.limit_timer = QTimer(self)
+        timing.limit_timer.setSingleShot(True)
+        timing.limit_timer.setInterval(COMMIT_TIMING_LIMIT_MS)
+        timing.limit_timer.timeout.connect(lambda: self._limit_reached(request.operation_id))
+        timing.limit_timer.start()
+        self.timing_by_operation_id[request.operation_id] = timing
+        self._write(CommitTimingEvent.CLICKED, request.operation_id, None)
+        self.finish_check_timer.start()
+
+    def commit_finished(self, outcome: CommitOutcome) -> None:
+        """Keep the new commit of a followed click, so its row is looked for in the refreshed histories.
+
+        Any other result, a commit that succeeded with a warning included, ends the timing with a failure line: no
+        result of this click will be called displayed.
+        """
+        timing = self.timing_by_operation_id.get(outcome.operation_id)
+        if timing is None:
+            return
+        if outcome.status != OperationStatus.SUCCESS or outcome.after is None or not outcome.after.snapshot.head_oid:
+            self._finish(timing, CommitTimingEvent.FAILED)
+            return
+        timing.oid = outcome.after.snapshot.head_oid
+        self.finish_check_timer.start()
+
+    def _refresh_failed(self, session_id: str, diagnostic: PreparedDiagnostic) -> None:
+        """End with a failure line every followed commit of the repository whose window could not read its history again."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or not self.timing_by_operation_id:
+            return
+        common_dir = canonical_path(session.repository_context.common_git_dir)
+        for timing in tuple(self.timing_by_operation_id.values()):
+            if timing.common_dir == common_dir:
+                self._finish(timing, CommitTimingEvent.FAILED)
+
+    def _history_published(self, session_id: str, generation: int) -> None:
+        """Take a history published after the click as the one to see painted, forgetting the paint of an older one."""
+        if not self.timing_by_operation_id:
+            return
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or generation != session.generation:
+            return
+        for timing in self.timing_by_operation_id.values():
+            initial_generation = timing.initial_generation_by_session_id.get(session_id)
+            if initial_generation is None or generation <= initial_generation:
+                continue
+            timing.published_generation_by_session_id[session_id] = generation
+            timing.confirming_generation_by_session_id.pop(session_id, None)
+            timing.painted_generation_by_session_id.pop(session_id, None)
+        self.finish_check_timer.start()
+
+    def _work_finished(self, *arguments: object) -> None:
+        """Look at the end again once the slots of this finished work have run, when a commit is followed."""
+        if self.timing_by_operation_id:
+            self.finish_check_timer.start()
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Note that Qt is painting the new commit's row; the paint is confirmed after Qt has processed it.
+
+        Nothing is built or changed during the paint: only the generation to confirm is noted, and the event goes on.
+        """
+        if event.type() != QEvent.Type.Paint or not self.timing_by_operation_id:
+            return False
+        for timing in self.timing_by_operation_id.values():
+            for session_id, viewport in timing.viewport_by_session_id.items():
+                if viewport is not watched:
+                    continue
+                window = self.session_registry_controller.window_by_session.get(session_id)
+                session = self.session_registry_controller.session_by_id.get(session_id)
+                published_generation = timing.published_generation_by_session_id.get(session_id)
+                if window is None or not isValid(window) or not commit_row_visible(window, session, timing.oid, published_generation):
+                    continue
+                rectangle = commit_row_rectangle(window, timing.oid)
+                if rectangle is None or not event.region().intersects(rectangle):
+                    continue
+                timing.confirming_generation_by_session_id[session_id] = published_generation
+                self.finish_check_timer.start()
+        return False
+
+    def _confirm_paints(self, timing: CommitTiming) -> None:
+        """Keep a noted paint only if the row it painted still shows the same published history."""
+        for session_id, generation in tuple(timing.confirming_generation_by_session_id.items()):
+            del timing.confirming_generation_by_session_id[session_id]
+            window = self.session_registry_controller.window_by_session.get(session_id)
+            session = self.session_registry_controller.session_by_id.get(session_id)
+            if (window is not None and isValid(window) and generation == timing.published_generation_by_session_id.get(session_id)
+                    and commit_row_visible(window, session, timing.oid, generation)):
+                timing.painted_generation_by_session_id[session_id] = generation
+
+    def _displayed_everywhere(self, timing: CommitTiming) -> bool:
+        """Tell whether every followed window the user can see shows the new commit in its last published history.
+
+        A window closed, hidden or minimized since the click shows nothing to wait for. A row outside the visible part
+        of the list has no paint to wait for either: the published history that holds it is what the user sees by
+        scrolling to it. A row in view must have been painted.
+        """
+        for session_id in timing.initial_generation_by_session_id:
+            session = self.session_registry_controller.session_by_id.get(session_id)
+            window = self.session_registry_controller.window_by_session.get(session_id)
+            if session is None or session.is_closed or window is None or not isValid(window) or window.is_closed or not window.isVisible() or window.isMinimized():
+                continue
+            published_generation = timing.published_generation_by_session_id.get(session_id)
+            if published_generation is None or not commit_row_current(window, session, timing.oid, published_generation):
+                return False
+            if commit_row_in_view(window, timing.oid) and timing.painted_generation_by_session_id.get(session_id) != published_generation:
+                return False
+        return True
+
+    def _check_finished(self) -> None:
+        """Write the result line of every followed commit now displayed with no work of its repository left.
+
+        A followed commit without a new commit whose request was dropped ends with a failure line instead.
+        """
+        if not self._log_open():
+            self._forget_every_timing()
+            return
+        for timing in tuple(self.timing_by_operation_id.values()):
+            if timing.oid is None and self._request_dropped(timing):
+                self._finish(timing, CommitTimingEvent.FAILED)
+                continue
+            self._confirm_paints(timing)
+            if timing.oid is None or not self._displayed_everywhere(timing) or self.pending_work(timing.common_dir):
+                continue
+            self._finish(timing, CommitTimingEvent.SHOWN)
+
+    def _request_dropped(self, timing: CommitTiming) -> bool:
+        """Tell whether the commit's request was dropped before the commit service gave a result for it.
+
+        Prepare changes clears its active request and gives the result in the same call, with no turn of the event
+        loop between them: a request cleared without a result cannot be a commit about to finish. That is a Commit &
+        push refused while it read where to push, or a Prepare changes session that no longer exists.
+        """
+        staging = self.staging_session_registry_controller.staging_by_key.get(timing.key)
+        if staging is None:
+            return True
+        request = staging.active_commit_request
+        return request is None or request.operation_id != timing.operation_id
+
+    def _limit_reached(self, operation_id: str) -> None:
+        """End with an "abandoned" line a commit still followed when the time limit since its click has passed."""
+        timing = self.timing_by_operation_id.get(operation_id)
+        if timing is None:
+            return
+        elapsed_ms = (time.monotonic_ns() - timing.clicked_ns) // NANOSECONDS_PER_MILLISECOND
+        if elapsed_ms < COMMIT_TIMING_LIMIT_MS and timing.limit_timer is not None:
+            # Qt lets a coarse timer fire up to a twentieth of its interval early: wait for the rest of the limit.
+            timing.limit_timer.start(COMMIT_TIMING_LIMIT_MS - elapsed_ms)
+            return
+        self._finish(timing, CommitTimingEvent.ABANDONED)
+
+    def _finish(self, timing: CommitTiming, event: CommitTimingEvent) -> None:
+        """Write the last line of a followed commit, with the time since its click, then stop following it."""
+        elapsed_ms = (time.monotonic_ns() - timing.clicked_ns) // NANOSECONDS_PER_MILLISECOND
+        self._forget(timing)
+        self._write(event, timing.operation_id, elapsed_ms)
+
+    def _forget(self, timing: CommitTiming) -> None:
+        """Stop following a commit: its time limit is stopped and released, and the filter taken off every viewport no other followed commit watches."""
+        self.timing_by_operation_id.pop(timing.operation_id, None)
+        if timing.limit_timer is not None:
+            timing.limit_timer.stop()
+            timing.limit_timer.deleteLater()
+            timing.limit_timer = None
+        for session_id, viewport in timing.viewport_by_session_id.items():
+            if not isValid(viewport):
+                continue
+            watched_elsewhere = False
+            for other in self.timing_by_operation_id.values():
+                if other.viewport_by_session_id.get(session_id) is viewport:
+                    watched_elsewhere = True
+            if not watched_elsewhere:
+                viewport.removeEventFilter(self)
+
+    def _forget_every_timing(self) -> None:
+        """Stop following every commit once the log can take no more lines."""
+        for timing in tuple(self.timing_by_operation_id.values()):
+            self._forget(timing)
+
+    def _write(self, event: CommitTimingEvent, operation_id: str, elapsed_ms: int | None) -> None:
+        """Write one line; a disk error that closes the log ends every timing without raising."""
+        if not self._log_open():
+            self._forget_every_timing()
+            return
+        self.diagnostic_log.write_line(format_commit_timing_line(event, operation_id, local_now(), elapsed_ms))
+        if not self._log_open():
+            self._forget_every_timing()