Aishwarya Sivaraman

This commit introduces a **versioning mechanism** to control the rollout of **cgroup functionality** for the Buck2 daemon. It adds a `DAEMON_CGROUP_VERSION` constant and modifies `ResourceControlConfig::from_config` in `app/buck2_common/src/init.rs` to enable daemon cgroup wrapping based on a version gate. This **new capability** allows for a controlled, staged deployment of resource control features, preventing immediate, widespread impact. Comprehensive **Python tests** have been added to the `tests/core/resource_control` subsystem to verify the correct behavior of this version gating logic.

This commit introduces a **fix** within the **`buck2_resource_control`** module to enhance error reporting during **daemon spawning**. It adds a **soft error log** when the resource control system, configured as `IfAvailable`, encounters an error (e.g., a cgroup failure) while attempting to create a daemon spawn command in `spawn_daemon.rs`. This change ensures that potential issues with **resource control** setup are no longer silently ignored, providing crucial diagnostic information without causing a hard failure. The system can now proceed with daemon operations even if cgroups are not fully functional, while still alerting administrators to the underlying problem.

This commit **fixes a common `DAEMON_STARTUP_FAILED` error** in Buck2, specifically addressing issues where the daemon failed to start due to problems connecting to the user's `systemd` session bus for cgroup management. A **probe** is added to the `systemd_check_available` function within the **resource control module** (`buck2_resource_control`) to explicitly verify `systemd-run --user` connectivity. If this probe fails, the daemon will now **gracefully fall back** to running without cgroups, preventing startup failures and improving overall reliability. This **bug fix** is accompanied by new **integration tests** (`test_daemon_cgroup_fallback`) to ensure the daemon correctly handles `systemd` connectivity issues.

This commit **refines the Buck2 data model** by **correcting the naming** of a cgroup path field within the `SystemInfo` protocol buffer message. It introduces a new optional `allprocs_cgroup_path` field in `app/buck2_data/data.proto` to accurately represent process cgroup information. Concurrently, the **Buck2 server daemon** (`buck2_server/src/daemon/server.rs`) is updated to populate this new field within the `SystemInfo` method. This ensures that downstream consumers of `SystemInfo` receive the correct and semantically accurate cgroup path data, improving the reliability of system information reporting.

This commit introduces a **new capability** to enhance **Buck2 daemon observability** by reporting the **cgroup slice path** where the daemon is running. It **adds a `daemon_cgroup_slice_path` field to the `SystemInfo` protobuf message** in `app/buck2_data/data.proto` and implements the logic in `app/buck2_server/src/daemon/server.rs` to retrieve and populate this field for Unix systems. This allows for better identification of the parent cgroup a Buck daemon is associated with, significantly aiding in **resource control** and monitoring efforts. A new test case `test_cgroup_path_tag` verifies this functionality, with the slice information emitted as events to optimize telemetry storage.

This commit introduces a **new capability** to log details about **orphan processes killed** by Buck2's resource control mechanisms, particularly **cgroups**. It adds new `OrphanProcessInfo` data structures and proto messages to capture information about these processes, such as their PIDs and commands. The **`buck2_execute_local`** and **`buck2_resource_control`** modules are refactored to collect this information during process group cleanup, which is then dispatched as an `OrphanProcessesKilled` **instant event** via **`buck2_execute_impl`**. This enhancement significantly improves the **debuggability** of build issues caused by lingering processes, providing valuable insights into how Buck2 manages and cleans up child processes.

This commit **refactors** the **error handling** within the **`buck2_execute_local`** crate's **process group management**. The `wait` function, implemented across `process_group.rs`, `unix/process_group.rs`, and `win/process_group.rs`, has been updated to return `buck2_error::Result` instead of `io::Result` or `tokio::io::Result`. This change standardizes error propagation for process waiting operations, ensuring consistent error reporting across different platforms and aligning with the project's internal error type system. It also removes the `tokio::io` import from the platform-specific implementations, streamlining dependencies.

This commit introduces a **critical enhancement** to **Buck2's process management** by ensuring the atomic cleanup of all processes within an action's cgroup. It implements a new `kill_remaining_pids` function in the **`buck2_resource_control`** module, which is then integrated into `buck2_execute_local::unix::process_group` to terminate any lingering child processes, such as `hg` daemons, after the main action exits or during explicit kills. This **bug fix** and **refactoring** effort prevents orphaned processes and resource leaks, significantly improving the reliability of **action execution** and preparing for a robust **cgroup rollout to users**.

This commit performs **code cleanup** and **optimization** by **removing several unused `tset` data structures**. These elements, some of which originated from an earlier revision, were identified as dead code after re-evaluating calculations related to a previous change (D82357595). This **maintenance** effort significantly impacts system resource usage, yielding approximately **1% memory savings**. The removal of these obsolete `tset`s contributes to a more efficient and streamlined codebase.

This commit **adjusts the Python package build logic** by **removing the preference for local builds for inplace PARs** within the `_make_py_package_impl` function in `prelude/python/make_py_package.bzl`. This **optimization reversal** is now feasible due to the recent introduction and enablement of `make_par_live` for `aps`. The change aims to **accelerate "long tail" builds** by allowing the build system to leverage the new `make_par_live` mechanism more efficiently. Ultimately, this modification to the **Python build system** is expected to improve overall build performance for projects utilizing PARs.

This commit **reverts a previous optimization** within the **Python packaging** system, specifically for the `par` action in the `_make_py_package_live` function defined in `prelude/python/make_py_package.bzl`. By setting the `prefer_local` parameter to `False`, the `par` action will now execute as a **hybrid** action, leveraging remote execution rather than being forced to run locally. This **performance optimization** addresses significant **local resource contention** and **slow build times** observed in large Python builds, such as `ads aps build`, which were negatively impacted by the prior local-only execution strategy. The change aims to improve overall build performance by re-enabling distributed execution for these critical packaging steps.

This commit **refactors** the build system by making specific **compiler flag attributes** `anon_target_compatible`. It updates the `compiler_flags` and `platform_compiler_flags` within `cxx_implicit_attrs` in `prelude/python/linking/link_helper.bzl`, and the `compiler_flags` attribute in `_python_executable_attrs` within `prelude/rules_impl.bzl`. This **maintenance** change ensures proper handling and compatibility of these flags when used with anonymous targets, improving the robustness of **Python linking** and **C++ compilation** within the build system. The update addresses a previous revert, re-establishing this crucial compatibility.

This commit introduces a **new capability** to **track native dependencies** within the Python build system by defining `NativeDepsInfo` and integrating it into `PythonLibraryInfo`. It modifies **Python build rules** like `cxx_python_extension`, `prebuilt_python_library`, `python_library`, and `python_binary` to store and propagate this crucial dependency information. This **enhancement** allows for more precise **native linking**, as `cxx_deps` are now explicitly identified, merged via `merge_native_deps`, and passed to the anonymous target for processing. The change improves the robustness and correctness of the build process for Python modules that rely on C++ components.

This commit **introduces a new Starlark helper** in `prelude/python/linking/link_helper.bzl` to encapsulate native linking logic for **Python targets**. It adds a new rule and provider, specifically `_process_native_linking_rule_impl`, designed to wrap the existing `process_native_linking` functionality. This **refactoring** effort aims to extract link computation into its own anonymous target, improving modularity and reusability for Python build configurations. The change provides a foundational utility for managing implicit C++ and Python attributes during the linking phase, enabling more structured build definitions.

This commit introduces **support for anonymous targets** across the **Python build system**, enhancing how **Python binaries and tests** are linked and analyzed. It modifies `prelude/python/python_binary.bzl` to incorporate new helper functions and conditional logic for native linking, adapting return types to handle `Promise`s for asynchronous operations. The `prelude/python/linking/native.bzl` file is updated to conditionally set link tree names for C++ executables, while `prelude/python/python_test.bzl` now includes `Promise` support in its return type annotations. This **new capability** streamlines build analysis and dependency resolution by enabling the use of unnamed targets for Python artifacts.

This commit **introduces a new rollout attribute** `use_anon_target_for_analysis` to the **Python executable rules** within `prelude/rules_impl.bzl`. A boolean attribute, defaulting to `false`, is added to the `_python_executable_attrs` function. This **new capability** provides a crucial control mechanism for the **anonymous target analysis feature**, enabling quick rollbacks and phased rollouts. The change facilitates safer deployment and management of this analysis feature within the build system.

This commit **refactors** the **Python build rules** to streamline provider handling within the build system. Specifically, the `python_executable` and `python_test_executable` functions in `prelude/python/python_binary.bzl` and `prelude/python/python_test.bzl` are updated to directly return a `list[Provider]`. This **refactoring** simplifies the internal implementation by removing explicit `compute_providers` calls and passing `executable_type` for provider computation. The change improves the clarity and maintainability of the **Python build system's** core logic for generating executables.

This commit introduces a **unified entry point** for computing providers within the **Python build rules** by creating a new `compute_providers` function in `prelude/python/compute_providers.bzl`. This **refactoring** centralizes the logic previously duplicated across `python_binary_impl` and `python_test_impl`, which now delegate to the new function using an `ExecutableType` enum. The change simplifies the codebase and lays the groundwork for future enhancements, such as returning different provider types, by providing a consistent mechanism for handling Python executable providers.

This commit performs a **refactoring** of the **Python build rules** within the `prelude` system to centralize provider computation logic. It introduces a new helper module, `prelude/python/compute_providers.bzl`, which encapsulates functions like `compute_binary_providers` and `compute_test_providers`. The existing `python_binary_impl` and `python_test_impl` functions are updated to utilize these new helpers, thereby **improving code organization and reducing duplication** in the `prelude/python` subsystem. This change enhances the **maintainability** of the Python target definitions.

This commit introduces a **refactoring** to the **Python build rules** defined in `prelude/python/python_binary.bzl`. Specifically, it modifies the `python_executable` function to directly return the result of calling `_convert_python_library_to_executable`. This change streamlines the internal implementation of how Python executables are defined, aiming to improve code clarity and maintainability. The scope of this work is limited to internal build system logic, with no expected impact on external functionality or behavior.