chore(deps): update rust crate fs4 to v1

[renovate]

This PR contains the following updates:

Package	Type	Update	Change
fs4	workspace.dependencies	major	0.13.1 → 1.0.0

---

Warning

Some dependencies could not be looked up. Check the Dependency Dashboard for more information.

Cargo major update — Before merging, verify the workspace compiles and check upstream release notes for removed features or API changes.

---

Release Notes

al8n/fs4 (fs4)

v1.1.0

Changes

• Consolidate FileExt and AsyncFileExt into single crate-root traits
  (fs4::FileExt, fs4::AsyncFileExt) instead of generating a distinct
  trait per backend module. The per-backend modules (fs4::tokio,
  fs4::async_std, fs4::smol, fs4::fs_err2, fs4::fs_err3,
  fs4::fs_err2_tokio, fs4::fs_err3_tokio) now re-export the unified
  crate-root trait. Method-call sites that import the trait via use
  continue to compile unchanged; code that named two backend traits as
  distinct types will see them unify.
• Add blanket impls impl<F: FileExt + ?Sized> FileExt for &F and
  impl<F: AsyncFileExt + ?Sized> AsyncFileExt for &F, so the
  extension methods are now callable through shared references.
• Seal FileExt and AsyncFileExt via a private sealed::Sealed
  supertrait, so the set of implementing types is closed to the
  concrete file types fs4 already supports (and references to them).
  This locks in the freedom to add methods to either trait in future
  minor releases without breaking downstream impls.
• Add DynAsyncFileExt, an object-safe mirror of AsyncFileExt whose
  async methods return BoxFuture<'_, T> (alias for
  Pin<Box<dyn Future<Output = T> + Send + '_>>). Use it whenever
  type erasure is needed (Box<dyn DynAsyncFileExt>,
  &dyn DynAsyncFileExt); prefer the static AsyncFileExt for
  generic code since it has no allocation or dynamic-dispatch
  overhead. Every type implementing AsyncFileExt also implements
  DynAsyncFileExt, and the trait is sealed.
• Mark the delegating methods #[inline(always)] (skipped under
  tarpaulin coverage builds).

v1.0.1

Fixes

• Unix allocate: short-circuit on allocated blocks
  (metadata().blocks() * 512 >= len) instead of logical EOF. The
  previous metadata().len() >= len check silently turned allocate
  into a no-op on sparse files (logical length large, zero blocks
  reserved), violating the documented preallocation guarantee. The
  new check still skips the macOS F_PREALLOCATE re-allocate-ENOSPC
  path from #​15, since it asks the right question: "are the blocks
  already reserved?" Applies to both the sync and async
  implementations.
• Windows statvfs: route the three GetDiskFreeSpaceExW outputs
  correctly. free_space now comes from lpTotalNumberOfFreeBytes
  (volume-wide, quota-independent), available_space from
  lpFreeBytesAvailable (caller-scoped, honours per-user quotas),
  and total_space is computed from cluster math
  (sectors_per_cluster * bytes_per_sector * total_number_of_clusters)
  so it reports volume capacity rather than the caller's quota. On
  quota-enabled volumes the three fields now carry distinct,
  documented meanings; previously free_space and available_space
  were identical and total_space under-reported capacity.
• Added target_os = "fuchsia" to the Unix allocate fallocate
  branch (sync and async). Fuchsia is cfg(unix) under rustc and
  rustix exposes fallocate there, so the previous omission left
  the Fuchsia Unix build without an allocate symbol once FileExt
  was enabled. With this fix, every fs4 feature builds on Fuchsia
  except fs-err3 and fs-err3-tokio; those remain blocked on
  fs-err v3.3.0 referencing std::os::unix::fs::chroot, which
  rustc gates out on target_os = "fuchsia". The fs4 code no longer
  has a Fuchsia gap — the remaining one is upstream
  (andrewhickman/fs-err#90).

Testing

• New regression test allocate_reserves_blocks_on_sparse_file
  (sync and async, Linux-gated) creates a sparse file via set_len,
  asserts allocated_size == 0, calls allocate, and asserts
  blocks are reserved.

Documentation

• README gained a Minimum Supported Rust Version section noting
  that the crate's declared MSRV (rust-version = "1.75.0") covers
  the default sync feature, and that async-std / smol inherit
  a higher effective MSRV (1.85) from their transitive dependencies
  (async-lock, async-signal).

v1.0.0

Breakage

• Renamed FileExt::lock_exclusive / AsyncFileExt::lock_exclusive to
  lock, matching the stabilized [std::fs::File::lock] API.
• Renamed FileExt::try_lock_exclusive / AsyncFileExt::try_lock_exclusive
  to try_lock, matching [std::fs::File::try_lock].
• Changed the return type of try_lock and try_lock_shared from
  std::io::Result<bool> to Result<(), TryLockError>. Ok(()) still
  indicates the lock was acquired; Err(TryLockError::WouldBlock) now
  indicates the lock is held by another handle. This matches the stable
  [std::fs::File::try_lock] signature (Ok(false) was the nightly
  shape prior to 1.89).
• Removed the top-level lock_contended_error() helper. Use
  TryLockError::WouldBlock instead.
• Flattened the fs_std module: the FileExt trait for
  std::fs::File now lives at the crate root. Update imports from
  use fs4::fs_std::FileExt; to use fs4::FileExt;. All other
  backends (fs_err2, fs_err3, tokio, smol, async_std,
  fs_err2_tokio, fs_err3_tokio) remain nested, since each
  defines its own FileExt/AsyncFileExt over a different concrete
  File type.

Additions

• New fs4::TryLockError enum, mirroring [std::fs::TryLockError]
  with Error(io::Error) and WouldBlock variants. Implements
  Debug, Display, std::error::Error (with source() exposing
  the inner io::Error), From<io::Error> (kind WouldBlock
  collapses into the WouldBlock variant; everything else wraps into
  Error), and From<TryLockError> for io::Error (WouldBlock
  becomes io::Error::from(io::ErrorKind::WouldBlock); Error(inner)
  passes through verbatim).

Fixes

• Fixed feature typos that made the crate fail to compile with only
  fs-err2, fs-err3, fs-err2-tokio, or fs-err3-tokio enabled
  (without sync / tokio). #[cfg(feature = "fs-err")] and
  feature = "fs-err-tokio" both referenced feature names that do not
  exist in Cargo.toml.
• On Windows, skip the internal set_len call when the file's existing
  cluster-aligned allocation already covers len. Avoids the Windows
  buffered-I/O quirks observed when the end-of-file pointer is moved
  inside an already-allocated cluster (#​13). The trait doc now carves
  this behavior out from the general "file size is at least len
  bytes" contract.
• Short-circuited allocate on Unix when the file is already at least
  len bytes long. Fixes macOS fallocate spuriously returning
  ENOSPC when re-calling allocate(len) on an existing file (#​15).
• Added cygwin to the allocate target_os set so builds stop
  failing with a missing sys::allocate symbol on that target (#​44).
• Added redox and cygwin to the async allocate fallback branch
  so it matches the sync variant (#​43 follow-up).
• Moved AIX from the async fallocate branch to the set_len
  fallback branch, matching the sync implementation.
• Trait docs now explicitly state that locks are released
  automatically when the owning file handle is closed (#​23).
• Removed the stale trait-doc reference to non-existent cross-platform
  tests in lib.rs (#​16).
• Mitigated #​31 (compiler warning about name collisions with upcoming
  std methods): because 1.0 renames the trait methods to match std
  exactly, std::fs::File::lock / try_lock / unlock (stable in
  Rust 1.89+) now win via inherent dispatch and unstable_name_collisions
  no longer fires for std users on recent rustc.
• Gated the lock_impl! macro with #[allow(unused_macros)] so
  cargo clippy --no-default-features (filesystem-stats-only build)
  does not fail under -D warnings.
• Removed dead duplicate macros cfg_fs2_err / cfg_fs3_err from
  lib.rs (unified with cfg_fs_err2 / cfg_fs_err3).
• Updated html_root_url to the 1.0.0 docs.rs path.

Dependency updates

• Bumped windows-sys from 0.59 to 0.61.

Testing

• Removed all #[bench] functions from the test harness. They
  measured OS syscalls (flock, LockFileEx, fallocate, statvfs)
  rather than fs4 code, and produced numbers dominated by the
  underlying filesystem. Dropping them lets the crate build and test
  on stable Rust (the bench harness was the only thing pinning
  nightly via #![cfg_attr(test, feature(test))]).
  rust-toolchain.toml is now stable.
• Added regression tests:
  • allocate_preserves_eof_within_cluster — exercises the #​13
    precondition (cluster-aligned AllocationSize with EOF inside
    the cluster) and asserts EOF is not moved when allocate(len) is
    re-called with len <= allocated_size on Windows.
  • allocate_idempotent — exercises the #​15 precondition (back-to-back
    allocate(len) calls on macOS) to prevent a regression in the
    short-circuit.
  • Seven TryLockError unit tests covering variants, Display,
    std::error::Error::source, From<io::Error>, From<TryLockError> for io::Error, and round-trip preservation of ErrorKind.
  • FsStats getter + derive unit tests (previously every test
    destructured the struct, so the four getter method bodies were
    never executed and showed as uncovered).
• Fixed a long-standing macOS test failure: the cross-platform
  filesystem_space test asserted available_space <= free_space,
  which does not hold on macOS APFS. APFS counts purgeable space
  (snapshots, cached data reclaimable on demand) in f_bavail but
  not in f_bfree, so the POSIX invariant is violated on every run.
  The assertion is removed and the async variant now makes a single
  statvfs call plus destructure instead of three separate calls
  racing with concurrent filesystem activity from other tests.

CI / tooling

• New .github/workflows/coverage.yml workflow: per-OS matrix
  (ubuntu-latest, macos-latest, windows-latest) running
  cargo tarpaulin --engine llvm --all-features --run-types tests --ignore-tests on each runner and uploading per-OS reports to
  Codecov with per-OS flags. Each runner --exclude-files the other
  OS's sources so they do not register as 0/N uncovered lines.
• The cross job now installs the MinGW-w64 toolchain when targeting
  *-pc-windows-gnu. windows-sys 0.61 invokes dlltool during
  build, and ubuntu-latest ships only the x86_64 MinGW toolchain
  by default.
• README install snippets updated from fs4 = { version = "0.13", ... }
  to fs4 = { version = "1", ... }.
• Housekeeping: added .codecov.yml, rustfmt.toml (2-space indent,
  explains the session-wide reformat), and
  .github/workflows/loc.yml; removed the obsolete tea.yaml.

---

Configuration

📅 Schedule: (UTC)

• Branch creation
  • Between 12:00 AM and 03:59 AM, only on Monday (* 0-3 * * 1)
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 5b8201d4b0

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Preserve quota-based disk limits on Windows

This upgrade resolves to fs4 1.1.0, whose Windows total_space now reports the full volume capacity while available_space remains caller/quota-scoped. The retry queue still combines those two values in lib/saluki-io/src/net/util/retry/queue/persisted.rs::on_disk_bytes_limit as available_space - total_space * (1 - storage_max_disk_ratio), so on quota-enabled Windows volumes (for example a 10 GB quota on a 1 TB disk with the default 80% ratio) the reserved amount is based on 1 TB and the limit saturates to 0, preventing persistence even though the user has quota space available. The dependency bump needs either pinning before that behavior change or adjusting the limit calculation to use comparable quota/volume values.

Useful? React with 👍 / 👎.

[tobz]

Looking at this locally, I agree that using fs4 1.10 (really, 1.0.1 and later) would very likely break things on Windows when quotas were in use. Just to drive it home, laying it all out in sort of a "if this, then that" way with tabular data:

A 1 TB volume, with the agent's data directory on it. I'll use the default storage_max_disk_ratio = 0.8 (so the queue reserves the bottom 20% of "total" as headroom). Two physical situations:

• No quota: 512 GB actually free on the volume.
• Per-user quota on the agent's account: limit 160 GB, 32 GB already used → 128 GB free to the caller (and still 512 GB free volume-wide).

Raw Windows values in each situation:

(quoted field names abbreviated to better fit in a PR comment)

	FreeBytesAvailCaller	TotalNumBytes	TotalNumFreeBytes	Volume Size
No quota	512 GB	1000 GB	512 GB	1000 GB
Quota	128 GB	160 GB (= quota limit)	512 GB	1000 GB

How it flows through on_disk_bytes_limit

We calculate the following values:

• total = TotalNumBytes
• available = FreeBytesAvailCaller
• reserved = total * 0.2
• available_adj = (available_space − reserved).ceil()
• limit = min(max_on_disk_bytes, available_adj)

Case	total	available	reserved	available_adj	limit
A. No quota, 0.13.1	1000 GB	512 GB	200 GB	312 GB	312 GB ✅
B. No quota, 1.1.0	1000 GB	512 GB	200 GB	312 GB	312 GB ✅
C. Quota, 0.13.1	160 GB	128 GB	32 GB	96 GB	96 GB ✅
D. Quota, 1.1.0	1000 GB	128 GB	200 GB	−72 GB	0 ❌

Two takeaways from the table:

• No quota → no change. A vs. B are identical (312 GB). On a quota-free volume, TotalNumBytes already equals the full volume, so swapping it for cluster geometry changes nothing. This is why the bug is invisible on most Windows hosts and on all of Linux.
• Quota → regression. C (96 GB, scales sensibly to the quota) becomes D (0). The breakage is that reserved is now computed off the 1 TB physical disk (200 GB) while available is the 128 GB quota free — the reservation alone is bigger than the caller's entire free quota, so the subtraction goes negative and clamps to 0.

Forgive the clanker output being pasted verbatim, but it did a reasonable job explaining this succinctly.

[pr-commenter]

Binary Size Analysis (Agent Data Plane)

Baseline: 06d0a65 · Comparison: 498fcde · diff
Analysis Configuration: stripped binaries · Pass/Fail Threshold: +5%
Sizes: 38.01 MiB (baseline) vs 38.03 MiB (comparison)
Size Change: +12.55 KiB (+0.03%)

✅ Binary size difference within threshold

Changes by Module

Module	File Size	Symbols
figment	+11.78 KiB	686
tower	+4.85 KiB	327
saluki_io::deser::framing	+4.47 KiB	43
saluki_components::sources::dogstatsd	-4.01 KiB	337
anon.ae75cd3060d8b952a6fd466cba97c1c5.103.llvm.298110800033293764	-3.99 KiB	1
anon.52592df239d56a76307acb2ba83e4c2c.270.llvm.13298005866488041116	+3.99 KiB	1
anon.833b6a0935915f892603f5d7a9fc6534.220.llvm.18260048508852717064	-3.06 KiB	1
anon.541a332332572eb1770d6450dd728441.1.llvm.3647011001667702951	+3.05 KiB	1
anon.bb2ab94f3b5ea1d61d8504371d045475.1852.llvm.4675944216699713421	-2.55 KiB	1
anon.3a32d655b85d258e267800ab41772790.3.llvm.8166433902847694424	+2.55 KiB	1
[Unmapped]	-1.88 KiB	1
anon.fac4c6313aa5ade7b2cca691c7d50a61.239.llvm.7305213830500556523	+1.77 KiB	1
anon.1c0c55e0de89dc33cc41a50bdc4c5f32.239.llvm.443180845460807624	-1.77 KiB	1
anon.7e3a71ef325499b58f1a61a66c4a296b.7.llvm.11997505951469668062	-1.76 KiB	1
anon.2738ce2f00c5c8f4740961ebe5401aeb.1.llvm.5036317403232026154	+1.76 KiB	1
anon.f9fb8b64da5907c5fede69996ec2b13c.133.llvm.1493513854981006845	-1.52 KiB	1
anon.ea94449b2117046521eb59da9aa4aa1b.26.llvm.587556979796268436	+1.52 KiB	1
anon.5100a2c1b67a0f6892baf9f7395e9163.63.llvm.5709936899054390979	-1.50 KiB	1
anon.52592df239d56a76307acb2ba83e4c2c.44.llvm.13298005866488041116	+1.50 KiB	1
futures_util	-1.48 KiB	138

Detailed Symbol Changes

    FILE SIZE        VM SIZE    
 --------------  -------------- 
  [NEW]  +148Ki  [NEW]  +148Ki    agent_data_plane::cli::run::handle_run_command::_{{closure}}::hf15fce3240548925
  [NEW] +84.5Ki  [NEW] +84.3Ki    agent_data_plane::cli::dogstatsd::handle_dogstatsd_command::_{{closure}}::h1f663c1c0743a58c
  [NEW] +67.1Ki  [NEW] +66.9Ki    agent_data_plane::cli::run::create_topology::_{{closure}}::h9f8642533a86636d
  [NEW] +65.3Ki  [NEW] +65.1Ki    saluki_core::topology::built::BuiltTopology::spawn::_{{closure}}::h5c37e4c0a6d6da48
  [NEW] +57.9Ki  [NEW] +57.8Ki    saluki_core::topology::blueprint::TopologyBlueprint::build::_{{closure}}::h617bc373eb322009
  [NEW] +56.9Ki  [NEW] +56.7Ki    agent_data_plane::cli::debug::handle_debug_command::_{{closure}}::h8da1a092278a31dd
  [NEW] +55.7Ki  [NEW] +55.6Ki    core::ops::function::FnOnce::call_once::h6af6fbd829ad8fff
  [NEW] +49.3Ki  [NEW] +48.9Ki    agent_data_plane::main::_{{closure}}::h014649a0dfbaa605
  [NEW] +47.8Ki  [NEW] +47.7Ki    saluki_components::common::datadog::io::run_endpoint_io_loop::_{{closure}}::h2fbca47cfd3986e0
  [NEW] +38.4Ki  [NEW] +38.2Ki    agent_data_plane::internal::env::workload::build_collector::_{{closure}}::hb4d88bef1c84eb10
  +0.1% +12.8Ki  +0.1% +14.2Ki    [39408 Others]
  [DEL] -38.4Ki  [DEL] -38.2Ki    agent_data_plane::internal::env::workload::build_collector::_{{closure}}::h8518305f145d7e76
  [DEL] -48.1Ki  [DEL] -47.9Ki    saluki_components::common::datadog::io::run_endpoint_io_loop::_{{closure}}::h6760b52a19241012
  [DEL] -49.3Ki  [DEL] -48.9Ki    agent_data_plane::main::_{{closure}}::hf71541579e01974b
  [DEL] -55.7Ki  [DEL] -55.6Ki    core::ops::function::FnOnce::call_once::h5866b2464ddf0637
  [DEL] -56.9Ki  [DEL] -56.7Ki    agent_data_plane::cli::debug::handle_debug_command::_{{closure}}::hbd804be8c7f9a296
  [DEL] -57.9Ki  [DEL] -57.8Ki    saluki_core::topology::blueprint::TopologyBlueprint::build::_{{closure}}::hbf871b3913e42c66
  [DEL] -65.3Ki  [DEL] -65.1Ki    saluki_core::topology::built::BuiltTopology::spawn::_{{closure}}::he1098066cae96b1f
  [DEL] -67.1Ki  [DEL] -66.9Ki    agent_data_plane::cli::run::create_topology::_{{closure}}::h9f7e26f20fddfdc1
  [DEL] -84.5Ki  [DEL] -84.3Ki    agent_data_plane::cli::dogstatsd::handle_dogstatsd_command::_{{closure}}::h995e90a0721b5a8b
  [DEL]  -148Ki  [DEL]  -148Ki    agent_data_plane::cli::run::handle_run_command::_{{closure}}::h0215ea3520b410a0
  +0.0% +12.5Ki  +0.0% +13.9Ki    TOTAL

[pr-commenter]

Regression Detector (Agent Data Plane)

Run ID: 598858d2-66d0-4e5d-a835-f3007e66f0fa
Baseline: 06d0a651 · Comparison: 498fcde5 · diff

Optimization Goals: ✅ No significant changes detected

Fine details of change detection per experiment (35)

Experiments configured erratic: true are tagged (ignored) and skipped when determining which experiments regressed or improved. Experiments which are detected as erratic at runtime are tagged (erratic) to flag that the run's sample dispersion was high, but their regression / improvement signal still counts.

experiment	goal	Δ mean %	links
dsd_uds_1mb_3k_contexts_cpu (erratic)	cpu	⚪ +5.09	metrics profiles logs
otlp_ingest_metrics_5mb_memory	memory	⚪ +1.83	metrics profiles logs
dsd_uds_100mb_3k_contexts_cpu (erratic)	cpu	⚪ +0.50	metrics profiles logs
quality_gates_rss_dsd_heavy	memory	⚪ +0.35	metrics profiles logs
dsd_uds_1mb_3k_contexts_memory	memory	⚪ +0.30	metrics profiles logs
otlp_ingest_logs_5mb_cpu (ignored)	cpu	⚪ +0.29	metrics profiles logs
quality_gates_rss_idle	memory	⚪ +0.21	metrics profiles logs
dsd_uds_10mb_3k_contexts_memory	memory	⚪ +0.20	metrics profiles logs
otlp_ingest_traces_5mb_throughput	throughput	⚪ -0.19	metrics profiles logs
otlp_ingest_traces_ottl_transform_5mb_throughput	throughput	⚪ -0.14	metrics profiles logs
dsd_uds_512kb_3k_contexts_memory	memory	⚪ +0.11	metrics profiles logs
dsd_uds_100mb_3k_contexts_memory	memory	⚪ +0.10	metrics profiles logs
dsd_uds_500mb_3k_contexts_cpu (erratic)	cpu	⚪ +0.06	metrics profiles logs
otlp_ingest_traces_ottl_transform_5mb_memory	memory	⚪ +0.03	metrics profiles logs
otlp_ingest_metrics_5mb_throughput	throughput	⚪ -0.02	metrics profiles logs
otlp_ingest_traces_5mb_memory	memory	⚪ +0.01	metrics profiles logs
dsd_uds_1mb_3k_contexts_throughput	throughput	⚪ -0.00	metrics profiles logs
dsd_uds_10mb_3k_contexts_throughput	throughput	⚪ -0.00	metrics profiles logs
dsd_uds_100mb_3k_contexts_throughput	throughput	⚪ +0.00	metrics profiles logs
dsd_uds_512kb_3k_contexts_throughput	throughput	⚪ +0.00	metrics profiles logs
otlp_ingest_logs_5mb_throughput (ignored)	throughput	⚪ +0.02	metrics profiles logs
otlp_ingest_traces_ottl_filtering_5mb_memory	memory	⚪ -0.02	metrics profiles logs
otlp_ingest_metrics_5mb_cpu (erratic)	cpu	⚪ -0.03	metrics profiles logs
quality_gates_rss_dsd_ultraheavy	memory	⚪ -0.03	metrics profiles logs
otlp_ingest_traces_ottl_filtering_5mb_throughput	throughput	⚪ +0.09	metrics profiles logs
otlp_ingest_traces_ottl_transform_5mb_cpu (erratic)	cpu	⚪ -0.15	metrics profiles logs
quality_gates_rss_dsd_low	memory	⚪ -0.17	metrics profiles logs
dsd_uds_500mb_3k_contexts_memory	memory	⚪ -0.18	metrics profiles logs
quality_gates_rss_dsd_medium	memory	⚪ -0.32	metrics profiles logs
dsd_uds_500mb_3k_contexts_throughput	throughput	⚪ +0.68	metrics profiles logs
otlp_ingest_traces_ottl_filtering_5mb_cpu (erratic)	cpu	⚪ -0.77	metrics profiles logs
otlp_ingest_traces_5mb_cpu (erratic)	cpu	⚪ -0.84	metrics profiles logs
dsd_uds_512kb_3k_contexts_cpu (erratic)	cpu	⚪ -2.91	metrics profiles logs
dsd_uds_10mb_3k_contexts_cpu (erratic)	cpu	🟢 -5.41	metrics profiles logs
otlp_ingest_logs_5mb_memory (ignored)	memory	⚪ -5.45	metrics profiles logs

Bounds Checks: ✅ Passed (5)

experiment	check	replicates	observed	links
quality_gates_rss_dsd_heavy	memory_usage	10/10	✅ 124 MiB ≤ 140 MiB	metrics profiles logs
quality_gates_rss_dsd_low	memory_usage	10/10	✅ 39.5 MiB ≤ 50 MiB	metrics profiles logs
quality_gates_rss_dsd_medium	memory_usage	10/10	✅ 60 MiB ≤ 75 MiB	metrics profiles logs
quality_gates_rss_dsd_ultraheavy	memory_usage	10/10	✅ 186 MiB ≤ 200 MiB	metrics profiles logs
quality_gates_rss_idle	memory_usage	10/10	✅ 26.7 MiB ≤ 40 MiB	metrics profiles logs

Explanation

A change is flagged as a regression when |Δ mean %| > 5.00% in the regressing direction for its optimization goal AND SMP marks the experiment as a regression (is_regression: true). Improvements use the matching criteria for the improving direction. Experiments configured erratic: true (tagged (ignored)) are skipped outright; experiments detected as erratic at runtime (tagged (erratic)) still count, since that flag describes sample dispersion rather than directional certainty. The Δ mean % cell is colored accordingly: 🟢 = improvement, 🔴 = regression, ⚪ = neutral. Reduction in CPU or memory is an improvement; reduction in ingress throughput is a regression.

[renovate]

Edited/Blocked Notification

Renovate will not automatically rebase this PR, because it does not recognize the last commit author and assumes somebody else may have edited the PR.

You can manually request rebase by checking the rebase/retry box above.

⚠️ Warning: custom changes will be lost.

[tobz]

Based on my comment on Codex's review, my recommendation is that we do not merge this change as-is.

It seems like we'll need to either try and submit an upstream change to expose the additional information we need to calculate quota-aware disk usage, or roll our own thin wrapper to do it. Looking at the Datadog Agent's approach for calculating this, it does use the quota-aware measurements for both available and "total" space, so this would be a regression both in terms of matching the Datadog Agent and in the general sense of what Codex identified.