Dan Deng

This commit **introduces a new logging capability** to monitor **Thrift union deserialization** within the `thrift/lib/hack/src/protocol/ThriftUnionSerializationTrait.php` module. It adds logic to detect and log instances where Thrift unions are deserialized using PHP builtin methods. New methods, including `getFieldInfo` and modifications to `__wakeup`, are implemented to capture and send detailed field information and type data to a **SignalDynamicLoggerProject**, providing crucial insights into deserialization patterns.

This commit **migrates** the `signal dynamic logger`'s data storage from a deprecated shared Scuba table to a **dedicated Thrift Scuba table**. It **refactors** the `ThriftUnionSerializationTrait.php` within the **Thrift protocol library** for Hack, updating the internal dataset constant from `SHARED_DATASET_AVOID` to `THRIFT_SIGNAL_DYNAMIC_LOGGER`. This **maintenance** change ensures the continued functionality of signal logging by adapting to infrastructure deprecations, specifically impacting the serialization and access methods like `__read`, `__write`, and `__get` for signal data.

This commit **introduces new functionality for processing Thrift sinks** within the `ThriftProcessorBase` in the Hack language. It implements the critical `genExecuteSink` method, along with private helpers `genSinkGenerator` and `copyProtocol`, which will be invoked by Thrift compiler-generated code to handle sink operations. This **new feature** enables the server to correctly process incoming sink payloads and includes comprehensive **exception handling** mechanisms for scenarios where client sink code throws exceptions or errors occur during server-side processing. The changes in `thrift/lib/hack/src/ThriftProcessorBase.php` are essential for supporting robust Thrift sink communication.

This commit performs a **revert** within the **Thrift compiler's Hack generator** (`t_hack_generator.cc`), specifically rolling back changes related to **default value rendering for empty maps** and the assignment logic in **struct constructors**. It restores the prior behavior of functions like `render_const_value_helper` and `generate_php_struct_constructor_field_assignment`, which handle the generation of default values in the output Hack code. This **temporary rollback** is a **diagnostic measure** to investigate if the original modification was contributing to **timeouts observed during the msdk bump process**, aiming to resolve potential performance regressions.

This commit performs a **refactoring** within the **Thrift Hack generator** to standardize compiler options for server-side streaming. It **removes** the `server_sink_` option and its associated member variable from `t_hack_generator.cc`, consolidating its logic under the `server_stream_` flag, particularly affecting the `generate_function_helper` symbol. This **maintenance** change ensures consistency in how streaming capabilities are configured when generating Hack code. Consequently, the `hack` command option in the `thrift/compiler/test/fixtures/sink/cmd` test fixture is updated from `server_sink` to `server_stream` to align with this compiler modification, ensuring proper testing of the unified flag.

This commit introduces the **`legacy_default_values` compiler option** to resolve a **Hack code generation** issue related to **default values for structured types**. Specifically, it addresses type mismatches that occur when nested Thrift structs with default collection values are defined across files with inconsistent `hack_collections` settings, leading to incorrect type instantiation (e.g., `vec` versus `Vector`). The new flag, implemented in `thrift/compiler/generate/t_hack_generator.cc`, allows users to retain the previous default value generation behavior, serving as a **compatibility workaround**. This **maintenance fix** ensures correct code generation and prevents runtime errors for existing codebases, validated by new test cases across multiple Thrift fixtures.

This commit **introduces the `ServerSinkFactory` class** and **refactors** the Thrift C++2 codebase to utilize it for managing server-side sink replies. It **replaces `SinkConsumerImpl`** with `ServerSinkFactory` in critical components such as `ResponseChannel::sendSinkReply`, `HandlerCallbackBase::sendReply`, and the **compiler-generated service code** for async processors. This **refactoring** standardizes the mechanism for handling server-side sink operations, including setting interaction and context, across the **Thrift runtime** and **transport layers**. The new `ServerSinkFactory` centralizes the creation and management of server sinks, improving the robustness and clarity of sink-based RPC implementations. This change impacts **Thrift service implementation**, **compiler-generated code**, and **transport layers** for sink-based RPCs.

This commit introduces a **new capability** for **Thrift C++2 asynchronous server applications** by integrating a `ConsumerCallback` interface into the `ServerSinkFactory`. This callback provides a flexible mechanism for consumers to provision server sinks, allowing for more dynamic and potentially asynchronous management of these resources. Specifically, a new constructor for `ServerSinkFactory` is added to accept this callback, and the `ServerSinkBridge` is enhanced with a `getBufferSize` method to expose the consumer's buffer size, improving resource visibility and control.

This commit performs a **refactoring** by **renaming** the `ResponseAndClientSink` class and its associated type references to `ResponseAndSink` across the **Thrift Hack ecosystem**. The core change renames the class in `thrift/lib/hack/src/ResponseAndSink.php` and introduces a temporary type alias for the old name to maintain compatibility. This renaming is consistently applied to the **Thrift Hack compiler generator** (`t_hack_generator.cc`) and the **Thrift Hack client base** (`ThriftClientBase.php`) to update type hints and instantiations. This effort streamlines type naming and prepares for future compiler changes, with the type alias intended for removal once those changes land.

This commit introduces **server-side code generation** for **Thrift sink methods** within the **Hack language ecosystem**, marking a **new capability** for handling asynchronous operations. The `thrift/compiler/generate/t_hack_generator.cc` is updated to generate the necessary processing logic, while the `thrift/lib/hack/src/ThriftProcessorBase.php` runtime library gains a new `genExecuteSink` method to execute these sink handlers. This enables Hack services to define and efficiently process Thrift sink methods, expanding the framework's support for one-way, non-blocking communication patterns.

This commit introduces **new conformance testing capabilities** for **Thrift RPC sink methods**. It adds `sinkInitialDeclaredException` and `sinkServerDeclaredException` methods to the `thrift/conformance/if/rpc.thrift` service definition, enabling comprehensive testing of **exception handling** at various stages of a sink operation. The **Java reactive RPC server handler** is updated to implement these new methods, and the **Rust RPC client** is modified to recognize and handle them. This enhancement ensures more thorough validation of **exception propagation** within the **Thrift RPC framework**, covering scenarios where exceptions can be thrown in the initial handler, client generator, or server sink.

This commit **refactors** the `ServerSinkBridge` within the **Thrift C++2 asynchronous library** to enhance its flexibility. It modifies the `ServerSinkBridge` class and its `TwoWayBridge` template instantiation to utilize the more general `QueueConsumer` interface instead of the specific `CoroConsumer`. This **enables broader compatibility** for consumer implementations, particularly facilitating the integration of alternative consumer types required for a **Hack server sink implementation**. The change primarily affects `thrift/lib/cpp2/async/ServerSinkBridge.h` and `ServerSinkBridge.cpp`, making the `ServerSinkBridge` more adaptable to various consumer patterns.

This commit introduces a significant **logging improvement** for **Thrift union serialization** within the Hack environment. It enhances the `write` method in `thrift/lib/hack/src/protocol/ThriftUnionSerializationTrait.php` to provide more detailed error messages when an incorrect field is set in a union. Specifically, the updated logic now tracks all incorrect fields and explicitly includes both the **expected and actual field names** in the log output. This **observability enhancement** will greatly assist developers in debugging and diagnosing issues related to malformed Thrift union data.

This commit introduces a **new capability** to the **Thrift Hack compiler generator** by adding the `__union_logger_rollout` internal option. This flag enables **conditional generation of union logging code** within `t_hack_generator`, specifically affecting the `generate_php_union_methods` function. Accompanying test files in `thrift/compiler/test/fixtures/hack-strict-unions` have been updated to include new union definitions and a test command to validate the flag's functionality. This allows for a controlled and **gradual rollout of union logging changes** in Hack, ensuring stability and thorough testing before full deployment.

This commit **fixes incorrect logging** within the **Thrift Hack runtime** by introducing a null check to the `logIncorrectFieldAccessed` method. The **Thrift Hack code generator** (`thrift/compiler/generate/t_hack_generator.cc`) is updated to pass a null status to this function during the generation of union methods. Consequently, the `logIncorrectFieldAccessed` method in the **Thrift Hack library** (`thrift/lib/hack/src/protocol/ThriftUnionSerializationTrait.php`) now accepts this status and **prevents logging if the accessed field is null**. This ensures that logs are only generated when a non-null value is incorrectly accessed, **reducing noise from spurious logs** for legitimately null fields in Hack Thrift unions.

This commit introduces a **new capability** to the **Thrift/Hack library** by adding a **JustKnobs killswitch** for the `logIncorrectFieldAccessed` mechanism. This **maintenance feature** provides dynamic control over logging when an incorrect field of a Thrift union is accessed during serialization. Operators can now toggle this logging via the `log_incorrect_union_field_access` knob, allowing for flexible management of log verbosity and aiding in debugging **Thrift union serialization** issues.

This commit introduces a **new compiler flag**, `legacy_union_json_serialization`, within the **Thrift Hack code generator** to manage **JSON serialization behavior for Thrift unions**. This **new capability** provides explicit control over how unions are serialized, specifically unblocking the ongoing **Hack Union migration** by offering an alternative to problematic annotation-based methods. The flag is integrated into `t_hack_generator` and affects `_generate_php_struct_definition`, with accompanying **test infrastructure updates** to validate its functionality.

This commit introduces a **behavior alignment** for the JSON serialization of **non-protected Thrift unions** when processed by `fb_json_encode`. It addresses a discrepancy where `fb_json_encode` previously included `null` values for unset union fields, unlike `JSONThriftSerializer`. To resolve this, a new `ThriftLegacyJSONSerializationTrait.php` is added, implementing the `JsonSerializable` trait to explicitly omit `null` fields during serialization. The **Thrift compiler** (`thrift/compiler/generate/t_hack_generator.cc`) is updated to conditionally generate this trait for relevant unions. This **maintenance** effort ensures existing JSON serialization remains consistent and prevents breakage when these unions are eventually migrated to strict-unions.

This commit introduces a **new logging capability** within the **Hack Thrift runtime** to monitor access patterns for unions constructed with multiple fields. It adds a `logIncorrectFieldAccessed()` method to `thrift/lib/hack/src/protocol/ThriftUnionSerializationTrait.php` and modifies the **Hack Thrift compiler's generator** (`thrift/compiler/generate/t_hack_generator.cc`) to include calls to this method in generated union getter methods. This **instrumentation** is critical for identifying if "extra" fields are accessed, providing data to safely migrate existing unions to a strict-unions implementation. Additionally, it **refactors** existing `signal_log_in_psp` calls to use a more structured argument format.

This commit introduces a **new codemod** within the **Thrift compiler** to automate the annotation of specific **Thrift unions**. Implemented in `annotate_hack_legacy_json_serialization.cc`, this **new capability** adds the `@hack.MigrationBlockingLegacyJSONSerialization` annotation to unions currently listed in `ThriftOptionsMigrationIgnoreList::PROTECTED_UNIONS_IGNORELIST`. This **maintenance task** is crucial for an ongoing migration effort, ensuring that these particular unions are correctly identified and handled during changes related to legacy JSON serialization. Python tests in `annotate_hack_legacy_json_serialization_test.py` validate the codemod's functionality across various scenarios.