Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-25 04:23:25 +00:00
Code Issues Projects Releases Packages Wiki Activity

switch log crate to tracing

Browse source
This commit is contained in:
Dezhi Wu 2021-08-15 20:46:13 +08:00
parent d15f646ff1
commit ba0947dded
48 changed files with 277 additions and 239 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

35
Cargo.lock generated
View file

@ -324,15 +324,6 @@ dependencies = [
"log",
]
[[package]]
name = "env_logger"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
dependencies = [
"log",
]
[[package]]
name = "expect-test"
version = "1.1.0"
@ -380,12 +371,12 @@ dependencies = [
"cargo_metadata",
"crossbeam-channel",
"jod-thread",
"log",
"paths",
"serde",
"serde_json",
"stdx",
"toolchain",
"tracing",
]
[[package]]
@ -462,7 +453,6 @@ dependencies = [
"hir_ty",
"indexmap",
"itertools",
"log",
"once_cell",
"profile",
"rustc-hash",
@ -490,7 +480,6 @@ dependencies = [
"itertools",
"la-arena",
"limit",
"log",
"mbe",
"once_cell",
"profile",
@ -499,6 +488,7 @@ dependencies = [
"stdx",
"syntax",
"test_utils",
"tracing",
"tt",
]
@ -514,13 +504,13 @@ dependencies = [
"itertools",
"la-arena",
"limit",
"log",
"mbe",
"parser",
"profile",
"rustc-hash",
"syntax",
"test_utils",
"tracing",
"tt",
]
@ -541,7 +531,6 @@ dependencies = [
"itertools",
"la-arena",
"limit",
"log",
"once_cell",
"profile",
"rustc-hash",
@ -581,7 +570,6 @@ dependencies = [
"ide_ssr",
"indexmap",
"itertools",
"log",
"oorandom",
"profile",
"pulldown-cmark",
@ -591,6 +579,7 @@ dependencies = [
"syntax",
"test_utils",
"text_edit",
"tracing",
"url",
]
@ -625,7 +614,6 @@ dependencies = [
"hir",
"ide_db",
"itertools",
"log",
"once_cell",
"profile",
"rustc-hash",
@ -634,6 +622,7 @@ dependencies = [
"syntax",
"test_utils",
"text_edit",
"tracing",
"xshell",
]
@ -649,7 +638,6 @@ dependencies = [
"hir",
"itertools",
"limit",
"log",
"once_cell",
"profile",
"rayon",
@ -658,6 +646,7 @@ dependencies = [
"syntax",
"test_utils",
"text_edit",
"tracing",
]
[[package]]
@ -889,7 +878,6 @@ version = "0.0.0"
dependencies = [
"cov-mark",
"expect-test",
"log",
"parser",
"profile",
"rustc-hash",
@ -897,6 +885,7 @@ dependencies = [
"stdx",
"syntax",
"test_utils",
"tracing",
"tt",
]
@ -1121,7 +1110,6 @@ version = "0.0.0"
dependencies = [
"crossbeam-channel",
"jod-thread",
"log",
"memmap2",
"object",
"paths",
@ -1130,6 +1118,7 @@ dependencies = [
"serde_json",
"snap",
"stdx",
"tracing",
"tt",
]
@ -1188,7 +1177,6 @@ dependencies = [
"cfg",
"expect-test",
"la-arena",
"log",
"paths",
"profile",
"rustc-hash",
@ -1197,6 +1185,7 @@ dependencies = [
"serde_json",
"stdx",
"toolchain",
"tracing",
]
[[package]]
@ -1308,7 +1297,6 @@ dependencies = [
"cfg",
"crossbeam-channel",
"dissimilar",
"env_logger",
"expect-test",
"flycheck",
"hir",
@ -1319,7 +1307,6 @@ dependencies = [
"ide_ssr",
"itertools",
"jod-thread",
"log",
"lsp-server",
"lsp-types",
"mbe",
@ -1343,6 +1330,7 @@ dependencies = [
"tikv-jemallocator",
"toolchain",
"tracing",
"tracing-log",
"tracing-subscriber",
"tracing-tree",
"tt",
@ -1737,6 +1725,7 @@ dependencies = [
"thread_local",
"tracing",
"tracing-core",
"tracing-log",
]
[[package]]
@ -1838,10 +1827,10 @@ version = "0.0.0"
dependencies = [
"crossbeam-channel",
"jod-thread",
"log",
"notify",
"paths",
"rustc-hash",
"tracing",
"vfs",
"walkdir",
]

2
crates/flycheck/Cargo.toml
View file

@ -10,7 +10,7 @@ doctest = false
[dependencies]
crossbeam-channel = "0.5.0"
log = "0.4.8"
tracing = "0.1"
cargo_metadata = "0.14"
serde = { version = "1.0.106", features = ["derive"] }
serde_json = "1.0.48"

6
crates/flycheck/src/lib.rs
View file

@ -163,7 +163,7 @@ impl FlycheckActor {
self.cancel_check_process();
let mut command = self.check_command();
log::info!("restart flycheck {:?}", command);
tracing::info!("restart flycheck {:?}", command);
command.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
if let Ok(child) = command.spawn().map(JodChild) {
self.cargo_handle = Some(CargoHandle::spawn(child));
@ -176,7 +176,7 @@ impl FlycheckActor {
let cargo_handle = self.cargo_handle.take().unwrap();
let res = cargo_handle.join();
if res.is_err() {
log::error!(
tracing::error!(
"Flycheck failed to run the following command: {:?}",
self.check_command()
)
@ -319,7 +319,7 @@ impl CargoActor {
let message = match message {
Ok(message) => message,
Err(err) => {
log::error!("Invalid json from cargo check, ignoring ({})", err);
tracing::error!("Invalid json from cargo check, ignoring ({})", err);
continue;
}
};

1
crates/hir/Cargo.toml
View file

@ -9,7 +9,6 @@ edition = "2018"
doctest = false
[dependencies]
log = "0.4.8"
rustc-hash = "1.1.0"
either = "1.5.3"
arrayvec = "0.7"

2
crates/hir_def/Cargo.toml
View file

@ -11,7 +11,7 @@ doctest = false
[dependencies]
cov-mark = "2.0.0-pre.1"
dashmap = { version = "4.0.2", features = ["raw-api"] }
log = "0.4.8"
tracing = "0.1"
once_cell = "1.3.1"
rustc-hash = "1.1.0"
either = "1.5.3"

4
crates/hir_def/src/body.rs
View file

@ -135,7 +135,7 @@ impl Expander {
None => {
// Only `None` if the macro expansion produced no usable AST.
if err.is_none() {
log::warn!("no error despite `parse_or_expand` failing");
tracing::warn!("no error despite `parse_or_expand` failing");
}
return Ok(ExpandResult::only_err(err.unwrap_or_else(|| {
@ -152,7 +152,7 @@ impl Expander {
}
};
log::debug!("macro expansion {:#?}", node.syntax());
tracing::debug!("macro expansion {:#?}", node.syntax());
self.recursion_limit += 1;
let mark = Mark {

26
crates/hir_def/src/nameres/collector.rs
View file

@ -64,7 +64,7 @@ pub(super) fn collect_defs(
if block.is_none() {
// populate external prelude
for dep in &crate_graph[def_map.krate].dependencies {
log::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
tracing::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
let dep_def_map = db.crate_def_map(dep.crate_id);
def_map
.extern_prelude
@ -358,7 +358,7 @@ impl DefCollector<'_> {
i += 1;
if FIXED_POINT_LIMIT.check(i).is_err() {
log::error!("name resolution is stuck");
tracing::error!("name resolution is stuck");
break 'outer;
}
}
@ -510,7 +510,7 @@ impl DefCollector<'_> {
return;
}
_ => {
log::debug!(
tracing::debug!(
"could not resolve prelude path `{}` to module (resolved to {:?})",
path,
per_ns.types
@ -654,7 +654,7 @@ impl DefCollector<'_> {
current_module_id: LocalModuleId,
extern_crate: &item_tree::ExternCrate,
) {
log::debug!(
tracing::debug!(
"importing macros from extern crate: {:?} ({:?})",
extern_crate,
self.def_map.edition,
@ -718,7 +718,7 @@ impl DefCollector<'_> {
}
fn resolve_import(&self, module_id: LocalModuleId, import: &Import) -> PartialResolvedImport {
log::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition);
tracing::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition);
if import.is_extern_crate {
let res = self.def_map.resolve_name_in_extern_prelude(
self.db,
@ -794,7 +794,7 @@ impl DefCollector<'_> {
def.macros = None;
}
log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
tracing::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
// extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658
if import.is_extern_crate && module_id == self.def_map.root {
@ -806,7 +806,7 @@ impl DefCollector<'_> {
self.update(module_id, &[(name, def)], vis, ImportType::Named);
}
ImportKind::Glob => {
log::debug!("glob import: {:?}", import);
tracing::debug!("glob import: {:?}", import);
match def.take_types() {
Some(ModuleDefId::ModuleId(m)) => {
if import.is_prelude {
@ -895,10 +895,10 @@ impl DefCollector<'_> {
self.update(module_id, &resolutions, vis, ImportType::Glob);
}
Some(d) => {
log::debug!("glob import {:?} from non-module/enum {:?}", import, d);
tracing::debug!("glob import {:?} from non-module/enum {:?}", import, d);
}
None => {
log::debug!("glob import {:?} didn't resolve as type", import);
tracing::debug!("glob import {:?} didn't resolve as type", import);
}
}
}
@ -947,7 +947,7 @@ impl DefCollector<'_> {
let tr = match res.take_types() {
Some(ModuleDefId::TraitId(tr)) => tr,
Some(other) => {
log::debug!("non-trait `_` import of {:?}", other);
tracing::debug!("non-trait `_` import of {:?}", other);
continue;
}
None => continue,
@ -1167,7 +1167,7 @@ impl DefCollector<'_> {
) {
if EXPANSION_DEPTH_LIMIT.check(depth).is_err() {
cov_mark::hit!(macro_expansion_overflow);
log::warn!("macro expansion is too deep");
tracing::warn!("macro expansion is too deep");
return;
}
let file_id = macro_call_id.as_file();
@ -1694,7 +1694,7 @@ impl ModCollector<'_, '_> {
} else if self.is_builtin_or_registered_attr(&attr.path) {
continue;
} else {
log::debug!("non-builtin attribute {}", attr.path);
tracing::debug!("non-builtin attribute {}", attr.path);
let ast_id = AstIdWithPath::new(
self.file_id(),
@ -1768,7 +1768,7 @@ impl ModCollector<'_, '_> {
}
None => {
// FIXME: diagnose
log::debug!("malformed derive: {:?}", attr);
tracing::debug!("malformed derive: {:?}", attr);
}
}
}

2
crates/hir_def/src/nameres/mod_resolution.rs
View file

@ -27,7 +27,7 @@ impl ModDir {
fn child(&self, dir_path: DirPath, root_non_dir_owner: bool) -> Option<ModDir> {
let depth = self.depth + 1;
if MOD_DEPTH_LIMIT.check(depth as usize).is_err() {
log::error!("MOD_DEPTH_LIMIT exceeded");
tracing::error!("MOD_DEPTH_LIMIT exceeded");
cov_mark::hit!(circular_mods);
return None;
}

20
crates/hir_def/src/nameres/path_resolution.rs
View file

@ -116,7 +116,7 @@ impl DefMap {
if self.block_id() != m.block {
cov_mark::hit!(adjust_vis_in_block_def_map);
vis = Visibility::Module(self.module_id(self.root()));
log::debug!("visibility {:?} points outside DefMap, adjusting to {:?}", m, vis);
tracing::debug!("visibility {:?} points outside DefMap, adjusting to {:?}", m, vis);
}
}
@ -204,7 +204,7 @@ impl DefMap {
Some((idx, segment)) => (idx, segment),
None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
};
log::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
tracing::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
self.resolve_name_in_crate_root_or_extern_prelude(db, segment)
}
PathKind::Plain => {
@ -221,7 +221,7 @@ impl DefMap {
let prefer_module =
if path.segments().len() == 1 { shadow } else { BuiltinShadowMode::Module };
log::debug!("resolving {:?} in module", segment);
tracing::debug!("resolving {:?} in module", segment);
self.resolve_name_in_module(db, original_module, segment, prefer_module)
}
PathKind::Super(lvl) => {
@ -236,7 +236,11 @@ impl DefMap {
PathKind::Super(lvl - i),
path.segments().to_vec(),
);
log::debug!("`super` path: {} -> {} in parent map", path, new_path);
tracing::debug!(
"`super` path: {} -> {} in parent map",
path,
new_path
);
return block.parent.def_map(db).resolve_path_fp_with_macro(
db,
mode,
@ -246,7 +250,7 @@ impl DefMap {
);
}
None => {
log::debug!("super path in root module");
tracing::debug!("super path in root module");
return ResolvePathResult::empty(ReachedFixedPoint::Yes);
}
},
@ -270,7 +274,7 @@ impl DefMap {
None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
};
if let Some(def) = self.extern_prelude.get(segment) {
log::debug!("absolute path {:?} resolved to crate {:?}", path, def);
tracing::debug!("absolute path {:?} resolved to crate {:?}", path, def);
PerNs::types(*def, Visibility::Public)
} else {
return ResolvePathResult::empty(ReachedFixedPoint::No); // extern crate declarations can add to the extern prelude
@ -299,7 +303,7 @@ impl DefMap {
PathKind::Super(0),
path.segments()[i..].iter().cloned(),
);
log::debug!("resolving {:?} in other crate", path);
tracing::debug!("resolving {:?} in other crate", path);
let defp_map = module.def_map(db);
let (def, s) = defp_map.resolve_path(db, module.local_id, &path, shadow);
return ResolvePathResult::with(
@ -351,7 +355,7 @@ impl DefMap {
s => {
// could be an inherent method call in UFCS form
// (`Struct::method`), or some other kind of associated item
log::debug!(
tracing::debug!(
"path segment {:?} resolved to non-module {:?}, but is not last",
segment,
curr,

2
crates/hir_def/src/nameres/proc_macro.rs
View file

@ -70,7 +70,7 @@ impl Attrs {
}
_ => {
log::trace!("malformed `#[proc_macro_derive]`: {}", derive);
tracing::trace!("malformed `#[proc_macro_derive]`: {}", derive);
None
}
}

2
crates/hir_expand/Cargo.toml
View file

@ -10,7 +10,7 @@ doctest = false
[dependencies]
cov-mark = "2.0.0-pre.1"
log = "0.4.8"
tracing = "0.1"
either = "1.5.3"
rustc-hash = "1.0.0"
la-arena = { version = "0.2.0", path = "../../lib/arena" }

2
crates/hir_expand/src/builtin_derive.rs
View file

@ -1,6 +1,6 @@
//! Builtin derives.
use log::debug;
use tracing::debug;
use mbe::ExpandResult;
use parser::FragmentKind;

14
crates/hir_expand/src/db.rs
View file

@ -203,7 +203,7 @@ fn parse_macro_expansion(
.collect::<Vec<_>>()
.join("\n");
log::warn!(
tracing::warn!(
"fail on macro_parse: (reason: {:?} macro_call: {:#}) parents: {}",
err,
node.value,
@ -217,13 +217,13 @@ fn parse_macro_expansion(
let fragment_kind = macro_fragment_kind(db, macro_file.macro_call_id);
log::debug!("expanded = {}", tt.as_debug_string());
log::debug!("kind = {:?}", fragment_kind);
tracing::debug!("expanded = {}", tt.as_debug_string());
tracing::debug!("kind = {:?}", fragment_kind);
let (parse, rev_token_map) = match mbe::token_tree_to_syntax_node(&tt, fragment_kind) {
Ok(it) => it,
Err(err) => {
log::debug!(
tracing::debug!(
"failed to parse expansion to {:?} = {}",
fragment_kind,
tt.as_debug_string()
@ -250,7 +250,7 @@ fn parse_macro_expansion(
}
}
None => {
log::debug!("parse = {:?}", parse.syntax_node().kind());
tracing::debug!("parse = {:?}", parse.syntax_node().kind());
ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: None }
}
}
@ -321,7 +321,7 @@ fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<TokenExpander>>
Ok(it) => it,
Err(err) => {
let name = macro_rules.name().map(|n| n.to_string()).unwrap_or_default();
log::warn!("fail on macro_def parse ({}): {:?} {:#?}", name, err, tt);
tracing::warn!("fail on macro_def parse ({}): {:?} {:#?}", name, err, tt);
return None;
}
};
@ -334,7 +334,7 @@ fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<TokenExpander>>
Ok(it) => it,
Err(err) => {
let name = macro_def.name().map(|n| n.to_string()).unwrap_or_default();
log::warn!("fail on macro_def parse ({}): {:?} {:#?}", name, err, tt);
tracing::warn!("fail on macro_def parse ({}): {:?} {:#?}", name, err, tt);
return None;
}
};

2
crates/hir_expand/src/lib.rs
View file

@ -561,7 +561,7 @@ impl<'a> InFile<&'a SyntaxNode> {
Some(range) => {
let original_file = range.file_id.original_file(db);
if range.file_id != original_file.into() {
log::error!("Failed mapping up more for {:?}", range);
tracing::error!("Failed mapping up more for {:?}", range);
}
Some(FileRange { file_id: original_file, range: range.value })
}

2
crates/hir_ty/Cargo.toml
View file

@ -14,7 +14,7 @@ itertools = "0.10.0"
arrayvec = "0.7"
smallvec = "1.2.0"
ena = "0.14.0"
log = "0.4.8"
tracing = "0.1"
rustc-hash = "1.1.0"
scoped-tls = "1"
chalk-solve = { version = "0.70", default-features = false }

2
crates/hir_ty/src/autoderef.rs
View file

@ -10,7 +10,7 @@ use chalk_ir::{cast::Cast, fold::Fold, interner::HasInterner, VariableKind};
use hir_def::lang_item::LangItemTarget;
use hir_expand::name::name;
use limit::Limit;
use log::{info, warn};
use tracing::{info, warn};
use crate::{
db::HirDatabase, static_lifetime, AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds,

2
crates/hir_ty/src/chalk_db.rs
View file

@ -3,7 +3,7 @@
use std::sync::Arc;
use cov_mark::hit;
use log::debug;
use tracing::debug;
use chalk_ir::{cast::Cast, fold::shift::Shift, CanonicalVarKinds};
use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait};

5
crates/hir_ty/src/consteval.rs
View file

@ -28,7 +28,10 @@ impl ConstExt for Const {
chalk_ir::ConstValue::Concrete(..) => false,
_ => {
log::error!("is_unknown was called on a non-concrete constant value! {:?}", self);
tracing::error!(
"is_unknown was called on a non-concrete constant value! {:?}",
self
);
true
}
}

8
crates/hir_ty/src/traits.rs
View file

@ -81,7 +81,7 @@ pub(crate) fn trait_solve_query(
GoalData::DomainGoal(DomainGoal::Holds(WhereClause::AliasEq(_))) => "alias_eq".to_string(),
_ => "??".to_string(),
});
log::info!("trait_solve_query({:?})", goal.value.goal);
tracing::info!("trait_solve_query({:?})", goal.value.goal);
if let GoalData::DomainGoal(DomainGoal::Holds(WhereClause::AliasEq(AliasEq {
alias: AliasTy::Projection(projection_ty),
@ -106,7 +106,7 @@ fn solve(
goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>>,
) -> Option<chalk_solve::Solution<Interner>> {
let context = ChalkContext { db, krate };
log::debug!("solve goal: {:?}", goal);
tracing::debug!("solve goal: {:?}", goal);
let mut solver = create_chalk_solver();
let fuel = std::cell::Cell::new(CHALK_SOLVER_FUEL);
@ -116,7 +116,7 @@ fn solve(
let remaining = fuel.get();
fuel.set(remaining - 1);
if remaining == 0 {
log::debug!("fuel exhausted");
tracing::debug!("fuel exhausted");
}
remaining > 0
};
@ -136,7 +136,7 @@ fn solve(
solver.solve_limited(&context, goal, &should_continue)
};
log::debug!("solve({:?}) => {:?}", goal, solution);
tracing::debug!("solve({:?}) => {:?}", goal, solution);
solution
};

2
crates/ide/Cargo.toml
View file

@ -13,7 +13,7 @@ cov-mark = "2.0.0-pre.1"
either = "1.5.3"
indexmap = "1.4.0"
itertools = "0.10.0"
log = "0.4.8"
tracing = "0.1"
rustc-hash = "1.1.0"
oorandom = "11.1.2"
pulldown-cmark-to-cmark = "6.0.0"

2
crates/ide/src/display/navigation_target.rs
View file

@ -353,7 +353,7 @@ impl TryToNav for hir::MacroDef {
Either::Left(it) => it,
Either::Right(it) => it,
};
log::debug!("nav target {:#?}", name_owner.syntax());
tracing::debug!("nav target {:#?}", name_owner.syntax());
let mut res = NavigationTarget::from_named(
db,
src.as_ref().with_value(name_owner),

2
crates/ide_completion/Cargo.toml
View file

@ -11,7 +11,7 @@ doctest = false
[dependencies]
cov-mark = "2.0.0-pre.1"
itertools = "0.10.0"
log = "0.4.8"
tracing = "0.1"
rustc-hash = "1.1.0"
either = "1.6.1"
once_cell = "1.7"

2
crates/ide_db/Cargo.toml
View file

@ -10,7 +10,7 @@ doctest = false
[dependencies]
cov-mark = "2.0.0-pre.1"
log = "0.4.8"
tracing = "0.1"
rayon = "1.5.0"
fst = { version = "0.4", default-features = false }
rustc-hash = "1.1.0"

2
crates/ide_db/src/apply_change.rs
View file

@ -20,7 +20,7 @@ impl RootDatabase {
pub fn apply_change(&mut self, change: Change) {
let _p = profile::span("RootDatabase::apply_change");
self.request_cancellation();
log::info!("apply_change {:?}", change);
tracing::info!("apply_change {:?}", change);
if let Some(roots) = &change.roots {
let mut local_roots = FxHashSet::default();
let mut library_roots = FxHashSet::default();

2
crates/mbe/Cargo.toml
View file

@ -12,8 +12,8 @@ doctest = false
cov-mark = "2.0.0-pre.1"
rustc-hash = "1.1.0"
smallvec = "1.2.0"
log = "0.4.8"
expect-test = "1.1"
tracing = "0.1"
syntax = { path = "../syntax", version = "0.0.0" }
parser = { path = "../parser", version = "0.0.0" }

6
crates/mbe/src/expander/transcriber.rs
View file

@ -174,7 +174,11 @@ fn expand_repeat(
counter += 1;
if counter == limit {
log::warn!("expand_tt in repeat pattern exceed limit => {:#?}\n{:#?}", template, ctx);
tracing::warn!(
"expand_tt in repeat pattern exceed limit => {:#?}\n{:#?}",
template,
ctx
);
return ExpandResult {
value: Fragment::Tokens(Subtree::default().into()),
err: Some(ExpandError::Other("Expand exceed limit".to_string())),

2
crates/proc_macro_api/Cargo.toml
View file

@ -11,7 +11,7 @@ doctest = false
[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = { version = "1.0", features = ["unbounded_depth"] }
log = "0.4.8"
tracing = "0.1"
crossbeam-channel = "0.5.0"
jod-thread = "0.1.1"
memmap2 = "0.3.0"

4
crates/proc_macro_api/src/msg.rs
View file

@ -93,7 +93,7 @@ fn read_json<'a>(
// Some ill behaved macro try to use stdout for debugging
// We ignore it here
if !buf.starts_with('{') {
log::error!("proc-macro tried to print : {}", buf);
tracing::error!("proc-macro tried to print : {}", buf);
continue;
}
@ -102,7 +102,7 @@ fn read_json<'a>(
}
fn write_json(out: &mut impl Write, msg: &str) -> io::Result<()> {
log::debug!("> {}", msg);
tracing::debug!("> {}", msg);
out.write_all(msg.as_bytes())?;
out.write_all(b"\n")?;
out.flush()?;

2
crates/proc_macro_api/src/process.rs
View file

@ -54,7 +54,7 @@ impl ProcMacroProcessSrv {
Ok(res) => res,
Err(err) => {
let result = self.process.child.try_wait();
log::error!(
tracing::error!(
"proc macro server crashed, server process state: {:?}, server request error: {:?}",
result,
err

2
crates/project_model/Cargo.toml
View file

@ -9,7 +9,7 @@ edition = "2018"
doctest = false
[dependencies]
log = "0.4.8"
tracing = "0.1"
rustc-hash = "1.1.0"
cargo_metadata = "0.14"
semver = "1"

14
crates/project_model/src/cargo_workspace.rs
View file

@ -283,7 +283,7 @@ impl CargoWorkspace {
let meta = from_value::<PackageMetadata>(metadata.clone()).unwrap_or_default();
let is_member = ws_members.contains(id);
let edition = edition.parse::<Edition>().unwrap_or_else(|err| {
log::error!("Failed to parse edition {}", err);
tracing::error!("Failed to parse edition {}", err);
Edition::CURRENT
});
@ -322,7 +322,7 @@ impl CargoWorkspace {
// https://github.com/rust-lang/cargo/issues/7841
// is fixed and hits stable (around 1.43-is probably?).
None => {
log::error!("Node id do not match in cargo metadata, ignoring {}", node.id);
tracing::error!("Node id do not match in cargo metadata, ignoring {}", node.id);
continue;
}
};
@ -335,7 +335,7 @@ impl CargoWorkspace {
let pkg = match pkg_by_id.get(&dep_node.pkg) {
Some(&pkg) => pkg,
None => {
log::error!(
tracing::error!(
"Dep node id do not match in cargo metadata, ignoring {}",
dep_node.pkg
);
@ -385,7 +385,7 @@ impl CargoWorkspace {
fn rustc_discover_host_triple(cargo_toml: &ManifestPath) -> Option<String> {
let mut rustc = Command::new(toolchain::rustc());
rustc.current_dir(cargo_toml.parent()).arg("-vV");
log::debug!("Discovering host platform by {:?}", rustc);
tracing::debug!("Discovering host platform by {:?}", rustc);
match utf8_stdout(rustc) {
Ok(stdout) => {
let field = "host: ";
@ -394,12 +394,12 @@ fn rustc_discover_host_triple(cargo_toml: &ManifestPath) -> Option<String> {
Some(target.to_string())
} else {
// If we fail to resolve the host platform, it's not the end of the world.
log::info!("rustc -vV did not report host platform, got:\n{}", stdout);
tracing::info!("rustc -vV did not report host platform, got:\n{}", stdout);
None
}
}
Err(e) => {
log::warn!("Failed to discover host platform: {}", e);
tracing::warn!("Failed to discover host platform: {}", e);
None
}
}
@ -412,7 +412,7 @@ fn cargo_config_build_target(cargo_toml: &ManifestPath) -> Option<String> {
.args(&["-Z", "unstable-options", "config", "get", "build.target"])
.env("RUSTC_BOOTSTRAP", "1");
// if successful we receive `build.target = "target-triple"`
log::debug!("Discovering cargo config target by {:?}", cargo_config);
tracing::debug!("Discovering cargo config target by {:?}", cargo_config);
match utf8_stdout(cargo_config) {
Ok(stdout) => stdout
.strip_prefix("build.target = \"")

2
crates/project_model/src/rustc_cfg.rs
View file

@ -20,7 +20,7 @@ pub(crate) fn get(cargo_toml: Option<&ManifestPath>, target: Option<&str>) -> Ve
match get_rust_cfgs(cargo_toml, target) {
Ok(rustc_cfgs) => res.extend(rustc_cfgs.lines().map(|it| it.parse().unwrap())),
Err(e) => log::error!("failed to get rustc cfgs: {:#}", e),
Err(e) => tracing::error!("failed to get rustc cfgs: {:#}", e),
}
res

17
crates/project_model/src/sysroot.rs
View file

@ -54,7 +54,7 @@ impl Sysroot {
}
pub fn discover(dir: &AbsPath) -> Result<Sysroot> {
log::debug!("Discovering sysroot for {}", dir.display());
tracing::debug!("Discovering sysroot for {}", dir.display());
let sysroot_dir = discover_sysroot_dir(dir)?;
let sysroot_src_dir = discover_sysroot_src_dir(&sysroot_dir, dir)?;
let res = Sysroot::load(sysroot_src_dir)?;
@ -62,7 +62,7 @@ impl Sysroot {
}
pub fn discover_rustc(cargo_toml: &ManifestPath) -> Option<ManifestPath> {
log::debug!("Discovering rustc source for {}", cargo_toml.display());
tracing::debug!("Discovering rustc source for {}", cargo_toml.display());
let current_dir = cargo_toml.parent();
discover_sysroot_dir(current_dir).ok().and_then(|sysroot_dir| get_rustc_src(&sysroot_dir))
}
@ -132,7 +132,7 @@ impl Sysroot {
fn discover_sysroot_dir(current_dir: &AbsPath) -> Result<AbsPathBuf> {
let mut rustc = Command::new(toolchain::rustc());
rustc.current_dir(current_dir).args(&["--print", "sysroot"]);
log::debug!("Discovering sysroot by {:?}", rustc);
tracing::debug!("Discovering sysroot by {:?}", rustc);
let stdout = utf8_stdout(rustc)?;
Ok(AbsPathBuf::assert(PathBuf::from(stdout)))
}
@ -146,10 +146,10 @@ fn discover_sysroot_src_dir(
.map_err(|path| format_err!("RUST_SRC_PATH must be absolute: {}", path.display()))?;
let core = path.join("core");
if fs::metadata(&core).is_ok() {
log::debug!("Discovered sysroot by RUST_SRC_PATH: {}", path.display());
tracing::debug!("Discovered sysroot by RUST_SRC_PATH: {}", path.display());
return Ok(path);
}
log::debug!("RUST_SRC_PATH is set, but is invalid (no core: {:?}), ignoring", core);
tracing::debug!("RUST_SRC_PATH is set, but is invalid (no core: {:?}), ignoring", core);
}
get_rust_src(sysroot_path)
@ -174,7 +174,7 @@ try installing the Rust source the same way you installed rustc",
fn get_rustc_src(sysroot_path: &AbsPath) -> Option<ManifestPath> {
let rustc_src = sysroot_path.join("lib/rustlib/rustc-src/rust/compiler/rustc/Cargo.toml");
let rustc_src = ManifestPath::try_from(rustc_src).ok()?;
log::debug!("Checking for rustc source code: {}", rustc_src.display());
tracing::debug!("Checking for rustc source code: {}", rustc_src.display());
if fs::metadata(&rustc_src).is_ok() {
Some(rustc_src)
} else {
@ -185,7 +185,10 @@ fn get_rustc_src(sysroot_path: &AbsPath) -> Option<ManifestPath> {
fn get_rust_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> {
// Try the new path first since the old one still exists.
let rust_src = sysroot_path.join("lib/rustlib/src/rust");
log::debug!("Checking sysroot (looking for `library` and `src` dirs): {}", rust_src.display());
tracing::debug!(
"Checking sysroot (looking for `library` and `src` dirs): {}",
rust_src.display()
);
["library", "src"].iter().map(|it| rust_src.join(it)).find(|it| fs::metadata(it).is_ok())
}

8
crates/project_model/src/workspace.rs
View file

@ -384,9 +384,9 @@ impl ProjectWorkspace {
}
};
if crate_graph.patch_cfg_if() {
log::debug!("Patched std to depend on cfg-if")
tracing::debug!("Patched std to depend on cfg-if")
} else {
log::debug!("Did not patch std to depend on cfg-if")
tracing::debug!("Did not patch std to depend on cfg-if")
}
crate_graph
}
@ -623,7 +623,7 @@ fn detached_files_to_crate_graph(
let file_id = match load(detached_file) {
Some(file_id) => file_id,
None => {
log::error!("Failed to load detached file {:?}", detached_file);
tracing::error!("Failed to load detached file {:?}", detached_file);
continue;
}
};
@ -847,7 +847,7 @@ fn sysroot_to_crate_graph(
fn add_dep(graph: &mut CrateGraph, from: CrateId, name: CrateName, to: CrateId) {
if let Err(err) = graph.add_dep(from, name, to) {
log::error!("{}", err)
tracing::error!("{}", err)
}
}

5
crates/rust-analyzer/Cargo.toml
View file

@ -20,10 +20,8 @@ path = "src/bin/main.rs"
anyhow = "1.0.26"
crossbeam-channel = "0.5.0"
dissimilar = "1.0.2"
env_logger = { version = "0.9", default-features = false }
itertools = "0.10.0"
jod-thread = "0.1.0"
log = "0.4.8"
lsp-types = { version = "0.89.0", features = ["proposed"] }
parking_lot = "0.11.0"
xflags = "0.2.1"
@ -36,7 +34,8 @@ rayon = "1.5"
mimalloc = { version = "0.1.19", default-features = false, optional = true }
lsp-server = "0.5.1"
tracing = "0.1"
tracing-subscriber = { version = "0.2", default-features = false, features = ["env-filter", "registry"] }
tracing-subscriber = { version = "0.2", default-features = false, features = ["env-filter", "registry", "fmt", "tracing-log"] }
tracing-log = "0.1.2"
tracing-tree = { version = "0.1.4" }
always-assert = "0.1"

186
crates/rust-analyzer/src/bin/logger.rs
View file

@ -1,88 +1,142 @@
//! Simple logger that logs either to stderr or to a file, using `env_logger`
//! filter syntax. Amusingly, there's no crates.io crate that can do this and
//! only this.
//! Simple logger that logs either to stderr or to a file, using `tracing_subscriber`
//! filter syntax and `tracing_appender` for non blocking output.
use std::{
fmt::{self, Write},
fs::File,
io::{self, BufWriter, Write},
io,
sync::Arc,
};
use env_logger::filter::{Builder, Filter};
use log::{Log, Metadata, Record};
use parking_lot::Mutex;
use rust_analyzer::Result;
use tracing::{level_filters::LevelFilter, Event, Subscriber};
use tracing_log::NormalizeEvent;
use tracing_subscriber::{
fmt::{writer::BoxMakeWriter, FmtContext, FormatEvent, FormatFields, FormattedFields},
layer::SubscriberExt,
registry::LookupSpan,
util::SubscriberInitExt,
EnvFilter, Registry,
};
use tracing_tree::HierarchicalLayer;
pub(crate) struct Logger {
filter: Filter,
file: Option<Mutex<BufWriter<File>>>,
no_buffering: bool,
filter: EnvFilter,
file: Option<File>,
}
impl Logger {
pub(crate) fn new(log_file: Option<File>, no_buffering: bool, filter: Option<&str>) -> Logger {
let filter = {
let mut builder = Builder::new();
if let Some(filter) = filter {
builder.parse(filter);
pub(crate) fn new(file: Option<File>, filter: Option<&str>) -> Logger {
let filter = filter.map_or(EnvFilter::default(), |dirs| EnvFilter::new(dirs));
Logger { filter, file }
}
builder.build()
pub(crate) fn install(self) -> Result<()> {
// The meaning of CHALK_DEBUG I suspected is to tell chalk crates
// (i.e. chalk-solve, chalk-ir, chalk-recursive) how to filter tracing
// logs. But now we can only have just one filter, which means we have to
// merge chalk filter to our main filter (from RA_LOG env).
//
// The acceptable syntax of CHALK_DEBUG is `target[span{field=value}]=level`.
// As the value should only affect chalk crates, we'd better mannually
// specify the target. And for simplicity, CHALK_DEBUG only accept the value
// that specify level.
let chalk_level_dir = std::env::var("CHALK_DEBUG")
.map(|val| {
val.parse::<LevelFilter>().expect(
"invalid CHALK_DEBUG value, expect right log level (like debug or trace)",
)
})
.ok();
let chalk_layer = HierarchicalLayer::default()
.with_indent_lines(true)
.with_ansi(false)
.with_indent_amount(2)
.with_writer(std::io::stderr);
let writer = match self.file {
Some(file) => BoxMakeWriter::new(Arc::new(file)),
None => BoxMakeWriter::new(io::stderr),
};
let ra_fmt_layer =
tracing_subscriber::fmt::layer().event_format(LoggerFormatter).with_writer(writer);
let file = log_file.map(|it| Mutex::new(BufWriter::new(it)));
Logger { filter, file, no_buffering }
}
pub(crate) fn install(self) {
let max_level = self.filter.filter();
let _ = log::set_boxed_logger(Box::new(self)).map(|()| log::set_max_level(max_level));
}
}
impl Log for Logger {
fn enabled(&self, metadata: &Metadata) -> bool {
self.filter.enabled(metadata)
}
fn log(&self, record: &Record) {
if !self.filter.matches(record) {
return;
}
match &self.file {
Some(w) => {
let mut writer = w.lock();
let _ = writeln!(
writer,
"[{} {}] {}",
record.level(),
record.module_path().unwrap_or_default(),
record.args(),
);
if self.no_buffering {
let _ = writer.flush();
}
match chalk_level_dir {
Some(val) => {
Registry::default()
.with(
self.filter
.add_directive(format!("chalk_solve={}", val).parse()?)
.add_directive(format!("chalk_ir={}", val).parse()?)
.add_directive(format!("chalk_recursive={}", val).parse()?),
)
.with(ra_fmt_layer)
.with(chalk_layer)
.init();
}
None => {
let message = format!(
"[{} {}] {}\n",
record.level(),
record.module_path().unwrap_or_default(),
record.args(),
);
eprint!("{}", message);
Registry::default().with(self.filter).with(ra_fmt_layer).init();
}
};
Ok(())
}
}
fn flush(&self) {
match &self.file {
Some(w) => {
let _ = w.lock().flush();
}
None => {
let _ = io::stderr().flush();
}
#[derive(Debug)]
struct LoggerFormatter;
impl<S, N> FormatEvent<S, N> for LoggerFormatter
where
S: Subscriber + for<'a> LookupSpan<'a>,
N: for<'a> FormatFields<'a> + 'static,
{
fn format_event(
&self,
ctx: &FmtContext<'_, S, N>,
writer: &mut dyn Write,
event: &Event<'_>,
) -> fmt::Result {
// Write level and target
let level = *event.metadata().level();
// If this event is issued from `log` crate, then the value of target is
// always "log". `tracing-log` has hard coded it for some reason, so we
// need to extract it using `normalized_metadata` method which is part of
// `tracing_log::NormalizeEvent`.
let target = match event.normalized_metadata() {
// This event is issued from `log` crate
Some(log) => log.target(),
None => event.metadata().target(),
};
write!(writer, "[{} {}] ", level, target)?;
// Write spans and fields of each span
ctx.visit_spans(|span| {
write!(writer, "{}", span.name())?;
let ext = span.extensions();
// `FormattedFields` is a a formatted representation of the span's
// fields, which is stored in its extensions by the `fmt` layer's
// `new_span` method. The fields will have been formatted
// by the same field formatter that's provided to the event
// formatter in the `FmtContext`.
let fields = &ext.get::<FormattedFields<N>>().expect("will never be `None`");
if !fields.is_empty() {
write!(writer, "{{{}}}", fields)?;
}
write!(writer, ": ")?;
Ok(())
})?;
// Write fields on the event
ctx.field_format().format_fields(writer, event)?;
writeln!(writer)
}
}

42
crates/rust-analyzer/src/bin/main.rs
View file

@ -35,7 +35,7 @@ fn main() {
}
if let Err(err) = try_main() {
log::error!("Unexpected error: {}", err);
tracing::error!("Unexpected error: {}", err);
eprintln!("{}", err);
process::exit(101);
}
@ -60,7 +60,7 @@ fn try_main() -> Result<()> {
log_file = Some(Path::new(env_log_file));
}
setup_logging(log_file, flags.no_log_buffering)?;
setup_logging(log_file)?;
let verbosity = flags.verbosity();
match flags.subcommand {
@ -91,7 +91,7 @@ fn try_main() -> Result<()> {
Ok(())
}
fn setup_logging(log_file: Option<&Path>, no_buffering: bool) -> Result<()> {
fn setup_logging(log_file: Option<&Path>) -> Result<()> {
env::set_var("RUST_BACKTRACE", "short");
let log_file = match log_file {
@ -104,42 +104,20 @@ fn setup_logging(log_file: Option<&Path>, no_buffering: bool) -> Result<()> {
None => None,
};
let filter = env::var("RA_LOG").ok();
logger::Logger::new(log_file, no_buffering, filter.as_deref()).install();
tracing_setup::setup_tracing()?;
logger::Logger::new(log_file, filter.as_deref()).install()?;
profile::init();
Ok(())
}
mod tracing_setup {
use tracing::subscriber;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::EnvFilter;
use tracing_subscriber::Registry;
use tracing_tree::HierarchicalLayer;
pub(crate) fn setup_tracing() -> super::Result<()> {
let filter = EnvFilter::from_env("CHALK_DEBUG");
let layer = HierarchicalLayer::default()
.with_indent_lines(true)
.with_ansi(false)
.with_indent_amount(2)
.with_writer(std::io::stderr);
let subscriber = Registry::default().with(filter).with(layer);
subscriber::set_global_default(subscriber)?;
Ok(())
}
}
fn run_server() -> Result<()> {
log::info!("server version {} will start", env!("REV"));
tracing::info!("server version {} will start", env!("REV"));
let (connection, io_threads) = Connection::stdio();
let (initialize_id, initialize_params) = connection.initialize_start()?;
log::info!("InitializeParams: {}", initialize_params);
tracing::info!("InitializeParams: {}", initialize_params);
let initialize_params =
from_json::<lsp_types::InitializeParams>("InitializeParams", initialize_params)?;
@ -176,7 +154,7 @@ fn run_server() -> Result<()> {
connection.initialize_finish(initialize_id, initialize_result)?;
if let Some(client_info) = initialize_params.client_info {
log::info!("Client '{}' {}", client_info.name, client_info.version.unwrap_or_default());
tracing::info!("Client '{}' {}", client_info.name, client_info.version.unwrap_or_default());
}
if config.linked_projects().is_empty() && config.detached_files().is_empty() {
@ -193,9 +171,9 @@ fn run_server() -> Result<()> {
.unwrap_or_else(|| vec![config.root_path.clone()]);
let discovered = ProjectManifest::discover_all(&workspace_roots);
log::info!("discovered projects: {:?}", discovered);
tracing::info!("discovered projects: {:?}", discovered);
if discovered.is_empty() {
log::error!("failed to find any projects in {:?}", workspace_roots);
tracing::error!("failed to find any projects in {:?}", workspace_roots);
}
config.discovered_projects = Some(discovered);
}
@ -203,6 +181,6 @@ fn run_server() -> Result<()> {
rust_analyzer::main_loop(config, connection)?;
io_threads.join()?;
log::info!("server did shut down");
tracing::info!("server did shut down");
Ok(())
}

2
crates/rust-analyzer/src/caps.rs
View file

@ -131,7 +131,7 @@ fn completions_resolve_provider(client_caps: &ClientCapabilities) -> Option<bool
if completion_item_edit_resolve(client_caps) {
Some(true)
} else {
log::info!("No `additionalTextEdits` completion resolve capability was found in the client capabilities, autoimport completion is disabled");
tracing::info!("No `additionalTextEdits` completion resolve capability was found in the client capabilities, autoimport completion is disabled");
None
}
}

2
crates/rust-analyzer/src/cli/load_cargo.rs
View file

@ -85,7 +85,7 @@ pub fn load_workspace(
version: 0,
});
log::debug!("crate graph: {:?}", crate_graph);
tracing::debug!("crate graph: {:?}", crate_graph);
let host =
load_crate_graph(crate_graph, project_folders.source_root_config, &mut vfs, &receiver);

6
crates/rust-analyzer/src/config.rs
View file

@ -432,7 +432,7 @@ impl Config {
}
}
pub fn update(&mut self, mut json: serde_json::Value) {
log::info!("updating config from JSON: {:#}", json);
tracing::info!("updating config from JSON: {:#}", json);
if json.is_null() || json.as_object().map_or(false, |it| it.is_empty()) {
return;
}
@ -478,7 +478,9 @@ impl Config {
ManifestOrProjectJson::Manifest(it) => {
let path = self.root_path.join(it);
ProjectManifest::from_manifest_file(path)
.map_err(|e| log::error!("failed to load linked project: {}", e))
.map_err(|e| {
tracing::error!("failed to load linked project: {}", e)
})
.ok()?
.into()
}

4
crates/rust-analyzer/src/dispatch.rs
View file

@ -88,7 +88,7 @@ impl<'a> RequestDispatcher<'a> {
pub(crate) fn finish(&mut self) {
if let Some(req) = self.req.take() {
log::error!("unknown request: {:?}", req);
tracing::error!("unknown request: {:?}", req);
let response = lsp_server::Response::new_err(
req.id,
lsp_server::ErrorCode::MethodNotFound as i32,
@ -208,7 +208,7 @@ impl<'a> NotificationDispatcher<'a> {
pub(crate) fn finish(&mut self) {
if let Some(not) = &self.not {
if !not.method.starts_with("$/") {
log::error!("unhandled notification: {:?}", not);
tracing::error!("unhandled notification: {:?}", not);
}
}
}

2
crates/rust-analyzer/src/global_state.rs
View file

@ -271,7 +271,7 @@ impl GlobalState {
}
let duration = start.elapsed();
log::info!("handled {} - ({}) in {:0.2?}", method, response.id, duration);
tracing::info!("handled {} - ({}) in {:0.2?}", method, response.id, duration);
self.send(response.into());
}
}

4
crates/rust-analyzer/src/handlers.rs
View file

@ -1651,7 +1651,7 @@ fn run_rustfmt(
}
}
Err(_) => {
log::error!(
tracing::error!(
"Unable to get file path for {}, rustfmt.toml might be ignored",
text_document.uri
);
@ -1721,7 +1721,7 @@ fn run_rustfmt(
// formatting because otherwise an error is surfaced to the user on top of the
// syntax error diagnostics they're already receiving. This is especially jarring
// if they have format on save enabled.
log::info!("rustfmt exited with status 1, assuming parse error and ignoring");
tracing::info!("rustfmt exited with status 1, assuming parse error and ignoring");
Ok(None)
}
_ => {

28
crates/rust-analyzer/src/main_loop.rs
View file

@ -27,7 +27,7 @@ use crate::{
};
pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
log::info!("initial config: {:#?}", config);
tracing::info!("initial config: {:#?}", config);
// Windows scheduler implements priority boosts: if thread waits for an
// event (like a condvar), and event fires, priority of the thread is
@ -182,10 +182,10 @@ impl GlobalState {
// NOTE: don't count blocking select! call as a loop-turn time
let _p = profile::span("GlobalState::handle_event");
log::info!("handle_event({:?})", event);
tracing::info!("handle_event({:?})", event);
let task_queue_len = self.task_pool.handle.len();
if task_queue_len > 0 {
log::info!("task queue len: {}", task_queue_len);
tracing::info!("task queue len: {}", task_queue_len);
}
let was_quiescent = self.is_quiescent();
@ -359,7 +359,7 @@ impl GlobalState {
diag.fixes,
),
Err(err) => {
log::error!(
tracing::error!(
"File with cargo diagnostic not found in VFS: {}",
err
);
@ -380,7 +380,7 @@ impl GlobalState {
flycheck::Progress::DidCancel => (Progress::End, None),
flycheck::Progress::DidFinish(result) => {
if let Err(err) = result {
log::error!("cargo check failed: {}", err)
tracing::error!("cargo check failed: {}", err)
}
(Progress::End, None)
}
@ -486,7 +486,7 @@ impl GlobalState {
let loop_duration = loop_start.elapsed();
if loop_duration > Duration::from_millis(100) {
log::warn!("overly long loop turn: {:?}", loop_duration);
tracing::warn!("overly long loop turn: {:?}", loop_duration);
self.poke_rust_analyzer_developer(format!(
"overly long loop turn: {:?}",
loop_duration
@ -617,7 +617,7 @@ impl GlobalState {
.insert(path.clone(), DocumentData::new(params.text_document.version))
.is_err()
{
log::error!("duplicate DidOpenTextDocument: {}", path)
tracing::error!("duplicate DidOpenTextDocument: {}", path)
}
this.vfs
.write()
@ -635,7 +635,7 @@ impl GlobalState {
doc.version = params.text_document.version;
}
None => {
log::error!("expected DidChangeTextDocument: {}", path);
tracing::error!("expected DidChangeTextDocument: {}", path);
return Ok(());
}
};
@ -652,7 +652,7 @@ impl GlobalState {
.on::<lsp_types::notification::DidCloseTextDocument>(|this, params| {
if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
if this.mem_docs.remove(&path).is_err() {
log::error!("orphan DidCloseTextDocument: {}", path);
tracing::error!("orphan DidCloseTextDocument: {}", path);
}
this.semantic_tokens_cache.lock().remove(&params.text_document.uri);
@ -683,12 +683,12 @@ impl GlobalState {
}],
},
|this, resp| {
log::debug!("config update response: '{:?}", resp);
tracing::debug!("config update response: '{:?}", resp);
let lsp_server::Response { error, result, .. } = resp;
match (error, result) {
(Some(err), _) => {
log::error!("failed to fetch the server settings: {:?}", err)
tracing::error!("failed to fetch the server settings: {:?}", err)
}
(None, Some(mut configs)) => {
if let Some(json) = configs.get_mut(0) {
@ -699,7 +699,7 @@ impl GlobalState {
this.update_configuration(config);
}
}
(None, None) => log::error!(
(None, None) => tracing::error!(
"received empty server settings response from the client"
),
}
@ -727,7 +727,7 @@ impl GlobalState {
.map(|path| self.vfs.read().0.file_id(path).unwrap())
.collect::<Vec<_>>();
log::trace!("updating notifications for {:?}", subscriptions);
tracing::trace!("updating notifications for {:?}", subscriptions);
let snapshot = self.snapshot();
self.task_pool.handle.spawn(move || {
@ -737,7 +737,7 @@ impl GlobalState {
handlers::publish_diagnostics(&snapshot, file_id)
.map_err(|err| {
if !is_cancelled(&*err) {
log::error!("failed to compute diagnostics: {:?}", err);
tracing::error!("failed to compute diagnostics: {:?}", err);
}
()
})

18
crates/rust-analyzer/src/reload.rs
View file

@ -61,7 +61,7 @@ impl GlobalState {
if !changes.iter().any(|(path, kind)| is_interesting(path, *kind)) {
return;
}
log::info!(
tracing::info!(
"Requesting workspace reload because of the following changes: {}",
itertools::join(
changes
@ -153,7 +153,7 @@ impl GlobalState {
if !self.fetch_workspaces_queue.should_start_op() {
return;
}
log::info!("will fetch workspaces");
tracing::info!("will fetch workspaces");
self.task_pool.handle.spawn_with_sender({
let linked_projects = self.config.linked_projects();
@ -196,7 +196,7 @@ impl GlobalState {
.push(project_model::ProjectWorkspace::load_detached_files(detached_files));
}
log::info!("did fetch workspaces {:?}", workspaces);
tracing::info!("did fetch workspaces {:?}", workspaces);
sender
.send(Task::FetchWorkspace(ProjectWorkspaceProgress::End(workspaces)))
.unwrap();
@ -245,10 +245,10 @@ impl GlobalState {
pub(crate) fn switch_workspaces(&mut self) {
let _p = profile::span("GlobalState::switch_workspaces");
log::info!("will switch workspaces");
tracing::info!("will switch workspaces");
if let Some(error_message) = self.fetch_workspace_error() {
log::error!("failed to switch workspaces: {}", error_message);
tracing::error!("failed to switch workspaces: {}", error_message);
if !self.workspaces.is_empty() {
// It only makes sense to switch to a partially broken workspace
// if we don't have any workspace at all yet.
@ -257,7 +257,7 @@ impl GlobalState {
}
if let Some(error_message) = self.fetch_build_data_error() {
log::error!("failed to switch build data: {}", error_message);
tracing::error!("failed to switch build data: {}", error_message);
}
let workspaces = self
@ -367,7 +367,7 @@ impl GlobalState {
Some((path, args)) => match ProcMacroClient::extern_process(path.clone(), args) {
Ok(it) => Some(it),
Err(err) => {
log::error!(
tracing::error!(
"Failed to run proc_macro_srv from path {}, error: {:?}",
path.display(),
err
@ -407,7 +407,7 @@ impl GlobalState {
}
let res = vfs.file_id(&vfs_path);
if res.is_none() {
log::warn!("failed to load {}", path.display())
tracing::warn!("failed to load {}", path.display())
}
res
};
@ -425,7 +425,7 @@ impl GlobalState {
self.analysis_host.apply_change(change);
self.process_changes();
self.reload_flycheck();
log::info!("did switch workspaces");
tracing::info!("did switch workspaces");
}
fn fetch_workspace_error(&self) -> Option<String> {

5
crates/rust-analyzer/tests/slow-tests/support.rs
View file

@ -71,7 +71,10 @@ impl<'a> Project<'a> {
let tmp_dir = self.tmp_dir.unwrap_or_else(TestDir::new);
static INIT: Once = Once::new();
INIT.call_once(|| {
env_logger::builder().is_test(true).parse_env("RA_LOG").try_init().unwrap();
tracing_subscriber::fmt()
.with_test_writer()
.with_env_filter(tracing_subscriber::EnvFilter::from_env("RA_LOG"))
.init();
profile::init_from(crate::PROFILE);
});

2
crates/vfs-notify/Cargo.toml
View file

@ -9,7 +9,7 @@ edition = "2018"
doctest = false
[dependencies]
log = "0.4.8"
tracing = "0.1"
rustc-hash = "1.0"
jod-thread = "0.1.0"
walkdir = "2.3.1"

4
crates/vfs-notify/src/lib.rs
View file

@ -76,7 +76,7 @@ impl NotifyActor {
}
fn run(mut self, inbox: Receiver<Message>) {
while let Some(event) = self.next_event(&inbox) {
log::debug!("vfs-notify event: {:?}", event);
tracing::debug!("vfs-notify event: {:?}", event);
match event {
Event::Message(msg) => match msg {
Message::Config(config) => {
@ -227,5 +227,5 @@ fn read(path: &AbsPath) -> Option<Vec<u8>> {
}
fn log_notify_error<T>(res: notify::Result<T>) -> Option<T> {
res.map_err(|err| log::warn!("notify error: {}", err)).ok()
res.map_err(|err| tracing::warn!("notify error: {}", err)).ok()
}