Struct CommitTiming 

pub struct CommitTiming {
    pub reference: Option<String>,
    pub outcome: &'static str,
    pub attempts: usize,
    pub prepare: Duration,
    pub build: Duration,
    pub provision: Duration,
    pub submit: SubmitTrace,
    pub after_landing: Duration,
    pub gate: Duration,
    pub handoff: Duration,
    /* private fields */
}

What: The phases of one wrapped commit, filled as the commit runs and written when it ends. Why: Each field is one disjoint stretch of the command, so the phases add up to no more than the total, and what they do not cover is reported as otherMs instead of being hidden.

In TS you’d write (pseudocode):

type CommitTiming = { began: number; prepare: number; build: number; provision: number; submit: SubmitTrace; /* ... */ };

Fields

reference: Option<String>

The branch (or HEAD) the first preparation found.

outcome: &'static str

How the command ended: landed, ended (blocked or declined, nothing landed) or stopped (a failure).

attempts: usize

Preparations made: one, and one more for each time the service sent the commit back or Git built it again.

prepare: Duration

Policies, hooks, the private index, the tree and the objects of the commit, summed over the attempts.

build: Duration

The message, the identities, the tree check and Git’s own build of the commit, with the scratch hand-over.

provision: Duration

Setting up socket activation, which is the manager’s unit comparison and, after an upgrade, a rewrite and a reload.

submit: SubmitTrace

Sending the request and waiting for the answer.

after_landing: Duration

The summary line, the names it needs, and the files a policy corrected, after the branch moved.

gate: Duration

The post-commit gate.

handoff: Duration

Leaving the push and the upkeep for the service and waking it.

Implementations

impl CommitTiming

pub fn start() -> Self

Starts the clocks: the monotonic one for the durations and the wall clock for the stamp.

pub fn place_at(&mut self, git_dir: &Path)

Names the worktree whose Git directory the command found; a command outside a repository writes no record.

pub fn line(&self, total: Duration, exit_code: i32) -> String

What: The record as one line of JSON ending in a newline. Why: One write call per line keeps lines of concurrent commits from interleaving; a branch name with a quote or a newline is escaped by quote, so the line stays one line.

In TS you’d write (pseudocode):

JSON.stringify(record) + '\n'

pub fn finish(&self, exit_code: i32)

What: Appends the record to the repository’s timing file, best effort. Why: The command’s result never depends on the record: a file that cannot be written is only a debug line. The directory is never created, and nothing is flushed to disk, so the record costs one write.

In TS you’d write (pseudocode):

recordTiming(timing, exitCode)

Trait Implementations

impl Clone for CommitTiming

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CommitTiming

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.