From 52603ea43e2d6e89cd9c0acce3df23f1c8793216 Mon Sep 17 00:00:00 2001 From: daimond113 <72147841+daimond113@users.noreply.github.com> Date: Mon, 16 Dec 2024 23:00:37 +0100 Subject: [PATCH] feat: switch to tracing for logging --- Cargo.lock | 147 ++++++++++++++++++++++++++---- Cargo.toml | 10 +- src/cli/auth.rs | 17 +++- src/cli/commands/add.rs | 7 +- src/cli/commands/execute.rs | 11 +-- src/cli/commands/install.rs | 21 ++--- src/cli/commands/mod.rs | 14 +-- src/cli/commands/publish.rs | 4 +- src/cli/commands/update.rs | 12 +-- src/cli/config.rs | 3 + src/cli/mod.rs | 32 +++---- src/cli/version.rs | 50 ++++++---- src/download.rs | 8 +- src/download_and_link.rs | 13 ++- src/lib.rs | 27 +++++- src/linking/generator.rs | 12 ++- src/linking/mod.rs | 6 +- src/lockfile.rs | 41 +-------- src/main.rs | 55 ++++++++--- src/manifest/mod.rs | 11 ++- src/patches.rs | 10 +- src/resolver.rs | 69 +++++++++++--- src/scripts.rs | 16 ++-- src/source/fs.rs | 8 +- src/source/git/mod.rs | 8 +- src/source/git_index.rs | 10 +- src/source/pesde/mod.rs | 11 ++- src/source/wally/compat_util.rs | 7 +- src/source/wally/manifest.rs | 7 +- src/source/wally/mod.rs | 15 ++- src/source/workspace/mod.rs | 3 + src/source/workspace/specifier.rs | 2 +- 32 files changed, 446 insertions(+), 221 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c522d03..57760bd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -357,6 +357,12 @@ version = "1.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457" +[[package]] +name = "arrayvec" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" + [[package]] name = "async-broadcast" version = "0.7.1" @@ -680,7 +686,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1a68f1f47cdf0ec8ee4b941b2eee2a80cb796db73118c0dd09ac63fbe405be22" dependencies = [ "memchr", - "regex-automata", + "regex-automata 0.4.9", "serde", ] @@ -2893,19 +2899,10 @@ dependencies = [ "number_prefix", "portable-atomic", "unicode-width 0.2.0", + "vt100", "web-time", ] -[[package]] -name = "indicatif-log-bridge" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "63703cf9069b85dbe6fe26e1c5230d013dee99d3559cd3d02ba39e099ef7ab02" -dependencies = [ - "indicatif", - "log", -] - [[package]] name = "inout" version = "0.1.3" @@ -3240,6 +3237,15 @@ version = "0.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "75761162ae2b0e580d7e7c390558127e5f01b4194debd6221fd8c207fc80e3f5" +[[package]] +name = "matchers" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" +dependencies = [ + "regex-automata 0.1.10", +] + [[package]] name = "maybe-async" version = "0.2.10" @@ -3407,6 +3413,16 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "38bf9645c8b145698bb0b18a4637dcacbc421ea49bef2317e4fd8065a387cf21" +[[package]] +name = "nu-ansi-term" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84" +dependencies = [ + "overload", + "winapi", +] + [[package]] name = "num" version = "0.4.3" @@ -3606,6 +3622,12 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "overload" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" + [[package]] name = "ownedbytes" version = "0.7.0" @@ -3680,13 +3702,10 @@ dependencies = [ "git2", "gix", "indicatif", - "indicatif-log-bridge", "inquire", "keyring", - "log", "open", "pathdiff", - "pretty_env_logger", "relative-path", "reqwest", "semver", @@ -3701,6 +3720,9 @@ dependencies = [ "tokio-util", "toml", "toml_edit", + "tracing", + "tracing-indicatif", + "tracing-subscriber", "url", "wax", "winreg", @@ -4068,8 +4090,17 @@ checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" dependencies = [ "aho-corasick", "memchr", - "regex-automata", - "regex-syntax", + "regex-automata 0.4.9", + "regex-syntax 0.8.5", +] + +[[package]] +name = "regex-automata" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" +dependencies = [ + "regex-syntax 0.6.29", ] [[package]] @@ -4080,7 +4111,7 @@ checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" dependencies = [ "aho-corasick", "memchr", - "regex-syntax", + "regex-syntax 0.8.5", ] [[package]] @@ -4089,6 +4120,12 @@ version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a" +[[package]] +name = "regex-syntax" +version = "0.6.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" + [[package]] name = "regex-syntax" version = "0.8.5" @@ -4641,6 +4678,15 @@ dependencies = [ "digest", ] +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + [[package]] name = "shell-words" version = "1.1.0" @@ -4925,7 +4971,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d60769b80ad7953d8a7b2c70cdfe722bbcdcac6bccc8ac934c40c034d866fc18" dependencies = [ "byteorder", - "regex-syntax", + "regex-syntax 0.8.5", "utf8-ranges", ] @@ -5260,13 +5306,45 @@ dependencies = [ "valuable", ] +[[package]] +name = "tracing-indicatif" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74ba258e9de86447f75edf6455fded8e5242704c6fccffe7bf8d7fb6daef1180" +dependencies = [ + "indicatif", + "tracing", + "tracing-core", + "tracing-subscriber", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + [[package]] name = "tracing-subscriber" version = "0.3.19" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008" dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", "tracing-core", + "tracing-log", ] [[package]] @@ -5437,6 +5515,39 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" +[[package]] +name = "vt100" +version = "0.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84cd863bf0db7e392ba3bd04994be3473491b31e66340672af5d11943c6274de" +dependencies = [ + "itoa", + "log", + "unicode-width 0.1.14", + "vte", +] + +[[package]] +name = "vte" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f5022b5fbf9407086c180e9557be968742d839e68346af7792b8592489732197" +dependencies = [ + "arrayvec", + "utf8parse", + "vte_generate_state_changes", +] + +[[package]] +name = "vte_generate_state_changes" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e369bee1b05d510a7b4ed645f5faa90619e05437111783ea5848f28d97d3c2e" +dependencies = [ + "proc-macro2", + "quote", +] + [[package]] name = "walkdir" version = "2.5.0" diff --git a/Cargo.toml b/Cargo.toml index e751ee4..27a690e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,10 +13,10 @@ include = ["src/**/*", "Cargo.toml", "Cargo.lock", "README.md", "LICENSE", "CHAN bin = [ "dep:clap", "dep:dirs", - "dep:pretty_env_logger", + "dep:tracing-subscriber", "reqwest/json", "dep:indicatif", - "dep:indicatif-log-bridge", + "dep:tracing-indicatif", "dep:inquire", "dep:toml_edit", "dep:colored", @@ -54,7 +54,7 @@ tokio-tar = "0.3.1" async-compression = { version = "0.4.18", features = ["tokio", "gzip"] } pathdiff = "0.2.3" relative-path = { version = "1.9.3", features = ["serde"] } -log = "0.4.22" +tracing = { version = "0.1.41", features = ["attributes"] } thiserror = "2.0.7" tokio = { version = "1.42.0", features = ["process"] } tokio-util = "0.7.13" @@ -81,9 +81,9 @@ colored = { version = "2.1.0", optional = true } toml_edit = { version = "0.22.22", optional = true } clap = { version = "4.5.23", features = ["derive"], optional = true } dirs = { version = "5.0.1", optional = true } -pretty_env_logger = { version = "0.5.0", optional = true } +tracing-subscriber = { version = "0.3.19", features = ["env-filter"], optional = true } indicatif = { version = "0.17.9", optional = true } -indicatif-log-bridge = { version = "0.2.3", optional = true } +tracing-indicatif = { version = "0.3.8", optional = true } inquire = { version = "0.7.5", optional = true } [target.'cfg(target_os = "windows")'.dependencies] diff --git a/src/cli/auth.rs b/src/cli/auth.rs index 54ed228..21c4459 100644 --- a/src/cli/auth.rs +++ b/src/cli/auth.rs @@ -5,6 +5,7 @@ use keyring::Entry; use reqwest::header::AUTHORIZATION; use serde::{ser::SerializeMap, Deserialize, Serialize}; use std::collections::BTreeMap; +use tracing::instrument; #[derive(Debug, Clone)] pub struct Tokens(pub BTreeMap); @@ -37,15 +38,20 @@ impl<'de> Deserialize<'de> for Tokens { } } +#[instrument(level = "trace")] pub async fn get_tokens() -> anyhow::Result { let config = read_config().await?; if !config.tokens.0.is_empty() { + tracing::debug!("using tokens from config"); return Ok(config.tokens); } match Entry::new("tokens", env!("CARGO_PKG_NAME")) { Ok(entry) => match entry.get_password() { - Ok(token) => return serde_json::from_str(&token).context("failed to parse tokens"), + Ok(token) => { + tracing::debug!("using tokens from keyring"); + return serde_json::from_str(&token).context("failed to parse tokens"); + } Err(keyring::Error::PlatformFailure(_) | keyring::Error::NoEntry) => {} Err(e) => return Err(e.into()), }, @@ -56,16 +62,22 @@ pub async fn get_tokens() -> anyhow::Result { Ok(Tokens(BTreeMap::new())) } +#[instrument(level = "trace")] pub async fn set_tokens(tokens: Tokens) -> anyhow::Result<()> { let entry = Entry::new("tokens", env!("CARGO_PKG_NAME"))?; let json = serde_json::to_string(&tokens).context("failed to serialize tokens")?; match entry.set_password(&json) { - Ok(()) => return Ok(()), + Ok(()) => { + tracing::debug!("tokens saved to keyring"); + return Ok(()); + } Err(keyring::Error::PlatformFailure(_) | keyring::Error::NoEntry) => {} Err(e) => return Err(e.into()), } + tracing::debug!("tokens saved to config"); + let mut config = read_config().await?; config.tokens = tokens; write_config(&config).await.map_err(Into::into) @@ -86,6 +98,7 @@ struct UserResponse { login: String, } +#[instrument(level = "trace")] pub async fn get_token_login( reqwest: &reqwest::Client, access_token: &str, diff --git a/src/cli/commands/add.rs b/src/cli/commands/add.rs index 91bb585..fcbdd92 100644 --- a/src/cli/commands/add.rs +++ b/src/cli/commands/add.rs @@ -2,6 +2,7 @@ use std::{collections::HashSet, str::FromStr}; use anyhow::Context; use clap::Args; +use colored::Colorize; use semver::VersionReq; use crate::cli::{config::read_config, AnyPackageIdentifier, VersionedPackageName}; @@ -62,7 +63,7 @@ impl AddCommand { .cloned(); if let Some(index) = self.index.as_ref().filter(|_| index.is_none()) { - log::error!("index {index} not found"); + println!("{}: index {index} not found", "error".red().bold()); return Ok(()); } @@ -89,7 +90,7 @@ impl AddCommand { .cloned(); if let Some(index) = self.index.as_ref().filter(|_| index.is_none()) { - log::error!("wally index {index} not found"); + println!("{}: wally index {index} not found", "error".red().bold()); return Ok(()); } @@ -145,7 +146,7 @@ impl AddCommand { .pop_last() .map(|(v_id, _)| v_id) else { - log::error!("no versions found for package {specifier}"); + println!("{}: no versions found for package", "error".red().bold()); return Ok(()); }; diff --git a/src/cli/commands/execute.rs b/src/cli/commands/execute.rs index d3b77c2..a613324 100644 --- a/src/cli/commands/execute.rs +++ b/src/cli/commands/execute.rs @@ -2,7 +2,6 @@ use crate::cli::{config::read_config, progress_bar, VersionedPackageName}; use anyhow::Context; use clap::Args; use fs_err::tokio as fs; -use indicatif::MultiProgress; use pesde::{ linking::generator::generate_bin_linking_module, manifest::target::TargetKind, @@ -35,12 +34,7 @@ pub struct ExecuteCommand { } impl ExecuteCommand { - pub async fn run( - self, - project: Project, - multi: MultiProgress, - reqwest: reqwest::Client, - ) -> anyhow::Result<()> { + pub async fn run(self, project: Project, reqwest: reqwest::Client) -> anyhow::Result<()> { let index = match self.index { Some(index) => Some(index), None => read_config().await.ok().map(|c| c.default_index), @@ -84,7 +78,7 @@ impl ExecuteCommand { ); }; - log::info!("found package {}@{version}", pkg_ref.name); + println!("using {}@{version}", pkg_ref.name); let tmp_dir = project.cas_dir().join(".tmp"); fs::create_dir_all(&tmp_dir) @@ -134,7 +128,6 @@ impl ExecuteCommand { progress_bar( graph.values().map(|versions| versions.len() as u64).sum(), rx, - &multi, "📥 ".to_string(), "downloading dependencies".to_string(), "downloaded dependencies".to_string(), diff --git a/src/cli/commands/install.rs b/src/cli/commands/install.rs index dee73a0..3ecc6ad 100644 --- a/src/cli/commands/install.rs +++ b/src/cli/commands/install.rs @@ -6,7 +6,6 @@ use clap::Args; use colored::{ColoredString, Colorize}; use fs_err::tokio as fs; use futures::future::try_join_all; -use indicatif::MultiProgress; use pesde::{ download_and_link::filter_graph, lockfile::Lockfile, manifest::target::TargetKind, Project, MANIFEST_FILE_NAME, @@ -89,12 +88,7 @@ fn job(n: u8) -> ColoredString { struct CallbackError(#[from] anyhow::Error); impl InstallCommand { - pub async fn run( - self, - project: Project, - multi: MultiProgress, - reqwest: reqwest::Client, - ) -> anyhow::Result<()> { + pub async fn run(self, project: Project, reqwest: reqwest::Client) -> anyhow::Result<()> { let mut refreshed_sources = HashSet::new(); let manifest = project @@ -116,10 +110,10 @@ impl InstallCommand { match project.deser_lockfile().await { Ok(lockfile) => { if lockfile.overrides != manifest.overrides { - log::debug!("overrides are different"); + tracing::debug!("overrides are different"); None } else if lockfile.target != manifest.target.kind() { - log::debug!("target kind is different"); + tracing::debug!("target kind is different"); None } else { Some(lockfile) @@ -153,7 +147,7 @@ impl InstallCommand { deleted_folders .entry(folder.to_string()) .or_insert_with(|| async move { - log::debug!("deleting the {folder} folder"); + tracing::debug!("deleting the {folder} folder"); if let Some(e) = fs::remove_dir_all(package_dir.join(&folder)) .await @@ -219,7 +213,7 @@ impl InstallCommand { .map(|(alias, _, _)| alias) .filter(|alias| { if *alias == env!("CARGO_BIN_NAME") { - log::warn!( + tracing::warn!( "package {alias} has the same name as the CLI, skipping bin link" ); return false; @@ -281,7 +275,6 @@ exec lune run "$(dirname "$0")/.impl/{alias}.luau" -- "$@""# progress_bar( graph.values().map(|versions| versions.len() as u64).sum(), rx, - &multi, format!("{} 📥 ", job(3)), "downloading dependencies".to_string(), "downloaded dependencies".to_string(), @@ -303,7 +296,6 @@ exec lune run "$(dirname "$0")/.impl/{alias}.luau" -- "$@""# progress_bar( manifest.patches.values().map(|v| v.len() as u64).sum(), rx, - &multi, format!("{} 🩹 ", job(JOBS - 1)), "applying patches".to_string(), "applied patches".to_string(), @@ -323,9 +315,8 @@ exec lune run "$(dirname "$0")/.impl/{alias}.luau" -- "$@""# graph: downloaded_graph, workspace: run_on_workspace_members(&project, |project| { - let multi = multi.clone(); let reqwest = reqwest.clone(); - async move { Box::pin(self.run(project, multi, reqwest)).await } + async move { Box::pin(self.run(project, reqwest)).await } }) .await?, }) diff --git a/src/cli/commands/mod.rs b/src/cli/commands/mod.rs index 566b342..6b11cab 100644 --- a/src/cli/commands/mod.rs +++ b/src/cli/commands/mod.rs @@ -1,4 +1,3 @@ -use indicatif::MultiProgress; use pesde::Project; mod add; @@ -72,18 +71,13 @@ pub enum Subcommand { } impl Subcommand { - pub async fn run( - self, - project: Project, - multi: MultiProgress, - reqwest: reqwest::Client, - ) -> anyhow::Result<()> { + pub async fn run(self, project: Project, reqwest: reqwest::Client) -> anyhow::Result<()> { match self { Subcommand::Auth(auth) => auth.run(project, reqwest).await, Subcommand::Config(config) => config.run().await, Subcommand::Init(init) => init.run(project).await, Subcommand::Run(run) => run.run(project).await, - Subcommand::Install(install) => install.run(project, multi, reqwest).await, + Subcommand::Install(install) => install.run(project, reqwest).await, Subcommand::Publish(publish) => publish.run(project, reqwest).await, #[cfg(feature = "version-management")] Subcommand::SelfInstall(self_install) => self_install.run().await, @@ -94,9 +88,9 @@ impl Subcommand { #[cfg(feature = "version-management")] Subcommand::SelfUpgrade(self_upgrade) => self_upgrade.run(reqwest).await, Subcommand::Add(add) => add.run(project).await, - Subcommand::Update(update) => update.run(project, multi, reqwest).await, + Subcommand::Update(update) => update.run(project, reqwest).await, Subcommand::Outdated(outdated) => outdated.run(project).await, - Subcommand::Execute(execute) => execute.run(project, multi, reqwest).await, + Subcommand::Execute(execute) => execute.run(project, reqwest).await, } } } diff --git a/src/cli/commands/publish.rs b/src/cli/commands/publish.rs index 183522f..1672ee1 100644 --- a/src/cli/commands/publish.rs +++ b/src/cli/commands/publish.rs @@ -4,6 +4,7 @@ use async_compression::Level; use clap::Args; use colored::Colorize; use fs_err::tokio as fs; +#[allow(deprecated)] use pesde::{ manifest::{target::Target, DependencyType}, matching_globs_old_behaviour, @@ -129,6 +130,7 @@ impl PublishCommand { _ => None, }; + #[allow(deprecated)] let mut paths = matching_globs_old_behaviour( project.package_dir(), manifest.includes.iter().map(|s| s.as_str()), @@ -624,7 +626,7 @@ info: otherwise, the file was deemed unnecessary, if you don't understand why, p .body(archive); if let Some(token) = project.auth_config().tokens().get(index_url) { - log::debug!("using token for {index_url}"); + tracing::debug!("using token for {index_url}"); request = request.header(AUTHORIZATION, token); } diff --git a/src/cli/commands/update.rs b/src/cli/commands/update.rs index d079594..3793093 100644 --- a/src/cli/commands/update.rs +++ b/src/cli/commands/update.rs @@ -2,7 +2,6 @@ use crate::cli::{progress_bar, run_on_workspace_members}; use anyhow::Context; use clap::Args; use colored::Colorize; -use indicatif::MultiProgress; use pesde::{lockfile::Lockfile, Project}; use std::{collections::HashSet, sync::Arc}; use tokio::sync::Mutex; @@ -11,12 +10,7 @@ use tokio::sync::Mutex; pub struct UpdateCommand {} impl UpdateCommand { - pub async fn run( - self, - project: Project, - multi: MultiProgress, - reqwest: reqwest::Client, - ) -> anyhow::Result<()> { + pub async fn run(self, project: Project, reqwest: reqwest::Client) -> anyhow::Result<()> { let mut refreshed_sources = HashSet::new(); let manifest = project @@ -60,7 +54,6 @@ impl UpdateCommand { progress_bar( graph.values().map(|versions| versions.len() as u64).sum(), rx, - &multi, "📥 ".to_string(), "downloading dependencies".to_string(), "downloaded dependencies".to_string(), @@ -73,9 +66,8 @@ impl UpdateCommand { }, workspace: run_on_workspace_members(&project, |project| { - let multi = multi.clone(); let reqwest = reqwest.clone(); - async move { Box::pin(self.run(project, multi, reqwest)).await } + async move { Box::pin(self.run(project, reqwest)).await } }) .await?, }) diff --git a/src/cli/config.rs b/src/cli/config.rs index dce9ca2..1911b0f 100644 --- a/src/cli/config.rs +++ b/src/cli/config.rs @@ -2,6 +2,7 @@ use crate::cli::{auth::Tokens, home_dir}; use anyhow::Context; use fs_err::tokio as fs; use serde::{Deserialize, Serialize}; +use tracing::instrument; #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(default)] @@ -30,6 +31,7 @@ impl Default for CliConfig { } } +#[instrument(level = "trace")] pub async fn read_config() -> anyhow::Result { let config_string = match fs::read_to_string(home_dir()?.join("config.toml")).await { Ok(config_string) => config_string, @@ -44,6 +46,7 @@ pub async fn read_config() -> anyhow::Result { Ok(config) } +#[instrument(level = "trace")] pub async fn write_config(config: &CliConfig) -> anyhow::Result<()> { let config_string = toml::to_string(config).context("failed to serialize config")?; fs::write(home_dir()?.join("config.toml"), config_string) diff --git a/src/cli/mod.rs b/src/cli/mod.rs index 636aead..a18373b 100644 --- a/src/cli/mod.rs +++ b/src/cli/mod.rs @@ -2,7 +2,6 @@ use anyhow::Context; use colored::Colorize; use fs_err::tokio as fs; use futures::StreamExt; -use indicatif::MultiProgress; use pesde::{ lockfile::Lockfile, manifest::target::TargetKind, @@ -19,6 +18,7 @@ use std::{ time::Duration, }; use tokio::pin; +use tracing::instrument; pub mod auth; pub mod commands; @@ -43,6 +43,7 @@ pub async fn bin_dir() -> anyhow::Result { Ok(bin_dir) } +#[instrument(skip(project), ret(level = "trace"), level = "debug")] pub async fn up_to_date_lockfile(project: &Project) -> anyhow::Result> { let manifest = project.deser_manifest().await?; let lockfile = match project.deser_lockfile().await { @@ -56,17 +57,17 @@ pub async fn up_to_date_lockfile(project: &Project) -> anyhow::Result anyhow::Result Result { pub async fn progress_bar>( len: u64, mut rx: tokio::sync::mpsc::Receiver>, - multi: &MultiProgress, prefix: String, progress_msg: String, finish_msg: String, ) -> anyhow::Result<()> { - let bar = multi.add( - indicatif::ProgressBar::new(len) - .with_style( - indicatif::ProgressStyle::default_bar() - .template("{prefix}[{elapsed_precise}] {bar:40.208/166} {pos}/{len} {msg}")? - .progress_chars("█▓▒░ "), - ) - .with_prefix(prefix) - .with_message(progress_msg), - ); + let bar = indicatif::ProgressBar::new(len) + .with_style( + indicatif::ProgressStyle::default_bar() + .template("{prefix}[{elapsed_precise}] {bar:40.208/166} {pos}/{len} {msg}")? + .progress_chars("█▓▒░ "), + ) + .with_prefix(prefix) + .with_message(progress_msg); bar.enable_steady_tick(Duration::from_millis(100)); while let Some(result) = rx.recv().await { diff --git a/src/cli/version.rs b/src/cli/version.rs index 80e3267..b4f7ae9 100644 --- a/src/cli/version.rs +++ b/src/cli/version.rs @@ -15,7 +15,8 @@ use std::{ env::current_exe, path::{Path, PathBuf}, }; -use tokio::io::AsyncReadExt; +use tokio::io::AsyncWrite; +use tracing::instrument; pub fn current_version() -> Version { Version::parse(env!("CARGO_PKG_VERSION")).unwrap() @@ -33,14 +34,20 @@ struct Asset { url: url::Url, } +#[instrument(level = "trace")] fn get_repo() -> (String, String) { let mut parts = env!("CARGO_PKG_REPOSITORY").split('/').skip(3); - ( + let (owner, repo) = ( parts.next().unwrap().to_string(), parts.next().unwrap().to_string(), - ) + ); + + tracing::trace!("repository for updates: {owner}/{repo}"); + + (owner, repo) } +#[instrument(skip(reqwest), level = "trace")] pub async fn get_latest_remote_version(reqwest: &reqwest::Client) -> anyhow::Result { let (owner, repo) = get_repo(); @@ -72,6 +79,7 @@ pub fn no_build_metadata(version: &Version) -> Version { const CHECK_INTERVAL: chrono::Duration = chrono::Duration::hours(6); +#[instrument(skip(reqwest), level = "trace")] pub async fn check_for_updates(reqwest: &reqwest::Client) -> anyhow::Result<()> { let config = read_config().await?; @@ -79,8 +87,10 @@ pub async fn check_for_updates(reqwest: &reqwest::Client) -> anyhow::Result<()> .last_checked_updates .filter(|(time, _)| chrono::Utc::now() - *time < CHECK_INTERVAL) { + tracing::debug!("using cached version"); version } else { + tracing::debug!("checking for updates"); let version = get_latest_remote_version(reqwest).await?; write_config(&CliConfig { @@ -157,10 +167,12 @@ pub async fn check_for_updates(reqwest: &reqwest::Client) -> anyhow::Result<()> Ok(()) } -pub async fn download_github_release( +#[instrument(skip(reqwest, writer), level = "trace")] +pub async fn download_github_release( reqwest: &reqwest::Client, version: &Version, -) -> anyhow::Result> { + mut writer: W, +) -> anyhow::Result<()> { let (owner, repo) = get_repo(); let release = reqwest @@ -211,16 +223,13 @@ pub async fn download_github_release( .context("archive has no entry")? .context("failed to get first archive entry")?; - let mut result = Vec::new(); - - entry - .read_to_end(&mut result) + tokio::io::copy(&mut entry, &mut writer) .await - .context("failed to read archive entry bytes")?; - - Ok(result) + .context("failed to write archive entry to file") + .map(|_| ()) } +#[instrument(skip(reqwest), level = "trace")] pub async fn get_or_download_version( reqwest: &reqwest::Client, version: &Version, @@ -236,6 +245,8 @@ pub async fn get_or_download_version( let is_requested_version = !always_give_path && *version == current_version(); if path.exists() { + tracing::debug!("version already exists"); + return Ok(if is_requested_version { None } else { @@ -244,14 +255,20 @@ pub async fn get_or_download_version( } if is_requested_version { + tracing::debug!("copying current executable to version directory"); fs::copy(current_exe()?, &path) .await .context("failed to copy current executable to version directory")?; } else { - let bytes = download_github_release(reqwest, version).await?; - fs::write(&path, bytes) - .await - .context("failed to write downloaded version file")?; + tracing::debug!("downloading version"); + download_github_release( + reqwest, + version, + fs::File::create(&path) + .await + .context("failed to create version file")?, + ) + .await?; } make_executable(&path) @@ -265,6 +282,7 @@ pub async fn get_or_download_version( }) } +#[instrument(level = "trace")] pub async fn update_bin_exe(downloaded_file: &Path) -> anyhow::Result<()> { let bin_exe_path = bin_dir().await?.join(format!( "{}{}", diff --git a/src/download.rs b/src/download.rs index f0b4bcf..60ef5bf 100644 --- a/src/download.rs +++ b/src/download.rs @@ -13,6 +13,7 @@ use std::{ collections::HashSet, sync::{Arc, Mutex}, }; +use tracing::instrument; type MultithreadedGraph = Arc>; @@ -23,6 +24,7 @@ pub(crate) type MultithreadDownloadJob = ( impl Project { /// Downloads a graph of dependencies + #[instrument(skip(self, graph, refreshed_sources, reqwest), level = "debug")] pub async fn download_graph( &self, graph: &DependencyGraph, @@ -98,7 +100,7 @@ impl Project { let project = project.clone(); - log::debug!("downloading {name}@{version_id}"); + tracing::debug!("downloading {name}@{version_id}"); let (fs, target) = match source.download(&node.pkg_ref, &project, &reqwest).await { @@ -109,7 +111,7 @@ impl Project { } }; - log::debug!("downloaded {name}@{version_id}"); + tracing::debug!("downloaded {name}@{version_id}"); if write { if !prod || node.resolved_ty != DependencyType::Dev { @@ -123,7 +125,7 @@ impl Project { } }; } else { - log::debug!("skipping writing {name}@{version_id} to disk, dev dependency in prod mode"); + tracing::debug!("skipping writing {name}@{version_id} to disk, dev dependency in prod mode"); } } diff --git a/src/download_and_link.rs b/src/download_and_link.rs index e0ff57e..9ee1b85 100644 --- a/src/download_and_link.rs +++ b/src/download_and_link.rs @@ -11,6 +11,7 @@ use std::{ sync::{Arc, Mutex as StdMutex}, }; use tokio::sync::Mutex; +use tracing::instrument; /// Filters a graph to only include production dependencies, if `prod` is `true` pub fn filter_graph(graph: &DownloadedGraph, prod: bool) -> DownloadedGraph { @@ -33,8 +34,16 @@ pub fn filter_graph(graph: &DownloadedGraph, prod: bool) -> DownloadedGraph { .collect() } +/// Receiver for dependencies downloaded and linked +pub type DownloadAndLinkReceiver = + tokio::sync::mpsc::Receiver>; + impl Project { /// Downloads a graph of dependencies and links them in the correct order + #[instrument( + skip(self, graph, refreshed_sources, reqwest, pesde_cb), + level = "debug" + )] pub async fn download_and_link< F: FnOnce(&Arc) -> R + Send + 'static, R: Future> + Send, @@ -49,9 +58,7 @@ impl Project { pesde_cb: F, ) -> Result< ( - tokio::sync::mpsc::Receiver< - Result, - >, + DownloadAndLinkReceiver, impl Future>>, ), errors::DownloadAndLinkError, diff --git a/src/lib.rs b/src/lib.rs index d9bd14b..a8fb864 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -14,8 +14,10 @@ use futures::{future::try_join_all, Stream}; use gix::sec::identity::Account; use std::{ collections::{HashMap, HashSet}, + fmt::Debug, path::{Path, PathBuf}, }; +use tracing::instrument; use wax::Pattern; /// Downloading packages @@ -149,29 +151,35 @@ impl Project { } /// Read the manifest file + #[instrument(skip(self), ret(level = "trace"), level = "debug")] pub async fn read_manifest(&self) -> Result { let string = fs::read_to_string(self.package_dir.join(MANIFEST_FILE_NAME)).await?; Ok(string) } + // TODO: cache the manifest /// Deserialize the manifest file + #[instrument(skip(self), ret(level = "trace"), level = "debug")] pub async fn deser_manifest(&self) -> Result { let string = fs::read_to_string(self.package_dir.join(MANIFEST_FILE_NAME)).await?; Ok(toml::from_str(&string)?) } /// Write the manifest file + #[instrument(skip(self, manifest), level = "debug")] pub async fn write_manifest>(&self, manifest: S) -> Result<(), std::io::Error> { fs::write(self.package_dir.join(MANIFEST_FILE_NAME), manifest.as_ref()).await } /// Deserialize the lockfile + #[instrument(skip(self), ret(level = "trace"), level = "debug")] pub async fn deser_lockfile(&self) -> Result { let string = fs::read_to_string(self.package_dir.join(LOCKFILE_FILE_NAME)).await?; Ok(toml::from_str(&string)?) } /// Write the lockfile + #[instrument(skip(self, lockfile), level = "debug")] pub async fn write_lockfile( &self, lockfile: Lockfile, @@ -182,7 +190,8 @@ impl Project { } /// Get the workspace members - pub async fn workspace_members>( + #[instrument(skip(self), level = "debug")] + pub async fn workspace_members + Debug>( &self, dir: P, can_ref_self: bool, @@ -222,7 +231,16 @@ impl Project { } /// Gets all matching paths in a directory -pub async fn matching_globs_old_behaviour<'a, P: AsRef, I: IntoIterator>( +#[deprecated( + since = "0.5.0-rc.13", + note = "use `matching_globs` instead, which does not have the old behaviour of including whole directories by their name (`src` instead of `src/**`)" +)] +#[instrument(ret, level = "trace")] +pub async fn matching_globs_old_behaviour< + 'a, + P: AsRef + Debug, + I: IntoIterator + Debug, +>( dir: P, globs: I, relative: bool, @@ -270,7 +288,7 @@ pub async fn matching_globs_old_behaviour<'a, P: AsRef, I: IntoIterator, I: IntoIterator, I: IntoIterator>( +#[instrument(ret, level = "trace")] +pub async fn matching_globs<'a, P: AsRef + Debug, I: IntoIterator + Debug>( dir: P, globs: I, relative: bool, diff --git a/src/linking/generator.rs b/src/linking/generator.rs index ea7b9b6..f82771e 100644 --- a/src/linking/generator.rs +++ b/src/linking/generator.rs @@ -117,10 +117,18 @@ pub fn get_lib_require_path( ) -> Result { let path = pathdiff::diff_paths(destination_dir, base_dir).unwrap(); let path = if use_new_structure { - log::debug!("using new structure for require path with {:?}", lib_file); + tracing::debug!( + "using new structure for require path with {:?} of {}", + lib_file, + container_dir.display() + ); lib_file.to_path(path) } else { - log::debug!("using old structure for require path with {:?}", lib_file); + tracing::debug!( + "using old structure for require path with {:?} of {}", + lib_file, + container_dir.display() + ); path }; diff --git a/src/linking/mod.rs b/src/linking/mod.rs index 29242de..f1c3afb 100644 --- a/src/linking/mod.rs +++ b/src/linking/mod.rs @@ -20,6 +20,7 @@ use std::{ sync::Arc, }; use tokio::task::spawn_blocking; +use tracing::instrument; /// Generates linking modules for a project pub mod generator; @@ -44,6 +45,7 @@ async fn write_cas(destination: PathBuf, cas_dir: &Path, contents: &str) -> std: impl Project { /// Links the dependencies of the project + #[instrument(skip(self, graph), level = "debug")] pub async fn link_dependencies( &self, graph: &DownloadedGraph, @@ -110,7 +112,7 @@ impl Project { } }; - log::debug!("{name}@{version_id} has {} exported types", types.len()); + tracing::debug!("{name}@{version_id} has {} exported types", types.len()); types } else { @@ -122,7 +124,7 @@ impl Project { .and_then(|t| t.build_files()) { let Some(script_path) = roblox_sync_config_gen_script else { - log::warn!("not having a `{}` script in the manifest might cause issues with Roblox linking", ScriptName::RobloxSyncConfigGenerator); + tracing::warn!("not having a `{}` script in the manifest might cause issues with Roblox linking", ScriptName::RobloxSyncConfigGenerator); return Ok((version_id, types)); }; diff --git a/src/lockfile.rs b/src/lockfile.rs index 883ee38..87d0d20 100644 --- a/src/lockfile.rs +++ b/src/lockfile.rs @@ -14,7 +14,7 @@ use relative_path::RelativePathBuf; use semver::Version; use serde::{Deserialize, Serialize}; use std::{ - collections::{btree_map::Entry, BTreeMap}, + collections::BTreeMap, path::{Path, PathBuf}, }; @@ -74,45 +74,6 @@ impl DependencyGraphNode { /// A graph of `DependencyGraphNode`s pub type DependencyGraph = Graph; -pub(crate) fn insert_node( - graph: &mut DependencyGraph, - name: PackageNames, - version: VersionId, - mut node: DependencyGraphNode, - is_top_level: bool, -) { - if !is_top_level && node.direct.take().is_some() { - log::debug!( - "tried to insert {name}@{version} as direct dependency from a non top-level context", - ); - } - - match graph - .entry(name.clone()) - .or_default() - .entry(version.clone()) - { - Entry::Vacant(entry) => { - entry.insert(node); - } - Entry::Occupied(existing) => { - let current_node = existing.into_mut(); - - match (¤t_node.direct, &node.direct) { - (Some(_), Some(_)) => { - log::warn!("duplicate direct dependency for {name}@{version}"); - } - - (None, Some(_)) => { - current_node.direct = node.direct; - } - - (_, _) => {} - } - } - } -} - /// A downloaded dependency graph node, i.e. a `DependencyGraphNode` with a `Target` #[derive(Serialize, Deserialize, Debug, Clone)] pub struct DownloadedDependencyGraphNode { diff --git a/src/main.rs b/src/main.rs index 8e67863..abaf113 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,14 +4,18 @@ use crate::cli::{auth::get_tokens, display_err, home_dir, HOME_DIR}; use anyhow::Context; use clap::{builder::styling::AnsiColor, Parser}; use fs_err::tokio as fs; -use indicatif::MultiProgress; -use indicatif_log_bridge::LogWrapper; use pesde::{matching_globs, AuthConfig, Project, MANIFEST_FILE_NAME}; use std::{ collections::HashSet, path::{Path, PathBuf}, }; use tempfile::NamedTempFile; +use tracing::instrument; +use tracing_indicatif::IndicatifLayer; +use tracing_subscriber::{ + filter::LevelFilter, fmt::time::uptime, layer::SubscriberExt, util::SubscriberInitExt, + EnvFilter, +}; mod cli; pub mod util; @@ -38,6 +42,7 @@ struct Cli { subcommand: cli::commands::Subcommand, } +#[instrument(level = "trace")] async fn get_linkable_dir(path: &Path) -> PathBuf { let mut curr_path = PathBuf::new(); let file_to_try = NamedTempFile::new_in(path).expect("failed to create temporary file"); @@ -68,7 +73,7 @@ async fn get_linkable_dir(path: &Path) -> PathBuf { if fs::hard_link(file_to_try.path(), &try_path).await.is_ok() { if let Err(err) = fs::remove_file(&try_path).await { - log::warn!( + tracing::warn!( "failed to remove temporary file at {}: {err}", try_path.display() ); @@ -129,6 +134,29 @@ async fn run() -> anyhow::Result<()> { std::process::exit(status.code().unwrap()); } + let indicatif_layer = IndicatifLayer::new(); + + let tracing_env_filter = EnvFilter::builder() + .with_default_directive(LevelFilter::INFO.into()) + .from_env_lossy() + .add_directive("reqwest=info".parse().unwrap()) + .add_directive("rustls=info".parse().unwrap()) + .add_directive("tokio_util=info".parse().unwrap()) + .add_directive("goblin=info".parse().unwrap()) + .add_directive("tower=info".parse().unwrap()) + .add_directive("hyper=info".parse().unwrap()) + .add_directive("h2=info".parse().unwrap()); + + tracing_subscriber::registry() + .with(tracing_env_filter) + .with( + tracing_subscriber::fmt::layer() + .with_writer(indicatif_layer.get_stderr_writer()) + .with_timer(uptime()), + ) + .with(indicatif_layer) + .init(); + let (project_root_dir, project_workspace_dir) = 'finder: { let mut current_path = Some(cwd.clone()); let mut project_root = None::; @@ -191,16 +219,13 @@ async fn run() -> anyhow::Result<()> { (project_root.unwrap_or_else(|| cwd.clone()), workspace_dir) }; - let multi = { - let logger = pretty_env_logger::formatted_builder() - .parse_env(pretty_env_logger::env_logger::Env::default().default_filter_or("info")) - .build(); - let multi = MultiProgress::new(); - - LogWrapper::new(multi.clone(), logger).try_init().unwrap(); - - multi - }; + tracing::trace!( + "project root: {}\nworkspace root: {}", + project_root_dir.display(), + project_workspace_dir + .as_ref() + .map_or("none".to_string(), |p| p.display().to_string()) + ); let home_dir = home_dir()?; let data_dir = home_dir.join("data"); @@ -217,7 +242,7 @@ async fn run() -> anyhow::Result<()> { } .join("cas"); - log::debug!("using cas dir in {}", cas_dir.display()); + tracing::debug!("using cas dir in {}", cas_dir.display()); let project = Project::new( project_root_dir, @@ -278,7 +303,7 @@ async fn run() -> anyhow::Result<()> { let cli = Cli::parse(); - cli.subcommand.run(project, multi, reqwest).await + cli.subcommand.run(project, reqwest).await } #[tokio::main] diff --git a/src/manifest/mod.rs b/src/manifest/mod.rs index 6230b11..336f5f6 100644 --- a/src/manifest/mod.rs +++ b/src/manifest/mod.rs @@ -1,13 +1,13 @@ -use relative_path::RelativePathBuf; -use semver::Version; -use serde::{Deserialize, Serialize}; -use std::collections::{BTreeMap, HashMap}; - use crate::{ manifest::{overrides::OverrideKey, target::Target}, names::PackageName, source::specifiers::DependencySpecifiers, }; +use relative_path::RelativePathBuf; +use semver::Version; +use serde::{Deserialize, Serialize}; +use std::collections::{BTreeMap, HashMap}; +use tracing::instrument; /// Overrides pub mod overrides; @@ -107,6 +107,7 @@ pub enum DependencyType { impl Manifest { /// Get all dependencies from the manifest + #[instrument(skip(self), ret(level = "trace"), level = "debug")] pub fn all_dependencies( &self, ) -> Result< diff --git a/src/patches.rs b/src/patches.rs index 166e37f..13dd8f6 100644 --- a/src/patches.rs +++ b/src/patches.rs @@ -3,6 +3,7 @@ use fs_err::tokio as fs; use git2::{ApplyLocation, Diff, DiffFormat, DiffLineType, Repository, Signature}; use relative_path::RelativePathBuf; use std::path::Path; +use tracing::instrument; /// Set up a git repository for patches pub fn setup_patches_repo>(dir: P) -> Result { @@ -69,6 +70,7 @@ pub fn create_patch>(dir: P) -> Result, git2::Error> { impl Project { /// Apply patches to the project's dependencies + #[instrument(skip(self, graph), level = "debug")] pub async fn apply_patches( &self, graph: &DownloadedGraph, @@ -97,7 +99,7 @@ impl Project { .get(&name) .and_then(|versions| versions.get(&version_id)) else { - log::warn!( + tracing::warn!( "patch for {name}@{version_id} not applied because it is not in the graph" ); tx.send(Ok(format!("{name}@{version_id}"))).await.unwrap(); @@ -114,7 +116,7 @@ impl Project { ); tokio::spawn(async move { - log::debug!("applying patch to {name}@{version_id}"); + tracing::debug!("applying patch to {name}@{version_id}"); let patch = match fs::read(&patch_path).await { Ok(patch) => patch, @@ -195,7 +197,9 @@ impl Project { } } - log::debug!("patch applied to {name}@{version_id}, removing .git directory"); + tracing::debug!( + "patch applied to {name}@{version_id}, removing .git directory" + ); if let Err(e) = fs::remove_dir_all(container_folder.join(".git")).await { tx.send(Err(errors::ApplyPatchesError::DotGitRemove(e))) diff --git a/src/resolver.rs b/src/resolver.rs index e2012cb..5d29315 100644 --- a/src/resolver.rs +++ b/src/resolver.rs @@ -1,5 +1,5 @@ use crate::{ - lockfile::{insert_node, DependencyGraph, DependencyGraphNode}, + lockfile::{DependencyGraph, DependencyGraphNode}, manifest::DependencyType, names::PackageNames, source::{ @@ -11,10 +11,55 @@ use crate::{ }, Project, DEFAULT_INDEX_NAME, }; -use std::collections::{HashMap, HashSet, VecDeque}; +use std::collections::{btree_map::Entry, HashMap, HashSet, VecDeque}; +use tracing::instrument; + +fn insert_node( + graph: &mut DependencyGraph, + name: PackageNames, + version: VersionId, + mut node: DependencyGraphNode, + is_top_level: bool, +) { + if !is_top_level && node.direct.take().is_some() { + tracing::debug!( + "tried to insert {name}@{version} as direct dependency from a non top-level context", + ); + } + + match graph + .entry(name.clone()) + .or_default() + .entry(version.clone()) + { + Entry::Vacant(entry) => { + entry.insert(node); + } + Entry::Occupied(existing) => { + let current_node = existing.into_mut(); + + match (¤t_node.direct, &node.direct) { + (Some(_), Some(_)) => { + tracing::warn!("duplicate direct dependency for {name}@{version}"); + } + + (None, Some(_)) => { + current_node.direct = node.direct; + } + + (_, _) => {} + } + } + } +} impl Project { /// Create a dependency graph from the project's manifest + #[instrument( + skip(self, previous_graph, refreshed_sources), + ret(level = "trace"), + level = "debug" + )] pub async fn dependency_graph( &self, previous_graph: Option<&DependencyGraph>, @@ -51,13 +96,13 @@ impl Project { let Some(alias) = all_specifiers.remove(&(specifier.clone(), *source_ty)) else { - log::debug!( + tracing::debug!( "dependency {name}@{version} from old dependency graph is no longer in the manifest", ); continue; }; - log::debug!("resolved {}@{} from old dependency graph", name, version); + tracing::debug!("resolved {}@{} from old dependency graph", name, version); insert_node( &mut graph, name.clone(), @@ -80,7 +125,7 @@ impl Project { .get(dep_name) .and_then(|v| v.get(dep_version)) { - log::debug!( + tracing::debug!( "{}resolved dependency {}@{} from {}@{}", "\t".repeat(depth), dep_name, @@ -102,7 +147,7 @@ impl Project { .map(|(name, (version, _))| (name, version, depth + 1)) .for_each(|dep| queue.push_back(dep)); } else { - log::warn!( + tracing::warn!( "dependency {}@{} from {}@{} not found in previous graph", dep_name, dep_version, @@ -133,7 +178,7 @@ impl Project { let alias = path.last().unwrap().clone(); let depth = path.len() - 1; - log::debug!( + tracing::debug!( "{}resolving {specifier} from {}", "\t".repeat(depth), path.join(">") @@ -243,7 +288,7 @@ impl Project { .get_mut(&name) .and_then(|versions| versions.get_mut(&target_version_id)) { - log::debug!( + tracing::debug!( "{}{}@{} already resolved", "\t".repeat(depth), name, @@ -253,7 +298,7 @@ impl Project { if std::mem::discriminant(&already_resolved.pkg_ref) != std::mem::discriminant(pkg_ref) { - log::warn!( + tracing::warn!( "resolved package {name}@{target_version_id} has a different source than the previously resolved one at {}, this may cause issues", path.join(">") ); @@ -290,7 +335,7 @@ impl Project { depth == 0, ); - log::debug!( + tracing::debug!( "{}resolved {}@{} from new dependency graph", "\t".repeat(depth), name, @@ -318,7 +363,7 @@ impl Project { }); if overridden.is_some() { - log::debug!( + tracing::debug!( "{}overridden specifier found for {} ({dependency_spec})", "\t".repeat(depth), path.iter() @@ -346,7 +391,7 @@ impl Project { for (name, versions) in &graph { for (version_id, node) in versions { if node.resolved_ty == DependencyType::Peer { - log::warn!("peer dependency {name}@{version_id} was not resolved"); + tracing::warn!("peer dependency {name}@{version_id} was not resolved"); } } } diff --git a/src/scripts.rs b/src/scripts.rs index b7de514..bb14fab 100644 --- a/src/scripts.rs +++ b/src/scripts.rs @@ -1,7 +1,7 @@ use crate::Project; use std::{ ffi::OsStr, - fmt::{Display, Formatter}, + fmt::{Debug, Display, Formatter}, path::Path, process::Stdio, }; @@ -9,6 +9,7 @@ use tokio::{ io::{AsyncBufReadExt, BufReader}, process::Command, }; +use tracing::instrument; /// Script names used by pesde #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] @@ -30,7 +31,8 @@ impl Display for ScriptName { } } -pub(crate) async fn execute_script, S: AsRef>( +#[instrument(skip(project), level = "debug")] +pub(crate) async fn execute_script + Debug, S: AsRef + Debug>( script_name: ScriptName, script_path: &Path, args: A, @@ -59,10 +61,10 @@ pub(crate) async fn execute_script, S: AsRef>( while let Some(line) = stderr.next_line().await.transpose() { match line { Ok(line) => { - log::error!("[{script}]: {line}"); + tracing::error!("[{script}]: {line}"); } Err(e) => { - log::error!("ERROR IN READING STDERR OF {script}: {e}"); + tracing::error!("ERROR IN READING STDERR OF {script}: {e}"); break; } } @@ -78,11 +80,11 @@ pub(crate) async fn execute_script, S: AsRef>( stdout_str.push_str(&line); stdout_str.push('\n'); } else { - log::info!("[{script_2}]: {line}"); + tracing::info!("[{script_2}]: {line}"); } } Err(e) => { - log::error!("ERROR IN READING STDOUT OF {script_2}: {e}"); + tracing::error!("ERROR IN READING STDOUT OF {script_2}: {e}"); break; } } @@ -95,7 +97,7 @@ pub(crate) async fn execute_script, S: AsRef>( } } Err(e) if e.kind() == std::io::ErrorKind::NotFound => { - log::warn!("Lune could not be found in PATH: {e}"); + tracing::warn!("Lune could not be found in PATH: {e}"); Ok(None) } diff --git a/src/source/fs.rs b/src/source/fs.rs index 9be2472..e1136df 100644 --- a/src/source/fs.rs +++ b/src/source/fs.rs @@ -9,6 +9,7 @@ use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; use std::{ collections::BTreeMap, + fmt::Debug, future::Future, path::{Path, PathBuf}, }; @@ -17,6 +18,7 @@ use tokio::{ io::{AsyncReadExt, AsyncWriteExt}, pin, }; +use tracing::instrument; /// A file system entry #[derive(Debug, Clone, Serialize, Deserialize)] @@ -125,7 +127,8 @@ pub(crate) async fn store_in_cas< impl PackageFS { /// Write the package to the given destination - pub async fn write_to, Q: AsRef>( + #[instrument(skip(self), level = "debug")] + pub async fn write_to + Debug, Q: AsRef + Debug>( &self, destination: P, cas_path: Q, @@ -211,7 +214,8 @@ impl PackageFS { } /// Returns the contents of the file with the given hash - pub async fn read_file, H: AsRef>( + #[instrument(skip(self), ret(level = "trace"), level = "debug")] + pub async fn read_file + Debug, H: AsRef + Debug>( &self, file_hash: H, cas_path: P, diff --git a/src/source/git/mod.rs b/src/source/git/mod.rs index 82f1302..149ad93 100644 --- a/src/source/git/mod.rs +++ b/src/source/git/mod.rs @@ -27,6 +27,7 @@ use std::{ sync::Arc, }; use tokio::{sync::Mutex, task::spawn_blocking}; +use tracing::instrument; /// The Git package reference pub mod pkg_ref; @@ -70,10 +71,12 @@ impl PackageSource for GitPackageSource { type ResolveError = errors::ResolveError; type DownloadError = errors::DownloadError; + #[instrument(skip_all, level = "debug")] async fn refresh(&self, project: &Project) -> Result<(), Self::RefreshError> { GitBasedSource::refresh(self, project).await } + #[instrument(skip_all, level = "debug")] async fn resolve( &self, specifier: &Self::Specifier, @@ -329,6 +332,7 @@ impl PackageSource for GitPackageSource { )) } + #[instrument(skip_all, level = "debug")] async fn download( &self, pkg_ref: &Self::Ref, @@ -343,7 +347,7 @@ impl PackageSource for GitPackageSource { match fs::read_to_string(&index_file).await { Ok(s) => { - log::debug!( + tracing::debug!( "using cached index file for package {}#{}", pkg_ref.repo, pkg_ref.tree_id @@ -487,7 +491,7 @@ impl PackageSource for GitPackageSource { } if pkg_ref.use_new_structure() && name == "default.project.json" { - log::debug!( + tracing::debug!( "removing default.project.json from {}#{} at {path} - using new structure", pkg_ref.repo, pkg_ref.tree_id diff --git a/src/source/git_index.rs b/src/source/git_index.rs index f03e385..14fdb12 100644 --- a/src/source/git_index.rs +++ b/src/source/git_index.rs @@ -1,8 +1,11 @@ #![allow(async_fn_in_trait)] + use crate::{util::authenticate_conn, Project}; use fs_err::tokio as fs; use gix::remote::Direction; +use std::fmt::Debug; use tokio::task::spawn_blocking; +use tracing::instrument; /// A trait for sources that are based on Git repositories pub trait GitBasedSource { @@ -90,7 +93,11 @@ pub trait GitBasedSource { } /// Reads a file from a tree -pub fn read_file + Clone, P: ToString + PartialEq>( +#[instrument(skip(tree), ret, level = "trace")] +pub fn read_file< + I: IntoIterator + Clone + Debug, + P: ToString + PartialEq, +>( tree: &gix::Tree, file_path: I, ) -> Result, errors::ReadFile> { @@ -120,6 +127,7 @@ pub fn read_file + Clone, P: ToString + PartialEq Result { // this is a bare repo, so this is the actual path let path = repo.path().to_path_buf(); diff --git a/src/source/pesde/mod.rs b/src/source/pesde/mod.rs index a39037c..746eef6 100644 --- a/src/source/pesde/mod.rs +++ b/src/source/pesde/mod.rs @@ -30,6 +30,7 @@ use crate::{ use fs_err::tokio as fs; use futures::StreamExt; use tokio::task::spawn_blocking; +use tracing::instrument; /// The pesde package reference pub mod pkg_ref; @@ -73,6 +74,7 @@ impl PesdePackageSource { } /// Reads the config file + #[instrument(skip_all, ret(level = "trace"), level = "debug")] pub async fn config(&self, project: &Project) -> Result { let repo_url = self.repo_url.clone(); let path = self.path(project); @@ -99,10 +101,12 @@ impl PackageSource for PesdePackageSource { type ResolveError = errors::ResolveError; type DownloadError = errors::DownloadError; + #[instrument(skip_all, level = "debug")] async fn refresh(&self, project: &Project) -> Result<(), Self::RefreshError> { GitBasedSource::refresh(self, project).await } + #[instrument(skip_all, level = "debug")] async fn resolve( &self, specifier: &Self::Specifier, @@ -127,7 +131,7 @@ impl PackageSource for PesdePackageSource { let entries: IndexFile = toml::from_str(&string) .map_err(|e| Self::ResolveError::Parse(specifier.name.to_string(), e))?; - log::debug!("{} has {} possible entries", specifier.name, entries.len()); + tracing::debug!("{} has {} possible entries", specifier.name, entries.len()); Ok(( PackageNames::Pesde(specifier.name.clone()), @@ -155,6 +159,7 @@ impl PackageSource for PesdePackageSource { )) } + #[instrument(skip_all, level = "debug")] async fn download( &self, pkg_ref: &Self::Ref, @@ -171,7 +176,7 @@ impl PackageSource for PesdePackageSource { match fs::read_to_string(&index_file).await { Ok(s) => { - log::debug!( + tracing::debug!( "using cached index file for package {}@{} {}", pkg_ref.name, pkg_ref.version, @@ -192,7 +197,7 @@ impl PackageSource for PesdePackageSource { let mut request = reqwest.get(&url).header(ACCEPT, "application/octet-stream"); if let Some(token) = project.auth_config.tokens().get(&self.repo_url) { - log::debug!("using token for {}", self.repo_url); + tracing::debug!("using token for {}", self.repo_url); request = request.header(AUTHORIZATION, token); } diff --git a/src/source/wally/compat_util.rs b/src/source/wally/compat_util.rs index d481ab4..19f2bc6 100644 --- a/src/source/wally/compat_util.rs +++ b/src/source/wally/compat_util.rs @@ -11,6 +11,7 @@ use crate::{ Project, LINK_LIB_NO_FILE_FOUND, }; use fs_err::tokio as fs; +use tracing::instrument; #[derive(Deserialize)] #[serde(rename_all = "camelCase")] @@ -19,7 +20,8 @@ struct SourcemapNode { file_paths: Vec, } -pub(crate) async fn find_lib_path( +#[instrument(skip(project, package_dir), level = "debug")] +async fn find_lib_path( project: &Project, package_dir: &Path, ) -> Result, errors::FindLibPathError> { @@ -29,7 +31,7 @@ pub(crate) async fn find_lib_path( .scripts .get(&ScriptName::SourcemapGenerator.to_string()) else { - log::warn!("no sourcemap generator script found in manifest"); + tracing::warn!("no sourcemap generator script found in manifest"); return Ok(None); }; @@ -55,6 +57,7 @@ pub(crate) async fn find_lib_path( pub(crate) const WALLY_MANIFEST_FILE_NAME: &str = "wally.toml"; +#[instrument(skip(project, tempdir), level = "debug")] pub(crate) async fn get_target( project: &Project, tempdir: &TempDir, diff --git a/src/source/wally/manifest.rs b/src/source/wally/manifest.rs index 9845f48..3e25c5a 100644 --- a/src/source/wally/manifest.rs +++ b/src/source/wally/manifest.rs @@ -1,13 +1,13 @@ use std::collections::BTreeMap; -use semver::{Version, VersionReq}; -use serde::{Deserialize, Deserializer}; - use crate::{ manifest::{errors, DependencyType}, names::wally::WallyPackageName, source::{specifiers::DependencySpecifiers, wally::specifier::WallyDependencySpecifier}, }; +use semver::{Version, VersionReq}; +use serde::{Deserialize, Deserializer}; +use tracing::instrument; #[derive(Deserialize, Clone, Debug)] #[serde(rename_all = "lowercase")] @@ -63,6 +63,7 @@ pub struct WallyManifest { impl WallyManifest { /// Get all dependencies from the manifest + #[instrument(skip(self), ret(level = "trace"), level = "debug")] pub fn all_dependencies( &self, ) -> Result< diff --git a/src/source/wally/mod.rs b/src/source/wally/mod.rs index 7cfb931..50df173 100644 --- a/src/source/wally/mod.rs +++ b/src/source/wally/mod.rs @@ -30,6 +30,7 @@ use std::{ use tempfile::tempdir; use tokio::{io::AsyncWriteExt, sync::Mutex, task::spawn_blocking}; use tokio_util::compat::FuturesAsyncReadCompatExt; +use tracing::instrument; pub(crate) mod compat_util; pub(crate) mod manifest; @@ -68,6 +69,7 @@ impl WallyPackageSource { } /// Reads the config file + #[instrument(skip_all, ret(level = "trace"), level = "debug")] pub async fn config(&self, project: &Project) -> Result { let repo_url = self.repo_url.clone(); let path = self.path(project); @@ -94,10 +96,12 @@ impl PackageSource for WallyPackageSource { type ResolveError = errors::ResolveError; type DownloadError = errors::DownloadError; + #[instrument(skip_all, level = "debug")] async fn refresh(&self, project: &Project) -> Result<(), Self::RefreshError> { GitBasedSource::refresh(self, project).await } + #[instrument(skip_all, level = "debug")] async fn resolve( &self, specifier: &Self::Specifier, @@ -111,7 +115,7 @@ impl PackageSource for WallyPackageSource { let string = match read_file(&tree, [scope, name]) { Ok(Some(s)) => s, Ok(None) => { - log::debug!( + tracing::debug!( "{} not found in wally registry. searching in backup registries", specifier.name ); @@ -134,7 +138,7 @@ impl PackageSource for WallyPackageSource { .await { Ok((name, results)) => { - log::debug!("found {} in backup registry {registry}", name); + tracing::debug!("found {} in backup registry {registry}", name); return Ok((name, results)); } Err(errors::ResolveError::NotFound(_)) => { @@ -162,7 +166,7 @@ impl PackageSource for WallyPackageSource { .collect::>() .map_err(|e| Self::ResolveError::Parse(specifier.name.to_string(), e))?; - log::debug!("{} has {} possible entries", specifier.name, entries.len()); + tracing::debug!("{} has {} possible entries", specifier.name, entries.len()); Ok(( PackageNames::Wally(specifier.name.clone()), @@ -192,6 +196,7 @@ impl PackageSource for WallyPackageSource { )) } + #[instrument(skip_all, level = "debug")] async fn download( &self, pkg_ref: &Self::Ref, @@ -207,7 +212,7 @@ impl PackageSource for WallyPackageSource { let tempdir = match fs::read_to_string(&index_file).await { Ok(s) => { - log::debug!( + tracing::debug!( "using cached index file for package {}@{}", pkg_ref.name, pkg_ref.version @@ -240,7 +245,7 @@ impl PackageSource for WallyPackageSource { ); if let Some(token) = project.auth_config.tokens().get(&self.repo_url) { - log::debug!("using token for {}", self.repo_url); + tracing::debug!("using token for {}", self.repo_url); request = request.header(AUTHORIZATION, token); } diff --git a/src/source/workspace/mod.rs b/src/source/workspace/mod.rs index 88040c7..36e75f9 100644 --- a/src/source/workspace/mod.rs +++ b/src/source/workspace/mod.rs @@ -13,6 +13,7 @@ use relative_path::RelativePathBuf; use reqwest::Client; use std::collections::{BTreeMap, HashSet}; use tokio::pin; +use tracing::instrument; /// The workspace package reference pub mod pkg_ref; @@ -35,6 +36,7 @@ impl PackageSource for WorkspacePackageSource { Ok(()) } + #[instrument(skip_all, level = "debug")] async fn resolve( &self, specifier: &Self::Specifier, @@ -126,6 +128,7 @@ impl PackageSource for WorkspacePackageSource { )) } + #[instrument(skip_all, level = "debug")] async fn download( &self, pkg_ref: &Self::Ref, diff --git a/src/source/workspace/specifier.rs b/src/source/workspace/specifier.rs index 6025c61..4a2f886 100644 --- a/src/source/workspace/specifier.rs +++ b/src/source/workspace/specifier.rs @@ -19,7 +19,7 @@ impl DependencySpecifier for WorkspaceDependencySpecifier {} impl Display for WorkspaceDependencySpecifier { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "workspace:{}{}", self.version, self.name) + write!(f, "{}@workspace:{}", self.name, self.version) } }