Label the perf image per grid point

The image endpoint takes `parameters`, the same comma separated list of URL
encoded parameter sets the query endpoint takes, spelled the same way and read by
the same code path. The image query struct mirrors the query struct field for
field, doc comment included, so the image is the plot of the query it mirrors.

A line is a grid point, so the key names the grid point when the benchmark name no
longer says which line is which. A benchmark whose every line in the image plots
the empty parameter set keeps the bare benchmark name it has always had. One non
empty set among a benchmark's lines names them all, the empty set among them
included, which reads `{}`. The set is spelled in its canonical form and follows
the benchmark name on the same row, so the wrapping the key text already does for
a long benchmark name loses the tail of the set spelling first and the name never.

A project that never reported a parameter set is drawn from the inputs it was
always drawn from: every line of every such benchmark is labeled exactly as
before, which the fixtures pin, and nothing else on the draw path moved.

A point whose measure named no `value` has no point estimate to place on the axis,
so the plot leaves it out of the line. That already held; a fixture now pins it.

Author: epompeii

lib/api_projects/src/perf/img.rs

@@ -33,6 +33,8 @@ pub async fn proj_perf_img_options(
 /// The query results are every permutation of each branch, testbed, benchmark, and measure.
 /// There is a limit of 8 permutations for a single image.
 /// Therefore, only the first 8 permutations are plotted.
+/// Each permutation plots one line per grid point of its benchmark,
+/// narrowed by the `parameters` filter when one is given.
 /// If the project is public, then the user does not need to be authenticated.
 /// If the project is private, then the user must be authenticated and have `view` permissions for the project,
 /// or provide a valid project key for the project.

lib/api_projects/tests/perf.rs

@@ -3887,3 +3887,101 @@ async fn perf_point_without_a_value_name_keeps_its_line() {
     assert_eq!(p99.value, 99.5);
     assert!(p99.boundaries.is_none());
 }
+
+// =============================================================================
+// Section: The perf image
+// =============================================================================
+
+/// The perf image path for a fully built query, through the encoder a client uses.
+fn perf_img_url(project_slug: &str, query: &JsonPerfQuery) -> String {
+    format!(
+        "/v0/projects/{project_slug}/perf/img?{}",
+        query.to_query_string(&[]).expect("build query string")
+    )
+}
+
+/// GET a perf image path and return the JPEG.
+async fn get_perf_img(server: &TestServer, token: &str, url: &str) -> Vec<u8> {
+    let resp = server
+        .client
+        .get(server.api_url(url))
+        .header(
+            bencher_json::AUTHORIZATION,
+            bencher_json::bearer_header(token),
+        )
+        .send()
+        .await
+        .expect("Request failed");
+    assert_eq!(resp.status(), StatusCode::OK, "GET {url}");
+    assert_eq!(
+        resp.headers()
+            .get(http::header::CONTENT_TYPE)
+            .expect("content type"),
+        "image/jpeg",
+        "GET {url} is a JPEG"
+    );
+    resp.bytes().await.expect("read image").to_vec()
+}
+
+// The image takes the same `parameters` filter the query takes, and plots exactly
+// the lines the query answers with: the image of a filtered query is the plot of
+// that query's response, byte for byte.
+#[tokio::test]
+async fn perf_img_parameters_filter_plots_the_queried_grid_points() {
+    let server = TestServer::new().await;
+    let user = server
+        .signup("Test User", "perfimgfilter@example.com")
+        .await;
+    let org = server.create_org(&user, "Perf Img Filter Org").await;
+    let project = server
+        .create_project(&user, &org, "Perf Img Filter Project")
+        .await;
+
+    let project_id = get_project_id(&server, project.slug.as_ref());
+    let data = create_perf_data(&server, project_id);
+    create_grid_point(&server, &data, data.benchmark_id, r#"{"size_mb": 16}"#, 1.0);
+    create_grid_point(&server, &data, data.benchmark_id, r#"{"size_mb": 32}"#, 2.0);
+
+    let filtered = fixture_query(
+        &data,
+        vec![data.benchmark_uuid],
+        &[r#"{"size_mb": 16}"#, r#"{"size_mb": 32}"#],
+    );
+    let perf = get_perf(
+        &server,
+        &user.token,
+        &perf_query_url(project.slug.as_ref(), &filtered),
+    )
+    .await;
+    assert_eq!(
+        line_parameters(&perf),
+        vec![
+            r#"{"size_mb":16}"#.to_owned(),
+            r#"{"size_mb":32}"#.to_owned()
+        ],
+        "the filter leaves the empty grid point out"
+    );
+
+    // The image endpoint takes no title here, so both sides fall back to the
+    // project name and the plot is handed the very same inputs.
+    let jpeg = get_perf_img(
+        &server,
+        &user.token,
+        &perf_img_url(project.slug.as_ref(), &filtered),
+    )
+    .await;
+    let plotted = bencher_plot::LinePlot::new()
+        .draw(None, &perf)
+        .expect("draw the queried lines");
+    assert_eq!(jpeg, plotted, "the image plots the query's own lines");
+
+    // Without the filter the empty grid point is a third line, so the image differs.
+    let unfiltered = fixture_query(&data, vec![data.benchmark_uuid], &[]);
+    let all_jpeg = get_perf_img(
+        &server,
+        &user.token,
+        &perf_img_url(project.slug.as_ref(), &unfiltered),
+    )
+    .await;
+    assert_ne!(jpeg, all_jpeg, "the filter reaches the image query");
+}

lib/bencher_json/src/project/perf.rs

@@ -80,6 +80,11 @@ pub struct JsonPerfImgQueryParams {
     pub specs: Option<String>,
     /// A comma separated list of benchmark UUIDs to query.
     pub benchmarks: String,
+    /// An optional comma separated list of URL encoded parameter sets to filter on.
+    /// A grid point is queried when at least one of them is a subset of its
+    /// parameter set: every key the filter names, with the same value.
+    /// Leaving this off queries every grid point.
+    pub parameters: Option<String>,
     /// A comma separated list of measure UUIDs to query.
     pub measures: String,
     /// Search for metrics after the given date time in milliseconds.
@@ -97,6 +102,7 @@ impl From<JsonPerfImgQueryParams> for JsonPerfQueryParams {
             testbeds,
             specs,
             benchmarks,
+            parameters,
             measures,
             start_time,
             end_time,
@@ -107,9 +113,7 @@ impl From<JsonPerfImgQueryParams> for JsonPerfQueryParams {
             testbeds,
             specs,
             benchmarks,
-            // The perf image has no parameters filter of its own yet, so it plots
-            // every grid point its dimensions name.
-            parameters: None,
+            parameters,
             measures,
             start_time,
             end_time,