mab122
/
radicle-heartwood-lfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fetch: remove `target: "fetch"` 

Going forward, there will be a preference to not use the `target` in
logging, and allow the default of the crate and module to be used
instead.
This commit is contained in:
Fintan Halpenny 2026-01-19 16:31:13 +00:00 committed by Lorenz Leutgeb
parent e3cb36d950
commit 9236277abf
7 changed files with 30 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/radicle-fetch/src/git/packfile.rs
View File

@ -26,7 +26,7 @@ impl Keepfile {
impl Drop for Keepfile { impl Drop for Keepfile {
fn drop(&mut self) { fn drop(&mut self) {
if let Err(e) = fs::remove_file(&self.path) { if let Err(e) = fs::remove_file(&self.path) {
log::warn!(target: "fetch", "Failed to remove {:?}: {e}", self.path); log::warn!("Failed to remove {:?}: {e}", self.path);
} }
} }
} }

11
crates/radicle-fetch/src/lib.rs
View File

@ -88,7 +88,6 @@ where
.map_err(Error::Protocol); .map_err(Error::Protocol);
log::debug!( log::debug!(
target: "fetch",
"Finished pull of {} ({}ms)", "Finished pull of {} ({}ms)",
handle.repository().id(), handle.repository().id(),
start.elapsed().as_millis() start.elapsed().as_millis()
@ -123,16 +122,10 @@ where
match &result { match &result {
Ok(_) => { Ok(_) => {
log::debug!( log::debug!("Finished clone of {rid} from {remote} ({elapsed}ms)",);
target: "fetch",
"Finished clone of {rid} from {remote} ({elapsed}ms)",
);
} }
Err(e) => { Err(e) => {
log::debug!( log::debug!("Clone of {rid} from {remote} failed with '{e}' ({elapsed}ms)",);
target: "fetch",
"Clone of {rid} from {remote} failed with '{e}' ({elapsed}ms)",
);
} }
} }
result result

6
crates/radicle-fetch/src/policy.rs
View File

@ -20,7 +20,7 @@ impl Allowed {
.map_err(|err| error::Policy::FailedPolicy { rid, err })?; .map_err(|err| error::Policy::FailedPolicy { rid, err })?;
match entry.policy { match entry.policy {
SeedingPolicy::Block => { SeedingPolicy::Block => {
log::info!(target: "fetch", "Attempted to fetch non-seeded repo {rid}"); log::info!("Attempted to fetch non-seeded repo {rid}");
Err(error::Policy::BlockedPolicy { rid }) Err(error::Policy::BlockedPolicy { rid })
} }
SeedingPolicy::Allow { scope: Scope::All } => Ok(Self::All), SeedingPolicy::Allow { scope: Scope::All } => Ok(Self::All),
@ -37,7 +37,7 @@ impl Allowed {
let node = match node { let node = match node {
Ok(policy) => policy, Ok(policy) => policy,
Err(err) => { Err(err) => {
log::debug!(target: "fetch", "Failed to read follow policy for {rid}: {err}"); log::debug!("Failed to read follow policy for {rid}: {err}");
continue; continue;
} }
}; };
@ -81,7 +81,7 @@ impl BlockList {
let entry = match entry { let entry = match entry {
Ok(entry) => entry, Ok(entry) => entry,
Err(err) => { Err(err) => {
log::debug!(target: "fetch", "Failed to read follow policy: {err}"); log::debug!("Failed to read follow policy: {err}");
continue; continue;
} }
}; };

38
crates/radicle-fetch/src/state.rs
View File

@ -231,7 +231,7 @@ impl FetchState {
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
None => vec![], None => vec![],
}; };
log::trace!(target: "fetch", "Received refs {refs:?}"); log::trace!("Received refs {refs:?}");
step.pre_validate(&refs)?; step.pre_validate(&refs)?;
let wants_haves = step.wants_haves(handle.repository(), &refs)?; let wants_haves = step.wants_haves(handle.repository(), &refs)?;
@ -242,7 +242,7 @@ impl FetchState {
.fetch(wants_haves, handle.interrupt.clone(), handshake)?; .fetch(wants_haves, handle.interrupt.clone(), handshake)?;
self.keepfiles.extend(keepfile); self.keepfiles.extend(keepfile);
} else { } else {
log::trace!(target: "fetch", "Nothing to fetch") log::trace!("Nothing to fetch")
}; };
let mut fetched = BTreeSet::new(); let mut fetched = BTreeSet::new();
@ -308,7 +308,7 @@ impl FetchState {
blocked: handle.blocked.clone(), blocked: handle.blocked.clone(),
limit: limit.special, limit: limit.special,
}; };
log::trace!(target: "fetch", "{sigrefs_at:?}"); log::trace!("{sigrefs_at:?}");
self.run_stage(handle, handshake, &sigrefs_at)?; self.run_stage(handle, handshake, &sigrefs_at)?;
let remotes = refs_at.iter().map(|r| &r.remote); let remotes = refs_at.iter().map(|r| &r.remote);
@ -317,7 +317,7 @@ impl FetchState {
} }
None => { None => {
let followed = handle.allowed(); let followed = handle.allowed();
log::trace!(target: "fetch", "Followed nodes {followed:?}"); log::trace!("Followed nodes {followed:?}");
let special_refs = stage::SpecialRefs { let special_refs = stage::SpecialRefs {
blocked: handle.blocked.clone(), blocked: handle.blocked.clone(),
remote, remote,
@ -326,7 +326,7 @@ impl FetchState {
threshold, threshold,
limit: limit.special, limit: limit.special,
}; };
log::trace!(target: "fetch", "{special_refs:?}"); log::trace!("{special_refs:?}");
let fetched = self.run_stage(handle, handshake, &special_refs)?; let fetched = self.run_stage(handle, handshake, &special_refs)?;
let signed_refs = sigrefs::RemoteRefs::load( let signed_refs = sigrefs::RemoteRefs::load(
@ -378,7 +378,7 @@ impl FetchState {
limit: limit.special, limit: limit.special,
}, },
)?; )?;
log::debug!(target: "fetch", "Fetched rad/id ({}ms)", start.elapsed().as_millis()); log::debug!("Fetched rad/id ({}ms)", start.elapsed().as_millis());
// N.b. The error case here should not happen. In the case of // N.b. The error case here should not happen. In the case of
// a `clone` we have asked for refs/rad/id and ensured it was // a `clone` we have asked for refs/rad/id and ensured it was
@ -399,7 +399,7 @@ impl FetchState {
.map(|did| PublicKey::from(*did)) .map(|did| PublicKey::from(*did))
.collect::<BTreeSet<_>>(); .collect::<BTreeSet<_>>();
log::trace!(target: "fetch", "Identity delegates {delegates:?}"); log::trace!("Identity delegates {delegates:?}");
// The local peer does not need to count towards the threshold // The local peer does not need to count towards the threshold
// since they must be valid already. // since they must be valid already.
@ -418,7 +418,6 @@ impl FetchState {
refs_at, refs_at,
)?; )?;
log::debug!( log::debug!(
target: "fetch",
"Fetched data for {} remote(s) ({}ms)", "Fetched data for {} remote(s) ({}ms)",
signed_refs.len(), signed_refs.len(),
start.elapsed().as_millis() start.elapsed().as_millis()
@ -431,7 +430,6 @@ impl FetchState {
}; };
self.run_stage(handle, handshake, &data_refs)?; self.run_stage(handle, handshake, &data_refs)?;
log::debug!( log::debug!(
target: "fetch",
"Fetched data refs for {} remotes ({}ms)", "Fetched data refs for {} remotes ({}ms)",
data_refs.remotes.len(), data_refs.remotes.len(),
start.elapsed().as_millis() start.elapsed().as_millis()
@ -441,9 +439,9 @@ impl FetchState {
// We're finished fetching on this side, and all that's left // We're finished fetching on this side, and all that's left
// is validation. // is validation.
match handle.transport.done() { match handle.transport.done() {
Ok(()) => log::debug!(target: "fetch", "Sent done signal to remote {remote}"), Ok(()) => log::debug!("Sent done signal to remote {remote}"),
Err(err) => { Err(err) => {
log::debug!(target: "fetch", "Failed to signal EOF to {remote}: {err}") log::debug!("Failed to signal EOF to {remote}: {err}")
} }
} }
@ -472,7 +470,7 @@ impl FetchState {
// private function. // private function.
for remote in signed_refs.keys() { for remote in signed_refs.keys() {
if handle.is_blocked(remote) { if handle.is_blocked(remote) {
log::trace!(target: "fetch", "Skipping blocked remote {remote}"); log::trace!("Skipping blocked remote {remote}");
continue; continue;
} }
@ -480,12 +478,12 @@ impl FetchState {
.load(&self.as_cached(handle))?; .load(&self.as_cached(handle))?;
match remote { match remote {
sigrefs::DelegateStatus::NonDelegate { remote, data: None } => { sigrefs::DelegateStatus::NonDelegate { remote, data: None } => {
log::debug!(target: "fetch", "Pruning non-delegate {remote} tips, missing 'rad/sigrefs'"); log::debug!("Pruning non-delegate {remote} tips, missing 'rad/sigrefs'");
failures.push(sigrefs::Validation::MissingRadSigRefs(remote)); failures.push(sigrefs::Validation::MissingRadSigRefs(remote));
self.prune(&remote); self.prune(&remote);
} }
sigrefs::DelegateStatus::Delegate { remote, data: None } => { sigrefs::DelegateStatus::Delegate { remote, data: None } => {
log::debug!(target: "fetch", "Pruning delegate {remote} tips, missing 'rad/sigrefs'"); log::debug!("Pruning delegate {remote} tips, missing 'rad/sigrefs'");
failures.push(sigrefs::Validation::MissingRadSigRefs(remote)); failures.push(sigrefs::Validation::MissingRadSigRefs(remote));
self.prune(&remote); self.prune(&remote);
// This delegate has removed their `rad/sigrefs`. // This delegate has removed their `rad/sigrefs`.
@ -518,7 +516,6 @@ impl FetchState {
let cache = self.as_cached(handle); let cache = self.as_cached(handle);
if let Some(warns) = sigrefs::validate(&cache, sigrefs)?.as_mut() { if let Some(warns) = sigrefs::validate(&cache, sigrefs)?.as_mut() {
log::debug!( log::debug!(
target: "fetch",
"Pruning non-delegate {remote} tips, due to validation failures" "Pruning non-delegate {remote} tips, due to validation failures"
); );
self.prune(&remote); self.prune(&remote);
@ -536,7 +533,10 @@ impl FetchState {
{ {
let ancestry = repository::ancestry(handle.repository(), at, sigrefs.at)?; let ancestry = repository::ancestry(handle.repository(), at, sigrefs.at)?;
if matches!(ancestry, repository::Ancestry::Behind) { if matches!(ancestry, repository::Ancestry::Behind) {
log::trace!(target: "fetch", "Advertised `rad/sigrefs` {} is behind {at} for {remote}", sigrefs.at); log::trace!(
"Advertised `rad/sigrefs` {} is behind {at} for {remote}",
sigrefs.at
);
self.prune(&remote); self.prune(&remote);
continue; continue;
} else if matches!(ancestry, repository::Ancestry::Diverged) { } else if matches!(ancestry, repository::Ancestry::Diverged) {
@ -552,7 +552,7 @@ impl FetchState {
let mut fails = let mut fails =
sigrefs::validate(&cache, sigrefs)?.unwrap_or(Validations::default()); sigrefs::validate(&cache, sigrefs)?.unwrap_or(Validations::default());
if !fails.is_empty() { if !fails.is_empty() {
log::debug!(target: "fetch", "Pruning delegate {remote} tips, due to validation failures"); log::debug!("Pruning delegate {remote} tips, due to validation failures");
self.prune(&remote); self.prune(&remote);
valid_delegates.remove(&remote); valid_delegates.remove(&remote);
failed_delegates.insert(remote); failed_delegates.insert(remote);
@ -565,7 +565,6 @@ impl FetchState {
} }
} }
log::debug!( log::debug!(
target: "fetch",
"Validated {} remote(s) ({}ms)", "Validated {} remote(s) ({}ms)",
remotes.len(), remotes.len(),
start.elapsed().as_millis() start.elapsed().as_millis()
@ -581,7 +580,7 @@ impl FetchState {
.into_values() .into_values()
.flat_map(|ups| ups.into_iter()), .flat_map(|ups| ups.into_iter()),
)?; )?;
log::debug!(target: "fetch", "Applied updates ({}ms)", start.elapsed().as_millis()); log::debug!("Applied updates ({}ms)", start.elapsed().as_millis());
Ok(FetchResult::Success { Ok(FetchResult::Success {
applied, applied,
remotes, remotes,
@ -589,7 +588,6 @@ impl FetchState {
}) })
} else { } else {
log::debug!( log::debug!(
target: "fetch",
"Fetch failed: {} failure(s) ({}ms)", "Fetch failed: {} failure(s) ({}ms)",
failures.len(), failures.len(),
start.elapsed().as_millis() start.elapsed().as_millis()

7
crates/radicle-fetch/src/transport.rs
View File

@ -91,7 +91,7 @@ where
/// Perform the handshake with the server side. /// Perform the handshake with the server side.
#[allow(clippy::result_large_err)] #[allow(clippy::result_large_err)]
pub(crate) fn handshake(&mut self) -> Result<handshake::Outcome, handshake::Error> { pub(crate) fn handshake(&mut self) -> Result<handshake::Outcome, handshake::Error> {
log::trace!(target: "fetch", "Performing handshake for {}", self.repo); log::trace!("Performing handshake for {}", self.repo);
let (read, write) = self.stream.open(); let (read, write) = self.stream.open();
gix_protocol::fetch::handshake( gix_protocol::fetch::handshake(
&mut Connection::new(read, write, self.repo.clone()), &mut Connection::new(read, write, self.repo.clone()),
@ -129,7 +129,6 @@ where
handshake: &handshake::Outcome, handshake: &handshake::Outcome,
) -> Result<Option<Keepfile>, Error> { ) -> Result<Option<Keepfile>, Error> {
log::trace!( log::trace!(
target: "fetch",
"Running fetch wants={:?}, haves={:?}", "Running fetch wants={:?}, haves={:?}",
wants_haves.wants, wants_haves.wants,
wants_haves.haves wants_haves.haves
@ -328,8 +327,8 @@ fn agent_name() -> String {
Ok(version) => version, Ok(version) => version,
Err(err) => { Err(err) => {
use radicle::git::VERSION_REQUIRED; use radicle::git::VERSION_REQUIRED;
log::debug!(target: "fetch", "The git version could not be determined: {err}"); log::debug!("The git version could not be determined: {err}");
log::debug!(target: "fetch", "Pretending that we are on git version {VERSION_REQUIRED}."); log::debug!("Pretending that we are on git version {VERSION_REQUIRED}.");
VERSION_REQUIRED VERSION_REQUIRED
} }
}; };

4
crates/radicle-fetch/src/transport/fetch.rs
View File

@ -159,7 +159,7 @@ where
R: io::Read, R: io::Read,
W: io::Write, W: io::Write,
{ {
log::trace!(target: "fetch", "Performing fetch"); log::trace!("Performing fetch");
if wants_haves.wants.is_empty() { if wants_haves.wants.is_empty() {
return Err(Error::ReadRemainingBytes(io::Error::new( return Err(Error::ReadRemainingBytes(io::Error::new(
@ -214,6 +214,6 @@ where
.and_then(packfile::Keepfile::new); .and_then(packfile::Keepfile::new);
out.pack = Some(pack_out); out.pack = Some(pack_out);
log::trace!(target: "fetch", "fetched refs: {:?}", out.refs); log::trace!("fetched refs: {:?}", out.refs);
Ok(out) Ok(out)
} }

2
crates/radicle-fetch/src/transport/ls_refs.rs
View File

@ -38,7 +38,7 @@ where
R: io::Read, R: io::Read,
W: io::Write, W: io::Write,
{ {
log::trace!(target: "fetch", "Performing ls-refs: {:?}", config.prefixes); log::trace!("Performing ls-refs: {:?}", config.prefixes);
let handshake::Outcome { let handshake::Outcome {
server_protocol_version: protocol, server_protocol_version: protocol,
capabilities, capabilities,