reworked CI

runtime/lightproc/examples/proc_panic.rs

@@ -30,7 +30,8 @@ where
     }
 
     let schedule = |t| (QUEUE.deref()).send(t).unwrap();
-    let (proc, handle) = LightProc::recoverable(future, schedule);
+    let span = tracing::trace_span!("runtime.spawn", kind = "local");
+    let (proc, handle) = LightProc::recoverable(future, schedule, span, None);
 
     let handle = handle.on_panic(
         |err: Box<dyn Any + Send>| match err.downcast::<&'static str>() {

runtime/lightproc/examples/proc_run.rs

@@ -17,7 +17,8 @@ where
     let future = async move { fut.await };
 
     let schedule = move |t| sender.send(t).unwrap();
-    let (proc, handle) = LightProc::build(future, schedule);
+    let span = tracing::trace_span!("runtime.spawn", kind = "local");
+    let (proc, handle) = LightProc::build(future, schedule, span, None);
 
     proc.schedule();
 

runtime/lightproc/src/lightproc.rs

@@ -9,6 +9,7 @@
 //! # Example Usage
 //!
 //! ```rust
+//! use tracing::Span;
 //! use lightproc::prelude::*;
 //!
 //! // ... future that does work
@@ -23,6 +24,8 @@
 //! let panic_recoverable = LightProc::recoverable(
 //!     future,
 //!     schedule_function,
+//!     Span::current(),
+//!     None,
 //! );
 //! ```
 
@@ -60,6 +63,7 @@ impl LightProc {
     /// # Example
     /// ```rust
     /// # use std::any::Any;
+    /// # use tracing::Span;
     /// # use lightproc::prelude::*;
     /// #
     /// # // ... basic schedule function with no waker logic
@@ -72,9 +76,11 @@ impl LightProc {
     /// let (proc, handle) = LightProc::recoverable(
     ///     future,
     ///     schedule_function,
+    ///     Span::current(),
+    ///     None
     /// );
-    /// let handle = handle.on_panic(|s: &mut EmptyProcState, e: Box<dyn Any + Send>| {
-    ///     let reason = e.downcast::<String>();
+    /// let handle = handle.on_panic(|e: Box<dyn Any + Send>| {
+    ///     let reason = e.downcast::<String>().unwrap();
     ///     println!("future panicked!: {}", &reason);
     /// });
     /// ```
@@ -110,13 +116,6 @@ impl LightProc {
     /// # // ... basic schedule function with no waker logic
     /// # fn schedule_function(proc: LightProc) {;}
     /// #
-    /// # // ... process stack with a lifecycle callback
-    /// # let proc_stack =
-    /// #     ProcStack::default()
-    /// #         .with_after_panic(|s: &mut EmptyProcState| {
-    /// #             println!("After panic started!");
-    /// #         });
-    /// #
     /// // ... creating a standard process
     /// let standard = LightProc::build(
     ///     future,

runtime/lightproc/src/recoverable_handle.rs

@@ -49,8 +49,7 @@ impl<R> RecoverableHandle<R> {
     ///
     /// ```rust
     /// # use std::any::Any;
-    /// use lightproc::proc_stack::ProcStack;
-    /// use lightproc::proc_state::EmptyProcState;
+    /// # use tracing::Span;
     /// # use lightproc::prelude::*;
     /// #
     /// # // ... future that does work
@@ -61,21 +60,16 @@ impl<R> RecoverableHandle<R> {
     /// # // ... basic schedule function with no waker logic
     /// # fn schedule_function(proc: LightProc) {;}
     /// #
-    /// # // ... process stack with a lifecycle callback
-    /// # let proc_stack =
-    /// #     ProcStack::default()
-    /// #         .with_after_panic(|s: &mut EmptyProcState| {
-    /// #             println!("After panic started!");
-    /// #         });
-    /// #
     /// // ... creating a recoverable process
     /// let (proc, recoverable) = LightProc::recoverable(
     ///     future,
     ///     schedule_function,
+    ///     Span::current(),
+    ///     None
     /// );
     ///
     /// recoverable
-    ///     .on_return(|_e: Box<dyn Any + Send>| {
+    ///     .on_panic(|_e: Box<dyn Any + Send>| {
     ///         println!("Inner future panicked");
     ///     });
     /// ```