Trait LifecycleHooks 

pub trait LifecycleHooks:
    Send
    + Sync
    + 'static {
    // Provided methods
    fn observe(&self, _event: &LifecycleEvent<'_>) -> Result<(), AppError> { ... }
    fn observe_async<'a>(
        &'a self,
        _event: &'a LifecycleEvent<'a>,
    ) -> impl Future<Output = Result<(), AppError>> + Send + 'a { ... }
}

Caller-owned lifecycle observation without a transport or exporter owner.

Both methods default to success. Asynchronous execution calls the synchronous method before the asynchronous method; synchronous execution calls only the synchronous method. Events borrow their authoritative data for the duration of the call. Implementations own any data they choose to retain afterward.

Example

use app_kit::{AppError, workflow::{LifecycleEvent, LifecycleHooks}};
use std::sync::{Arc, atomic::{AtomicUsize, Ordering}};
struct CountEvents(Arc<AtomicUsize>);
impl LifecycleHooks for CountEvents {
    fn observe(&self, event: &LifecycleEvent<'_>) -> Result<(), AppError> {
        if matches!(event, LifecycleEvent::ExecuteStarted { .. }) {
            self.0.fetch_add(1, Ordering::SeqCst);
        }
        Ok(())
    }
    fn observe_async<'a>(&'a self, event: &'a LifecycleEvent<'a>)
        -> impl std::future::Future<Output = Result<(), AppError>> + Send + 'a {
        async move {
            if matches!(event, LifecycleEvent::ExecuteStarted { .. }) {
                self.0.fetch_add(10, Ordering::SeqCst);
            }
            Ok(())
        }
    }
}
let run = "run_8a7c251e-b5b8-4d9e-8f0b-123456789abc".parse()?;
let event = LifecycleEvent::ExecuteStarted {
    run: &run, occurrence: "00000000000040008000000000000001",
};
let count = Arc::new(AtomicUsize::new(0));
let hooks = CountEvents(Arc::clone(&count));
hooks.observe(&event)?;
runtime.block_on(hooks.observe_async(&event))?;
assert_eq!(count.load(Ordering::SeqCst), 11);

Provided Methods

fn observe(&self, _event: &LifecycleEvent<'_>) -> Result<(), AppError>

Observes one event synchronously; the default has no effect.

Errors

Return an error to report functional observation failure. App preserves an earlier execution failure as the structured cause of WorkflowFailure::Hook; a post-commit hook error does not roll back an accepted native commit.

See the complete lifecycle hook implementation.

fn observe_async<'a>( &'a self, _event: &'a LifecycleEvent<'a>, ) -> impl Future<Output = Result<(), AppError>> + Send + 'a

Observes one event asynchronously; the default has no effect.

Errors

Return an error to report functional observation failure. App preserves an earlier execution failure as the structured cause of WorkflowFailure::Hook; a post-commit hook error does not roll back an accepted native commit.

See the complete lifecycle hook implementation.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl LifecycleHooks for NoHooks