Struct IndexReport 

pub struct IndexReport {

    pub scanned: usize,
    pub indexed: usize,
    pub unchanged: usize,
    pub skipped: usize,
    pub removed: usize,
    pub chunks: usize,
    pub remaining: usize,
    pub pending: Vec<PathBuf>,
    pub generated: Vec<String>,
    pub rechunked: bool,
    pub refused: Vec<(String, String)>,
    pub failed: Vec<(String, String)>,
    pub skipped_reasons: BTreeMap<String, usize>,
    pub secrets_indexed: usize,
    pub dummies_indexed: usize,
    pub accepted_indexed: usize,
    pub symbols: usize,
    pub edges: usize,
    pub images: usize,
    pub stopped: bool,
    pub threads: usize,
    pub embedded: usize,
    pub batched: usize,
    pub lanes: BTreeMap<String, usize>,
    pub bytes: u64,
    pub bytes_total: u64,
    pub written: Vec<String>,
    pub stages: Stages,
    pub cache_lookups: usize,
    pub cache_hits: usize,
    pub rows: usize,
    pub expected_left: u64,
    pub images_left: usize,
    pub images_flight: usize,
    /* private fields */
}

Fields

scanned: usize

indexed: usize

unchanged: usize

skipped: usize

removed: usize

chunks: usize

remaining: usize

Paths a time-bounded run never reached. Zero unless a budget cut the run short — an unbounded index_paths always finishes what it walked.

pending: Vec<PathBuf>

Exactly the paths this slice did not reach, in the order it would have taken them.

The next slice indexes these rather than walking the roots again. A re-walk is not merely wasted directory traversal: every file the run had already done is re-opened and re-hashed to discover it is unchanged, so a run of N files over S slices read N×S files instead of N, and the progress a page drew restarted from one on every slice. The content hashes made it correct to re-walk, which is why it went unnoticed.

generated: Vec<String>

Generated or vendored directories the walk stepped over — node_modules, a target beside a Cargo.toml, and the rest of the default-ignore table.

Named rather than counted in files, because pruning the subtree is the point and counting what is inside it would undo the saving to report it. A person looking for a file that is not in their store needs the name of the directory that was stepped over, which is what this gives them.

rechunked: bool

Whether this pass re-embedded files nothing on disk had changed, because the store was written by a release that showed the embedding model less than this one does.

A user whose unchanged repository suddenly indexes from scratch is owed the reason, and the reason is a property of the run rather than of any one file — so it is reported here and said once, not per file.

refused: Vec<(String, String)>

Paths refused, each with the rule that refused it.

Listed rather than counted: “three paths were refused” is not something an agent or a person can act on, and a refusal that is not named reads as a file that quietly failed to index.

failed: Vec<(String, String)>

Paths that failed on their own content, each with what failed.

Listed like refused, and for the same reason: a count of failures is a number somebody has to go and investigate, and this release exists because those investigations had nothing to go on.

skipped_reasons: BTreeMap<String, usize>

How many files were skipped for each reason, by kind.

secrets_indexed: usize

Files the content scan would have refused and --include-secrets indexed anyway. Reported so that the flag is never silent about what it did: a store that holds credentials should say how many.

dummies_indexed: usize

Files indexed whose every secret-shaped match was a declared test dummy.

accepted_indexed: usize

Files indexed because a person accepted them, in their accepted mode.

symbols: usize

Symbols extracted in this run, and the edges between them.

edges: usize

images: usize

Images embedded in this run.

stopped: bool

Whether the run was stopped rather than finished.

threads: usize

The intra-op thread count the session ran with at the end of this call, or 0 when nothing was embedded.

embedded: usize

Chunks embedded so far in this call, counted per batch. chunks counts finished files, so it stands still through a large one; this does not.

batched: usize

Chunks whose batch has come back from a device, ahead of their window landing: what progress moves on while the writer waits.

lanes: BTreeMap<String, usize>

Chunks each lane has embedded for this store, since it was opened.

bytes: u64

See IndexProgress::bytes.

bytes_total: u64

written: Vec<String>

Every file this call embedded, in order. The caller keeps these across the slices of one logical run, so stopping can undo the whole run rather than only the slice that happened to be going.

stages: Stages

Where this call’s wall time went, stage by stage.

cache_lookups: usize

Chunks the machine-wide vector cache was asked for, and held.

cache_hits: usize

rows: usize

Chunk rows this call wrote, embedded or not yet: what embedded is catching up with, and what a card’s pending share is taken from.

expected_left: u64

The chunks and images expected from the files this call has not reached yet: the estimate a continuation slice starts from.

images_left: usize

images_flight: usize

Images with the image lane: read, not embedded yet. Counted in the total, or the total dropped by each one sent and rose as it landed.

Trait Implementations

impl Clone for IndexReport

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 IndexReport

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

Formats the value using the given formatter.

impl Default for IndexReport

fn default() -> Self

Returns the “default value” for a type.

impl Serialize for IndexReport

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.