feat: add broker run ID to log messages related to a specific CI run — radicle-ci-broker

radicle-ci-broker

rad:zwTxygwuz5LDGBq255RA2CbNGrz8

Radicle CI broker

feat: add broker run ID to log messages related to a specific CI run

Merged liw opened 1 year ago

Activity Changes +104 -28

4 files changed +104 -28 162d8034 → f42ea5cb

modified src/adapter.rs

@@ -271,9 +271,9 @@ mod test {

     use super::{Adapter, Db, Run};
     use crate::{
         adapter::AdapterError,
         msg::{MessageError, Response, RunResult},
         msg::{MessageError, Response, RunId, RunResult},
         notif::NotificationChannel,
         run::Whence,
         run::{RunBuilder, Whence},
         test::{mock_adapter, trigger_request, TestResult},
     };

@@ -286,16 +286,17 @@ mod test {

     }
     fn run() -> anyhow::Result<Run> {
         Ok(Run::new(
             RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8")?,
             "test.repo",
             Whence::branch(
         Ok(RunBuilder::default()
             .broker_run_id(RunId::default())
             .repo_id(RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8")?)
             .repo_name("test.repo")
             .whence(Whence::branch(
                 "main",
                 Oid::try_from("ff3099ba5de28d954c41d0b5a84316f943794ea4")?,
                 Some("J. Random Hacker <random@example.com>"),
             ),
             "2024-02-29T12:58:12+02:00".into(),
         ))
             ))
             .timestamp("2024-02-29T12:58:12+02:00".into())
             .build())
     }
     #[test]

modified src/bin/cibtoolcmd/run.rs

@@ -1,3 +1,5 @@

 use radicle_ci_broker::run::RunBuilder;
 use super::*;
 #[derive(Parser)]

@@ -63,7 +65,13 @@ impl Leaf for AddRun {

             commit: oid,
             who: self.who.clone(),
         };
         let mut run = Run::new(rid, &repo_name, whence, ts);
         let mut run = RunBuilder::default()
             .broker_run_id(RunId::default())
             .repo_id(rid)
             .repo_name(&repo_name)
             .whence(whence)
             .timestamp(ts)
             .build();
         let id = self.id.clone().unwrap_or_default();
         run.set_adapter_run_id(id);

modified src/broker.rs

@@ -10,6 +10,7 @@ use std::{

 };
 use time::{macros::format_description, OffsetDateTime};
 use tracing::{span, Level};
 use radicle::prelude::RepoId;

@@ -17,9 +18,9 @@ use crate::{

     adapter::Adapter,
     db::{Db, DbError},
     logger,
     msg::{PatchEvent, PushEvent, Request},
     msg::{PatchEvent, PushEvent, Request, RunId},
     notif::NotificationSender,
     run::{Run, Whence},
     run::{Run, RunBuilder, Whence},
 };
 /// A CI broker.

@@ -73,6 +74,19 @@ impl Broker {

         trigger: &Request,
         run_notification: &NotificationSender,
     ) -> Result<Run, BrokerError> {
         let broker_run_id = RunId::default();
         let span = span!(Level::TRACE, "execute_ci_run", %broker_run_id,).entered();
         let run =
             span.in_scope(|| self.execute_helper(broker_run_id, trigger, run_notification))?;
         Ok(run)
     }
     fn execute_helper(
         &self,
         broker_run_id: RunId,
         trigger: &Request,
         run_notification: &NotificationSender,
     ) -> Result<Run, BrokerError> {
         logger::broker_start_run(trigger);
         let run = match trigger {
             Request::Trigger {

@@ -104,7 +118,13 @@ impl Broker {

                         panic!("neither push not patch event");
                     };
                     let mut run = Run::new(*rid, &common.repository.name, whence, now()?);
                     let mut run = RunBuilder::default()
                         .broker_run_id(broker_run_id)
                         .repo_id(*rid)
                         .repo_name(&common.repository.name)
                         .whence(whence)
                         .timestamp(now()?)
                         .build();
                     self.db.push_run(&run)?;
                     // We run the adapter, but if that fails, we just

modified src/run.rs

@@ -7,6 +7,68 @@ use radicle::prelude::RepoId;

 use crate::msg::{Revision, RunId, RunResult};
 #[derive(Debug, Default)]
 pub struct RunBuilder {
     broker_run_id: Option<RunId>,
     repo_id: Option<RepoId>,
     repo_name: Option<String>,
     whence: Option<Whence>,
     timestamp: Option<String>,
 }
 impl RunBuilder {
     pub fn broker_run_id(mut self, run_id: RunId) -> Self {
         self.broker_run_id = Some(run_id);
         self
     }
     pub fn repo_id(mut self, repo_id: RepoId) -> Self {
         self.repo_id = Some(repo_id);
         self
     }
     pub fn repo_name(mut self, name: &str) -> Self {
         self.repo_name = Some(name.into());
         self
     }
     pub fn whence(mut self, whence: Whence) -> Self {
         self.whence = Some(whence);
         self
     }
     pub fn timestamp(mut self, ts: String) -> Self {
         self.timestamp = Some(ts);
         self
     }
     pub fn build(self) -> Run {
         let broker_run_id = self
             .broker_run_id
             .unwrap_or_else(|| panic!("missing: broker_run_id"));
         let repo_id = self.repo_id.unwrap_or_else(|| panic!("missing: repo_id"));
         let repo_name = self
             .repo_name
             .unwrap_or_else(|| panic!("missing: repo_name"));
         let whence = self.whence.unwrap_or_else(|| panic!("missing: whence"));
         let timestamp = self
             .timestamp
             .unwrap_or_else(|| panic!("missing: timestamp"));
         Run {
             broker_run_id,
             adapter_run_id: None,
             adapter_info_url: None,
             repo_id,
             repo_name,
             timestamp,
             whence,
             state: RunState::Triggered,
             result: None,
         }
     }
 }
 #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 pub struct Run {
     broker_run_id: RunId,

@@ -22,21 +84,6 @@ pub struct Run {

 }
 impl Run {
     /// Create a new run.
     pub fn new(repo_id: RepoId, name: &str, whence: Whence, timestamp: String) -> Self {
         Self {
             broker_run_id: RunId::default(),
             adapter_run_id: None,
             adapter_info_url: None,
             repo_id,
             repo_name: name.into(),
             timestamp,
             whence,
             state: RunState::Triggered,
             result: None,
         }
     }
     /// Return the repo alias.
     pub fn repo_alias(&self) -> &str {
         &self.repo_name