Struct EmergencyDiagnostics 

pub struct EmergencyDiagnostics { /* private fields */ }

Startup owner: at most one independent writer per process. No join on Drop.

Implementations

impl EmergencyDiagnostics

pub fn start(config: &FileLoggingConfig) -> Result<Self, EmergencyInitError>

Directory setup is performed by the worker, never the submitting request. Callers must check snapshot/written, not equate successful start with IO readiness.

Examples found in repository

examples/diagnostic_source.rs (line 32)

fn main() {
    // The application must pass its already resolved logging.directory here.
    let mut output =
        EmergencyDiagnostics::start(&FileLoggingConfig::default()).expect("emergency worker");
    let error = source_failure(&std::io::Error::from_raw_os_error(2));
    if let Some(diagnostic) = error.diagnostic() {
        let _admission_only = output.handle().submit(diagnostic);
    }
    // Illustrative bounded host wait; Runtime must use its EXISTING deadline.
    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(1);
    while output.shutdown() == DiagnosticShutdown::Pending && std::time::Instant::now() < deadline {
        std::thread::sleep(std::time::Duration::from_millis(1));
    }
    // Inspect written/first_failure + target; Enqueued alone never proves delivery.
    let _status = output.snapshot();
}

pub fn handle(&self) -> EmergencyDiagnosticHandle

Examples found in repository

examples/diagnostic_source.rs (line 35)

fn main() {
    // The application must pass its already resolved logging.directory here.
    let mut output =
        EmergencyDiagnostics::start(&FileLoggingConfig::default()).expect("emergency worker");
    let error = source_failure(&std::io::Error::from_raw_os_error(2));
    if let Some(diagnostic) = error.diagnostic() {
        let _admission_only = output.handle().submit(diagnostic);
    }
    // Illustrative bounded host wait; Runtime must use its EXISTING deadline.
    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(1);
    while output.shutdown() == DiagnosticShutdown::Pending && std::time::Instant::now() < deadline {
        std::thread::sleep(std::time::Duration::from_millis(1));
    }
    // Inspect written/first_failure + target; Enqueued alone never proves delivery.
    let _status = output.snapshot();
}

pub fn target(&self) -> &Path

pub fn snapshot(&self) -> DiagnosticOutputSnapshot

Examples found in repository

examples/diagnostic_source.rs (line 43)

fn main() {
    // The application must pass its already resolved logging.directory here.
    let mut output =
        EmergencyDiagnostics::start(&FileLoggingConfig::default()).expect("emergency worker");
    let error = source_failure(&std::io::Error::from_raw_os_error(2));
    if let Some(diagnostic) = error.diagnostic() {
        let _admission_only = output.handle().submit(diagnostic);
    }
    // Illustrative bounded host wait; Runtime must use its EXISTING deadline.
    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(1);
    while output.shutdown() == DiagnosticShutdown::Pending && std::time::Instant::now() < deadline {
        std::thread::sleep(std::time::Duration::from_millis(1));
    }
    // Inspect written/first_failure + target; Enqueued alone never proves delivery.
    let _status = output.snapshot();
}

pub fn shutdown(&mut self) -> DiagnosticShutdown

Call using the EXISTING lifecycle deadline; Pending is not a new budget.

Examples found in repository

examples/diagnostic_source.rs (line 39)

fn main() {
    // The application must pass its already resolved logging.directory here.
    let mut output =
        EmergencyDiagnostics::start(&FileLoggingConfig::default()).expect("emergency worker");
    let error = source_failure(&std::io::Error::from_raw_os_error(2));
    if let Some(diagnostic) = error.diagnostic() {
        let _admission_only = output.handle().submit(diagnostic);
    }
    // Illustrative bounded host wait; Runtime must use its EXISTING deadline.
    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(1);
    while output.shutdown() == DiagnosticShutdown::Pending && std::time::Instant::now() < deadline {
        std::thread::sleep(std::time::Duration::from_millis(1));
    }
    // Inspect written/first_failure + target; Enqueued alone never proves delivery.
    let _status = output.snapshot();
}

Trait Implementations

impl Drop for EmergencyDiagnostics

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.