feat: add tracing span and better error message for test cases (#10)

* feat: add tracing span and better error message for test cases

Signed-off-by: Alex Chi Z <[email protected]>

* testcase span

Signed-off-by: Alex Chi Z <[email protected]>

---------

Signed-off-by: Alex Chi Z <[email protected]>

Author: skyzh

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlplannertest"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 description = "A yaml-based SQL planner test framework."
 license = "MIT OR Apache-2.0"
@@ -22,6 +22,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_yaml = "0.9"
 similar = "2"
 tokio = { version = "1", features = ["rt", "fs"] }
+tracing = "0.1"
 
 [workspace]
 members = ["naivedb"]

src/apply.rs

@@ -5,6 +5,7 @@ use std::time::{Duration, Instant};
 use anyhow::{anyhow, Context, Error, Result};
 use console::style;
 use futures_util::{stream, StreamExt, TryFutureExt};
+use tracing::{info_span, Instrument};
 
 use crate::{
     discover_tests_with_selections, parse_test_cases, ParsedTestCase, PlannerTestRunner, TestCase,
@@ -59,37 +60,53 @@ where
     let test_stream = stream::iter(tests).map(|(path, testname)| {
         let runner_fn = &runner_fn;
         let testname_x = testname.clone();
+        let testname_y = testname.clone();
         async {
             let mut runner = runner_fn().await?;
             let start = Instant::now();
-            tokio::spawn(async move {
-                let testcases = tokio::fs::read(&path).await?;
-                let testcases: Vec<TestCase> = serde_yaml::from_slice(&testcases)?;
-                let testcases = parse_test_cases(
-                    {
-                        let mut path = path.clone();
-                        path.pop();
-                        path
-                    },
-                    testcases,
-                )?;
-                let mut generated_result = String::new();
-                for testcase in testcases {
-                    let runner_result = runner.run(&testcase).await;
-                    if !testcase.no_capture {
-                        generate_result(&testcase, &runner_result, &mut generated_result)?;
+            tokio::spawn(
+                async move {
+                    if options.serial {
+                        println!("{} {}", style("[RUN]").yellow().bold(), &testname_y);
                     }
-                }
-                let path = {
-                    let mut path = path;
-                    path.set_extension(RESULT_SUFFIX);
-                    path
-                };
-                tokio::fs::write(&path, generated_result).await?;
+                    let testcases = tokio::fs::read(&path).await?;
+                    let testcases: Vec<TestCase> = serde_yaml::from_slice(&testcases)?;
+                    let testcases = parse_test_cases(
+                        {
+                            let mut path = path.clone();
+                            path.pop();
+                            path
+                        },
+                        testcases,
+                    )?;
+                    let mut generated_result = String::new();
+                    for (idx, testcase) in testcases.into_iter().enumerate() {
+                        let runner_result = runner
+                            .run(&testcase)
+                            .instrument(if let Some(ref id) = testcase.id {
+                                info_span!("testcase", id = id)
+                            } else {
+                                info_span!("testcase", idx = idx)
+                            })
+                            .await;
+                        if !testcase.no_capture {
+                            generate_result(&testcase, &runner_result, &mut generated_result)?;
+                        }
+                    }
+                    let path = {
+                        let mut path = path;
+                        path.set_extension(RESULT_SUFFIX);
+                        path
+                    };
+                    tokio::fs::write(&path, generated_result).await?;
 
-                Ok::<_, Error>(())
-            })
-            .await??;
+                    Ok::<_, Error>(())
+                }
+                .instrument(info_span!("file", testname = testname.as_str())),
+            )
+            .await
+            .with_context(|| format!("when joining tokio task for testname={testname}"))?
+            .with_context(|| format!("when processing testname={testname}"))?;
             let time = start.elapsed();
             Ok::<_, Error>(TestResult { testname, time })
         }