6ef5675 feat: reduce log spam — radicle-ci-broker

modified src/adapter.rs

@@ -161,10 +161,6 @@ impl Adapter {

         }
         let wait_result = child.wait().expect("FIXME");
         logger::debug2(format!(
             "wait result? {wait_result:?} status.code: {:?}",
             wait_result.status().code()
         ));
         if wait_result.timed_out() {
             logger::adapter_did_not_exit_voluntarily();
             outcome.set_error(AdapterError::Failed(NOT_EXITED));

modified src/ci_event_source.rs

@@ -23,7 +23,6 @@ impl CiEventSource {

     pub fn event(&mut self) -> Result<Option<Vec<CiEvent>>, CiEventSourceError> {
         let result = self.source.node_event();
         logger::trace2(format!("ci_event_source: result={result:?}"));
         match result {
             Err(err) if matches!(err, NodeEventError::BrokenConnection) => {
                 logger::ci_event_source_disconnected();

@@ -40,7 +39,9 @@ impl CiEventSource {

             Ok(Some(event)) => {
                 let ci_events =
                     CiEvent::from_node_event(&event).map_err(CiEventSourceError::CiEvent)?;
                 logger::ci_event_source_got_events(&ci_events);
                 if !ci_events.is_empty() {
                     logger::ci_event_source_got_events(&ci_events);
                 }
                 Ok(Some(ci_events))
             }
         }

modified src/logger.rs

@@ -114,8 +114,6 @@ enum Id {

     AdapterStderrLine,
     AdapterTooManyMessages,
     AdHoc,
     BrokerDatabase,
     BrokerRunEnd,
     BrokerRunStart,

@@ -1001,38 +999,6 @@ pub fn event_filter_decision(filter: &'static str, allowed: bool, reason: &str)

     );
 }
 pub fn debug(msg: &str) {
     debug!(
         msg_id = ?Id::AdHoc,
         kind = %Kind::Debug,
         "{msg}"
     );
 }
 pub fn debug2(msg: String) {
     debug!(
         msg_id = ?Id::AdHoc,
         kind = %Kind::Debug,
         "{msg}"
     );
 }
 pub fn trace(msg: &str) {
     trace!(
         msg_id = ?Id::AdHoc,
         kind = %Kind::Debug,
         "{msg}"
     );
 }
 pub fn trace2(msg: String) {
     trace!(
         msg_id = ?Id::AdHoc,
         kind = %Kind::Debug,
         "{msg}"
     );
 }
 pub fn error(msg: &str, e: &impl std::error::Error) {
     error!("{msg}: {e}");
     let mut e = e.source();

modified src/msg.rs

@@ -144,19 +144,15 @@ impl<'a> RequestBuilder<'a> {

     /// Create a [`Request::Trigger``] message from a [`crate::ci_event::Civet`].
     pub fn build_trigger_from_ci_event(self) -> Result<Request, MessageError> {
         fn repository(repo: &RepoId, profile: &Profile) -> Result<Repository, MessageError> {
             logger::trace2(format!("build trigger: look up repository {repo}"));
             let rad_repo = match profile.storage.repository(*repo) {
                 Err(err) => {
                     logger::trace2(format!("build trigger: repo lookup result {err:?}"));
                     return Err(err)?;
                 }
                 Ok(rad_repo) => rad_repo,
             };
             logger::trace("build trigger: look up project");
             let project_info = match rad_repo.project() {
                 Err(err) => {
                     logger::trace2(format!("build trigger: project lookup result {err:?}"));
                     return Err(err)?;
                 }
                 Ok(x) => x,

@@ -177,11 +173,8 @@ impl<'a> RequestBuilder<'a> {

             repo: &RepoId,
             profile: &Profile,
         ) -> Result<EventCommonFields, MessageError> {
             logger::trace2(format!("build trigger: create common fields for {repo}"));
             logger::trace("build trigger: look up repository");
             let repository = match repository(repo, profile) {
                 Err(err) => {
                     logger::trace2(format!("build trigger: project lookup result {err:?}"));
                     return Err(err)?;
                 }
                 Ok(x) => x,

@@ -194,11 +187,8 @@ impl<'a> RequestBuilder<'a> {

         }
         fn author(node: &NodeId, profile: &Profile) -> Result<Author, MessageError> {
             logger::trace2(format!("build trigger: look up author {node}"));
             let did = Did::from(*node);
             let x = did_to_author(profile, &did);
             logger::trace2(format!("build trigger: author lookup result {x:?}"));
             x
             did_to_author(profile, &did)
         }
         fn commits(

@@ -206,24 +196,19 @@ impl<'a> RequestBuilder<'a> {

             tip: Oid,
             base: Oid,
         ) -> Result<Vec<Oid>, radicle_surf::Error> {
             logger::trace2(format!("build trigger: look commits {git_repo:?}"));
             let x = git_repo
             git_repo
                 .history(tip)?
                 .take_while(|c| if let Ok(c) = c { c.id != base } else { false })
                 .map(|r| r.map(|c| c.id))
                 .collect::<Result<Vec<Oid>, _>>();
             logger::trace2(format!("build trigger: revision lookup result {x:?}"));
             x
                 .collect::<Result<Vec<Oid>, _>>()
         }
         fn patch_cob(
             rad_repo: &radicle::storage::git::Repository,
             patch_id: &PatchId,
         ) -> Result<radicle::cob::patch::Patch, MessageError> {
             logger::trace2(format!("build trigger: look patch cob {patch_id}"));
             let x = match patch::Patches::open(rad_repo) {
                 Err(err) => {
                     logger::trace2(format!("patch repo open => {err:?}"));
                     return Err(err)?;
                 }
                 Ok(x) => x,

@@ -231,7 +216,6 @@ impl<'a> RequestBuilder<'a> {

             let x = match x.get(patch_id) {
                 Err(err) => {
                     logger::trace2(format!("get patch => {err:?}"));
                     return Err(err)?;
                 }
                 Ok(x) => x,

@@ -245,7 +229,6 @@ impl<'a> RequestBuilder<'a> {

                 Some(x) => x,
             };
             logger::trace2(format!("build trigger: patch cob lookup result {x:?}"));
             Ok(x)
         }

@@ -253,8 +236,7 @@ impl<'a> RequestBuilder<'a> {

             patch_cob: &radicle::cob::patch::Patch,
             author: &Author,
         ) -> Result<Vec<Revision>, MessageError> {
             logger::trace2(format!("build trigger: look patch revisions by {author:?}"));
             let x = patch_cob
             patch_cob
                 .revisions()
                 .map(|(rid, r)| {
                     Ok::<Revision, MessageError>(Revision {

@@ -266,9 +248,7 @@ impl<'a> RequestBuilder<'a> {

                         timestamp: r.timestamp().as_secs(),
                     })
                 })
                 .collect::<Result<Vec<Revision>, MessageError>>();
             logger::trace2(format!("build trigger: revision lookup result {x:?}"));
             x
                 .collect::<Result<Vec<Revision>, MessageError>>()
         }
         fn patch_base(

@@ -276,20 +256,14 @@ impl<'a> RequestBuilder<'a> {

             patch_id: &PatchId,
             author: &Author,
         ) -> Result<Oid, MessageError> {
             logger::trace2(format!(
                 "build trigger: look base commit for patch {patch_id}"
             ));
             let author_pk = radicle::crypto::PublicKey::from(author.id);
             let (_id, revision) = match patch_cob.latest_by(&author_pk) {
                 None => {
                     logger::trace("build trigger: patch base lookup failed: nothing found");
                     return Err(MessageError::LatestPatchRevision(*patch_id));
                 }
                 Some(x) => x,
             };
             let base = *revision.base();
             logger::trace2(format!("patch base commit is {base}"));
             Ok(base)
             Ok(*revision.base())
         }
         let profile = self.profile.ok_or(MessageError::NoProfile)?;

@@ -302,7 +276,6 @@ impl<'a> RequestBuilder<'a> {

                 branch,
                 tip,
             })) => {
                 logger::trace("build trigger: branch created");
                 Ok(Request::Trigger {
                     common: common_fields(EventType::Push, repo, profile)?,
                     push: Some(PushEvent {

@@ -322,7 +295,6 @@ impl<'a> RequestBuilder<'a> {

                 tip,
                 old_tip,
             })) => {
                 logger::trace("build trigger: branch updated");
                 let git_repo =
                     radicle_surf::Repository::open(paths::repository(&profile.storage, repo))?;
                 let mut commits = commits(&git_repo, *tip, *old_tip)?;

@@ -348,7 +320,6 @@ impl<'a> RequestBuilder<'a> {

                 branch,
                 tip,
             })) => {
                 logger::trace("build trigger: branch deleted");
                 Ok(Request::Trigger {
                     common: common_fields(EventType::Push, repo, profile)?,
                     push: Some(PushEvent {

@@ -367,7 +338,6 @@ impl<'a> RequestBuilder<'a> {

                 patch: patch_id,
                 new_tip,
             })) => {
                 logger::trace("build trigger: patch created");
                 let rad_repo = profile.storage.repository(*repo)?;
                 let git_repo =
                     radicle_surf::Repository::open(paths::repository(&profile.storage, repo))?;

@@ -410,7 +380,6 @@ impl<'a> RequestBuilder<'a> {

                 patch: patch_id,
                 new_tip,
             })) => {
                 logger::trace("build trigger: patch updated");
                 let rad_repo = profile.storage.repository(*repo)?;
                 let git_repo =
                     radicle_surf::Repository::open(paths::repository(&profile.storage, repo))?;

modified src/node_event_source.rs

@@ -46,7 +46,6 @@ impl NodeEventSource {

     /// A closed or broken connection to the node is not an error,
     /// it's treated as end of file.
     pub fn node_event(&mut self) -> Result<Option<Event>, NodeEventError> {
         logger::trace("node_event: try to get an event");
         if let Some(event) = self.events.next() {
             match event {
                 Ok(event) => {

modified src/queueadd.rs

@@ -59,7 +59,6 @@ impl QueueAdder {

         // event from the node.
         'event_loop: loop {
             let events = source.event();
             logger::trace2(format!("queueadd: events={events:?}"));
             match events {
                 Err(e) => {
                     logger::queueadd_control_socket_close();

modified src/queueproc.rs

@@ -239,7 +239,7 @@ impl QueueProcessor {

     fn process_event(&mut self, event: &CiEvent, adapter: &Adapter) -> Result<bool, QueueError> {
         logger::queueproc_processing_event(event);
         let x = match event {
         match event {
             CiEvent::V1(CiEventV1::Shutdown) => {
                 logger::queueproc_action_shutdown();
                 Ok(true)

@@ -319,7 +319,6 @@ impl QueueProcessor {

                 patch: _,
                 new_tip,
             }) => {
                 logger::debug("patch updated");
                 logger::queueproc_action_run(repo, new_tip);
                 let trigger = RequestBuilder::default()
                     .profile(&self.profile)

@@ -331,12 +330,9 @@ impl QueueProcessor {

                 self.broker
                     .execute_ci(adapter, &trigger, &self.run_tx)
                     .map_err(QueueError::execute_ci)?;
                 logger::debug("executed ci");
                 Ok(false)
             }
         };
         logger::debug("queproc::process_event: end");
         x
         }
     }
     fn drop_event(&mut self, id: &QueueId) -> Result<(), QueueError> {