Improve synthetic_size json output:

- add new fields 'parent_lsn' and 'wal_from_parent' to segments; - output 'timeline_inputs' lsns as u64 to be consistent with other places
Fix missing VM cgconfig.conf (#3718 )
2026-07-07 22:20:36 +00:00 · 2023-03-02 12:53:00 +02:00 · 2023-02-28 21:11:00 -08:00
24 changed files with 195 additions and 486 deletions
--- a/Dockerfile.vm-compute-node
+++ b/Dockerfile.vm-compute-node
@@ -10,7 +10,6 @@ RUN set -e \
 	&& rm -f /etc/inittab \
 	&& touch /etc/inittab

-ADD vm-cgconfig.conf /etc/cgconfig.conf
 RUN set -e \
 	&& echo "::sysinit:cgconfigparser -l /etc/cgconfig.conf -s 1664" >> /etc/inittab \
 	&& echo "::respawn:su vm-informant -c '/usr/local/bin/vm-informant --auto-restart --cgroup=neon-postgres'" >> /etc/inittab
@@ -26,6 +25,7 @@ RUN apt update && \
 RUN adduser vm-informant --disabled-password --no-create-home
 USER postgres

+ADD vm-cgconfig.conf /etc/cgconfig.conf
 COPY --from=informant /etc/inittab /etc/inittab
 COPY --from=informant /usr/bin/vm-informant /usr/local/bin/vm-informant

--- a/libs/tenant_size_model/src/lib.rs
+++ b/libs/tenant_size_model/src/lib.rs
@@ -37,10 +37,15 @@ pub struct Segment {
    /// LSN at this point
    pub lsn: u64,

+    pub parent_lsn: Option<u64>,
+
+    pub wal_from_parent: Option<u64>,
+
    /// Logical size at this node, if known.
    pub size: Option<u64>,

    /// If true, the segment from parent to this node is needed by `retention_period`
+    /// if wal_from_parent is needed by `retention_period`?
    pub needed: bool,
 }

--- a/libs/tenant_size_model/tests/tests.rs
+++ b/libs/tenant_size_model/tests/tests.rs
@@ -17,6 +17,8 @@ impl ScenarioBuilder {
        let init_segment = Segment {
            parent: None,
            lsn: 0,
+            parent_lsn: None,
+            wal_from_parent: None,
            size: Some(0),
            needed: false, // determined later
        };
@@ -36,6 +38,8 @@ impl ScenarioBuilder {
        let newseg = Segment {
            parent: Some(lastseg_id),
            lsn: lastseg.lsn + lsn_bytes,
+            parent_lsn: Some(lastseg.lsn),
+            wal_from_parent: Some(lsn_bytes),
            size: Some((lastseg.size.unwrap() as i64 + size_bytes) as u64),
            needed: false,
        };
--- a/pageserver/src/http/routes.rs
+++ b/pageserver/src/http/routes.rs
@@ -971,22 +971,19 @@ async fn timeline_checkpoint_handler(request: Request<Body>) -> Result<Response<
    let tenant_id: TenantId = parse_request_param(&request, "tenant_id")?;
    let timeline_id: TimelineId = parse_request_param(&request, "timeline_id")?;
    check_permission(&request, Some(tenant_id))?;
-    async {
-        let ctx = RequestContext::new(TaskKind::MgmtRequest, DownloadBehavior::Download);
-        let timeline = active_timeline_of_active_tenant(tenant_id, timeline_id).await?;
-        timeline
-            .freeze_and_flush()
-            .await
-            .map_err(ApiError::InternalServerError)?;
-        timeline
-            .compact(&ctx)
-            .await
-            .map_err(ApiError::InternalServerError)?;

-        json_response(StatusCode::OK, ())
-    }
-    .instrument(info_span!("manual_checkpoint", tenant_id = %tenant_id, timeline_id = %timeline_id))
-    .await
+    let ctx = RequestContext::new(TaskKind::MgmtRequest, DownloadBehavior::Download);
+    let timeline = active_timeline_of_active_tenant(tenant_id, timeline_id).await?;
+    timeline
+        .freeze_and_flush()
+        .await
+        .map_err(ApiError::InternalServerError)?;
+    timeline
+        .compact(&ctx)
+        .await
+        .map_err(ApiError::InternalServerError)?;
+
+    json_response(StatusCode::OK, ())
 }

 async fn timeline_download_remote_layers_handler_post(
--- a/pageserver/src/tenant/config.rs
+++ b/pageserver/src/tenant/config.rs
@@ -103,7 +103,6 @@ pub struct TenantConfOpt {
    pub checkpoint_distance: Option<u64>,

    #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(with = "humantime_serde")]
    #[serde(default)]
    pub checkpoint_timeout: Option<Duration>,

--- a/pageserver/src/tenant/size.rs
+++ b/pageserver/src/tenant/size.rs
@@ -85,23 +85,16 @@ pub struct TimelineInputs {
    #[serde_as(as = "Option<serde_with::DisplayFromStr>")]
    pub ancestor_id: Option<TimelineId>,

-    #[serde_as(as = "serde_with::DisplayFromStr")]
    ancestor_lsn: Lsn,
-    #[serde_as(as = "serde_with::DisplayFromStr")]
    last_record: Lsn,
-    #[serde_as(as = "serde_with::DisplayFromStr")]
    latest_gc_cutoff: Lsn,
-    #[serde_as(as = "serde_with::DisplayFromStr")]
    horizon_cutoff: Lsn,
-    #[serde_as(as = "serde_with::DisplayFromStr")]
    pitr_cutoff: Lsn,

    /// Cutoff point based on GC settings
-    #[serde_as(as = "serde_with::DisplayFromStr")]
    next_gc_cutoff: Lsn,

    /// Cutoff point calculated from the user-supplied 'max_retention_period'
-    #[serde_as(as = "Option<serde_with::DisplayFromStr>")]
    retention_param_cutoff: Option<Lsn>,
 }

@@ -252,6 +245,8 @@ pub(super) async fn gather_inputs(
            segment: Segment {
                parent: None, // filled in later
                lsn: branch_start_lsn.0,
+                parent_lsn: None,
+                wal_from_parent: None,
                size: None, // filled in later
                needed: branch_start_needed,
            },
@@ -270,6 +265,8 @@ pub(super) async fn gather_inputs(
                segment: Segment {
                    parent: Some(parent),
                    lsn: lsn.0,
+                    parent_lsn: Some(segments[parent].segment.lsn),
+                    wal_from_parent: Some(lsn.0 - segments[parent].segment.lsn),
                    size: None,
                    needed: lsn > next_gc_cutoff,
                },
@@ -284,6 +281,8 @@ pub(super) async fn gather_inputs(
            segment: Segment {
                parent: Some(parent),
                lsn: last_record_lsn.0,
+                parent_lsn: Some(segments[parent].segment.lsn),
+                wal_from_parent: Some(last_record_lsn.0 - segments[parent].segment.lsn),
                size: None, // Filled in later, if necessary
                needed: true,
            },
@@ -613,32 +612,32 @@ fn verify_size_for_multiple_branches() {
  "timeline_inputs": [
    {
      "timeline_id": "20b129c9b50cff7213e6503a31b2a5ce",
-      "ancestor_lsn": "0/18D3D98",
-      "last_record": "0/2230CD0",
-      "latest_gc_cutoff": "0/1698C48",
-      "horizon_cutoff": "0/2210CD0",
-      "pitr_cutoff": "0/2210CD0",
-      "next_gc_cutoff": "0/2210CD0",
+      "ancestor_lsn": 26033560,
+      "last_record": 35851472,
+      "latest_gc_cutoff": 23694408,
+      "horizon_cutoff": 35720400,
+      "pitr_cutoff": 35720400,
+      "next_gc_cutoff": 35720400,
      "retention_param_cutoff": null
    },
    {
      "timeline_id": "454626700469f0a9914949b9d018e876",
-      "ancestor_lsn": "0/176D998",
-      "last_record": "0/1837770",
-      "latest_gc_cutoff": "0/1698C48",
-      "horizon_cutoff": "0/1817770",
-      "pitr_cutoff": "0/1817770",
-      "next_gc_cutoff": "0/1817770",
+      "ancestor_lsn": 24566168,
+      "last_record": 25393008,
+      "latest_gc_cutoff": 23694408,
+      "horizon_cutoff": 25261936,
+      "pitr_cutoff": 25261936,
+      "next_gc_cutoff": 25261936,
      "retention_param_cutoff": null
    },
    {
      "timeline_id": "cb5e3cbe60a4afc00d01880e1a37047f",
-      "ancestor_lsn": "0/0",
-      "last_record": "0/18D3D98",
-      "latest_gc_cutoff": "0/1698C48",
-      "horizon_cutoff": "0/18B3D98",
-      "pitr_cutoff": "0/18B3D98",
-      "next_gc_cutoff": "0/18B3D98",
+      "ancestor_lsn": 0,
+      "last_record": 26033560,
+      "latest_gc_cutoff": 23694408,
+      "horizon_cutoff":25902488,
+      "pitr_cutoff":25902488,
+      "next_gc_cutoff":25902488,
      "retention_param_cutoff": null
    }
  ]
@@ -688,13 +687,13 @@ fn verify_size_for_one_branch() {
  "timeline_inputs": [
    {
      "timeline_id": "f15ae0cf21cce2ba27e4d80c6709a6cd",
-      "ancestor_lsn": "0/0",
-      "last_record": "47/280A5860",
-      "latest_gc_cutoff": "47/240A5860",
-      "horizon_cutoff": "47/240A5860",
-      "pitr_cutoff": "47/240A5860",
-      "next_gc_cutoff": "47/240A5860",
-      "retention_param_cutoff": "0/0"
+      "ancestor_lsn": 0,
+      "last_record": 305547335776,
+      "latest_gc_cutoff": 305614444640,
+      "horizon_cutoff": 305614444640,
+      "pitr_cutoff": 305614444640,
+      "next_gc_cutoff": 305614444640,
+      "retention_param_cutoff": 0
    }
  ]
 }"#;
@@ -707,12 +706,15 @@ fn verify_size_for_one_branch() {
    println!("result: {:?}", serde_json::to_string(&res.segments));

    use utils::lsn::Lsn;
-    let latest_gc_cutoff_lsn: Lsn = "47/240A5860".parse().unwrap();
-    let last_lsn: Lsn = "47/280A5860".parse().unwrap();
+    let latest_gc_cutoff_lsn: Lsn = Lsn(305614444640);
+    let last_lsn: Lsn = Lsn(305547335776);
    println!(
-        "latest_gc_cutoff lsn 47/240A5860 is {}, last_lsn lsn 47/280A5860 is {}",
+        "latest_gc_cutoff lsn {} is {}, last_lsn lsn {} is {}",
+        latest_gc_cutoff_lsn,
        u64::from(latest_gc_cutoff_lsn),
+        last_lsn,
        u64::from(last_lsn)
    );
+
    assert_eq!(res.total_size, 220121784320);
 }
--- a/pageserver/src/tenant/storage_layer.rs
+++ b/pageserver/src/tenant/storage_layer.rs
@@ -364,7 +364,7 @@ pub trait PersistentLayer: Layer {
    }

    /// Permanently remove this layer from disk.
-    fn delete_resident_layer_file(&self) -> Result<()>;
+    fn delete(&self) -> Result<()>;

    fn downcast_remote_layer(self: Arc<Self>) -> Option<std::sync::Arc<RemoteLayer>> {
        None
--- a/pageserver/src/tenant/storage_layer/delta_layer.rs
+++ b/pageserver/src/tenant/storage_layer/delta_layer.rs
@@ -438,7 +438,7 @@ impl PersistentLayer for DeltaLayer {
        ))
    }

-    fn delete_resident_layer_file(&self) -> Result<()> {
+    fn delete(&self) -> Result<()> {
        // delete underlying file
        fs::remove_file(self.path())?;
        Ok(())
--- a/pageserver/src/tenant/storage_layer/image_layer.rs
+++ b/pageserver/src/tenant/storage_layer/image_layer.rs
@@ -252,7 +252,7 @@ impl PersistentLayer for ImageLayer {
        unimplemented!();
    }

-    fn delete_resident_layer_file(&self) -> Result<()> {
+    fn delete(&self) -> Result<()> {
        // delete underlying file
        fs::remove_file(self.path())?;
        Ok(())
--- a/pageserver/src/tenant/storage_layer/remote_layer.rs
+++ b/pageserver/src/tenant/storage_layer/remote_layer.rs
@@ -155,8 +155,8 @@ impl PersistentLayer for RemoteLayer {
        bail!("cannot iterate a remote layer");
    }

-    fn delete_resident_layer_file(&self) -> Result<()> {
-        bail!("remote layer has no layer file");
+    fn delete(&self) -> Result<()> {
+        Ok(())
    }

    fn downcast_remote_layer<'a>(self: Arc<Self>) -> Option<std::sync::Arc<RemoteLayer>> {
--- a/pageserver/src/tenant/timeline.rs
+++ b/pageserver/src/tenant/timeline.rs
@@ -662,8 +662,8 @@ impl Timeline {
            // update the index file on next flush iteration too. But it
            // could take a while until that happens.
            //
-            // Additionally, only do this once before we return from this function.
-            if last_round || res.is_ok() {
+            // Additionally, only do this on the terminal round before sleeping.
+            if last_round {
                if let Some(remote_client) = &self.remote_client {
                    remote_client.schedule_index_upload_for_file_changes()?;
                }
@@ -1047,12 +1047,11 @@ impl Timeline {
            return Ok(false);
        }

-        let layer_file_size = local_layer
-            .file_size()
-            .expect("Local layer should have a file size");
-
-        let layer_metadata = LayerFileMetadata::new(layer_file_size);
-
+        let layer_metadata = LayerFileMetadata::new(
+            local_layer
+                .file_size()
+                .expect("Local layer should have a file size"),
+        );
        let new_remote_layer = Arc::new(match local_layer.filename() {
            LayerFileName::Image(image_name) => RemoteLayer::new_img(
                self.tenant_id,
@@ -1076,22 +1075,15 @@ impl Timeline {

        let replaced = match batch_updates.replace_historic(local_layer, new_remote_layer)? {
            Replacement::Replaced { .. } => {
-                if let Err(e) = local_layer.delete_resident_layer_file() {
+                let layer_size = local_layer.file_size();
+
+                if let Err(e) = local_layer.delete() {
                    error!("failed to remove layer file on evict after replacement: {e:#?}");
                }
-                // Always decrement the physical size gauge, even if we failed to delete the file.
-                // Rationale: we already replaced the layer with a remote layer in the layer map,
-                // and any subsequent download_remote_layer will
-                // 1. overwrite the file on disk and
-                // 2. add the downloaded size to the resident size gauge.
-                //
-                // If there is no re-download, and we restart the pageserver, then load_layer_map
-                // will treat the file as a local layer again, count it towards resident size,
-                // and it'll be like the layer removal never happened.
-                // The bump in resident size is perhaps unexpected but overall a robust behavior.
-                self.metrics
-                    .resident_physical_size_gauge
-                    .sub(layer_file_size);
+
+                if let Some(layer_size) = layer_size {
+                    self.metrics.resident_physical_size_gauge.sub(layer_size);
+                }

                true
            }
@@ -1950,14 +1942,11 @@ impl Timeline {
        layer: Arc<dyn PersistentLayer>,
        updates: &mut BatchedUpdates<'_, dyn PersistentLayer>,
    ) -> anyhow::Result<()> {
-        if !layer.is_remote_layer() {
-            layer.delete_resident_layer_file()?;
-            let layer_file_size = layer
-                .file_size()
-                .expect("Local layer should have a file size");
-            self.metrics
-                .resident_physical_size_gauge
-                .sub(layer_file_size);
+        let layer_size = layer.file_size();
+
+        layer.delete()?;
+        if let Some(layer_size) = layer_size {
+            self.metrics.resident_physical_size_gauge.sub(layer_size);
        }

        // TODO Removing from the bottom of the layer map is expensive.
--- a/test_runner/fixtures/benchmark_fixture.py
+++ b/test_runner/fixtures/benchmark_fixture.py
@@ -366,9 +366,17 @@ class NeonBenchmarker:

    def get_int_counter_value(self, pageserver: NeonPageserver, metric_name: str) -> int:
        """Fetch the value of given int counter from pageserver metrics."""
+        # TODO: If we start to collect more of the prometheus metrics in the
+        # performance test suite like this, we should refactor this to load and
+        # parse all the metrics into a more convenient structure in one go.
+        #
+        # The metric should be an integer, as it's a number of bytes. But in general
+        # all prometheus metrics are floats. So to be pedantic, read it as a float
+        # and round to integer.
        all_metrics = pageserver.http_client().get_metrics()
-        sample = all_metrics.query_one(metric_name)
-        return int(round(sample.value))
+        matches = re.search(rf"^{metric_name} (\S+)$", all_metrics, re.MULTILINE)
+        assert matches, f"metric {metric_name} not found"
+        return int(round(float(matches.group(1))))

    def get_timeline_size(
        self, repo_dir: Path, tenant_id: TenantId, timeline_id: TimelineId
--- a/test_runner/fixtures/metrics.py
+++ b/test_runner/fixtures/metrics.py
@@ -13,8 +13,7 @@ class Metrics:
        self.metrics = defaultdict(list)
        self.name = name

-    def query_all(self, name: str, filter: Optional[Dict[str, str]] = None) -> List[Sample]:
-        filter = filter or {}
+    def query_all(self, name: str, filter: Dict[str, str]) -> List[Sample]:
        res = []
        for sample in self.metrics[name]:
            try:
--- a/test_runner/fixtures/neon_fixtures.py
+++ b/test_runner/fixtures/neon_fixtures.py
@@ -14,7 +14,6 @@ import tempfile
 import textwrap
 import time
 import uuid
-from collections import defaultdict
 from contextlib import closing, contextmanager
 from dataclasses import dataclass, field
 from enum import Flag, auto
@@ -29,6 +28,7 @@ import asyncpg
 import backoff  # type: ignore
 import boto3
 import jwt
+import prometheus_client
 import psycopg2
 import pytest
 import requests
@@ -36,7 +36,7 @@ from _pytest.config import Config
 from _pytest.config.argparsing import Parser
 from _pytest.fixtures import FixtureRequest
 from fixtures.log_helper import log
-from fixtures.metrics import Metrics, parse_metrics
+from fixtures.metrics import parse_metrics
 from fixtures.types import Lsn, TenantId, TimelineId
 from fixtures.utils import (
    ATTACHMENT_NAME_REGEX,
@@ -45,6 +45,7 @@ from fixtures.utils import (
    get_self_dir,
    subprocess_capture,
 )
+from prometheus_client.parser import text_string_to_metric_families

 # Type-related stuff
 from psycopg2.extensions import connection as PgConnection
@@ -1435,27 +1436,22 @@ class PageserverHttpClient(requests.Session):
                assert completed["successful_download_count"] > 0
            return completed

-    def get_metrics_str(self) -> str:
-        """You probably want to use get_metrics() instead."""
+    def get_metrics(self) -> str:
        res = self.get(f"http://localhost:{self.port}/metrics")
        self.verbose_error(res)
        return res.text

-    def get_metrics(self) -> Metrics:
-        res = self.get_metrics_str()
-        return parse_metrics(res)
-
-    def get_timeline_metric(
-        self, tenant_id: TenantId, timeline_id: TimelineId, metric_name: str
-    ) -> float:
-        metrics = self.get_metrics()
-        return metrics.query_one(
-            metric_name,
-            filter={
-                "tenant_id": str(tenant_id),
-                "timeline_id": str(timeline_id),
-            },
-        ).value
+    def get_timeline_metric(self, tenant_id: TenantId, timeline_id: TimelineId, metric_name: str):
+        raw = self.get_metrics()
+        family: List[prometheus_client.Metric] = list(text_string_to_metric_families(raw))
+        [metric] = [m for m in family if m.name == metric_name]
+        [sample] = [
+            s
+            for s in metric.samples
+            if s.labels["tenant_id"] == str(tenant_id)
+            and s.labels["timeline_id"] == str(timeline_id)
+        ]
+        return sample.value

    def get_remote_timeline_client_metric(
        self,
@@ -1465,7 +1461,7 @@ class PageserverHttpClient(requests.Session):
        file_kind: str,
        op_kind: str,
    ) -> Optional[float]:
-        metrics = self.get_metrics()
+        metrics = parse_metrics(self.get_metrics(), "pageserver")
        matches = metrics.query_all(
            name=metric_name,
            filter={
@@ -1484,16 +1480,14 @@ class PageserverHttpClient(requests.Session):
            assert len(matches) < 2, "above filter should uniquely identify metric"
        return value

-    def get_metric_value(
-        self, name: str, filter: Optional[Dict[str, str]] = None
-    ) -> Optional[float]:
+    def get_metric_value(self, name: str) -> Optional[str]:
        metrics = self.get_metrics()
-        results = metrics.query_all(name, filter=filter)
-        if not results:
+        relevant = [line for line in metrics.splitlines() if line.startswith(name)]
+        if len(relevant) == 0:
            log.info(f'could not find metric "{name}"')
            return None
-        assert len(results) == 1, f"metric {name} with given filters is not unique, got: {results}"
-        return results[0].value
+        assert len(relevant) == 1
+        return relevant[0].lstrip(name).strip()

    def layer_map_info(
        self,
@@ -1522,11 +1516,6 @@ class PageserverHttpClient(requests.Session):

        assert res.status_code == 200

-    def evict_all_layers(self, tenant_id: TenantId, timeline_id: TimelineId):
-        info = self.layer_map_info(tenant_id, timeline_id)
-        for layer in info.historic_layers:
-            self.evict_layer(tenant_id, timeline_id, layer.layer_file_name)
-

@dataclass
 class TenantConfig:
@@ -1562,14 +1551,6 @@ class LayerMapInfo:

        return info

-    def kind_count(self) -> Dict[str, int]:
-        counts: Dict[str, int] = defaultdict(int)
-        for inmem_layer in self.in_memory_layers:
-            counts[inmem_layer.kind] += 1
-        for hist_layer in self.historic_layers:
-            counts[hist_layer.kind] += 1
-        return counts
-

@dataclass
 class InMemoryLayerInfo:
@@ -1586,7 +1567,7 @@ class InMemoryLayerInfo:
        )


-@dataclass(frozen=True)
+@dataclass
 class HistoricLayerInfo:
    kind: str
    layer_file_name: str
@@ -3535,23 +3516,3 @@ def wait_for_sk_commit_lsn_to_reach_remote_storage(
    ps_http.timeline_checkpoint(tenant_id, timeline_id)
    wait_for_upload(ps_http, tenant_id, timeline_id, lsn)
    return lsn
-
-
-def wait_for_upload_queue_empty(
-    pageserver: NeonPageserver, tenant_id: TenantId, timeline_id: TimelineId
-):
-    ps_http = pageserver.http_client()
-    while True:
-        all_metrics = ps_http.get_metrics()
-        tl = all_metrics.query_all(
-            "pageserver_remote_timeline_client_calls_unfinished",
-            {
-                "tenant_id": str(tenant_id),
-                "timeline_id": str(timeline_id),
-            },
-        )
-        assert len(tl) > 0
-        log.info(f"upload queue for {tenant_id}/{timeline_id}: {tl}")
-        if all(m.value == 0 for m in tl):
-            return
-        time.sleep(0.2)
--- a/test_runner/regress/test_build_info_metric.py
+++ b/test_runner/regress/test_build_info_metric.py
@@ -8,7 +8,7 @@ def test_build_info_metric(neon_env_builder: NeonEnvBuilder, link_proxy: NeonPro

    parsed_metrics = {}

-    parsed_metrics["pageserver"] = parse_metrics(env.pageserver.http_client().get_metrics_str())
+    parsed_metrics["pageserver"] = parse_metrics(env.pageserver.http_client().get_metrics())
    parsed_metrics["safekeeper"] = parse_metrics(env.safekeepers[0].http_client().get_metrics_str())
    parsed_metrics["proxy"] = parse_metrics(link_proxy.get_metrics())

--- a/test_runner/regress/test_gc_aggressive.py
+++ b/test_runner/regress/test_gc_aggressive.py
@@ -4,6 +4,7 @@ import random

 import pytest
 from fixtures.log_helper import log
+from fixtures.metrics import parse_metrics
 from fixtures.neon_fixtures import (
    NeonEnv,
    NeonEnvBuilder,
@@ -133,7 +134,7 @@ def test_gc_index_upload(neon_env_builder: NeonEnvBuilder, remote_storage_kind:

    # Helper function that gets the number of given kind of remote ops from the metrics
    def get_num_remote_ops(file_kind: str, op_kind: str) -> int:
-        ps_metrics = env.pageserver.http_client().get_metrics()
+        ps_metrics = parse_metrics(env.pageserver.http_client().get_metrics(), "pageserver")
        total = 0.0
        for sample in ps_metrics.query_all(
            name="pageserver_remote_operation_seconds_count",
--- a/test_runner/regress/test_layer_eviction.py
+++ b/test_runner/regress/test_layer_eviction.py
@@ -1,13 +1,8 @@
-import time
-
 import pytest
-from fixtures.log_helper import log
 from fixtures.neon_fixtures import (
    NeonEnvBuilder,
    RemoteStorageKind,
-    wait_for_last_flush_lsn,
    wait_for_last_record_lsn,
-    wait_for_sk_commit_lsn_to_reach_remote_storage,
    wait_for_upload,
 )
 from fixtures.types import Lsn, TenantId, TimelineId
@@ -143,160 +138,3 @@ def test_basic_eviction(
    assert (
        redownloaded_layer_map_info == initial_layer_map_info
    ), "Should have the same layer map after redownloading the evicted layers"
-
-
-def test_gc_of_remote_layers(neon_env_builder: NeonEnvBuilder):
-
-    neon_env_builder.enable_remote_storage(
-        remote_storage_kind=RemoteStorageKind.LOCAL_FS,
-        test_name="test_gc_of_remote_layers",
-    )
-
-    env = neon_env_builder.init_start()
-
-    tenant_config = {
-        "pitr_interval": "1s",  # set to non-zero, so GC actually does something
-        "gc_period": "0s",  # we want to control when GC runs
-        "compaction_period": "0s",  # we want to control when compaction runs
-        "checkpoint_timeout": "24h",  # something we won't reach
-        "checkpoint_distance": f"{50 * (1024**2)}",  # something we won't reach, we checkpoint manually
-        "compaction_threshold": "3",
-        # "image_creation_threshold": set at runtime
-        "compaction_target_size": f"{128 * (1024**2)}",  # make it so that we only have 1 partition => image coverage for delta layers => enables gc of delta layers
-    }
-
-    def tenant_update_config(changes):
-        tenant_config.update(changes)
-        env.neon_cli.config_tenant(tenant_id, tenant_config)
-
-    tenant_id, timeline_id = env.neon_cli.create_tenant(conf=tenant_config)
-    log.info("tenant id is %s", tenant_id)
-    env.initial_tenant = tenant_id  # update_and_gc relies on this
-    ps_http = env.pageserver.http_client()
-
-    pg = env.postgres.create_start("main")
-
-    log.info("fill with data, creating delta & image layers, some of which are GC'able after")
-    # no particular reason to create the layers like this, but we are sure
-    # not to hit the image_creation_threshold here.
-    with pg.cursor() as cur:
-        cur.execute("create table a (id bigserial primary key, some_value bigint not null)")
-        cur.execute("insert into a(some_value) select i from generate_series(1, 10000) s(i)")
-    wait_for_last_flush_lsn(env, pg, tenant_id, timeline_id)
-    ps_http.timeline_checkpoint(tenant_id, timeline_id)
-
-    # Create delta layers, then turn them into image layers.
-    # Do it multiple times so that there's something to GC.
-    for k in range(0, 2):
-        # produce delta layers => disable image layer creation by setting high threshold
-        tenant_update_config({"image_creation_threshold": "100"})
-        for i in range(0, 2):
-            for j in range(0, 3):
-                # create a minimal amount of "delta difficulty" for this table
-                with pg.cursor() as cur:
-                    cur.execute("update a set some_value = -some_value + %s", (j,))
-
-                with pg.cursor() as cur:
-                    # vacuuming should aid to reuse keys, though it's not really important
-                    # with image_creation_threshold=1 which we will use on the last compaction
-                    cur.execute("vacuum")
-
-                wait_for_last_flush_lsn(env, pg, tenant_id, timeline_id)
-
-                if i == 1 and j == 2 and k == 1:
-                    # last iteration; stop before checkpoint to avoid leaving an inmemory layer
-                    pg.stop_and_destroy()
-
-                ps_http.timeline_checkpoint(tenant_id, timeline_id)
-
-            # images should not yet be created, because threshold is too high,
-            # but these will be reshuffled to L1 layers
-            ps_http.timeline_compact(tenant_id, timeline_id)
-
-        for _ in range(0, 20):
-            # loop in case flushing is still in progress
-            layers = ps_http.layer_map_info(tenant_id, timeline_id)
-            if not layers.in_memory_layers:
-                break
-            time.sleep(0.2)
-
-        # now that we've grown some delta layers, turn them into image layers
-        tenant_update_config({"image_creation_threshold": "1"})
-        ps_http.timeline_compact(tenant_id, timeline_id)
-
-    # wait for all uploads to finish
-    wait_for_sk_commit_lsn_to_reach_remote_storage(
-        tenant_id, timeline_id, env.safekeepers, env.pageserver
-    )
-
-    # shutdown safekeepers to avoid on-demand downloads from walreceiver
-    for sk in env.safekeepers:
-        sk.stop()
-
-    ps_http.timeline_checkpoint(tenant_id, timeline_id)
-
-    log.info("ensure the code above produced image and delta layers")
-    pre_evict_info = ps_http.layer_map_info(tenant_id, timeline_id)
-    log.info("layer map dump: %s", pre_evict_info)
-    by_kind = pre_evict_info.kind_count()
-    log.info("by kind: %s", by_kind)
-    assert by_kind["Image"] > 0
-    assert by_kind["Delta"] > 0
-    assert by_kind["InMemory"] == 0
-    resident_layers = list(env.timeline_dir(tenant_id, timeline_id).glob("*-*_*"))
-    log.info("resident layers count before eviction: %s", len(resident_layers))
-
-    log.info("evict all layers")
-    ps_http.evict_all_layers(tenant_id, timeline_id)
-
-    def ensure_resident_and_remote_size_metrics():
-        log.info("ensure that all the layers are gone")
-        resident_layers = list(env.timeline_dir(tenant_id, timeline_id).glob("*-*_*"))
-        # we have disabled all background loops, so, this should hold
-        assert len(resident_layers) == 0
-
-        info = ps_http.layer_map_info(tenant_id, timeline_id)
-        log.info("layer map dump: %s", info)
-
-        log.info("ensure that resident_physical_size metric is zero")
-        resident_physical_size_metric = ps_http.get_timeline_metric(
-            tenant_id, timeline_id, "pageserver_resident_physical_size"
-        )
-        assert resident_physical_size_metric == 0
-        log.info("ensure that resident_physical_size metric corresponds to layer map dump")
-        assert resident_physical_size_metric == sum(
-            [layer.layer_file_size or 0 for layer in info.historic_layers if not layer.remote]
-        )
-
-        log.info("ensure that remote_physical_size metric matches layer map")
-        remote_physical_size_metric = ps_http.get_timeline_metric(
-            tenant_id, timeline_id, "pageserver_remote_physical_size"
-        )
-        log.info("ensure that remote_physical_size metric corresponds to layer map dump")
-        assert remote_physical_size_metric == sum(
-            layer.layer_file_size or 0 for layer in info.historic_layers if layer.remote
-        )
-
-    log.info("before runnning GC, ensure that remote_physical size is zero")
-    ensure_resident_and_remote_size_metrics()
-
-    log.info("run GC")
-    time.sleep(2)  # let pitr_interval + 1 second pass
-    ps_http.timeline_gc(tenant_id, timeline_id, 0)
-    time.sleep(1)
-    assert not env.pageserver.log_contains("Nothing to GC")
-
-    log.info("ensure GC deleted some layers, otherwise this test is pointless")
-    post_gc_info = ps_http.layer_map_info(tenant_id, timeline_id)
-    log.info("layer map dump: %s", post_gc_info)
-    log.info("by kind: %s", post_gc_info.kind_count())
-    pre_evict_layers = set([layer.layer_file_name for layer in pre_evict_info.historic_layers])
-    post_gc_layers = set([layer.layer_file_name for layer in post_gc_info.historic_layers])
-    assert post_gc_layers.issubset(pre_evict_layers)
-    assert len(post_gc_layers) < len(pre_evict_layers)
-
-    log.info("update_gc_info might download some layers. Evict them again.")
-    ps_http.evict_all_layers(tenant_id, timeline_id)
-
-    log.info("after running GC, ensure that resident size is still zero")
-    ensure_resident_and_remote_size_metrics()
--- a/test_runner/regress/test_metric_collection.py
+++ b/test_runner/regress/test_metric_collection.py
@@ -9,6 +9,7 @@ from typing import Iterator

 import pytest
 from fixtures.log_helper import log
+from fixtures.metrics import parse_metrics
 from fixtures.neon_fixtures import (
    PSQL,
    NeonEnvBuilder,
@@ -142,7 +143,7 @@ def test_metric_collection(

    # Helper function that gets the number of given kind of remote ops from the metrics
    def get_num_remote_ops(file_kind: str, op_kind: str) -> int:
-        ps_metrics = env.pageserver.http_client().get_metrics()
+        ps_metrics = parse_metrics(env.pageserver.http_client().get_metrics(), "pageserver")
        total = 0.0
        for sample in ps_metrics.query_all(
            name="pageserver_remote_operation_seconds_count",
--- a/test_runner/regress/test_ondemand_download.py
+++ b/test_runner/regress/test_ondemand_download.py
@@ -11,7 +11,6 @@ from fixtures.log_helper import log
 from fixtures.neon_fixtures import (
    NeonEnvBuilder,
    PageserverApiException,
-    PageserverHttpClient,
    RemoteStorageKind,
    assert_tenant_status,
    available_remote_storages,
@@ -26,16 +25,9 @@ from fixtures.types import Lsn
 from fixtures.utils import query_scalar


-def get_num_downloaded_layers(client: PageserverHttpClient, tenant_id, timeline_id):
+def get_num_downloaded_layers(client, tenant_id, timeline_id):
    value = client.get_metric_value(
-        "pageserver_remote_operation_seconds_count",
-        {
-            "file_kind": "layer",
-            "op_kind": "download",
-            "status": "success",
-            "tenant_id": tenant_id,
-            "timeline_id": timeline_id,
-        },
+        f'pageserver_remote_operation_seconds_count{{file_kind="layer",op_kind="download",status="success",tenant_id="{tenant_id}",timeline_id="{timeline_id}"}}'
    )
    if value is None:
        return 0
--- a/test_runner/regress/test_tenant_detach.py
+++ b/test_runner/regress/test_tenant_detach.py
@@ -6,6 +6,7 @@ from threading import Thread
 import asyncpg
 import pytest
 from fixtures.log_helper import log
+from fixtures.metrics import parse_metrics
 from fixtures.neon_fixtures import (
    NeonEnv,
    NeonEnvBuilder,
@@ -78,7 +79,7 @@ def test_tenant_reattach(
        ".*failed to perform remote task UploadMetadata.*, will retry.*"
    )

-    ps_metrics = pageserver_http.get_metrics()
+    ps_metrics = parse_metrics(pageserver_http.get_metrics(), "pageserver")
    tenant_metric_filter = {
        "tenant_id": str(tenant_id),
        "timeline_id": str(timeline_id),
@@ -92,7 +93,7 @@ def test_tenant_reattach(

    time.sleep(1)  # for metrics propagation

-    ps_metrics = pageserver_http.get_metrics()
+    ps_metrics = parse_metrics(pageserver_http.get_metrics(), "pageserver")
    pageserver_last_record_lsn = int(
        ps_metrics.query_one("pageserver_last_record_lsn", filter=tenant_metric_filter).value
    )
--- a/test_runner/regress/test_tenant_size.py
+++ b/test_runner/regress/test_tenant_size.py
@@ -52,12 +52,26 @@ def test_empty_tenant_size(neon_simple_env: NeonEnv, test_output_dir: Path):
    expected_inputs = {
        "segments": [
            {
-                "segment": {"parent": None, "lsn": 23694408, "size": 25362432, "needed": True},
+                "segment": {
+                    "parent": None,
+                    "lsn": 23694408,
+                    "parent_lsn": None,
+                    "wal_from_parent": None,
+                    "size": 25362432,
+                    "needed": True,
+                },
                "timeline_id": f"{main_timeline_id}",
                "kind": "BranchStart",
            },
            {
-                "segment": {"parent": 0, "lsn": 23694528, "size": None, "needed": True},
+                "segment": {
+                    "parent": 0,
+                    "lsn": 23694528,
+                    "parent_lsn": 23694408,
+                    "wal_from_parent": 120,
+                    "size": None,
+                    "needed": True,
+                },
                "timeline_id": f"{main_timeline_id}",
                "kind": "BranchEnd",
            },
@@ -66,16 +80,17 @@ def test_empty_tenant_size(neon_simple_env: NeonEnv, test_output_dir: Path):
            {
                "timeline_id": f"{main_timeline_id}",
                "ancestor_id": None,
-                "ancestor_lsn": "0/0",
-                "last_record": "0/1698CC0",
-                "latest_gc_cutoff": "0/1698C48",
-                "horizon_cutoff": "0/0",
-                "pitr_cutoff": "0/0",
-                "next_gc_cutoff": "0/0",
+                "ancestor_lsn": 0,
+                "last_record": 23694528,
+                "latest_gc_cutoff": 23694408,
+                "horizon_cutoff": 0,
+                "pitr_cutoff": 0,
+                "next_gc_cutoff": 0,
                "retention_param_cutoff": None,
            }
        ],
    }
+
    expected_inputs = mask_model_inputs(expected_inputs)
    actual_inputs = mask_model_inputs(inputs)

@@ -641,7 +656,11 @@ def mask_model_inputs(x):
    if isinstance(x, dict):
        newx = {}
        for k, v in x.items():
-            if k == "size":
+            if (
+                k in ["size", "wal_from_parent", "last_record"]
+                or k.endswith("lsn")
+                or k.endswith("cutoff")
+            ):
                if v is None or v == 0:
                    # no change
                    newx[k] = v
@@ -649,12 +668,6 @@ def mask_model_inputs(x):
                    newx[k] = "<0"
                else:
                    newx[k] = ">0"
-            elif k.endswith("lsn") or k.endswith("cutoff") or k == "last_record":
-                if v is None or v == 0 or v == "0/0":
-                    # no change
-                    newx[k] = v
-                else:
-                    newx[k] = "masked"
            else:
                newx[k] = mask_model_inputs(v)
        return newx
--- a/test_runner/regress/test_tenant_tasks.py
+++ b/test_runner/regress/test_tenant_tasks.py
@@ -50,22 +50,16 @@ def test_tenant_tasks(neon_env_builder: NeonEnvBuilder):
        wait_until(10, 0.2, lambda: assert_active(tenant_id))

    # Assert that all tasks finish quickly after tenant is detached
-    task_starts = client.get_metric_value("pageserver_tenant_task_events_total", {"event": "start"})
+    task_starts = client.get_metric_value('pageserver_tenant_task_events{event="start"}')
    assert task_starts is not None
    assert int(task_starts) > 0
    client.tenant_detach(tenant)
    client.tenant_detach(env.initial_tenant)

    def assert_tasks_finish():
-        tasks_started = client.get_metric_value(
-            "pageserver_tenant_task_events_total", {"event": "start"}
-        )
-        tasks_ended = client.get_metric_value(
-            "pageserver_tenant_task_events_total", {"event": "stop"}
-        )
-        tasks_panicked = client.get_metric_value(
-            "pageserver_tenant_task_events_total", {"event": "panic"}
-        )
+        tasks_started = client.get_metric_value('pageserver_tenant_task_events{event="start"}')
+        tasks_ended = client.get_metric_value('pageserver_tenant_task_events{event="stop"}')
+        tasks_panicked = client.get_metric_value('pageserver_tenant_task_events{event="panic"}')
        log.info(f"started {tasks_started}, ended {tasks_ended}, panicked {tasks_panicked}")
        assert tasks_started == tasks_ended
        assert tasks_panicked is None or int(tasks_panicked) == 0
--- a/test_runner/regress/test_tenants.py
+++ b/test_runner/regress/test_tenants.py
@@ -107,7 +107,7 @@ def test_metrics_normal_work(neon_env_builder: NeonEnvBuilder):
                assert cur.fetchone() == (5000050000,)

    collected_metrics = {
-        "pageserver": env.pageserver.http_client().get_metrics_str(),
+        "pageserver": env.pageserver.http_client().get_metrics(),
    }
    for sk in env.safekeepers:
        collected_metrics[f"safekeeper{sk.id}"] = sk.http_client().get_metrics_str()
@@ -207,7 +207,7 @@ def test_pageserver_metrics_removed_after_detach(
                assert cur.fetchone() == (5000050000,)

    def get_ps_metric_samples_for_tenant(tenant_id: TenantId) -> List[Sample]:
-        ps_metrics = env.pageserver.http_client().get_metrics()
+        ps_metrics = parse_metrics(env.pageserver.http_client().get_metrics(), "pageserver")
        samples = []
        for metric_name in ps_metrics.metrics:
            for sample in ps_metrics.query_all(
@@ -307,7 +307,7 @@ def test_pageserver_with_empty_tenants(

    time.sleep(1)  # to allow metrics propagation

-    ps_metrics = client.get_metrics()
+    ps_metrics = parse_metrics(client.get_metrics(), "pageserver")
    broken_tenants_metric_filter = {
        "tenant_id": str(tenant_without_timelines_dir),
        "state": "broken",
--- a/test_runner/regress/test_timeline_size.py
+++ b/test_runner/regress/test_timeline_size.py
@@ -1,11 +1,11 @@
 import math
 import queue
 import random
+import re
 import threading
 import time
 from contextlib import closing
 from pathlib import Path
-from typing import Optional

 import psycopg2.errors
 import psycopg2.extras
@@ -19,11 +19,9 @@ from fixtures.neon_fixtures import (
    PgBin,
    PortDistributor,
    Postgres,
-    RemoteStorageKind,
    VanillaPostgres,
    assert_tenant_status,
    wait_for_last_flush_lsn,
-    wait_for_upload_queue_empty,
    wait_until,
 )
 from fixtures.types import TenantId, TimelineId
@@ -304,18 +302,8 @@ def test_timeline_initial_logical_size_calculation_cancellation(
    # message emitted by the code behind failpoint "timeline-calculate-logical-size-check-dir-exists"


-@pytest.mark.parametrize("remote_storage_kind", [None, RemoteStorageKind.LOCAL_FS])
-def test_timeline_physical_size_init(
-    neon_env_builder: NeonEnvBuilder, remote_storage_kind: Optional[RemoteStorageKind]
-):
-
-    if remote_storage_kind is not None:
-        neon_env_builder.enable_remote_storage(
-            remote_storage_kind, "test_timeline_physical_size_init"
-        )
-
-    env = neon_env_builder.init_start()
-
+def test_timeline_physical_size_init(neon_simple_env: NeonEnv):
+    env = neon_simple_env
    new_timeline_id = env.neon_cli.create_branch("test_timeline_physical_size_init")
    pg = env.postgres.create_start("test_timeline_physical_size_init")

@@ -343,22 +331,12 @@ def test_timeline_physical_size_init(
    )

    assert_physical_size_invariants(
-        get_physical_size_values(env, env.initial_tenant, new_timeline_id, remote_storage_kind),
-        remote_storage_kind,
+        get_physical_size_values(env, env.initial_tenant, new_timeline_id)
    )


-@pytest.mark.parametrize("remote_storage_kind", [None, RemoteStorageKind.LOCAL_FS])
-def test_timeline_physical_size_post_checkpoint(
-    neon_env_builder: NeonEnvBuilder, remote_storage_kind: Optional[RemoteStorageKind]
-):
-    if remote_storage_kind is not None:
-        neon_env_builder.enable_remote_storage(
-            remote_storage_kind, "test_timeline_physical_size_init"
-        )
-
-    env = neon_env_builder.init_start()
-
+def test_timeline_physical_size_post_checkpoint(neon_simple_env: NeonEnv):
+    env = neon_simple_env
    pageserver_http = env.pageserver.http_client()
    new_timeline_id = env.neon_cli.create_branch("test_timeline_physical_size_post_checkpoint")
    pg = env.postgres.create_start("test_timeline_physical_size_post_checkpoint")
@@ -376,21 +354,11 @@ def test_timeline_physical_size_post_checkpoint(
    pageserver_http.timeline_checkpoint(env.initial_tenant, new_timeline_id)

    assert_physical_size_invariants(
-        get_physical_size_values(env, env.initial_tenant, new_timeline_id, remote_storage_kind),
-        remote_storage_kind,
+        get_physical_size_values(env, env.initial_tenant, new_timeline_id)
    )


-@pytest.mark.parametrize("remote_storage_kind", [None, RemoteStorageKind.LOCAL_FS])
-def test_timeline_physical_size_post_compaction(
-    neon_env_builder: NeonEnvBuilder, remote_storage_kind: Optional[RemoteStorageKind]
-):
-
-    if remote_storage_kind is not None:
-        neon_env_builder.enable_remote_storage(
-            remote_storage_kind, "test_timeline_physical_size_init"
-        )
-
+def test_timeline_physical_size_post_compaction(neon_env_builder: NeonEnvBuilder):
    # Disable background compaction as we don't want it to happen after `get_physical_size` request
    # and before checking the expected size on disk, which makes the assertion failed
    neon_env_builder.pageserver_config_override = (
@@ -419,33 +387,15 @@ def test_timeline_physical_size_post_compaction(
    )

    wait_for_last_flush_lsn(env, pg, env.initial_tenant, new_timeline_id)
-
-    # shutdown safekeepers to prevent new data from coming in
-    for sk in env.safekeepers:
-        sk.stop()
-
    pageserver_http.timeline_checkpoint(env.initial_tenant, new_timeline_id)
    pageserver_http.timeline_compact(env.initial_tenant, new_timeline_id)

-    if remote_storage_kind is not None:
-        wait_for_upload_queue_empty(env.pageserver, env.initial_tenant, new_timeline_id)
-
    assert_physical_size_invariants(
-        get_physical_size_values(env, env.initial_tenant, new_timeline_id, remote_storage_kind),
-        remote_storage_kind,
+        get_physical_size_values(env, env.initial_tenant, new_timeline_id)
    )


-@pytest.mark.parametrize("remote_storage_kind", [None, RemoteStorageKind.LOCAL_FS])
-def test_timeline_physical_size_post_gc(
-    neon_env_builder: NeonEnvBuilder, remote_storage_kind: Optional[RemoteStorageKind]
-):
-
-    if remote_storage_kind is not None:
-        neon_env_builder.enable_remote_storage(
-            remote_storage_kind, "test_timeline_physical_size_init"
-        )
-
+def test_timeline_physical_size_post_gc(neon_env_builder: NeonEnvBuilder):
    # Disable background compaction and GC as we don't want it to happen after `get_physical_size` request
    # and before checking the expected size on disk, which makes the assertion failed
    neon_env_builder.pageserver_config_override = "tenant_config={checkpoint_distance=100000, compaction_period='0s', gc_period='0s', pitr_interval='1s'}"
@@ -481,12 +431,8 @@ def test_timeline_physical_size_post_gc(
    pageserver_http.timeline_checkpoint(env.initial_tenant, new_timeline_id)
    pageserver_http.timeline_gc(env.initial_tenant, new_timeline_id, gc_horizon=None)

-    if remote_storage_kind is not None:
-        wait_for_upload_queue_empty(env.pageserver, env.initial_tenant, new_timeline_id)
-
    assert_physical_size_invariants(
-        get_physical_size_values(env, env.initial_tenant, new_timeline_id, remote_storage_kind),
-        remote_storage_kind,
+        get_physical_size_values(env, env.initial_tenant, new_timeline_id)
    )


@@ -519,26 +465,26 @@ def test_timeline_size_metrics(

    # get the metrics and parse the metric for the current timeline's physical size
    metrics = env.pageserver.http_client().get_metrics()
-    tl_physical_size_metric = metrics.query_one(
-        name="pageserver_resident_physical_size",
-        filter={
-            "tenant_id": str(env.initial_tenant),
-            "timeline_id": str(new_timeline_id),
-        },
-    ).value
+    matches = re.search(
+        f'^pageserver_resident_physical_size{{tenant_id="{env.initial_tenant}",timeline_id="{new_timeline_id}"}} (\\S+)$',
+        metrics,
+        re.MULTILINE,
+    )
+    assert matches
+    tl_physical_size_metric = int(matches.group(1))

    # assert that the physical size metric matches the actual physical size on disk
    timeline_path = env.timeline_dir(env.initial_tenant, new_timeline_id)
    assert tl_physical_size_metric == get_timeline_dir_size(timeline_path)

    # Check that the logical size metric is sane, and matches
-    tl_logical_size_metric = metrics.query_one(
-        name="pageserver_current_logical_size",
-        filter={
-            "tenant_id": str(env.initial_tenant),
-            "timeline_id": str(new_timeline_id),
-        },
-    ).value
+    matches = re.search(
+        f'^pageserver_current_logical_size{{tenant_id="{env.initial_tenant}",timeline_id="{new_timeline_id}"}} (\\S+)$',
+        metrics,
+        re.MULTILINE,
+    )
+    assert matches
+    tl_logical_size_metric = int(matches.group(1))

    pgdatadir = test_output_dir / "pgdata-vanilla"
    pg_bin = PgBin(test_output_dir, pg_distrib_dir, pg_version)
@@ -570,29 +516,18 @@ def test_timeline_size_metrics(
    assert math.isclose(dbsize_sum, tl_logical_size_metric, abs_tol=2 * 1024 * 1024)


-@pytest.mark.parametrize("remote_storage_kind", [None, RemoteStorageKind.LOCAL_FS])
-def test_tenant_physical_size(
-    neon_env_builder: NeonEnvBuilder, remote_storage_kind: Optional[RemoteStorageKind]
-):
+def test_tenant_physical_size(neon_simple_env: NeonEnv):
    random.seed(100)

-    if remote_storage_kind is not None:
-        neon_env_builder.enable_remote_storage(
-            remote_storage_kind, "test_timeline_physical_size_init"
-        )
-
-    env = neon_env_builder.init_start()
-
+    env = neon_simple_env
    pageserver_http = env.pageserver.http_client()
    client = env.pageserver.http_client()

    tenant, timeline = env.neon_cli.create_tenant()
-    if remote_storage_kind is not None:
-        wait_for_upload_queue_empty(env.pageserver, tenant, timeline)

    def get_timeline_resident_physical_size(timeline: TimelineId):
-        sizes = get_physical_size_values(env, tenant, timeline, remote_storage_kind)
-        assert_physical_size_invariants(sizes, remote_storage_kind)
+        sizes = get_physical_size_values(env, tenant, timeline)
+        assert_physical_size_invariants(sizes)
        return sizes.prometheus_resident_physical

    timeline_total_resident_physical_size = get_timeline_resident_physical_size(timeline)
@@ -612,9 +547,6 @@ def test_tenant_physical_size(
        wait_for_last_flush_lsn(env, pg, tenant, timeline)
        pageserver_http.timeline_checkpoint(tenant, timeline)

-        if remote_storage_kind is not None:
-            wait_for_upload_queue_empty(env.pageserver, tenant, timeline)
-
        timeline_total_resident_physical_size += get_timeline_resident_physical_size(timeline)

        pg.stop()
@@ -632,39 +564,21 @@ def test_tenant_physical_size(

 class TimelinePhysicalSizeValues:
    api_current_physical: int
-    prometheus_resident_physical: float
-    prometheus_remote_physical: Optional[float] = None
+    prometheus_resident_physical: int
    python_timelinedir_layerfiles_physical: int
-    layer_map_file_size_sum: int


 def get_physical_size_values(
-    env: NeonEnv,
-    tenant_id: TenantId,
-    timeline_id: TimelineId,
-    remote_storage_kind: Optional[RemoteStorageKind],
+    env: NeonEnv, tenant_id: TenantId, timeline_id: TimelineId
 ) -> TimelinePhysicalSizeValues:
    res = TimelinePhysicalSizeValues()

    client = env.pageserver.http_client()

-    res.layer_map_file_size_sum = sum(
-        layer.layer_file_size or 0
-        for layer in client.layer_map_info(tenant_id, timeline_id).historic_layers
+    res.prometheus_resident_physical = client.get_timeline_metric(
+        tenant_id, timeline_id, "pageserver_resident_physical_size"
    )

-    metrics = client.get_metrics()
-    metrics_filter = {"tenant_id": str(tenant_id), "timeline_id": str(timeline_id)}
-    res.prometheus_resident_physical = metrics.query_one(
-        "pageserver_resident_physical_size", metrics_filter
-    ).value
-    if remote_storage_kind is not None:
-        res.prometheus_remote_physical = metrics.query_one(
-            "pageserver_remote_physical_size", metrics_filter
-        ).value
-    else:
-        res.prometheus_remote_physical = None
-
    detail = client.timeline_detail(
        tenant_id, timeline_id, include_timeline_dir_layer_file_size_sum=True
    )
@@ -676,20 +590,11 @@ def get_physical_size_values(
    return res


-def assert_physical_size_invariants(
-    sizes: TimelinePhysicalSizeValues, remote_storage_kind: Optional[RemoteStorageKind]
-):
+def assert_physical_size_invariants(sizes: TimelinePhysicalSizeValues):
    # resident phyiscal size is defined as
    assert sizes.python_timelinedir_layerfiles_physical == sizes.prometheus_resident_physical
-    assert sizes.python_timelinedir_layerfiles_physical == sizes.layer_map_file_size_sum
-
    # we don't do layer eviction, so, all layers are resident
    assert sizes.api_current_physical == sizes.prometheus_resident_physical
-    if remote_storage_kind is not None:
-        assert sizes.prometheus_resident_physical == sizes.prometheus_remote_physical
-        # XXX would be nice to assert layer file physical storage utilization here as well, but we can only do that for LocalFS
-    else:
-        assert sizes.prometheus_remote_physical is None


 # Timeline logical size initialization is an asynchronous background task that runs once,