Davis Rollman
90d · built 2026-11-06
Performance
What Davis Rollman shipped in the selected window, measured in ETV, and how it compares with the 90 days before it.
Effective capacity
+167.2engineers
delivers like 168.2 (168.2x pre-AI)
Output (ETV)
40.4ETV
+284.0% vs 10.5 prior
Features share
21.4%
−61.3 pp vs prior window
Fixes share
2.8%
−1.9 pp vs prior window
Work mix
21.4% Features7.9% Maintenance67% Tests0.9% Docs2.8% Fixes
134 commits over 90 days, ending 2026-11-06.
Daily performance
Daily ETV, stacked by Features, Maintenance, Tests, Docs and Fixes.
Repository spread
Where this developer's commits land. Concentrated work (top1 > 80%) vs polymath spread (top1 < 30%).
Most impactful commits
Top 10 by ETV in the last 90 days.
- 18.4ETVtests/core: pytest → python_unittest Summary: # Stack Context pytest is unsupported at Meta. The buck2 e2e test harness (`fbcode/buck2/tests/e2e_util`, used through `buck_e2e.bzl`) ran its ~500 test modules as `python_pytest` targets. This stack moves the harness and every module on it to `python_unittest`, then deletes the pytest support: a harness that runs tests as `unittest` methods (D124484084), the modules converted in four groups (D124484085 `tests/core`, D124484086 the rest of `buck2/tests`, D124484087 the agentcloud guards, D124484088 everything else), and the removal of the pytest path (D124487800). Test bodies are untouched; test ids change from `test_x.py::test_y[case]` to `pkg.test_x.XTest.test_y_case`. `buck2_core_tests` makes `python_unittest`s, and the 322 modules under `tests/core` are converted with `tools/pytest_to_unittest`: each module's tests move into a `<Module>Test(BuckTestCase)` class and gain `self`; `pytest.mark.parametrize`/`pytest.param` → `parametrize`/`param`; `pytest.raises` → `self.assertRaises` (`assertRaisesRegex` for `match=`, `.value` → `.exception`); `pytest.skip` → `self.skipTest`; `pytest.mark.xfail` → `unittest.expectedFailure`. Done by hand: - Modules that generated tests with `globals()[name] = ...` (`build/test_build_report*.py`, `build/test_artifact_path_sketch.py`, `build/test_build_modifiers_report.py`, `completion/*`, `errors/test_command_report.py`, `errors/test_formatting.py`, `test/test_build_report.py`, `test/test_modifiers.py`): the factory returns the decorated method and the class body assigns it, `test_x = build_report_test("test_x", [...])`. `completion_test` is one method parametrized over the shells; a scenario with a bash-specific expectation gets a `test_x_bash` attribute beside `test_x`, so the test ids stay what they were. - `build/actions/test_http_proxy_env.py`: the autouse `monkeypatch` fixture is a `setUp` that patches `os.environ`. - `build/test_artifact_path_sketch.py`, `build/test_detailed_aggregated_metrics.py`: `pytest.approx` → `helper.utils.approx`. - `build/test_modify.py`: `test_modify_genrule_notify` called `test_modify_genrule`; the shared body is a helper. - `docs/test_docs.py`: `test_docs_fail_with_invalid_patterns` was `xfail`ed in 2022 and passes today; `expectedFailure` would fail it for passing, so the mark is gone. Test ids change shape (see the stack context), so test history and by-name disablement start over. A bare `assert` loses pytest's operand introspection: a failure prints `AssertionError` alone unless the assert carries a message. Reviewed By: IanChilds Differential Revision: D124484085 fbshipit-source-id: 3110efb82913b75e1b919d54168e93dc3440c29dgithub.com-facebook-buck2 · ff8610e8 · 2026-10-21
- 6.1ETVtests/e2e, tests/meta_only, the bxl_test and check_dependencies_test templates: pytest → python_unittest Summary: # Stack Context pytest is unsupported at Meta. The buck2 e2e test harness (`fbcode/buck2/tests/e2e_util`, used through `buck_e2e.bzl`) ran its ~500 test modules as `python_pytest` targets. This stack moves the harness and every module on it to `python_unittest`, then deletes the pytest support: a harness that runs tests as `unittest` methods (D124484084), the modules converted in four groups (D124484085 `tests/core`, D124484086 the rest of `buck2/tests`, D124484087 the agentcloud guards, D124484088 everything else), and the removal of the pytest path (D124487800). Test bodies are untouched; test ids change from `test_x.py::test_y[case]` to `pkg.test_x.XTest.test_y_case`. The rest of the modules under `buck2/tests` (115: `e2e`, `meta_only`, `select_type_params`, and the two `e2e_util` templates behind `bxl_test` and `check_dependencies_test`) are converted with `tools/pytest_to_unittest`, as `tests/core` was. The `buck2_e2e_test.use_unittest` package value in `buck2/tests/PACKAGE` switches every `buck2_e2e_test` under it to `python_unittest`. `bxl_test` and `check_dependencies_test` pass `use_unittest = True` themselves, since their template modules are the converted ones whichever package the target lives in. Users of `buck_e2e.bzl` outside `buck2/tests` stay on pytest until D124484088. Done by hand: - `e2e_util/test_bxl_check_dependencies_template.py`: the three flavors' list-argument helpers are one module-level `pass_list_arg`, so the `if FLAVOR == ...` chain in the class body holds tests only. - `e2e/test/test_testname_formatting.py`: the test was `testname_formatting` (collected on the `test` prefix); it is `test_name_formatting`, and its dead `pytest.xfail` branch is a `skipTest`. - `meta_only/e2e/rules/cxx/test_cxx.py`: `cxx_link_test` wrote a test per target into `globals()` from a loop; it is one method parametrized over the targets. - `meta_only/e2e/rules/link_groups/test_link_groups.py`: `pytest.param` in module-level lists. `meta_only/e2e/rules/nodejs/test_nodejs.py`: `pytest.fail` in a helper. Reviewed By: IanChilds Differential Revision: D124484086 fbshipit-source-id: 21c9bcc0ced3ab8a69bbb09a59d9a05bf070c6a1github.com-facebook-buck2 · 1ea7bf67 · 2026-10-21
- 5.1ETVtests: Add a Rust harness for e2e tests Summary: # Stack Context buck2's e2e tests are Python, on a harness (`tests/e2e_util`) that mostly reimplements in Python what Rust already has, and they don't run in the open source build. This stack adds a Rust harness next to the Python one and moves the tests over to it a directory at a time, improving the harness as the tests need. # This diff `tests/e2e_util/rust` is the harness. A test module is `test_foo.rs` next to its `test_foo_data`, as with Python, and each test is an `async fn` marked `#[buck_test(...)]`: ``` #[buck_test(data_dir = "sub")] async fn test_bad_target(buck: &Buck) -> anyhow::Result<()> { buck.build(&["//:good"]).await?; buck.build(&["//:bad"]) .await .expect_failure() .assert_stderr_matches("Error running analysis"); Ok(()) } ``` - The options of `#[buck_test]` are those of `buck_test()`, and a test gets the same project, environment and buckconfig as a Python test would. - A failed command is an `Err` carrying the command line, stdout and stderr, so `?` reports it in full, and `expect_failure()` turns the expectation around. A command can also be started and waited for later. - When a test fails, by an error or a panic, the harness stops its daemon and deletes its project, as Python's `finally` did. Rust tests here abort on a panic, so a panic hook does that part. - After a passed test, the harness fails an isolated test whose daemon panicked at any point unless it sets `allow_daemon_panics = true`, as Python does since D129123674. - `buck2_e2e::json::Json` is JSON as Python's `json` reads and writes it, keys in their order and `dumps` taking `json.dumps`'s `indent` and `sort_keys`, for the golden files Python tests wrote: the harness's `serde_json` sorts keys. - Golden files and their sanitizers, the event log and streaming build report helpers, and the HTTP server for download tests are ported as they are. Where Python and Rust differ (`re` vs `regex`, `splitlines`, exit codes of signals), the harness keeps Python's meaning. `buck_e2e_test` makes a `rust_unittest` when its `srcs` are Rust, and `buck2_core_tests` picks up `test_*.rs` as it does `test_*.py`. A Rust test starts in the project root with paths relative to it, so the macro tells the harness which of its variables are paths to make absolute. Like the tests, the harness builds with buck only: no Cargo manifests. Most tests outside `tests/core` run inplace: in the repository itself, with an isolation dir of their own per test case, rather than in a copy of their test data. The harness runs them as the Python one does, from the root of the test target's cell. A Rust test starts in the project root rather than in that cell, so `buck_e2e_test` names the cell and the harness finds its path in the repository's `.buckconfig`. The isolation dir is named after the test target and case, as with Python, so that what the test builds has the same action cache keys on every machine, and inplace tests keep soft errors soft (`BUCK2_HARD_ERROR=false`): they build the repository's own targets. A test that copies its test data can also have a copy of the prelude (`PRELUDE`) and of the toolchain platform cells (`OVR_CONFIG`) put in its project. ___ landed-with-radar-review Differential Revision: D129372986 fbshipit-source-id: 84510ef5a47fb96b1b22553ea8825c2b3c872af1github.com-facebook-buck2 · 6e3b2e3c · 2026-11-05
- 1.3ETVe2e harness: `BuckTestCase`, `buck_test` as a method decorator, `parametrize` Summary: # Stack Context pytest is unsupported at Meta. The buck2 e2e test harness (`fbcode/buck2/tests/e2e_util`, used through `buck_e2e.bzl`) ran its ~500 test modules as `python_pytest` targets. This stack moves the harness and every module on it to `python_unittest`, then deletes the pytest support: a harness that runs tests as `unittest` methods (D124484084), the modules converted in four groups (D124484085 `tests/core`, D124484086 the rest of `buck2/tests`, D124484087 the agentcloud guards, D124484088 everything else), and the removal of the pytest path (D124487800). Test bodies are untouched; test ids change from `test_x.py::test_y[case]` to `pkg.test_x.XTest.test_y_case`. The harness learns to run tests as `python_unittest`s. Nothing changes for the pytest modules yet. - A test module becomes a `BuckTestCase` subclass (an `IsolatedAsyncioTestCase`); its tests are `async def test_*(self, buck: Buck, ...)` methods. - `buck_test(...)` on a method does what the pytest `buck` fixture did: runs the method with a `Buck` on a fresh daemon, and a fresh `tmp_path` when the method takes one. `env`, `nobuckd` and `windows_cmd_option` work as before. A sync method that takes neither is left alone, so `buck_test(skip_for_os=...)` still works on a plain `unittest.TestCase`. - `parametrize(argnames, argvalues, ids=)` and `param(..., id=)` replace `pytest.mark.parametrize`/`pytest.param` with the same arguments. `BuckTestCase` expands a parametrized method into one `test_x_<id>` method per case when the class is created; stacked decorators run the product, innermost first, as pytest did; an empty `argvalues` leaves one skipping test. - `expect_failure` no longer needs `pytest.raises`; `helper.utils.approx` replaces `pytest.approx`. `buck_fixture` takes the test id for its isolation prefix instead of reading `PYTEST_CURRENT_TEST`. - `buck_e2e_test(use_unittest = True)` / `buck2_e2e_test(use_unittest = True)` make a `python_unittest`. Static listing is off for them: it reads names off the source and would miss the expanded parametrized cases. - `tools/pytest_to_unittest` is the libcst codemod the later diffs use: it wraps a module's tests into the class, adds `self`, and rewrites the pytest marks and `pytest.raises`/`fail`/`skip`; what it cannot handle it reports. ___ landed-with-radar-review Differential Revision: D124484084 fbshipit-source-id: c3bf98ed909f336d3cd4feb0a3e70952a261208fgithub.com-facebook-buck2 · d6080da2 · 2026-10-20
- 0.5ETVReport every buck1 #flavor use by category, with a fix hint Summary: # Stack Context Buck2 still accepts buck1 `//pkg:target#flavor` labels through a compatibility shim that maps a few known flavors to subtargets and drops platform flavors. This stack rewrites every remaining use in fbsource to the buck2 spelling, then makes `#flavor` a hard error and deletes the shim. # This diff Today the shim logs one soft error (`platform_flavor`) that names only `name#flavor`, so the remaining usages cannot be attributed or fixed from logs. The mapping is unchanged; the reporting is split into three categories (`platform_flavor`, `legacy_flavor_subtarget`, `legacy_flavor_unrecognized`), given a low-cardinality logview key, and the message now carries the full label and the replacement to write (`[shared]`, "remove it", or "unsupported"). New e2e test `test_buck1_flavors.py` covers each category. Nothing is user-visible yet: the new categories are quiet. Reviewed By: IanChilds Differential Revision: D124524381 fbshipit-source-id: a5e18b8ba6796902d4a0108b182a0714885d7f3cgithub.com-facebook-buck2 · 306178c4 · 2026-10-16
- 0.4ETVChunk stdout partial results so a huge package can't kill the stream Summary: `buck2 targets --streaming` formats each package into one `String` and writes it with a single `write_all`. `StdoutPartialOutput` wraps a 16 KiB `BufWriter`, but `BufWriter` passes writes larger than its capacity straight through, so `WriterWrapper::write` turned the whole package into a single `StdoutBytes` partial result, i.e. a single gRPC message. tonic allows messages up to 4 GiB and buck2 raises its configurable limits to `usize::MAX`, but `h2` refuses to send a single DATA payload of 2^31-1 bytes or more (`UserError::PayloadTooBig`). hyper propagates that error out of its body-sending future, which drops the `SendStream`, and h2 then sends `RST_STREAM(CANCEL)`. The client sees only `Reset(StreamId(3), CANCEL, Remote)` / "Buck daemon event bus encountered an error" and the daemon logs nothing. `--keep-going` can't help because the failure is in the transport after evaluation already succeeded. This is what broke the BTD v1 base-graph jobs once `fbcode//pyper_models/tp4fb/ads:` crossed ~2 GiB of JSON output (S715091, T291606076). Fix: cap each `StdoutBytes` emitted by `WriterWrapper::write` at 16 MiB, returning a short write so `write_all` loops. The existing `BUCK2_DEBUG_RAWOUTPUT_CHUNK_SIZE` override is shared with the stderr writer (whose 1 MiB default is unchanged) so tests can force tiny chunks on both paths. 16 MiB rather than 1 MiB because jemalloc returns allocations at or above its 8 MiB `oversize_threshold` to the OS immediately on free; see the test plan for the measurements behind that choice. This fixes every command that writes through `StdoutPartialOutput` (targets, uquery/cquery/aquery, audit, starlark, bxl, ...), and as a side effect the client no longer has to buffer a whole package's output as one message (client peak RSS on `targets --streaming fbcode//folly/...` drops from ~4 GiB to ~0.5 GiB). Reviewed By: Wilfred, mzlee Differential Revision: D123515148 fbshipit-source-id: 4d61af5d03194206cf9de5b84536d3d8f90d186dgithub.com-facebook-buck2 · 854459d1 · 2026-10-07
- 0.4ETVSkip unselected GNU distributed ThinLTO backends Summary: A ThinLTO link in Buck is three kinds of actions. For `fbcode//mcrouter:mcrouter` in `mode/opt-clang-thinlto`: - `thin_lto_index_executable` (1 per binary): the planner runs `clang++ ... -Wl,--thinlto-index-only`. LLD does symbol resolution over all 19,759 bitcode inputs, writes `<obj>.thinlto.bc` + `<obj>.imports` for each, and `index`, the list of modules it actually linked. - `thin_lto_opt_object_executable <obj>` / `thin_lto_opt_archive_executable <member>` (1 per bitcode module): `clang++ -x ir -fthinlto-index=<obj>.thinlto.bc -c <obj>` on RE. - `thin_lto_link_executable` (1 per binary): `clang++ mcrouter.final_link_index`. fbcode links non-`link_whole` libraries as `--start-lib`/`--end-lib` object lists, so LLD only pulls in objects that resolve a symbol. For the rest it still writes an empty `.imports` and a 136-byte `.thinlto.bc` stub carrying only the "skip" flag, and leaves them out of `index`. The planner treated "has an imports file" as "needs a backend", so those got backends too: clang saw the skip flag and emitted an empty object that `final_link_index` never referenced. Example: `libACL_CHECKER_BYPASS-cpp2-types.a` contributes six objects. mcrouter uses `_constants`, `_data`, `_types` and `_types_serialization`, so LLD links those four. `_types_binary` and `_types_compact` (the binary/compact protocol serializers) are unused, stay lazy, and used to get a backend each for nothing. In mcrouter that is 7,144 of 18,280 direct objects (mostly thrift `gen-cpp2`) plus 416 rlib members: 38% of the backends, 1.2 RE-hours and 1.5 TB of input materialization per link. adfinder: 27,226 of 81,298, 2.9 RE-hours and 8.5 TB per link. Now the planner marks every module not in `index` as `skip_backend`. Skipped direct objects get their `.opt.o` bound to an empty file (as machine-code objects already did); skipped archive members are dropped from the archive's manifest. The planner fails loudly where LLD's output contradicts the model, including the zero-byte index LLD writes for `-flto` (non-thin) bitcode, which previously vanished from the link silently. mcrouter: 12,199 backends instead of 19,759, byte-identical post-BOLT binary. adfinder: 54,072 instead of 81,298, byte-identical final link index. Part of the duplicated-actions cleanup from [Callum's post](https://fb.workplace.com/groups/200907040536486/permalink/2078585026102002/). Reviewed By: christycylee Differential Revision: D113627766 fbshipit-source-id: 342368303839dfa3de30e88a42e5c6f901ba13d9github.com-facebook-buck2 · 45333827 · 2026-11-03
- 0.4ETVoss: fmt.py formats Rust and Starlark as arc f does Summary: Stack goal: let GitHub contributors format buck2's Rust and Starlark exactly as `arc f` does, so imported pull requests no longer need to be commandeered and reformatted. This diff is the script and the GitHub check; the configerator diff D125022466 exports its config inputs, and the next two diffs mirror the check internally. Pull requests arrive formatted by whatever the contributor had, so the importer commandeers each diff and runs `arc f`. `python3 fmt.py` does the Rust and Starlark part of that formatting on GitHub, and the new "Format" workflow checks it on every pull request. Rust goes through the nightly `rustfmt` that `RUSTFMT` pins (`.rustfmt-version`, now exported next to `rust-toolchain.toml`), installed through `rustup` on first use; `cargo fmt` would use the toolchain's `rustfmt`, a different version. `rustfmt.toml` gains the one setting (`format_code_in_doc_comments`) the lint engine's `tools/rust/ossconfigs/rustfmt.toml` had and this copy did not. Starlark goes through `tools/starlark_fmt`, built from the tree with `cargo`, with the lint engine's config, which the export now carries to `tools/starlark_fmt/config.json`. File selection and the `generated`/`nolint`/`lint-ignore-every` skips mirror the `RUSTFMT` and `BUCKFORMAT` rulesets. The export rewrites `oss-disable`/`oss-enable` lines (`X # oss-disable` -> `# oss-disable[end= ]: X`), and the formatters do not know the rewritten shape: run on the export directly, `starlark_fmt` wants to change 42 files that are clean internally. So each file is formatted in its internal form -- the rewrite undone (a port of codesync's `ConditionalLinesFilterMutator`), formatted, redone -- which makes the result exactly what the file will be once imported and formatted here. `--check` prints a unified diff and the command to fix it. The check is its own workflow: it is independent of the build and takes about a minute, so it fails fast. Needs the configerator diff that exports `.rustfmt-version` and `tools/starlark_fmt/config.json` to land first (the mapping is in `opensource/shipit_config/facebook/buck2.cconf`), plus ShipIt's fixup for the two files it then lists; until then the "Format" check fails with "`tools/starlark_fmt/config.json` is missing". Reviewed By: ndmitchell Differential Revision: D125022522 fbshipit-source-id: fba89436a395adc0e92c3a1fb92e21749401bf86github.com-facebook-buck2 · 3b19b417 · 2026-10-20
- 0.3ETVReference registered static heaps by StaticHeapId Summary: ## Problem The OSS `linux-build-and-test` job fails on `pagable::tests::test_globals_roundtrip`: ``` cannot serialize the inner value of a PartialPagableArc backed by DataKey(..) ``` The failure is test-order dependent. `test_bcinstrs_def_round_trip_via_module` pages a module graph through real storage; that graph transitively references the process-wide `REGISTER_LIST_STATICS` static heap, and `page_out_item` stamps a `DataKey` on its shared `PartialPagableArc`. Any later inline (testing-serializer) serialization of a graph referencing the same static heap — `test_globals_roundtrip` reaches it via `register_list` — then fails in `serialize_inner`, which refuses stamped arcs. Whether CI hits it depends purely on thread interleaving, which is why it reproduces on the 4-core CI runner (and locally with `--test-threads=4` or `=1`) but not on wide devservers. The deeper issue: paging a static heap's body is dead weight. Every value allocated in a `globals_static!` / `methods_static!` heap already serializes as a `StaticValueId` and resolves to the live value on page-in, so the paged body is never consulted — but paging it mutates process-wide state (`DataKey` stamp) that couples otherwise independent serialization consumers, and page-in reconstructs a shadow copy that can collide with the live heap under the same `HeapRefId` in a deser scope. ## Fix Complete the static-value design at the heap level: `FrozenHeapRef` gains a wire tag, and references to heaps registered through `StaticHeapEntry` serialize as a dense `StaticHeapId` (tag 2) instead of going through the pagable arc mechanism. Ids are assigned by enumerating the `StaticHeapEntry` inventory in deterministic (file, line) order — the same same-binary index-order assumption `StaticValueId` already makes — so serializer and deserializer in the same binary always agree. Deserialization resolves the id back to the live heap and publishes its graph in the deser scope. Static heaps are therefore never paged, never stamped, and never shadow-copied. Heap names cannot serve as the reference (and `HeapRefId` is a name hash): distinct static heaps can legally share a name — every `#[starlark_module]` expands to a `globals_static!` named `<module_path>::<FN>_STATICS`, so two function-local `fn module` helpers in one file collide. Registration-site ids sidestep the ambiguity entirely, so every static heap — same-named or not — takes the by-id path. (V1 of this diff referenced heaps by name and had to leave same-named heaps on the paged-arc path; this follows nero's suggestion to mirror the `StaticValueId` scheme instead.) The `FrozenHeapRef` wire format change (bool → tag byte) invalidates previously paged data; paged storage is a same-binary cache, matching the existing `StaticValueId` index-order assumption. ## Attribution The stamp-then-refuse symptom dates to D114793220; the same test pair previously failed with "Frozen heap is already registered with a different StarlarkSerState" at least back to D114793219. The colliding test arrived in D108842734. The Aug 18 landings only shifted CI thread scheduling enough to surface it. Reviewed By: Nero5023 Differential Revision: D116795644 fbshipit-source-id: 7e2414c538e0f0eed0269b6a376d761c2e6af928github.com-facebook-buck2 · b4689ca0 · 2026-08-22
- 0.3ETVdaemon: Test that a command reports its result exactly once Summary: The 2026-11-02 buck2 bump (D129074969) was fast reverted because daemons were panicking in `ChannelEventSink::send` at the end of ordinary commands: the task monitor that D123711955 added to `streaming` sent a second `CommandResult` after the command had sent its own. A client that receives its result and closes its stream cancels the command's task, and a task whose body completes in the same poll in which the cancel arrives still resolves as cancelled, so the monitor took a completed command for a stopped one. `pump_events` had already exited at the first result, and the sink panics on a control event that has no receiver. D128172115 fixed it by reporting from a guard that the body disarms before the task resolves, and D129150231 stopped the sink from panicking. The rule underneath is that `streaming` dispatches exactly one `CommandResult` per command, whatever the interleaving of its completion and its cancellation: the client reads one, and a second is a soft error in production and a panic under the hard errors the tests run with. This adds unit tests for that rule across the interleavings: a plain completion; a client disconnect inside the poll that reports, both after and before the body has sent its result; a client disconnect while the body is pending; a tenant eviction while the body is pending; and a command admitted after its tenant was evicted. The tests run `streaming` itself, with a recording sink in front of the channel the client reads from, hold the reporting poll open with a blocking receive so that the cancel lands deterministically, and wait for every holder of the dispatcher to go before counting what was dispatched. Those two tests also pin what D128172115's guard relies on: nothing may await between the body's `command_result` and the guard being disarmed, or a cancel at that await drops the body before it disarms and the guard reports a second time. Without D128172115, the two tests where the cancel lands in the reporting poll fail: one records a second result, `Tenant command stopped: Cancelled`, beside the body's; the other hits the production panic itself, `failed to send control event to ChannelEventSink: sending on a disconnected channel`. ___ landed-with-radar-review Differential Revision: D129106102 fbshipit-source-id: 9857f344492ddf4b79d6bbb44a5dac5f96e7dd96github.com-facebook-buck2 · 3962ba84 · 2026-11-03