Struct LogDiffOpts 

pub struct LogDiffOpts {

    pub strip_lines: bool,
    pub canonicalize_addresses: bool,
    pub comparison: LogComparisonMode,
    pub side_labels: ComparisonSideLabels,
    pub require_structured_events: bool,
    pub print_logs: bool,
    pub limit: u64,
    pub ignore_lines: Vec<String>,
    pub syscall_history: u64,
    pub no_color: bool,
    pub skip_commit: bool,
    pub skip_detlog: bool,
    pub git_diff: bool,
    pub include_detlogs: Vec<DetLogFilter>,
}

Options for calling log_diff.

Fields

strip_lines: bool

UNSAFE: strips numbers and temporary paths before comparison.

This erases timestamps and syscall values that bitwise parity exists to compare. Never use this option to make a failing parity diff pass; doing so is cheating. It is only for non-parity diagnostic localization.

canonicalize_addresses: bool

Canonicalize host memory addresses before comparison WITHOUT erasing them.

Only addresses a producer has explicitly marked with the <hostaddr 0x...> wrapper (see host_addr) are canonicalized; each distinct marked address is rewritten to an ordinal placeholder <addr{N}> assigned by order of first appearance within a single run (see canonicalize_addresses_in_line). Unlike Self::strip_lines, this discards ONLY the host-specific raw pointer value: it preserves identity (same address -> same ordinal), ordering (introduction sequence), and aliasing (two names for one address collapse to one ordinal), and it leaves every other byte – virtual-time timestamps, syscall argument/result values, counts, sizes, flags – untouched for an exact comparison. In canonical parity, this preserves the ability to DETECT a difference (allocation-order or aliasing changes still diverge), which wholesale stripping throws away.

The marker is REQUIRED (a bare 0x... literal is left exact) because nothing in the compared DETLOG stream can otherwise distinguish a varying host pointer from a reproducible hex value – syscall arguments printed {:#x} (e.g. flock operation=0x2 vs 0x6), guest memory ranges, content digests, cpuid leaves. A blanket 0x canonicalization would collapse those too, silently erasing real syscall-argument divergence: a “softer strip” and exactly the fake-green this policy exists to prevent.

--canonical-info and --json always apply it. This flag applies it to the other comparisons too (DETLOG/COMMIT subsets, --ignore-lines), which is what separate-process comparisons such as hermit-verify need: ASLR moves the marked launcher pointers between the two processes (https://github.com/rrnewton/hermit/issues/3412).

comparison: LogComparisonMode

The internal message set to compare.

side_labels: ComparisonSideLabels

Reader-facing names for the left and right inputs. Standalone callers retain the historical defaults; verification paths bind their own.

require_structured_events: bool

Require current producer-owned DETLOG records instead of using the historical text compatibility path.

print_logs: bool

Print both selected logs exactly as they are passed to the comparator.

The output names the active comparison policy and reflects every selection, wall-clock-prefix removal, and normalization step.

limit: u64

Limit the number of differences printed. Set to 0 for no limit.

ignore_lines: Vec<String>

Before comparison, filter out lines which contain this substring.

syscall_history: u64

Show this many completed syscalls before each side-specific divergence point. Set to 0 to omit history.

no_color: bool

Disable colored console output for line diffs.

skip_commit: bool

Do not consider “COMMIT” messages for deterministic checks.

skip_detlog: bool

Do not consider “DETLOG” messages for deterministic checks.

git_diff: bool

Use git diff instead of the internal, basic log comparison.

include_detlogs: Vec<DetLogFilter>

In case –skip-detlog=false this parameter further filters which “DETLOG” messages will be included for deterministic checks

Trait Implementations

impl Args for LogDiffOpts

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl Clone for LogDiffOpts

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CommandFactory for LogDiffOpts

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for LogDiffOpts

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

Formats the value using the given formatter.

impl Default for LogDiffOpts

N.B. we don’t want to specify two different notions of “default”, so we use the Clap instance above.

fn default() -> Self

Returns the “default value” for a type.

impl FromArgMatches for LogDiffOpts

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for LogDiffOpts

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.