add argv to start event, +tests

Author: mikrostew

crates/volta-core/src/event.rs

@@ -3,22 +3,22 @@
 use std::env;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 use crate::error::{ExitCode, VoltaError};
 use crate::hook::Publish;
 use crate::monitor::Monitor;
 use crate::session::ActivityKind;
 
 // the Event data that is serialized to JSON and sent the plugin
-#[derive(Serialize)]
+#[derive(Deserialize, Serialize)]
 pub struct Event {
     timestamp: u64,
-    name: String,
-    event: EventKind,
+    pub name: String,
+    pub event: EventKind,
 }
 
-#[derive(Serialize)]
+#[derive(Deserialize, Serialize, PartialEq, Debug)]
 pub struct ErrorEnv {
     argv: String,
     exec_path: String,
@@ -27,10 +27,12 @@ pub struct ErrorEnv {
     platform_version: String,
 }
 
-#[derive(Serialize)]
+#[derive(Deserialize, Serialize, PartialEq, Debug)]
 #[serde(rename_all = "lowercase")]
-enum EventKind {
-    Start,
+pub enum EventKind {
+    Start {
+        argv: String,
+    },
     End {
         exit_code: i32,
     },
@@ -98,8 +100,8 @@ impl EventLog {
         EventLog { events: Vec::new() }
     }
 
-    pub fn add_event_start(&mut self, activity_kind: ActivityKind) {
-        self.add_event(EventKind::Start, activity_kind)
+    pub fn add_event_start(&mut self, activity_kind: ActivityKind, argv: String) {
+        self.add_event(EventKind::Start { argv }, activity_kind)
     }
     pub fn add_event_end(&mut self, activity_kind: ActivityKind, exit_code: ExitCode) {
         self.add_event(
@@ -144,7 +146,7 @@ impl EventLog {
 #[cfg(test)]
 pub mod tests {
 
-    use super::EventLog;
+    use super::{EventKind, EventLog};
     use crate::error::{ErrorKind, ExitCode};
     use crate::session::ActivityKind;
 
@@ -153,21 +155,33 @@ pub mod tests {
         let mut event_log = EventLog::init();
         assert_eq!(event_log.events.len(), 0);
 
-        event_log.add_event_start(ActivityKind::Current);
+        event_log.add_event_start(ActivityKind::Current, String::from("foo"));
         assert_eq!(event_log.events.len(), 1);
         assert_eq!(event_log.events[0].name, "current");
+        assert_eq!(
+            event_log.events[0].event,
+            EventKind::Start {
+                argv: String::from("foo")
+            }
+        );
 
         event_log.add_event_end(ActivityKind::Pin, ExitCode::NetworkError);
         assert_eq!(event_log.events.len(), 2);
         assert_eq!(event_log.events[1].name, "pin");
+        assert_eq!(event_log.events[1].event, EventKind::End { exit_code: 5 });
 
         event_log.add_event_tool_end(ActivityKind::Version, 12);
         assert_eq!(event_log.events.len(), 3);
         assert_eq!(event_log.events[2].name, "version");
+        assert_eq!(
+            event_log.events[2].event,
+            EventKind::ToolEnd { exit_code: 12 }
+        );
 
         let error = ErrorKind::BinaryExecError.into();
         event_log.add_event_error(ActivityKind::Install, &error);
         assert_eq!(event_log.events.len(), 4);
         assert_eq!(event_log.events[3].name, "install");
+        // not checking the error because it has too much machine-specific info
     }
 }

crates/volta-core/src/lib.rs

@@ -2,7 +2,7 @@
 
 mod command;
 pub mod error;
-mod event;
+pub mod event;
 pub mod fs;
 mod hook;
 pub mod inventory;

crates/volta-core/src/monitor.rs

@@ -28,7 +28,7 @@ impl Monitor {
                 match json {
                     Ok(data) => {
                         // FIXME: tighten up this error message
-                        write!(p_stdin, "{}", data).expect("Writing data to plugin failed!");
+                        write!(p_stdin, "{}\n", data).expect("Writing data to plugin failed!");
                     }
                     Err(error) => {
                         // FIXME: tighten up this error message

crates/volta-core/src/run/node.rs

@@ -9,7 +9,12 @@ use crate::session::{ActivityKind, Session};
 
 /// Build a `ToolCommand` for Node
 pub(super) fn command(args: &[OsString], session: &mut Session) -> Fallible<Executor> {
-    session.add_event_start(ActivityKind::Node);
+    let node_argv = args
+        .iter()
+        .map(|s| s.to_string_lossy().to_string())
+        .collect::<Vec<String>>()
+        .join(" ");
+    session.add_event_start(ActivityKind::Node, node_argv);
     // Don't re-evaluate the platform if this is a recursive call
     let platform = match env::var_os(RECURSION_ENV_VAR) {
         Some(_) => None,

crates/volta-core/src/run/npm.rs

@@ -20,7 +20,12 @@ use crate::version::VersionSpec;
 /// If the command is _not_ a global install / uninstall or we don't have a default platform, then
 /// we will allow npm to execute the command as usual.
 pub(super) fn command(args: &[OsString], session: &mut Session) -> Fallible<Executor> {
-    session.add_event_start(ActivityKind::Npm);
+    let npm_argv = args
+        .iter()
+        .map(|s| s.to_string_lossy().to_string())
+        .collect::<Vec<String>>()
+        .join(" ");
+    session.add_event_start(ActivityKind::Npm, npm_argv);
     // Don't re-evaluate the context or global install interception if this is a recursive call
     let platform = match env::var_os(RECURSION_ENV_VAR) {
         Some(_) => None,

crates/volta-core/src/run/npx.rs

@@ -16,7 +16,12 @@ lazy_static! {
 
 /// Build a `ToolCommand` for npx
 pub(super) fn command(args: &[OsString], session: &mut Session) -> Fallible<Executor> {
-    session.add_event_start(ActivityKind::Npx);
+    let npx_argv = args
+        .iter()
+        .map(|s| s.to_string_lossy().to_string())
+        .collect::<Vec<String>>()
+        .join(" ");
+    session.add_event_start(ActivityKind::Npx, npx_argv);
     // Don't re-evaluate the context if this is a recursive call
     let platform = match env::var_os(RECURSION_ENV_VAR) {
         Some(_) => None,

crates/volta-core/src/run/yarn.rs

@@ -17,7 +17,12 @@ use crate::session::{ActivityKind, Session};
 /// If the command is _not_ a global add / remove or we don't have a default platform, then
 /// we will allow Yarn to execute the command as usual.
 pub(super) fn command(args: &[OsString], session: &mut Session) -> Fallible<Executor> {
-    session.add_event_start(ActivityKind::Yarn);
+    let yarn_argv = args
+        .iter()
+        .map(|s| s.to_string_lossy().to_string())
+        .collect::<Vec<String>>()
+        .join(" ");
+    session.add_event_start(ActivityKind::Yarn, yarn_argv);
     // Don't re-evaluate the context or global install interception if this is a recursive call
     let platform = match env::var_os(RECURSION_ENV_VAR) {
         Some(_) => None,

crates/volta-core/src/session.rs

@@ -131,8 +131,8 @@ impl Session {
         self.hooks.get(self.project()?)
     }
 
-    pub fn add_event_start(&mut self, activity_kind: ActivityKind) {
-        self.event_log.add_event_start(activity_kind)
+    pub fn add_event_start(&mut self, activity_kind: ActivityKind, argv: String) {
+        self.event_log.add_event_start(activity_kind, argv)
     }
     pub fn add_event_end(&mut self, activity_kind: ActivityKind, exit_code: ExitCode) {
         self.event_log.add_event_end(activity_kind, exit_code)

src/cli.rs

@@ -45,7 +45,7 @@ pub(crate) struct Volta {
 }
 
 impl Volta {
-    pub(crate) fn run(self, session: &mut Session) -> Fallible<ExitCode> {
+    pub(crate) fn run(self, session: &mut Session, argv: String) -> Fallible<ExitCode> {
         if self.version {
             // suffix indicator for dev build
             if cfg!(debug_assertions) {
@@ -55,9 +55,9 @@ impl Volta {
             }
             Ok(ExitCode::Success)
         } else if let Some(command) = self.command {
-            command.run(session)
+            command.run(session, argv)
         } else {
-            Volta::from_iter(["volta", "help"].iter()).run(session)
+            Volta::from_iter(["volta", "help"].iter()).run(session, argv)
         }
     }
 }
@@ -130,18 +130,18 @@ otherwise, they will be written to `stdout`.
 }
 
 impl Subcommand {
-    pub(crate) fn run(self, session: &mut Session) -> Fallible<ExitCode> {
+    pub(crate) fn run(self, session: &mut Session, argv: String) -> Fallible<ExitCode> {
         match self {
-            Subcommand::Fetch(fetch) => fetch.run(session),
-            Subcommand::Install(install) => install.run(session),
-            Subcommand::Uninstall(uninstall) => uninstall.run(session),
-            Subcommand::Pin(pin) => pin.run(session),
-            Subcommand::List(list) => list.run(session),
-            Subcommand::Completions(completions) => completions.run(session),
-            Subcommand::Which(which) => which.run(session),
-            Subcommand::Use(r#use) => r#use.run(session),
-            Subcommand::Setup(setup) => setup.run(session),
-            Subcommand::Run(run) => run.run(session),
+            Subcommand::Fetch(fetch) => fetch.run(session, argv),
+            Subcommand::Install(install) => install.run(session, argv),
+            Subcommand::Uninstall(uninstall) => uninstall.run(session, argv),
+            Subcommand::Pin(pin) => pin.run(session, argv),
+            Subcommand::List(list) => list.run(session, argv),
+            Subcommand::Completions(completions) => completions.run(session, argv),
+            Subcommand::Which(which) => which.run(session, argv),
+            Subcommand::Use(r#use) => r#use.run(session, argv),
+            Subcommand::Setup(setup) => setup.run(session, argv),
+            Subcommand::Run(run) => run.run(session, argv),
         }
     }
 }

src/command/completions.rs

@@ -32,8 +32,8 @@ pub(crate) struct Completions {
 }
 
 impl Command for Completions {
-    fn run(self, session: &mut Session) -> Fallible<ExitCode> {
-        session.add_event_start(ActivityKind::Completions);
+    fn run(self, session: &mut Session, argv: String) -> Fallible<ExitCode> {
+        session.add_event_start(ActivityKind::Completions, argv);
 
         let mut app = crate::cli::Volta::clap();
         match self.out_file {