Fixed issue with tail not deserailzing event properly

Cargo.toml

@@ -17,10 +17,11 @@ backtrace = { version = "0.3.58" }
 base64 = "0.13.0"
 billboard = "0.1.0"
 binary-install = "0.0.3-alpha.1"
-chrome-devtools-rs = { version = "=0.0.0-alpha.1", features = ["color"] }
+chrome-devtools-rs = { version = "=0.0.0-alpha.2", features = ["color"] }
 chrono = "0.4.19"
 clap = "2.33.3"
 cloudflare = "0.8.3"
+colored_json = "2.1.0"
 config = "0.11.0"
 console = "0.14.1"
 dirs = "3.0.1"

src/commands/dev/socket.rs

@@ -7,6 +7,7 @@ use futures_util::sink::SinkExt;
 use futures_util::stream::{SplitStream, StreamExt};
 use tokio_stream::wrappers::UnboundedReceiverStream;
 
+use crate::terminal::colored_json_string;
 use crate::terminal::message::{Message, StdErr, StdOut};
 use tokio::net::TcpStream;
 use tokio::sync::mpsc;
@@ -107,14 +108,15 @@ async fn print_ws_messages(
                 log::info!("{}", &message_text);
 
                 let parsed_message: Result<protocol::Runtime> = serde_json::from_str(&message_text)
-                    .map_err(|e| anyhow!("this event could not be parsed:\n{}", e));
+                    .map_err(|e| anyhow!("Failed to parse event:\n{}", e));
 
                 if let Ok(protocol::Runtime::Event(event)) = parsed_message {
                     // Try to parse json to pretty print, otherwise just print string
                     let json_parse: Result<serde_json::Value, serde_json::Error> =
                         serde_json::from_str(&*event.to_string());
+
                     if let Ok(json) = json_parse {
-                        if let Ok(json_str) = serde_json::to_string_pretty(&json) {
+                        if let Ok(json_str) = colored_json_string(&json) {
                             println!("{}", json_str);
                         } else {
                             StdOut::message(&format!("{:?}", event.to_string()));

src/tail/log_server.rs

@@ -1,4 +1,4 @@
-use crate::terminal::{emoji, styles};
+use crate::terminal::{colored_json_string, emoji, styles};
 use anyhow::Result;
 use hyper::server::conn::AddrIncoming;
 use hyper::server::Builder;
@@ -31,54 +31,43 @@ impl LogServer {
     }
 
     pub async fn run(self) -> Result<()> {
-        // this is so bad
-        // but i also am so bad at types
-        // TODO: make this less terrible
-        match self.format.as_str() {
-            "json" => {
-                let service = make_service_fn(|_| async {
-                    Ok::<_, hyper::Error>(service_fn(print_logs_json))
-                });
-
-                let server = self.server.serve(service);
-
-                // The shutdown receiver listens for a one shot message from our sigint handler as a signal
-                // to gracefully shut down the hyper server.
-                let shutdown_rx = self.shutdown_rx;
-
-                let graceful = server.with_graceful_shutdown(async {
-                    shutdown_rx.await.ok();
-                });
-
-                graceful.await?;
-
-                Ok(())
+        let format = self.format.clone(); // Having to clone this so much is a little gross TODO
+
+        let service = make_service_fn(move |_| {
+            let format = format.clone();
+            async move {
+                let format = format.clone();
+                Ok::<_, hyper::Error>(service_fn(move |req| {
+                    let format = format.clone();
+                    async move {
+                        let format = format.clone();
+                        match format.as_str() {
+                            "pretty" => print_logs_pretty(req).await,
+                            "json" => print_logs_json(req).await,
+                            _ => unreachable!(),
+                        }
+                    }
+                }))
             }
-            "pretty" => {
-                let service = make_service_fn(|_| async {
-                    Ok::<_, hyper::Error>(service_fn(print_logs_pretty))
-                });
+        });
 
-                let server = self.server.serve(service);
+        let server = self.server.serve(service);
 
-                // The shutdown receiver listens for a one shot message from our sigint handler as a signal
-                // to gracefully shut down the hyper server.
-                let shutdown_rx = self.shutdown_rx;
+        // The shutdown receiver listens for a one shot message from our sigint handler as a signal
+        // to gracefully shut down the hyper server.
+        let shutdown_rx = self.shutdown_rx;
 
-                let graceful = server.with_graceful_shutdown(async {
-                    shutdown_rx.await.ok();
-                });
+        let graceful = server.with_graceful_shutdown(async {
+            shutdown_rx.await.ok();
+        });
 
-                graceful.await?;
+        graceful.await?;
 
-                Ok(())
-            }
-            _ => unreachable!(),
-        }
+        Ok(())
     }
 }
 
-async fn print_logs_json(req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
+async fn print_logs_json(req: Request<Body>) -> Result<Response<Body>> {
     match (req.method(), req.uri().path()) {
         (&Method::POST, "/") => {
             let whole_body = hyper::body::to_bytes(req.into_body()).await?;
@@ -137,7 +126,12 @@ async fn print_logs_pretty(req: Request<Body>) -> Result<Response<Body>> {
             if !parsed.logs.is_empty() {
                 println!("  Logs:");
                 parsed.logs.iter().for_each(|log| {
-                    let messages = log.message.join(" ");
+                    let message = colored_json_string(&log.message);
+                    let messages = if let Ok(m) = message {
+                        m
+                    } else {
+                        "Error: Failed to convert encoded message to string".to_string()
+                    };
 
                     let output = match log.level.as_str() {
                         "assert" | "error" => format!("{} {}", emoji::X, styles::warning(messages)),
@@ -183,7 +177,7 @@ struct LogException {
 
 #[derive(Debug, Serialize, Deserialize)]
 struct LogMessage {
-    message: Vec<String>,
+    message: serde_json::Value,
     level: String,
     timestamp: usize,
 }

src/terminal/json.rs

@@ -0,0 +1,20 @@
+use colored_json::{Color, ColoredFormatter, PrettyFormatter, Styler};
+use serde_json::Value;
+
+pub fn colored_json_string(value: &Value) -> Result<String, serde_json::Error> {
+    let formatter = ColoredFormatter::with_styler(
+        PrettyFormatter::new(),
+        Styler {
+            key: Color::Green.normal(),
+            string_value: Color::Blue.bold(),
+            integer_value: Color::Purple.bold(),
+            float_value: Color::Purple.italic(),
+            object_brackets: Color::Yellow.bold(),
+            array_brackets: Color::Cyan.bold(),
+            bool_value: Color::Red.bold(),
+            ..Default::default()
+        },
+    );
+
+    formatter.to_colored_json_auto(&value)
+}

src/terminal/mod.rs

@@ -1,6 +1,8 @@
 mod browser;
 pub mod emoji;
 pub mod interactive;
+mod json;
 pub mod message;
 pub mod styles;
 pub use browser::open_browser;
+pub use json::colored_json_string;