grpc/grpc-rust

This system is a comprehensive Rust gRPC framework, primarily known as Tonic, that provides the core infrastructure for building high-performance client and server applications using Protocol Buffers. It encompasses a modular ecosystem including code generation tools, serialization codecs, and specialized libraries for health checking, server reflection, and richer error handling. The system also supports advanced networking features such as TLS, gRPC-Web, xDS-based service discovery, and dynamic load balancing, alongside extensive tooling for benchmarking and interoperability testing.

37 changes.

This period focused on a comprehensive rewrite of the Tonic gRPC library, removing the tower-grpc dependency and the tonic-macros crate in favor of a standalone, modular architecture. The codebase was upgraded to Rust 2024 and Hyper 1.0, introducing type-safe metadata handling, generic server/client implementations, and improved codec performance. Extensive examples and interop test infrastructure were added to validate the new design and ensure compatibility with standard gRPC implementations.

28 changes.

This period focused on expanding the Tonic ecosystem by introducing dedicated crates for gRPC health checking, reflection, richer error models, and gRPC-Web protocol translation. Significant effort was also directed toward comprehensive documentation and testing, with numerous examples demonstrating advanced features like middleware, load balancing, and compression, alongside robust integration test suites for new functionality.

42 changes.

This period focused on introducing the preview \grpc\ crate, a new Rust gRPC implementation featuring advanced load balancing, transport layer refactoring, and xDS client support. It also expanded the ecosystem with dedicated crates for protobuf integration, code generation, and rich error handling, alongside comprehensive examples and test coverage for these new capabilities.

The C++ implementation files for the protoc-gen-rust-grpc code generator have been added to the repository. This includes the build configuration (BUILD), the main plugin entry point (grpc\_rust\_plugin.cc), and the core generator logic (grpc\_rust\_generator.cc/h). The generator now supports generating Rust gRPC service interfaces from .proto files, with options to configure the message module path, enable client-only generation, and map import paths to crate names via a mapping file.

_protoc-gen-rust-grpc/src/cpp\source/src · high confidence

Introduces the \grpc-google\ crate, which provides \GcpCallCredentials\ to automatically fetch and attach Google Cloud Platform OAuth2 access tokens to gRPC calls using Application Default Credentials (ADC). This allows users to authenticate gRPC channels against GCP services without manually handling token acquisition.

grpc-google · high confidence

A new example demonstrating how to connect to Google Cloud Pub/Sub via gRPC has been added. It shows how to authenticate using an OAuth bearer token passed via the GCP\_AUTH\_TOKEN environment variable, configure TLS with root certificates, and use a gRPC interceptor to attach authorization headers when listing topics.

examples/src/gcp, examples/src/grpc-gcp · high confidence

The examples directory now includes a complete client and server implementation for gRPC over HTTP/2 Cleartext (h2c). The server example demonstrates how to accept initial HTTP/1.1 connections, upgrade them to HTTP/2 using \hyper\_util\'s connection builder, and serve gRPC requests via Tonic's \Routes\. The client example shows how to initiate an h2c upgrade handshake and subsequently send gRPC requests over the upgraded HTTP/2 connection.

examples/src/h2c · high confidence

The examples/src/grpc-routeguide directory now includes a client implementation for the gRPC Route Guide service. This example demonstrates how to use the generated protobuf code and the gRPC client channel to perform unary, server-streaming, client-streaming, and bidirectional-streaming RPCs, supported by a sample JSON database of geographic features.

examples/src/grpc-routeguide · high confidence

Introduces a new Rust-based gRPC benchmarking framework in the grpc-benchmark directory, providing the worker, server, and client implementations required to drive performance tests. This includes the build configuration to generate code from gRPC testing protocol buffers, TLS certificates for secure testing, and the core Rust source files (bench, client, server, worker) that execute the benchmark workloads and report metrics.

grpc-benchmark · high confidence

The \examples/src/tls\_client\_auth\ directory now includes a complete client and server example demonstrating mutual TLS (mTLS). The client configures a \ClientTlsConfig\ with a CA certificate and client identity, connecting via HTTPS, while the server uses \ServerTlsConfig\ with a client CA root to validate incoming certificates and exposes the peer certificates via \request.peer\_certs()\.

_examples/src/tls\_client\auth · high confidence

This change adds the necessary TLS certificates and keys (CA, server certificate, and private key) to the \interop/data\ directory, enabling interoperability testing between Tonic's gRPC implementation and the Go implementation. It also includes the Terraform configuration files (\cert-generator/ca.tf\, \cert-generator/server\_certs.tf\) and a README explaining how to regenerate these certificates using Terraform, ensuring the test environment has valid, committed credentials for secure communication.

interop/data · high confidence

A new gRPC-based Hello World example has been added to the examples directory. This example demonstrates how to build a gRPC channel using the Channel builder, create a Greeter client, and send a request by passing the HelloRequest as a view to the say\_hello method.

examples/src/grpc-helloworld · high confidence

Users can now construct and parse gRPC Status objects with structured error details (such as BadRequest, DebugInfo, ErrorInfo, and others) using the new \StatusExt\ trait. This adds methods like \with\_error\_details\ to build statuses with specific error types and \check\_error\_details\ to validate and extract these details from incoming responses, enabling more granular error handling beyond simple status codes.

_tonic-types/src/richer\error · high confidence

The examples/src/authentication directory now includes client.rs and server.rs files that demonstrate how to implement authentication in gRPC using interceptors. The client example shows how to attach a Bearer token to outgoing requests via a client interceptor, while the server example demonstrates how to validate the authorization header using a server interceptor before processing requests.

examples/src/authentication · high confidence

The \tonic-types/proto\ location now includes the \error\_details.proto\ and \status.proto\ files, providing the standard Google RPC error model definitions. This adds support for structured error details such as \ErrorInfo\, \RetryInfo\, \DebugInfo\, and \QuotaFailure\, enabling richer error handling in gRPC services.

tonic-types/proto · high confidence

The examples/src/health directory now includes a Rust server example demonstrating the gRPC health checking protocol using the tonic-health crate. This example runs a Greeter service alongside a HealthServer, allowing users to monitor service status changes via tools like grpc\_health\_probe.

examples/src/health · high confidence

The \examples/src/richer-error\ directory now includes client and server examples demonstrating how to use the gRPC richer error model. The server-side examples (\server.rs\, \server\_vec.rs\) show how to construct \Status\ responses with structured error details, including \BadRequest\ violations, help links, and localized messages. The client-side examples (\client.rs\, \client\_vec.rs\) demonstrate how to extract and handle these error details from incoming gRPC status codes.

examples/src/richer-error · high confidence

A new example demonstrating gRPC-Web communication has been added to the examples directory. The server-side code (server.rs) implements a Greeter service using Tonic, configured with a CORS layer and the gRPC-Web layer, and explicitly enables HTTP/1 support required for the protocol. The client-side code (client.rs) shows how to construct a gRPC-Web client using Hyper and Tonic's GrpcWebClientLayer to call the Greeter service.

examples/src/grpc-web · high confidence

This change introduces the new \grpc-xds\ crate, which provides the foundational infrastructure for the xDS implementation. It includes a \build.rs\ script that automatically generates Rust modules from a comprehensive set of vendored Protocol Buffers (including Envoy, CEL-spec, and Google APIs) during compilation. This setup enables the rest of the codebase to use strongly-typed, generated types for xDS resources and configuration.

grpc-xds · high confidence

A new mock example has been added to demonstrate how to run a gRPC server and client within the same process using an in-memory duplex channel. This allows users to test gRPC interactions without requiring a real network connection or separate processes.

examples/src/mock · high confidence

New example applications have been added to demonstrate advanced gRPC client and server patterns. The multiplex example shows how a single server can host multiple service implementations (Greeter and Echo) on one port, while a client reuses a single channel to call both services. The load-balance example demonstrates client-side load balancing by connecting to multiple server endpoints using a balanced channel.

examples/src/multiplex · high confidence

The \tonic-types\ library now includes typed wrappers for the standard error details defined in \error\_details.proto\. This change adds new structs for \BadRequest\, \DebugInfo\, \ErrorInfo\, \Help\, \LocalizedMessage\, \PreconditionFailure\, \QuotaFailure\, \RequestInfo\, \ResourceInfo\, and \RetryInfo\. These types allow users to easily construct, serialize, and deserialize rich error details from \google.rpc.Status\ messages, providing structured access to specific error contexts like field violations, quota limits, and retry delays.

_tonic-types/src/richer\_error/std\messages · high confidence

The tonic-reflection module now includes the canonical \grpc.reflection.v1\ and legacy \grpc.reflection.v1alpha\ Protocol Buffer definitions. These files establish the schema for the ServerReflection service, enabling clients to query registered services, resolve file names to descriptors, and inspect extension numbers via bidirectional streaming.

tonic-reflection/proto · high confidence

This change introduces a new benchmarking suite in \tonic/benches-disabled\ to measure the performance of constructing Tonic Requests and Responses. The benchmarks, driven by the Criterion framework, evaluate throughput across various payload sizes (from 100 bytes to 10 MB) using both simple \helloworld\ messages and complex \diverse\_types\ messages with many fields. These benchmarks are gated behind the \broken\ feature flag and rely on pre-compiled \.rs\ files to isolate construction performance from \tonic-build\ compilation time.

tonic/benches-disabled · high confidence

The examples now include a new set of TLS certificates in \examples/data/tls/\ (including CA, server, and client keys/certs) and a \create.sh\ script to regenerate them, alongside a \roots.pem\ file containing public CA roots and a \route\_guide\_db.json\ dataset, enabling secure and data-driven testing of the example applications.

examples/data · high confidence

A new example server at examples/src/autoreload/server.rs demonstrates how to run a gRPC service with systemd-style socket activation for seamless autoreloading. The server now checks for a pre-listened TCP socket via listenfd; if present, it wraps the listener in a Tokio stream for serve\_with\_incoming, otherwise it falls back to binding directly to \[::1\]:50051, enabling zero-downtime restarts when the process is signaled.

examples/src/autoreload · high confidence

New example files for the blocking module demonstrate how to run gRPC services and clients using a synchronous Tokio runtime. The client example shows how to wrap a tonic client within a struct that holds the runtime to safely handle blocking calls without deadlocking, while the server example illustrates starting a tonic server inside a dedicated runtime instance.

examples/src/blocking · high confidence

A new example demonstrating how to handle request cancellation in gRPC has been added to the examples directory. The client-side code shows how to use a timeout to cancel a request if it does not complete within one second, while the server-side code illustrates how to detect when a client has cancelled a request using a cancellation token and handle the resulting status appropriately.

examples/src/cancellation · high confidence

The \examples/proto\ directory now includes a comprehensive set of \.proto\ files to serve as reference implementations and examples. This adds standard gRPC examples such as \helloworld\, \routeguide\, \echo\, and \unaryecho\, alongside Google API standard definitions (including \annotations\, \client\, \field\_behavior\, \http\, and \resource\ protos) and the \google.pubsub.v1\ service definitions for Pub/Sub topics and schemas. These files provide the schema contracts for various RPC services, enabling developers to generate client and server code for testing and integration.

examples/proto · high confidence

The tonic-health module now includes the canonical \health.proto\ file defining the \grpc.health.v1\ package. This introduces the \Health\ service with \Check\ and \Watch\ RPCs, allowing clients to query and monitor the serving status of gRPC services. The protocol defines the \ServingStatus\ enum, which includes \UNKNOWN\, \SERVING\, \NOT\_SERVING\, and a new \SERVICE\_UNKNOWN\ status specifically for use with the \Watch\ method when a requested service is not found.

tonic-health/proto · high confidence

A new Python script, \check\_license.py\, has been added to the \tools\ directory to enforce consistent MIT license headers across Rust source files. This tool scans tracked \.rs\ files (excluding specific third-party adaptations and generated code), validates the copyright year is within the allowed range (2025 to current year), and ensures the license text matches the expected boilerplate exactly, failing the build if discrepancies are found.

tools · high confidence

The \grpc-protobuf/src/server\ module now includes the core infrastructure for handling all four gRPC RPC types (unary, client-streaming, server-streaming, and bidirectional-streaming). This change introduces specific method traits (e.g., \UnaryMethod\, \BidiStreamingMethod\) that generated service code implements, along with corresponding adapter structs (e.g., \UnaryAdapter\) that wrap these implementations to handle incoming requests. It also provides the \GrpcStreamingRequest\ and \GrpcStreamingResponse\ types that allow handlers to receive and send message streams, effectively enabling the server to process streaming RPC calls using protobuf messages.

grpc-protobuf/src/server · high confidence

A new example server in examples/src/dynamic demonstrates how to register gRPC services (Greeter and Echo) dynamically at runtime based on command-line arguments, using Tonic's RoutesBuilder to conditionally add services rather than hardcoding them.

examples/src/dynamic · high confidence

The tonic-reflection crate is introduced, providing a gRPC Server Reflection implementation for the tonic ecosystem. It exposes generated protobuf types for both the v1 and v1alpha reflection API versions under the \pb\ module, along with their corresponding file descriptor sets. The server-side implementation is available as a separate module, gated behind the \server\ feature flag, allowing users to enable reflection capabilities in their gRPC servers.

tonic-reflection/src · high confidence

This change establishes the foundational project files for the Tonic gRPC library. It adds the \CHANGELOG.md\ (noting that releases are now managed via GitHub releases from v0.13.0 onward), \README.md\ (documenting the library's features, dependencies like \hyper\ and \prost\, and MSRV of 1.88), \CONTRIBUTING.md\ (including a Generative AI policy), \LICENSE\ (MIT), and \SECURITY.md\ (linking to the gRPC CVE process). It also introduces \flake.nix\ and \flake.lock\ for Nix-based development environments with pre-commit hooks, configures \release-plz.toml\ for automated versioning of the tonic crate group, and updates \.gitignore\ to standardize target directory exclusion.

(repo-wide) · high confidence

The \tonic-xds\ crate is introduced as a new xDS-aware gRPC client implementation for Rust. It provides an \XdsChannelBuilder\ to construct channels that discover endpoints and load-balance via an xDS management server, supporting features such as circuit breaking, retry policies, and TLS configuration. The release includes a full set of example applications (\channel\, \greeter\_server\, \xds\_server\) and a test utility crate to facilitate local testing and integration.

tonic-xds · high confidence

Added the \ErrorDetails\ struct and \ErrorDetail\ enum in \tonic-types/src/richer\_error/error\_details\ to support the gRPC richer error model. \ErrorDetails\ provides a container for standard error message types (such as RetryInfo, DebugInfo, QuotaFailure, ErrorInfo, PreconditionFailure, BadRequest, RequestInfo, ResourceInfo, Help, and LocalizedMessage) with associated constructors for setting individual fields. The \ErrorDetail\ enum wraps these standard message structs, enabling them to be handled uniformly in vectors.

_tonic-types/src/richer\_error/error\details · high confidence

The \tonic/src/server\ module now provides a generic, codec-agnostic gRPC server handler (\Grpc\) that manages request handling for unary, client-streaming, server-streaming, and bidirectional streaming calls. This implementation adds support for configuring compression encodings (accepting and sending compressed messages) and setting limits on maximum decoding and encoding message sizes, allowing users to build servers with fine-grained control over message handling and resource constraints.

tonic/src/server · high confidence

The \xds-client\ crate is now available, providing a protocol-agnostic Rust implementation of the xDS client. It manages the ADS stream lifecycle, including connection, reconnection with exponential backoff and jitter, and resource subscription/watching with version/nonce tracking. The crate exposes a builder API (\XdsClient::builder\) that accepts a transport builder (e.g., \TonicTransportBuilder\), a codec (e.g., \ProstCodec\), and a runtime. It includes a \basic\ example demonstrating how to configure the client with environment variables for the xDS server URI, listener names, and optional TLS/mTLS credentials. The client supports watching specific resources or using wildcard subscriptions, and delivers events via \ResourceWatcher\ with flow control signals (\ProcessingDone\) to manage cascading subscriptions.

xds-client · high confidence

The \tonic/src/client\ module now exposes the core components for building gRPC clients: the \Grpc\ dispatcher, the \GrpcService\ trait, and the \GrpcConfig\ configuration struct. Users can now configure client behavior directly, including setting the server origin URI, enabling request/response compression (e.g., Gzip), and defining limits for maximum encoded and decoded message sizes. The \GrpcService\ trait provides a type-safe abstraction over \tower\_service::Service\, ensuring that underlying transport channels correctly handle HTTP request/response bodies and errors within the gRPC protocol context.

tonic/src/client · high confidence

Added the \grpc-protobuf-build\ crate, a build-time tool that compiles \.proto\ files and generates Rust service stubs and message definitions for use with tonic. The library provides a \CodeGen\ API allowing users to configure inputs, include paths, external dependencies, and output directories within a \build.rs\ script. This is currently a preview feature with unstable APIs, not recommended for production use.

grpc-protobuf-build · high confidence

A new \codegen\ binary has been added to the project to automate the generation of Rust source files containing embedded file descriptor sets for internal proto definitions (such as \tonic-health\, \tonic-reflection\, \tonic-types\, and the \grpc\ echo example). This tool compiles the specified \.proto\ files, writes the resulting file descriptor sets to a constant byte array in the generated output, and removes source code info to keep the generated code clean. This change centralizes the generation of these descriptor constants, which are used by other crates like \tonic-reflection\ to support reflection without requiring the original \.proto\ files at runtime.

codegen · high confidence

The new \tonic-health\ crate provides a complete implementation of the gRPC Health Checking Protocol, exposing \HealthService\ and \HealthReporter\ types. Users can now serve health status for individual services or the overall server via the \grpc.health.v1.Health\ service, supporting both synchronous checks and streaming watch updates through \WatchStream\. The crate includes generated protobuf types for \grpc\_health\_v1\ and a \ServingStatus\ enum to manage service states.

tonic-health/src · high confidence

A new \tonic-prost-build\ crate has been added to provide code generation for gRPC services using protobuf definitions via the \prost\ ecosystem. This crate exposes a \Builder\ API (accessible via \configure()\) that allows users to customize code generation, including options for building clients and servers, setting attributes, and handling well-known types. It re-exports core build functionality from \tonic-build\ and prost types, serving as a bridge between \prost\ and \tonic\ for users preferring \prost\'s code generation approach.

tonic-prost-build/src · high confidence

The new \tonic-types\ crate provides a collection of useful protobuf types and introduces the \StatusExt\ trait, which extends \tonic::Status\ to support the gRPC Richer Error Model. This allows server-side code to attach structured error details (such as \BadRequest\, \Help\, and \LocalizedMessage\) to status responses, and enables client-side code to easily extract and handle these specific error details from incoming status errors.

tonic-types/src · high confidence

Adds the \tonic-web\ crate, providing \GrpcWebLayer\ and \GrpcWebClientLayer\ to enable Tonic servers and clients to communicate using the gRPC-Web protocol. The server layer translates incoming gRPC-Web requests (including Base64-encoded bodies and trailer handling) into standard gRPC for inner services and converts responses back, while the client layer coerces HTTP/2 requests to HTTP/1.1 and sets the appropriate content-type headers.

tonic-web/src · high confidence

The tonic-prost crate has been introduced as a standalone component to provide the ProstCodec, enabling encoding and decoding of protobuf messages via the prost library within the tonic gRPC framework. This change extracts the prost codec implementation into its own crate, allowing users to leverage prost-based serialization for their gRPC services. The codec supports configurable buffer settings for both encoding and decoding operations, and includes proper error mapping from prost decode errors to gRPC status codes.

tonic-prost · high confidence

Added a new example in examples/src/json-codec that demonstrates how to use JSON instead of protobuf for message serialization. The example includes a client and server implementation along with a common module defining HelloRequest, HelloResponse, and a custom JsonCodec using serde for encoding and decoding, illustrating the use of the application/grpc+json content type.

examples/src/json-codec · high confidence

A new \xds-client-opentelemetry\ crate has been added, providing an \OtelMetricsRecorder\ that bridges the xDS client's internal metrics to the OpenTelemetry SDK. This allows applications to route gRFC A78-compliant xDS metrics (counters, histograms, gauges) into their existing OpenTelemetry observability pipelines by passing a \Meter\ to the recorder during xDS client construction.

xds-client-opentelemetry · high confidence

Added client and server example files in the \examples/src/tls\_rustls\ directory that demonstrate how to combine \hyper-rustls\ and \tonic\ to provide a custom \ClientConfig\ for TLS configuration. The client example shows how to load root certificates and configure an HTTPS connector, while the server example illustrates setting up a TLS acceptor with HTTP/2 support and extracting peer certificate information from incoming connections.

_examples/src/tls\rustls · high confidence

Added new example files in examples/src/tls demonstrating how to configure and use TLS for gRPC connections. The client example shows how to load a CA certificate, configure a ClientTlsConfig with a domain name, and connect via an https scheme. The server example demonstrates setting up a ServerTlsConfig with an identity (certificate and key) and accessing TLS connection metadata (TlsConnectInfo) within a service handler.

examples/src/tls · high confidence

Added client and server example files in the tower example directory that demonstrate how to integrate Tower middleware with gRPC services. The client example shows wrapping a gRPC channel with an interceptor and a custom authentication service using Tower's ServiceBuilder, while the server example demonstrates applying a custom middleware layer and an interceptor to a gRPC server before serving requests.

examples/src/tower · high confidence

Added client and server example files in the compression directory that demonstrate how to enable Gzip compression for gRPC communication using Tonic's \send\_compressed\ and \accept\_compressed\ APIs.

examples/src/compression · high confidence

Added a new example in \examples/src/dynamic\_load\_balance\ demonstrating how to use \Channel::balance\_channel\ to dynamically add and remove endpoints at runtime. The client example shows how to send \Change::Insert\ and \Change::Remove\ operations via a receiver channel to update the load-balanced connection pool while making unary echo requests, and includes a corresponding server example that runs multiple instances to support this dynamic topology.

_examples/src/dynamic\_load\balance · high confidence

The \examples/src/codec\_buffers\ directory now includes a complete client/server example that uses a custom \SmallBufferCodec\ instead of the default Prost codec. This example illustrates how to configure specific buffer sizes (512 bytes initial, 4096 bytes max) for encoding and decoding, which is useful for scenarios with many concurrent RPCs and small data volumes.

_examples/src/codec\buffers · high confidence

The \examples\ directory now contains a comprehensive \build.rs\ script that generates gRPC code for multiple services (Helloworld, RouteGuide, Echo, Google Cloud Pub/Sub, and a custom JSON codec example) using \tonic-prost-build\, alongside updated \README.md\ and tutorial files (\helloworld-tutorial.md\, \routeguide-tutorial.md\) that guide users through setting up and running these examples.

examples · high confidence

Added example code in \examples/src/interceptor\ demonstrating how to use gRPC interceptors in Tonic. The client example (\client.rs\) shows how to attach an interceptor to a \GreeterClient\ to inspect or modify outbound requests, including using both function pointers and named types implementing the \Interceptor\ trait. The server example (\server.rs\) demonstrates attaching an interceptor to a \GreeterServer\ to inspect inbound requests and attach custom data (extensions) that can be accessed by the service implementation.

examples/src/interceptor · high confidence

The interop/src module now provides a comprehensive gRPC interoperability test suite, introducing separate client and server implementations for both the Prost and Protobuf code generation backends. This adds concrete test logic for standard gRPC scenarios—including unary, client/server streaming, and full-duplex calls—alongside a shared assertion framework to validate behavior across different serialization strategies.

interop/src · high confidence

Added new \client.rs\ and \server.rs\ binaries in the interop tooling to run gRPC interoperability tests. These tools support both \prost\ and \protobuf\ codecs, allowing users to select the serialization format via the \--codec\ flag. The client binary connects to a target server (defaulting to localhost:10000) and executes a suite of standard interop test cases (e.g., empty unary, large unary, streaming), while the server binary starts a listener that can serve test requests using either tonic or the native gRPC Rust server implementation, with optional TLS configuration enabled via the \--use\_tls\ flag.

interop/src/bin · high confidence

The interop directory now includes a build script, test runner, and binary update utility to facilitate integration testing between Rust and Go gRPC implementations. The build script (build.rs) configures code generation using tonic-prost and grpc-protobuf-build, with optional support for protoc-gen-rust-grpc. The test script (test.sh) orchestrates interop tests by launching Go and Rust servers and clients, supporting multiple operating systems (Linux, macOS, Windows via Cygwin/MSYS) and testing various gRPC features like unary, streaming, and metadata handling. The update\_binaries.sh script automates the compilation of Go interop binaries for different platforms. This enables users to verify compatibility between their Rust gRPC implementations and standard Go gRPC servers/clients.

interop · high confidence

The \grpc-protobuf\ crate has been introduced to provide Protobuf integration for the \grpc\ crate, implementing \SendMessage\ and \RecvMessage\ traits to handle serialization and deserialization of protobuf message views. This change adds support for rich gRPC error details via the \grpc-status-details-bin\ trailer, allowing server handlers to attach structured payloads (such as \google.rpc.Status\ details) to error responses, which are then parsed and exposed to clients. The crate also includes a \SendFuture\ helper trait to work around Rust compiler limitations regarding \Send\ bounds on async blocks.

grpc-protobuf/src · high confidence

This change introduces several new components in tonic/src/service to enhance service composition and error handling. It adds an Interceptor trait and InterceptorLayer, allowing users to inspect or modify request metadata and cancel requests before they reach the core service. A new RecoverError middleware and layer are provided to gracefully handle service errors by converting them into HTTP responses with appropriate gRPC status codes. Additionally, a Layered service wrapper and LayerExt trait enable the propagation of NamedService implementations through Tower layers, while a new Routes and RoutesBuilder API offers a convenient way to register and manage gRPC services using an underlying axum router.

tonic/src/service · high confidence

Added new \client.rs\ and \server.rs\ examples in the streaming directory that demonstrate how to detect client drops in bidirectional streams on the server side. The server implementation uses \tokio::sync::mpsc\ channels and spawned tasks to handle stream termination, allowing it to distinguish between graceful disconnections and unexpected errors like broken pipes by inspecting underlying I/O errors.

examples/src/streaming · high confidence

Added client and server example files in the tracing examples directory that demonstrate how to integrate the \tracing\ library with gRPC services. The client example initializes a \FmtSubscriber\ and uses the \\#\[tracing::instrument\]\ macro on the \say\_hi\ function to automatically log request and response details. The server example configures the gRPC server with a \trace\_fn\ to create spans for incoming requests and applies \\#\[tracing::instrument\]\ to the \say\_hello\ service method, providing structured logging for debugging and observability.

examples/src/tracing · high confidence

Added the \xds-test-util\ crate, which provides test helpers for exercising xDS clients against an in-process fake Aggregated Discovery Service (ADS) control plane. The crate exposes \XdsTestControlPlaneService\ to spin up a mock server and \config\ module utilities to build standard xDS resources (Listeners, RouteConfigurations, Clusters, and ClusterLoadAssignments) for test scenarios.

xds-test-util · high confidence

A new \grpc-protobuf\ crate has been added to provide Protobuf integration for the \grpc\ crate. This preview release includes a build script that generates client-side code from \google/rpc/status.proto\ and other well-known types, intended for use with \protoc-gen-rust-grpc\. Users should note that this is an unstable preview version not recommended for production use.

grpc-protobuf · high confidence

The \grpc\ crate is introduced as a new, preview-level Rust implementation of the gRPC framework. This release establishes the core client-side architecture, including the \Channel\ and \ChannelBuilder\ for managing connections, a generic \Attributes\ store for configuration, and a comprehensive load-balancing system featuring \GracefulSwitch\, \Lazy\, \PickFirst\, and \RoundRobin\ policies. It also provides client-side interceptor support, metadata handling, and name resolution for DNS and Unix sockets. The project sets a minimum supported Rust version (MSRV) of 1.88 and includes benchmarks comparing its metadata performance against Tonic.

grpc · high confidence

The gRPC integration now includes generated Rust bindings for the \google.rpc.Status\ protobuf message, enabling applications to handle and expose structured error details (code, message, and repeated Any-type details) in gRPC responses. This change adds the necessary \status.proto\ definition, its Apache 2.0 license, and the corresponding \generated.rs\ and \status.u.pb.rs\ files to the \grpc-protobuf\ module, allowing users to leverage the standard gRPC error model for richer error reporting.

_grpc-protobuf/generated, grpc-protobuf/third\party · high confidence

A new UDS example has been added to the examples directory, demonstrating how to use Unix domain sockets for gRPC communication on Unix systems. The example includes a server implementation that listens on a specified socket path and a client implementation that connects to this socket, showcasing both standard connection methods and custom connector usage for UDS.

examples/src/uds · high confidence

The reflection example server has been updated to include support for the v1alpha reflection protocol, allowing clients to use this older version for service introspection. The example demonstrates how to register the file descriptor set and build the reflection service alongside the standard Greeter service.

examples/src/reflection · high confidence

The \tonic-build\ crate has been restructured to decouple code generation logic from the build entry point, introducing a new \CodeGenBuilder\ and dedicated modules for client (\client.rs\) and server (\server.rs\) generation. This change exposes a \Service\ trait and a \Method\ trait, allowing the build system to generate gRPC stubs from both \.proto\ files and manually defined Rust service descriptors via the new \manual\ module. The generated client and server structs now include built-in support for compression encoding/decoding, message size limits, and interceptors, with the transport-specific \connect\ method conditionally generated based on the \transport\ feature flag.

tonic-build/src · high confidence

The \tonic-macros\ crate has been removed from the codebase. This deletion eliminates the \\#\[grpc\]\ procedural macro attribute and its associated code generation logic, which previously implemented the \tonic::GrpcInnerService\ trait for service implementations.

tonic-macros/src · high confidence

A change to existing behaviour in interop/bin — 2 commits, 6 files.

interop/bin · medium confidence · unverified

The transport service layer now enforces gRPC timeouts by parsing the \grpc-timeout\ header and applying the shorter of the client-provided duration or the server's configured timeout, returning a \TimeoutExpired\ error if the limit is reached. Additionally, the TLS handling code has been refactored to use the \rustls-pki-types\ crate for certificate and private key parsing, introducing specific error types for handshake timeouts and certificate parsing failures.

tonic/src/transport/service · high confidence

The build configuration for protoc-gen-rust-grpc has switched from Bazel to CMake. This change updates the build process to use CMake 3.14+ for compiling the underlying C++ protobuf sources and the plugin itself, as evidenced by the removal of Bazel-specific files and the introduction of a build.rs script that invokes cmake to configure and build the binaries into a separate install directory. Users relying on the previous Bazel-based build steps will need to update their build environment to use CMake.

protoc-gen-rust-grpc · high confidence

The code previously located in grpc/src/client/service\_config.rs has been moved and rewritten as protoc-gen-rust-grpc/src/lib.rs, replacing internal service configuration structures with public functions (protoc, protoc\_gen\_rust\_grpc, bin) that return the file paths to the protoc executable, the gRPC protoc plugin, and the installation bin directory. This change enables consumers of the protoc-gen-rust-grpc crate to programmatically locate the built binaries, with path handling adjusted for Windows (adding .exe extension) and using the OUT\_DIR-based install/bin location.

protoc-gen-rust-grpc/src · high confidence

The generated source files in \tonic-reflection/src/generated\ have been updated to implement the \grpc.reflection.v1\ server reflection protocol. This change replaces the previous \v1alpha\ definitions with the stable \v1\ API, providing updated message structures for requests (such as \ServerReflectionRequest\) and responses (such as \ServerReflectionResponse\), along with corresponding client implementations and embedded file descriptor sets for both the v1 and v1alpha versions.

tonic-reflection/src/generated · high confidence

The Hello World example has been updated to show the remote client address in the server logs. When the server receives a request, it now prints the client's IP address and port (e.g., "Got a request from \[::1\]:50051") before responding, helping users verify connectivity and inspect incoming connection details.

examples/src/helloworld · high confidence

The metadata module has been completely rewritten to enforce gRPC specification compliance through type safety. \MetadataKey\ and \MetadataValue\ are now generic over \Ascii\ or \Binary\ encoding types, preventing the accidental mixing of ASCII strings and base64-encoded binary data. The \MetadataMap\ now exposes \IterMut\ and \ValuesMut\ iterators, allowing users to modify metadata entries in place. Additionally, the module now defines \GRPC\_CONTENT\_TYPE\ as a constant and implements \AsRef\ and \AsMut\ for \MetadataMap\ to seamlessly interact with the underlying \http::HeaderMap\.

tonic/src/metadata · high confidence

The server transport layer now exposes a \Connected\ trait and associated \ConnectInfo\ types (such as \TcpConnectInfo\ and \TlsConnectInfo\) that allow users to access connection metadata like local/remote addresses and TLS peer certificates via request extensions. Additionally, the server now includes a \DisplayErrorStack\ utility to format error chains for better debugging, and the \ServerIoStream\ implementation has been refactored to handle TCP accept errors (like \ConnectionAborted\ or \BrokenPipe\) gracefully without shutting down the server.

tonic/src/transport/server · high confidence

The \grpc-protobuf/src/client\ module now provides a new set of generated-code-friendly client APIs for all four gRPC RPC patterns: unary, client-streaming, server-streaming, and bidirectional streaming. Each pattern has a dedicated builder (\UnaryCallBuilder\, \ClientStreamingCallBuilder\, \ServerStreamingCallBuilder\, \BidiCallBuilder\) that implements \CallBuilder\ for common configuration and \IntoFuture\ to initiate the call. These builders return protobuf-aware streaming types (\GrpcStreamingRequest\/\GrpcStreamingResponse\) or direct results, replacing the previous client-side abstractions in this crate with a unified, builder-based approach that integrates with the underlying \grpc\ channel and interceptor infrastructure.

grpc-protobuf/src/client · high confidence

The internal implementation of the HTTP/2 client channel has been restructured to use a Tower service layer architecture. This change introduces dedicated service components for managing connection lifecycle (reconnection), TLS handshakes, and request modification (such as setting the User-Agent header and URI origin). For users, this provides a more robust and modular transport layer that better handles connection failures and allows for finer-grained control over HTTP/2 settings and TLS configuration, while maintaining the same public API.

tonic/src/transport/channel/service · high confidence

The codec module has been restructured to improve memory management and streaming performance. New specialized buffer types, \DecodeBuf\ and \EncodeBuf\, now wrap \BytesMut\ to provide safer and more efficient access for encoding and decoding gRPC messages. The \Streaming\ type has been rewritten to use these buffers and a new \Decoder\ trait, allowing for better handling of partial frames and compression. Additionally, the \EncodeBody\ combinator (\EncodedBytes\) now batches ready messages into larger buffers based on a configurable \yield\_threshold\ (default 32 KiB) to reduce system call overhead, while \BufferSettings\ allows tuning the initial buffer size (default 8 KiB) and growth strategy.

tonic/src/codec · high confidence

The transport channel implementation has been restructured into distinct modules: \endpoint.rs\ now houses the \Endpoint\ builder with expanded configuration options (including TCP keepalive, HTTP/2 keep-alive, and adaptive window settings), \tls.rs\ manages \ClientTlsConfig\ with support for trust anchors and custom verifiers, and \uds\_connector.rs\ introduces a dedicated connector for Unix Domain Sockets. This modularization separates connection logic, TLS handling, and transport-specific connectors while maintaining the existing \Channel\ API for building and balancing connections.

tonic/src/transport/channel · high confidence

The transport module now uses a new, structured \Error\ type that distinguishes between generic transport failures and specific configuration issues (such as invalid URIs or TLS settings for Unix domain sockets), while TLS-related types like \Certificate\ and \Identity\ have been simplified to store raw PEM bytes directly instead of relying on external crypto library wrappers.

tonic/src/transport · high confidence

The generated code in the examples directory has been updated to use protobuf version 4.35.1, introducing a new runtime with view/mut proxy types for message handling. Additionally, the gRPC code generation now includes server-side implementations (e.g., \route\_guide\_server\), allowing examples to demonstrate both client and server gRPC interactions.

examples/generated · high confidence

The generated code for the gRPC health check service (grpc\_health\_v1) has been regenerated to align with recent prost updates. This includes the addition of a new file descriptor set constant (FILE\_DESCRIPTOR\_SET) for efficient serialization, the use of the Status constructor for status handling, and the adoption of the new Body type. Users relying on this generated client will see updated internal implementations for the HealthClient, including changes to how requests are encoded and how the service name is exposed, ensuring compatibility with the latest tonic and prost versions.

tonic-health/src/generated · medium confidence

The server module now exposes both v1 and v1alpha interfaces for the gRPC Reflection Service, allowing clients using the legacy v1alpha protocol to query service descriptors and file information again. The implementation adds a dedicated v1alpha module alongside the existing v1 module, reusing the shared \ReflectionServiceState\ to serve reflection data. This restores backward compatibility for tools and clients that rely on the older reflection API version.

tonic-reflection/src/server · high confidence

The RouteGuide example in examples/src/routeguide has been completely rewritten to use modern Rust async/await syntax and the latest Tokio ecosystem. The client now uses \tokio::time\ for intervals and \rand::rng()\ for random point generation, while the server leverages \tokio::sync::mpsc\ channels and \tokio\_stream::ReceiverStream\ for efficient server-side streaming. Data loading has been updated to use \serde\ for JSON deserialization instead of previous methods, and the service implementation now properly handles bidirectional streaming with \async\_stream::try\_stream!\. This change improves code clarity, performance, and alignment with current Rust best practices for gRPC applications.

examples/src/routeguide · high confidence

The server transport service module has been restructured to introduce a new \ConnectInfo\ service layer that injects connection details (such as peer address) into request extensions, making this information available to application handlers. Additionally, the TLS implementation now supports a configurable handshake timeout, allowing servers to reject slow TLS negotiations, and includes support for ignoring client certificate order preferences and optional SSL key logging for debugging.

tonic/src/transport/server/service · high confidence

The tonic crate has been rewritten to remove the \tower-grpc\ dependency and replace its internal architecture with new, standalone modules. \tonic::Request\ and \tonic::Response\ now use \http::Extensions\ directly for metadata and extensions, providing \into\_parts\ and \from\_parts\ methods for easier manipulation. A new \tonic::Body\ type wraps HTTP bodies, and \tonic::Status\ is now boxed internally to reduce stack size. The public API surface has shifted from the old \tower\_grpc\ traits to new types like \IntoRequest\, \IntoStreamingRequest\, and \CancellationHandle\, while the \tonic-build\ codegen exports are centralized in a new \codegen\ module.

tonic/src · high confidence

The generated code in \tonic-types/src/generated\ has been updated to reflect the latest \google.rpc\ protobuf definitions. This includes new or refreshed Rust structs for standard error handling types such as \Status\, \ErrorInfo\, \RetryInfo\, \DebugInfo\, and \QuotaFailure\, ensuring compatibility with current API error models. Additionally, a new \types\_fds.rs\ file now exposes the compiled \FILE\_DESCRIPTOR\_SET\ as a byte constant, enabling runtime reflection and type resolution for these generated types without requiring external \.proto\ files.

tonic-types/src/generated · high confidence

1 commit adding/updating tests in tonic-web/tests; Added compile-time tests for Tonic code generation edge cases; Added decode benchmarks for Streaming performance analysis; Added gRPC interop test protocol definitions; Added integration test infrastructure with mock stream support; Added integration tests for gRPC message compression; Added integration tests for gRPC reflection service; Added integration tests for gRPC transport features; Added integration tests for tonic-web gRPC-Web support; Added test coverage for extern\_path configuration; Added test suite for compiling well-known protobuf types; Added test to verify deprecated method annotations; Added tests for default unimplemented stubs generation; Added tests for extern\_path integration with custom trait implementations; Added tests for the disable\_comments build option; Added tests for well-known protobuf types; Removed obsolete gRPC macro integration test.

This release updates the Tonic crate and its associated modules (tonic-build, tonic-prost, tonic-health, tonic-reflection, tonic-types, tonic-web, tonic-xds) to version 0.14.6. The codebase has been migrated to the Rust 2024 edition and requires Rust 1.88. A significant architectural change is the upgrade to Hyper 1.0 and Axum 0.8 for the transport layer, replacing the previous Hyper 0.14/Axum 0.6 stack. Additionally, the protobuf dependency has been updated to version 4.35.1, and the internal tonic-macros crate has been removed in favor of direct dependencies in tonic-build.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 58 → 62 (+4.1)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 94 → 93 (-0.4)
• Architecture 96 → 94 (-1.8)
• Maturity 65 → 65 (-0.1)
• Readiness 46 → 51 (+4.9)
• Security 52 → 60 (+8.0)
• Event Sourcing 100 → 100 (+0.0)
• Performance 100 (new)

• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (examples/src/gcp/README.md)
• Documentation: no installation or build instructions (examples/src/health/README.md)
• Documentation: no project overview (examples/src/health/README.md)
• Duplicated block (12–13 lines × 2) (grpc/src/client/load_balancing/child_manager.rs)
• Duplicated block (25 lines × 2) (interop/src/server_prost.rs)
• Duplicated block (8 lines × 2) (interop/src/server_protobuf.rs)
• Duplicated block (8 lines × 2) (tonic-build/src/client.rs)
• Hotspot: grpc-protobuf-build/src/lib.rs (grpc-protobuf-build/src/lib.rs)
• Hotspot: grpc-protobuf/src/status.rs (grpc-protobuf/src/status.rs)
• Hotspot: tonic-prost-build/src/lib.rs (tonic-prost-build/src/lib.rs)
• Hotspot: tonic/src/codec/decode.rs (tonic/src/codec/decode.rs)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3
• OutlierStatsRegistry::run_housekeeping (cognitive 31) (tonic-xds/src/client/loadbalance/outlier_detection.rs)
• TodoComment (grpc/src/client/load_balancing/child_manager.rs)
• TodoComment (grpc/src/server/mod.rs)
• TodoComment (tonic-protobuf/src/lib.rs)

• AdsWorker::add_watcher (cognitive 40) (xds-client/src/client/worker.rs)
• AdsWorker::add_watcher (cyclomatic 16) (xds-client/src/client/worker.rs)
• AdsWorker::run_stream_task (cognitive 19) (xds-client/src/client/worker.rs)
• Dependency hygiene PARTLY measured — Cargo dependencies read, no committed lock to grade for currency
• Documentation: no project overview (tonic/benches-disabled/README.md)
• Duplicate WorkScheduler types in different modules. Both grpc.client.name_resolution.WorkScheduler and grpc.client.load_balancing.WorkScheduler have the same signature schedule_work(data: WorkData). It is unclear if these are distinct interfaces or if one is a duplicate/refactor artifact.
• Duplicated block (10 lines × 2) (xds-client/src/client/worker.rs)
• Duplicated block (11–12 lines × 2) (grpc/src/client/load_balancing/child_manager.rs)
• Duplicated block (11–15 lines × 2) (grpc-protobuf/src/server/client_streaming.rs)
• Duplicated block (31 lines × 2) (grpc-protobuf/src/server/server_streaming.rs)
• Duplicated block (8–10 lines × 2) (tonic-build/src/client.rs)
• Edited copy of a member (35 corresponding lines) (grpc-protobuf/src/server/server_streaming.rs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Hotspot: xds-client/src/client/worker.rs (xds-client/src/client/worker.rs)
• Inconsistent API surface for CallOptions between client and server. The client-side CallOptions exposes mutable setters and getters for properties like deadline, whereas the server-side CallOptions only exposes a constructor with no visible property accessors or setters. This suggests a divergence in how call configuration is handled or exposed.
• Inconsistent interceptor signatures. Client interceptors return streams (SendStream, RecvStream), while server interceptors return Trailers and take explicit tx/rx streams. This makes it difficult to write shared interceptor logic or understand the flow.
• Inconsistent method naming and signatures for ChannelController. The name resolution controller uses update with a ResolverUpdate, while the load balancing controller uses update_picker with an LbState. These are likely part of the same controller interface but are split or named inconsistently.
• Inconsistent method naming for receiving messages. Client uses recv, while server uses next. These perform the same logical operation (advancing the stream and retrieving the next message) but have different names and return types (ResponseStreamItem vs Result).
• …and 16 more

• 28 commits — 25 feature/other, 3 fixes

• grpc/src — 11 commits
• tonic-xds/src — 7 commits
• xds-client/src — 4 commits
• .github/workflows — 1 commit
• examples/generated — 1 commit
• grpc-xds/Cargo.toml — 1 commit
• tonic-prost/src — 1 commit
• tonic-types/src — 1 commit
• tonic/src — 1 commit

• fix: Fix Code-QL breakage with CI configuration. (#2870)
• fix: fix(types): Serialize BadRequest::FieldViolation reason and localized_message (#2461)
• fix: grpc/service_config: fix flaky service_config tests caused by a test LB policy name collision (#2892)
• change: Make ParsedLbConfig available to load balancers, include child selection mechanism. (#2887)
• change: chore(xds): bump crates to 0.1.0-alpha.4 (#2886)
• change: feat(tonic-xds): expose ADS message size limit knobs in config (#2879)
• change: feat(tonic-xds): implement gRFC A50 outlier detection success-rate algorithm (#2673)
• change: feat(tonic-xds): make outlier detection transport-agnostic (#2849)
• change: feat(tonic-xds): support A65 ADS TLS credentials (#2869)
• change: grpc-protobuf: add server codegen utils (#2818)
• change: grpc/attributes: add remove API and inline persistent list (#2891)
• change: grpc/client/load_balancing: add endpoint filtering utils (#2850)
• change: grpc/client: avoid unnecessary CallOptions clone (#2872)
• change: grpc/lb: add SubchannelUpdate and remove LbPolicy::subchannel_update (#2873)
• change: grpc/lb: require LbConfig in resolver_update (#2880)
• change: grpc/service_config: memoize default_lb_policy via LazyLock (#2862)
• change: grpc: allow external TLS implementations with __unstable (#2842)
• change: grpc: ignore large enum variant clippy in Lazy (#2874)
• change: prost: relax codec Default bounds (#2681)
• change: protoc-gen-rust-grpc: add gRPC server support (#2867)
• …and 8 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

grpc/grpc-rust was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.