Wrap event::Cucumber in Event to allow metadata

Cargo.toml

@@ -32,6 +32,7 @@ macros = ["cucumber-codegen", "inventory"]
 [dependencies]
 async-trait = "0.1.40"
 atty = "0.2.14"
+chrono = "0.4.19"
 console = "0.15"
 derive_more = { version = "0.99.16", features = ["deref", "deref_mut", "display", "error", "from"], default_features = false }
 either = "1.6"

src/cucumber.rs

@@ -882,8 +882,8 @@ where
 
         let events_stream = runner.run(filtered, runner_cli);
         futures::pin_mut!(events_stream);
-        while let Some(ev) = events_stream.next().await {
-            writer.handle_event(ev, &writer_cli).await;
+        while let Some((ev, at)) = events_stream.next().await {
+            writer.handle_event(ev, at, &writer_cli).await;
         }
         writer
     }

src/runner/basic.rs

@@ -23,6 +23,7 @@ use std::{
     },
 };
 
+use chrono::{DateTime, Utc};
 use futures::{
     channel::mpsc,
     future::{self, Either, LocalBoxFuture},
@@ -386,8 +387,10 @@ where
 {
     type Cli = Cli;
 
-    type EventStream =
-        LocalBoxStream<'static, parser::Result<event::Cucumber<W>>>;
+    type EventStream = LocalBoxStream<
+        'static,
+        (parser::Result<event::Cucumber<W>>, DateTime<Utc>),
+    >;
 
     fn run<S>(self, features: S, cli: Cli) -> Self::EventStream
     where
@@ -442,7 +445,10 @@ async fn insert_features<W, S, F>(
     into: Features,
     features: S,
     which_scenario: F,
-    sender: mpsc::UnboundedSender<parser::Result<event::Cucumber<W>>>,
+    sender: mpsc::UnboundedSender<(
+        parser::Result<event::Cucumber<W>>,
+        DateTime<Utc>,
+    )>,
 ) where
     S: Stream<Item = parser::Result<gherkin::Feature>> + 'static,
     F: Fn(
@@ -459,7 +465,7 @@ async fn insert_features<W, S, F>(
             // If the receiver end is dropped, then no one listens for events
             // so we can just stop from here.
             Err(e) => {
-                if sender.unbounded_send(Err(e)).is_err() {
+                if sender.unbounded_send((Err(e), Utc::now())).is_err() {
                     break;
                 }
             }
@@ -476,7 +482,10 @@ async fn execute<W, Before, After>(
     features: Features,
     max_concurrent_scenarios: Option<usize>,
     collection: step::Collection<W>,
-    sender: mpsc::UnboundedSender<parser::Result<event::Cucumber<W>>>,
+    sender: mpsc::UnboundedSender<(
+        parser::Result<event::Cucumber<W>>,
+        DateTime<Utc>,
+    )>,
     before_hook: Option<Before>,
     after_hook: Option<After>,
 ) where
@@ -584,7 +593,10 @@ struct Executor<W, Before, After> {
     /// Sender for notifying state of [`Feature`]s completion.
     ///
     /// [`Feature`]: gherkin::Feature
-    sender: mpsc::UnboundedSender<parser::Result<event::Cucumber<W>>>,
+    sender: mpsc::UnboundedSender<(
+        parser::Result<event::Cucumber<W>>,
+        DateTime<Utc>,
+    )>,
 }
 
 impl<W: World, Before, After> Executor<W, Before, After>
@@ -609,7 +621,10 @@ where
         collection: step::Collection<W>,
         before_hook: Option<Before>,
         after_hook: Option<After>,
-        sender: mpsc::UnboundedSender<parser::Result<event::Cucumber<W>>>,
+        sender: mpsc::UnboundedSender<(
+            parser::Result<event::Cucumber<W>>,
+            DateTime<Utc>,
+        )>,
     ) -> Self {
         Self {
             features_scenarios_count: HashMap::new(),
@@ -1098,7 +1113,7 @@ where
     fn send(&self, event: event::Cucumber<W>) {
         // If the receiver end is dropped, then no one listens for events
         // so we can just ignore it.
-        drop(self.sender.unbounded_send(Ok(event)));
+        drop(self.sender.unbounded_send((Ok(event), Utc::now())));
     }
 
     /// Notifies with the given [`Cucumber`] events.
@@ -1108,7 +1123,7 @@ where
         for ev in events {
             // If the receiver end is dropped, then no one listens for events
             // so we can just stop from here.
-            if self.sender.unbounded_send(Ok(ev)).is_err() {
+            if self.sender.unbounded_send((Ok(ev), Utc::now())).is_err() {
                 break;
             }
         }

src/runner/mod.rs

@@ -16,6 +16,7 @@
 
 pub mod basic;
 
+use chrono::{DateTime, Utc};
 use futures::Stream;
 use structopt::StructOptInternal;
 
@@ -75,8 +76,10 @@ pub trait Runner<World> {
     // details being a subject of instability.
     type Cli: StructOptInternal;
 
-    /// Output events [`Stream`].
-    type EventStream: Stream<Item = parser::Result<event::Cucumber<World>>>;
+    /// Output events [`Stream`] paired with a [`DateTime`] when they happened.
+    type EventStream: Stream<
+        Item = (parser::Result<event::Cucumber<World>>, DateTime<Utc>),
+    >;
 
     /// Executes the given [`Stream`] of [`Feature`]s transforming it into
     /// a [`Stream`] of executed [`Cucumber`] events.

src/writer/basic.rs

@@ -20,6 +20,7 @@ use std::{
 };
 
 use async_trait::async_trait;
+use chrono::{DateTime, Utc};
 use console::Term;
 use itertools::Itertools as _;
 use regex::CaptureLocations;
@@ -106,6 +107,7 @@ impl<W: World + Debug> Writer<W> for Basic {
     async fn handle_event(
         &mut self,
         ev: parser::Result<event::Cucumber<W>>,
+        _: DateTime<Utc>,
         cli: &Self::Cli,
     ) {
         use event::{Cucumber, Feature};

src/writer/fail_on_skipped.rs

@@ -17,6 +17,7 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
+use chrono::{DateTime, Utc};
 use derive_more::Deref;
 
 use crate::{event, parser, ArbitraryWriter, FailureWriter, World, Writer};
@@ -64,6 +65,7 @@ where
     async fn handle_event(
         &mut self,
         ev: parser::Result<event::Cucumber<W>>,
+        at: DateTime<Utc>,
         cli: &Self::Cli,
     ) {
         use event::{
@@ -95,7 +97,7 @@ where
             _ => ev,
         };
 
-        self.writer.handle_event(ev, cli).await;
+        self.writer.handle_event(ev, at, cli).await;
     }
 }
 

src/writer/mod.rs

@@ -20,6 +20,7 @@ pub mod summarized;
 pub mod term;
 
 use async_trait::async_trait;
+use chrono::{DateTime, Utc};
 use sealed::sealed;
 use structopt::StructOptInternal;
 
@@ -63,6 +64,7 @@ pub trait Writer<World> {
     async fn handle_event(
         &mut self,
         ev: parser::Result<event::Cucumber<World>>,
+        at: DateTime<Utc>,
         cli: &Self::Cli,
     );
 }