run

Author: epompeii

lib/bencher_context/src/client/mod.rs

@@ -7,12 +7,12 @@ mod platform;
 pub use platform::Fingerprint;
 use platform::OperatingSystem;
 
-use crate::ReportContext;
+use crate::{ContextKey, ReportContext};
 
 const ROOT: &str = "root";
 
 impl ReportContext {
-    pub fn new() -> Self {
+    pub fn current() -> Self {
         get_context()
     }
 
@@ -42,28 +42,31 @@ fn git_context(context: &mut ReportContext) {
     };
 
     if let Some(repo_name) = repo_name(&repo) {
-        context.insert("/repo/name", repo_name);
+        context.insert(ContextKey::REPO_NAME, repo_name);
     }
 
     if let Some(root_commit) = repo_hash(&repo) {
-        context.insert("/repo/hash", root_commit);
+        context.insert(ContextKey::REPO_HASH, root_commit);
     }
 
     if let Some((branch_ref, branch_ref_name)) = branch_ref(&repo) {
-        context.insert("/branch/ref", branch_ref);
-        context.insert("/branch/ref/name", branch_ref_name);
+        context.insert(ContextKey::BRANCH_REF, branch_ref);
+        context.insert(ContextKey::BRANCH_REF_NAME, branch_ref_name);
     }
 
     if let Some(hash) = branch_hash(&repo) {
-        context.insert("/branch/hash", hash);
+        context.insert(ContextKey::BRANCH_HASH, hash);
     }
 }
 
 fn platform_context(context: &mut ReportContext) {
-    context.insert("/testbed/os", OperatingSystem::current().to_string());
+    context.insert(
+        ContextKey::TESTBED_OS,
+        OperatingSystem::current().to_string(),
+    );
 
     if let Some(fingerprint) = Fingerprint::current() {
-        context.insert("/testbed/fingerprint", fingerprint.to_string());
+        context.insert(ContextKey::TESTBED_FINGERPRINT, fingerprint.to_string());
     }
 }
 
@@ -96,12 +99,14 @@ fn repo_hash(repo: &Repository) -> Option<String> {
 }
 
 fn branch_ref(repo: &Repository) -> Option<(String, String)> {
-    repo.head().ok()?.referent_name().map(|name| {
-        (
+    if let Ok(Some(name)) = repo.head_name() {
+        Some((
             String::from_utf8_lossy(name.as_bstr()).to_string(),
             String::from_utf8_lossy(name.shorten()).to_string(),
-        )
-    })
+        ))
+    } else {
+        None
+    }
 }
 
 fn branch_hash(repo: &Repository) -> Option<String> {

lib/bencher_context/src/lib.rs

@@ -14,3 +14,48 @@ pub use client::Fingerprint;
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 #[cfg_attr(feature = "schema", derive(JsonSchema))]
 pub struct ReportContext(pub HashMap<String, String>);
+
+#[allow(clippy::multiple_inherent_impl)]
+impl ReportContext {
+    pub fn repo_name(&self) -> Option<&str> {
+        self.0.get(ContextKey::REPO_NAME).map(String::as_str)
+    }
+
+    pub fn repo_hash(&self) -> Option<&str> {
+        self.0.get(ContextKey::REPO_HASH).map(String::as_str)
+    }
+
+    pub fn branch_ref(&self) -> Option<&str> {
+        self.0.get(ContextKey::BRANCH_REF).map(String::as_str)
+    }
+
+    pub fn branch_ref_name(&self) -> Option<&str> {
+        self.0.get(ContextKey::BRANCH_REF_NAME).map(String::as_str)
+    }
+
+    pub fn branch_hash(&self) -> Option<&str> {
+        self.0.get(ContextKey::BRANCH_HASH).map(String::as_str)
+    }
+
+    pub fn testbed_os(&self) -> Option<&str> {
+        self.0.get(ContextKey::TESTBED_OS).map(String::as_str)
+    }
+
+    pub fn testbed_fingerprint(&self) -> Option<&str> {
+        self.0
+            .get(ContextKey::TESTBED_FINGERPRINT)
+            .map(String::as_str)
+    }
+}
+
+struct ContextKey;
+
+impl ContextKey {
+    pub const REPO_NAME: &str = "/repo/name";
+    pub const REPO_HASH: &str = "/repo/hash";
+    pub const BRANCH_REF: &str = "/branch/ref";
+    pub const BRANCH_REF_NAME: &str = "/branch/ref/name";
+    pub const BRANCH_HASH: &str = "/branch/hash";
+    pub const TESTBED_OS: &str = "/testbed/os";
+    pub const TESTBED_FINGERPRINT: &str = "/testbed/fingerprint";
+}

lib/bencher_json/src/lib.rs

@@ -20,6 +20,7 @@ pub mod big_int;
 pub mod organization;
 pub mod pagination;
 pub mod project;
+pub mod run;
 pub mod system;
 pub(crate) mod typed_uuid;
 pub mod urlencoded;
@@ -53,6 +54,7 @@ pub use project::{
     threshold::{JsonNewThreshold, JsonThreshold, JsonThresholds, ThresholdUuid},
     JsonNewProject, JsonProject, JsonProjects, ProjectUuid,
 };
+pub use run::JsonNewRun;
 #[cfg(feature = "plus")]
 pub use system::{
     auth::JsonOAuth,

lib/bencher_json/src/project/branch.rs

@@ -14,6 +14,12 @@ pub const START_POINT_MAX_VERSIONS: u32 = 255;
 
 pub const BRANCH_MAIN_STR: &str = "main";
 #[allow(clippy::expect_used)]
+pub static DEFAULT_BRANCH: LazyLock<NameId> = LazyLock::new(|| {
+    BRANCH_MAIN_STR
+        .parse()
+        .expect("Failed to parse branch name.")
+});
+#[allow(clippy::expect_used)]
 static BRANCH_MAIN: LazyLock<BranchName> = LazyLock::new(|| {
     BRANCH_MAIN_STR
         .parse()

lib/bencher_json/src/project/testbed.rs

@@ -1,7 +1,7 @@
 use std::fmt;
 use std::sync::LazyLock;
 
-use bencher_valid::{DateTime, ResourceName, Slug};
+use bencher_valid::{DateTime, NameId, ResourceName, Slug};
 #[cfg(feature = "schema")]
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -10,6 +10,12 @@ use crate::ProjectUuid;
 
 pub const TESTBED_LOCALHOST_STR: &str = "localhost";
 #[allow(clippy::expect_used)]
+pub static DEFAULT_TESTBED: LazyLock<NameId> = LazyLock::new(|| {
+    TESTBED_LOCALHOST_STR
+        .parse()
+        .expect("Failed to parse testbed name.")
+});
+#[allow(clippy::expect_used)]
 static TESTBED_LOCALHOST: LazyLock<ResourceName> = LazyLock::new(|| {
     TESTBED_LOCALHOST_STR
         .parse()

lib/bencher_json/src/run.rs

@@ -0,0 +1,111 @@
+use bencher_context::ReportContext;
+use bencher_valid::{DateTime, GitHash, ResourceId};
+#[cfg(feature = "schema")]
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    project::{
+        branch::{JsonUpdateStartPoint, DEFAULT_BRANCH},
+        report::{JsonReportSettings, JsonReportThresholds},
+        testbed::DEFAULT_TESTBED,
+    },
+    JsonNewReport, NameId,
+};
+
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schema", derive(JsonSchema))]
+pub struct JsonNewRun {
+    /// Organization UUID or slug.
+    /// If the organization is not provided, it will be created.
+    pub organization: Option<ResourceId>,
+    /// Project UUID, slug, or name.
+    /// If the project is not provided or does not exist, it will be created.
+    /// If a name is provided, the `organization` field must also be provided.
+    pub project: Option<NameId>,
+    /// Branch UUID, slug, or name.
+    /// If the branch is not provided or does not exist, it will be created.
+    pub branch: Option<NameId>,
+    /// Full `git` commit hash.
+    /// All reports with the same `git` commit hash will be considered part of the same branch version.
+    /// This can be useful for tracking the performance of a specific commit across multiple testbeds.
+    pub hash: Option<GitHash>,
+    /// The start point for the report branch.
+    /// If the branch does not exist, the start point will be used to create a new branch.
+    /// If the branch already exists and the start point is not provided, the current branch will be used.
+    /// If the branch already exists and the start point provided is different, a new branch head will be created from the new start point.
+    /// If a new branch or new branch head is created with a start point,
+    /// historical branch versions from the start point branch will be shallow copied over to the new branch.
+    /// That is, historical metrics data for the start point branch will appear in queries for the branch.
+    /// For example, pull request branches often use their base branch as their start point branch.
+    /// If a new branch is created, it is not kept in sync with the start point branch.
+    pub start_point: Option<JsonUpdateStartPoint>,
+    /// Testbed UUID, slug, or name.
+    /// If the testbed is not provided or does not exist, it will be created.
+    pub testbed: Option<NameId>,
+    /// Thresholds to use for the branch, testbed, and measures in the report.
+    /// If a threshold does not exist, it will be created.
+    /// If a threshold exists and the model is different, it will be updated with the new model.
+    /// If a measure name or slug is provided, the measure will be created if it does not exist.
+    pub thresholds: Option<JsonReportThresholds>,
+    /// Start time for the report. Must be an ISO 8601 formatted string.
+    pub start_time: DateTime,
+    /// End time for the report. Must be an ISO 8601 formatted string.
+    pub end_time: DateTime,
+    /// An array of benchmarks results.
+    pub results: Vec<String>,
+    /// Settings for how to handle the results.
+    pub settings: Option<JsonReportSettings>,
+    /// Context for the report.
+    pub context: Option<ReportContext>,
+}
+
+impl From<JsonNewRun> for JsonNewReport {
+    fn from(run: JsonNewRun) -> Self {
+        let JsonNewRun {
+            organization: _,
+            project: _,
+            branch,
+            hash,
+            start_point,
+            testbed,
+            thresholds,
+            start_time,
+            end_time,
+            results,
+            settings,
+            context,
+        } = run;
+        let branch = branch
+            .or_else(|| {
+                context
+                    .as_ref()
+                    .and_then(|ctx| ctx.branch_ref_name().and_then(|branch| branch.parse().ok()))
+            })
+            .unwrap_or_else(|| DEFAULT_BRANCH.clone());
+        let hash = hash.or_else(|| {
+            context
+                .as_ref()
+                .and_then(|ctx| ctx.branch_hash().and_then(|hash| hash.parse().ok()))
+        });
+        let testbed = testbed
+            .or_else(|| {
+                context
+                    .as_ref()
+                    .and_then(|ctx| ctx.testbed_os().and_then(|testbed| testbed.parse().ok()))
+            })
+            .unwrap_or_else(|| DEFAULT_TESTBED.clone());
+        Self {
+            branch,
+            hash,
+            start_point,
+            testbed,
+            thresholds,
+            start_time,
+            end_time,
+            results,
+            settings,
+            context,
+        }
+    }
+}

services/api/src/endpoints/run/run.rs

@@ -1,4 +1,4 @@
-use bencher_json::{JsonNewReport, JsonReport};
+use bencher_json::{JsonNewRun, JsonReport};
 
 use dropshot::{endpoint, HttpError, RequestContext, TypedBody};
 use slog::Logger;
@@ -39,7 +39,7 @@ pub async fn run_options(_rqctx: RequestContext<ApiContext>) -> Result<CorsRespo
 pub async fn run_post(
     rqctx: RequestContext<ApiContext>,
     bearer_token: PubBearerToken,
-    body: TypedBody<JsonNewReport>,
+    body: TypedBody<JsonNewRun>,
 ) -> Result<ResponseCreated<JsonReport>, HttpError> {
     let auth_user = AuthUser::from_pub_token(rqctx.context(), bearer_token).await?;
     let json = post_inner(&rqctx.log, rqctx.context(), body.into_inner(), auth_user).await?;
@@ -49,7 +49,7 @@ pub async fn run_post(
 async fn post_inner(
     log: &Logger,
     context: &ApiContext,
-    json_report: JsonNewReport,
+    json_run: JsonNewRun,
     auth_user: Option<AuthUser>,
 ) -> Result<JsonReport, HttpError> {
     #[allow(clippy::unimplemented)]
@@ -62,5 +62,5 @@ async fn post_inner(
         Err(bad_request_error("pub run creation is not yet implemented"))
     };
     let auth_user = todo_pub_run_user(auth_user)?;
-    QueryReport::create(log, context, &query_project, json_report, &auth_user).await
+    QueryReport::create(log, context, &query_project, json_run.into(), &auth_user).await
 }

services/cli/src/bencher/sub/project/run/mod.rs

@@ -201,7 +201,7 @@ impl Run {
                 average: self.average,
                 fold: self.fold,
             }),
-            context: Some(ReportContext::new().into()),
+            context: Some(ReportContext::current().into()),
         }))
     }