Struct CommitTiming 

pub struct CommitTiming {
    pub reference: Option<String>,
    pub request: 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,
    pub quiet: Vec<(String, 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.

request: Option<String>

The identity the commit’s request carries, which the service’s answered line states as request and as the journal field CLI_GIT_REQUEST_ID; the key that joins this record to the service’s.

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.

quiet: Vec<(String, Duration)>

The longest quiet gap of every Git step and tool this command ran, by step name, taken from the ledger when the record is written; a step that was ended for being quiet is listed apart from the steps that ended by themselves.

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.