Jeff Bahr

This commit introduces a **performance optimization** to the **Thrift Swift Java codegen template**, specifically for generated struct `hashCode()` methods. It **eliminates the `Object[]` allocation** that previously occurred on every `hashCode()` call by replacing `Arrays.deepHashCode` with an inline hash computation using the standard `31 * result + fieldHash` pattern. This **refactoring** significantly **reduces GC pressure** for structs used as `HashMap` keys on hot paths, such as `TopicKey` in Iris, by avoiding unnecessary object creation. The change affects the generated Java code for all Thrift structs, improving overall application efficiency without altering hash values.

This commit **fixes a bug** in the **generated Java Thrift RPC server handler** where the `RequestContext` thread-local was not set before `ThriftEventHandler` callbacks executed, leading to `null` context issues. It moves the `setCurrentContext()` call to the beginning of the `Mono.defer()` lambda in `singleRequestSingleResponse`, `singleRequestStreamingResponse`, and `singleRequestNoResponse` methods. This ensures the `RequestContext` is available for all event handler callbacks like `preRead` and `postRead`, even when execution is forced off the event loop. Additionally, `doFinally(() -> clearCurrentContext())` is added to prevent **thread-local leaks**, improving the robustness of the **Thrift runtime**. New tests validate the correct availability of the `RequestContext` within these callbacks.

This commit **backs out** the previously introduced **`io_uring` transport support** from the **Thrift Java runtime**. It **removes `IO_URING` specific logic** from `NettyUtil.java` and refactors `RpcClientUtils.java` and `RpcServerUtils.java` to no longer determine channel types based on `IO_URING` or `NettyUtil.getTransportType()`. Consequently, `LegacyRpcClientFactory.java` and `LegacyServerTransport.java` are adjusted to use updated `getChannelClass` signatures and local `EventLoopGroup` variables. This **revert** simplifies the **Thrift Java transport layer** by removing the experimental `io_uring` integration and updating related test cases.

This commit is a **complete rewrite** of the **`MonoTimeoutTransformer`** to address **critical race conditions** and ensure **Reactive Streams specification compliance**. It introduces robust **atomic state management** (`STATE`, `S`, `TIMEOUT_MARKER`) to prevent multiple terminal signals and correctly handle cancellation, particularly between source emissions, timeout firing, and fallback subscriptions. This **bug fix** significantly improves the **multithreaded safety** and **reliability** of timeout and fallback mechanisms within the reactive stream processing, also adding comprehensive test coverage and an optimized `RpcTimeoutException` for the **Thrift RPC runtime**.

This commit introduces **io_uring transport support** to the **Thrift Java runtime**, a **new capability** designed to significantly improve I/O performance on Linux systems by leveraging the high-performance asynchronous I/O interface. It involves a **major refactoring** of the network transport layer, replacing `EventLoopGroup`-based channel selection with a new `TransportType` enum (`IO_URING`, `EPOLL`, `KQUEUE`, `NIO`) that prioritizes `io_uring` where available. This change impacts core **client and server utilities** (`RpcClientUtils`, `RpcServerUtils`), `NettyUtil` for event loop creation, and legacy transport components, ensuring the most efficient I/O mechanism is automatically selected. Users of the **Thrift Java runtime** will benefit from **enhanced network throughput and latency**, with a new system property available to enable or disable `io_uring` functionality.

This commit implements a **performance fix** to address severe lock contention in the **ThriftClientStats** and **ServerStats** classes within the Java Thrift runtime. It optimizes the update mechanisms for counters, histograms, averages, and distributions by introducing an optimistic get-first pattern for `ConcurrentHashMap` operations. This change significantly reduces CPU overhead by avoiding unnecessary synchronization on hash buckets, especially after initial startup when keys are stable. The fix targets methods like `incrementCounterValues`, `addHistogramValue`, `incrementAverages`, `incrementCounter`, and `updateDistribution`, which were identified as dominant sources of contention under heavy load, thereby improving the scalability of high-throughput Thrift services.

This commit **reverts** a previous **refactoring** of the `MonoTimeoutTransformer` within the **Thrift Java runtime library**. Specifically, it undoes the changes that aimed to simplify the internal state management and remove custom exception types by directly utilizing Reactor's `BaseSubscriber` and Netty's `HashedWheelTimer`. This **rollback** restores the prior implementation of the `Mono` stream timeout mechanism, affecting the `com.facebook.thrift.util.MonoTimeoutTransformer` utility. The revert ensures the system returns to its previous state, potentially reintroducing the original complexity or custom exception handling that the reverted change sought to address.

This commit delivers a crucial **bug fix** for a **Netty ByteBuf memory leak** in the **Thrift Java runtime**. It addresses a scenario where cancelling a `ListenableFuture` converted from a `Mono` via `FutureUtil.toListenableFuture()` failed to propagate the cancellation upstream, leaving resources unreleased. The fix introduces a listener in `ListenableFutureSubscriber.hookOnSubscribe()` that disposes the subscriber when the `ListenableFuture` is cancelled, ensuring **bidirectional cancellation** and proper cleanup of `Mono` resources. This **resource management improvement** is part of a series of fixes to prevent memory exhaustion in `Thrift` client applications.

This commit introduces a **bug fix** to the **Thrift client layer** by refactoring the `LegacyRpcClient` to lazily allocate `Netty ByteBuf`s. Previously, `ByteBuf`s were eagerly allocated in methods like `singleRequestSingleResponse()` and `singleRequestNoResponse()`, leading to memory leaks if a `Mono` was never subscribed to (e.g., due to a timeout). By wrapping the request handling logic in `Mono.defer()`, `ByteBuf` allocation is now deferred until actual subscription, effectively preventing these leaks. This **refactoring** ensures that `ByteBuf`s are only allocated when there is downstream demand, improving resource management within the reactive pipeline. This is the third part of a series of fixes addressing `ByteBuf` memory leaks in the Thrift client.

This commit **fixes critical bugs** and **improves resource management** within the **Thrift Java RSocket client** (`RSocketRpcClient.java`). It addresses issues with deferred execution by wrapping all RSocket calls in `Mono.defer` or `Flux.defer`, ensuring **lazy and idempotent `Payload` creation** for reactive streams across methods like `singleRequestSingleResponse` and `metadataPush`. This prevents "already released" errors that could occur during retries. Additionally, it resolves potential resource leaks by guaranteeing `Payload` release even when synchronous exceptions occur within the defer lambda, thereby enhancing the **stability and reliability** of RSocket communication.

This commit delivers a **complete rewrite** of the **`MonoTimeoutTransformer`** operator, addressing **critical race conditions** and ensuring **Reactive Streams specification compliance** within the `thrift/lib/java/runtime` module. The **refactoring** introduces robust **multithreaded safety** by implementing atomic state management using `STATE` and `S` fields, including a `TIMEOUT_MARKER` sentinel, and employs a defensive `FallbackSubscriber` to prevent signal leaks after cancellation. This **bug fix** eliminates issues like multiple terminal signals and ignored cancellations, significantly improving the operator's reliability and testability through timer injection and comprehensive input validation. A new `RpcTimeoutException` is also introduced to optimize performance during RPC timeouts.

This commit **updates the `jar_builder_main.jar` prebuilt artifact** within the **Buck build system's Android toolchain** by uploading its latest version to CAS. This **maintenance update** ensures that all subsequent builds leverage the most recent `jar_builder` source, which includes a critical fix (D90636340). The fix specifically addresses **incorrect merging of Manifest files**, particularly for **multi-release JARs**, thereby improving the reliability and correctness of Android builds by preventing potential build issues related to JAR structure.

This commit implements a **new capability** to expose **low-level Netty transport metrics** within the **Thrift Java runtime**. It **plumbs `SPINiftyMetrics`** through the server transport layer, allowing counters like active channel count, bytes read, and bytes written to be reported via `fb303`. This **feature enhancement** modifies `ServerTransportFactory` interfaces and concrete implementations (e.g., `LegacyServerTransport`, `RSocketServerTransport`) to accept and utilize these metrics, with `RpcServerUtils` handling their instantiation and injection. The change significantly improves **observability and diagnostics** for **Thrift servers**, providing crucial data for troubleshooting connection issues and understanding network performance.

This commit **fixes a critical bug** in the **Java Reactive Client** implementation where the `dispose()` method failed to disconnect underlying transport connections, leading to potential resource leaks. It introduces robust logic within the `ReactiveClient.mustache` template to **track RPC clients** created upon `Mono` subscription, ensuring they are properly disposed of when the reactive client's `dispose()` method is invoked. This **enhances resource management** by guaranteeing that all associated transport connections are explicitly closed, improving the stability and efficiency of applications utilizing the reactive client interface.

This commit addresses critical **memory leaks** and **broken event serialization** within the **`VirtualThreadScheduler.Worker`** in the Thrift Java runtime. It implements a **queue-based serial execution pattern** to ensure tasks run in **FIFO order** and are properly serialized, resolving contract violations and preventing unbounded memory growth caused by unremoved completed tasks. Furthermore, this **bug fix** significantly improves **disposal semantics** and **resource cleanup** by correctly tracking and cancelling delayed tasks, enhancing `DisposableFuture` and `TrampolinedTask` behavior, and ensuring full compliance with the Reactor Scheduler API. This ensures reliable and efficient operation of virtual thread-based scheduling, preventing resource exhaustion and guaranteeing task execution order.

This commit performs a **refactoring and cleanup** by **removing legacy thread pool and fork join pool flag checks** from the `ResourceConfiguration.java` file within the **Thrift Java runtime**. This change completes the migration to a unified scheduler flag system, eliminating outdated configuration pathways. The **resource management logic** for concurrency calculations in the Thrift Java runtime is now simplified and relies solely on the updated scheduler flags, improving maintainability and consistency.

This commit **fixes a bug** in the **Thrift Java runtime's Reactor RSocket client transport** (`ReactorClientTransport.java`). Previously, fluent configuration calls like `TcpClient.secure()`, `noSSL()`, or `observe()` were not correctly reassigning the `TcpClient` instance within the `build` method. This oversight meant that **SSL/TLS security settings** and other configurations applied via these methods were effectively ignored, leading to incorrect or insecure client connections. The fix ensures that the updated `TcpClient` instance, returned by these fluent calls, is properly captured and used, thereby **correctly applying all intended security and observation configurations** for the client.

This commit provides a crucial **bug fix** for the **`CachedRpcClientFactory`** in the **Thrift Java runtime**, addressing a severe **memory leak** and **stale connection issues**. It resolves the problem where RSocket keep-alive timeout exceptions were indefinitely cached, leading to an accumulation of suppressed exceptions and preventing `FusableReconnectingRpcClientMono` from re-establishing connections. The fix introduces **active cache invalidation** by subscribing to `RpcClient.onClose()` events, ensuring that cached `Mono` instances are cleared upon connection termination. This prevents exception accumulation, allows for proper reconnection, and significantly improves the stability and resource management of RPC client connections.

This commit introduces a **new capability** to the **Thrift Java runtime** by implementing `ThriftHeaderFrameLengthBasedDecoder`. This specialized decoder enables the **THeader protocol** to correctly handle **variable-length and large frames**, including those utilizing `BIG_FRAME_MAGIG`, which was previously unsupported. The existing **Thrift protocol detection logic** within `ThriftProtocolDetection` is updated to integrate and leverage this new decoder. This enhancement ensures that **Thrift Java servers** can now reliably process larger data payloads, improving the robustness and data throughput for services communicating via the THeader protocol. Comprehensive unit tests are included to validate the decoder's behavior across various frame scenarios.

This commit introduces a **new capability** to the **Thrift Java runtime** by implementing `ThriftHeaderFrameLengthBasedDecoder`. This specialized decoder, adapted from Netty, enables the **Thrift THeader protocol** to correctly handle **variable-length "big frames"**, which are essential for larger data payloads. The `ThriftProtocolDetection` pipeline is updated to integrate this new decoder, ensuring proper frame handling for both standard and extended-length messages. This enhancement allows **Thrift Java applications** to reliably process significantly larger frames, improving scalability and robustness for data-intensive services.