Skip to content
CAI
Software that uses CAICheck a score

grpc/grpc-rust

64.6

Weak · 14 November 2026

116k

lines of production code

Rust

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Google Cloud Pub/Sub example

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

Add HTTP/2 Cleartext (h2c) gRPC example

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

Add Route Guide gRPC example

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

Add Rust gRPC benchmarking framework implementation

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. Also in this area: Update Rust gRPC code generator and fix proto import paths.

grpc-benchmark, grpc-benchmark/src · high confidence

Add TLS mutual authentication example

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

Add Tonic gRPC interop test certificates and generation scripts

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

Add gRPC Hello World example

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

Add gRPC Richer Error Model support for extracting structured error details

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

Add gRPC authentication example with client and server interceptors

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

Add gRPC error model protocol buffers

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

Add gRPC health check example

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

Add gRPC richer error model examples

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

Add gRPC-Web example application

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

Add grpc-xds crate with vendored xDS protos and build-time codegen

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. Also in this area: Implement xDS route matching for path, header, and fraction criteria; Rename protoc-gen-rust-grpc to protoc-gen-grpc-rust. Also in this area: 2 commits (1 fix) modifying grpc-xds.

grpc-xds · medium confidence · unverified

Add in-process gRPC mock example

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

Add multiplexing and load-balancing example applications

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

Add support for gRPC Richer Error Model standard message types

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

Add v1 and v1alpha server reflection proto definitions

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

Added Criterion benchmarks for Tonic request/response construction

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

Added TLS certificates and data for examples

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

Added autoreload-capable gRPC server example

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

Added blocking gRPC client and server examples

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

Added cancellation example for gRPC requests

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

Added example and reference Protocol Buffers definitions

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

Added gRPC Health Check Protocol Buffer definitions

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

Added script to synchronize gRPC proto files

A new shell script, \tools/sync-grpc-proto.sh\, has been added to automate the synchronization of \.proto\ files from the upstream \grpc-proto\ repository. This tool downloads the latest definitions and updates the local \proto\ directories for the \interop\ and \grpc-benchmark\ projects, while also reporting any discrepancies between the upstream definitions and the local copies. Also in this area: Rustls TLS support moved to a separate crate; Added license boilerplate validation tool.

tools · high confidence

Dynamic service registration example for gRPC server

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

Initial release of tonic-reflection crate

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

Initial repository structure and documentation setup

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

Initial tonic-xds client library and examples

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

Introduce ErrorDetails and ErrorDetail types for gRPC richer error model support

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

Introduce generic gRPC server implementation

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

Introduce initial xDS client crate with tonic transport and prost codec

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. Also in this area: 2 commits (0 fixes) modifying xds-client; XDS client now validates responses before processing; Corrects xDS client connected metric lifecycle and connection loop behavior.

xds-client · medium confidence · unverified

Introduce low-level gRPC client dispatcher and service trait

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

Introduce preview gRPC protobuf build integration for Rust

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

Introduce standalone codegen tool to generate file descriptor set constants

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

Introduce tonic-health crate for gRPC health checking

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

Introduce tonic-prost-build crate for prost-based code generation

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

Introduce tonic-types crate for gRPC Richer Error Model support

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

Introduce tonic-web crate for gRPC-Web protocol translation

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

Introduction of tonic-prost crate with ProstCodec for gRPC

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. Also in this area: Updated repository URLs from hyperium/tonic to grpc/grpc-rust.

tonic-prost/src · high confidence

New JSON codec example for gRPC services

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

New OpenTelemetry metrics integration for xDS client

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

New TLS example using hyper-rustls and tonic

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

New TLS-enabled gRPC examples for client and server

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

New Tower middleware examples for gRPC clients and servers

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

New compression example for gRPC clients and servers

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

New dynamic load balancing example for gRPC clients

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

New example demonstrating custom gRPC codecs with small buffer settings

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

New examples directory with build scripts and tutorials

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

New gRPC interceptor examples for client and server

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

New gRPC interop test suite with Prost and Protobuf implementations

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

New interop test binaries for gRPC client and server

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

New interop test infrastructure for Rust gRPC clients and servers

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

New protobuf integration crate with rich error details support

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

New server-side streaming RPC adapters and traits for gRPC-protobuf

The \grpc-protobuf/src/server\ module now includes generated server codegen utilities that provide traits and adapters for all four gRPC RPC types: unary, client-streaming, server-streaming, and bidirectional streaming. These new files (\unary.rs\, \client\_streaming.rs\, \server\_streaming.rs\, \bidi.rs\) define handler traits (e.g., \UnaryMethod\, \BidiStreamingMethod\) and corresponding adapters that wrap them to implement \DynHandle\. This allows developers to implement server-side logic using strongly-typed protobuf messages and stream abstractions (\GrpcStreamingRequest\, \GrpcStreamingResponse\) rather than low-level stream handling, with built-in validation for message counts (e.g., ensuring unary calls receive exactly one request).

grpc-protobuf/src/server · high confidence

New service middleware and routing utilities

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

New streaming example demonstrating client disconnect detection

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

New tracing-enabled gRPC examples

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

New xDS test utility crate for in-process control plane testing

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

Preview release of grpc-protobuf crate for Protobuf integration

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

Preview release of the Rust gRPC implementation

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

Unix domain socket (UDS) example added

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

gRPC Reflection example now supports v1alpha protocol

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

tonic-build refactors code generation into a modular builder architecture

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

Removals

Removal of tonic-macros crate

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

Behavioural changes

1 commit (0 fixes) modifying grpc-benchmark/third\_party

A change to existing behaviour in grpc-benchmark/third\_party — 1 commit, 9 files: “Move grpc-proto files to third\_party dirs (\#2998)” (refs \#2998).

_grpc-benchmark/third\party · medium confidence · unverified

1 commit (0 fixes) modifying grpc-xds/proto

A change to existing behaviour in grpc-xds/proto — 1 commit, 161 files: “grpc/xds: Add grpc-xds crate for xds implementation and proto codegen (\#2723)” (refs \#2723).

grpc-xds/proto · medium confidence · unverified

19 commits (1 fix) modifying grpc-xds/src

A change to existing behaviour in grpc-xds/src — 19 commits (1 fix), 24 files: “grpc/xds: Add grpc-xds crate for xds implementation and proto codegen (\#2723)”; “grpc-xds: Add insecure ChannelCredentials to bootstrap (\#3000)”; “grpc-xds: Fix import for new protobuf-generated module (\#3021)”; and 16 more (refs \#2723, \#3000, \#3021, \#2884, \#2920, …).

grpc-xds/src · medium confidence · unverified

2 commits (0 fixes) modifying interop/bin

A change to existing behaviour in interop/bin — 2 commits, 6 files: “chore: Update interop go binaries (\#440)”; “chore: Reorganize examples and interop crates (\#180)” (refs \#440, \#180).

interop/bin · medium confidence · unverified

4 commits (0 fixes) modifying grpc-rustls

A change to existing behaviour in grpc-rustls — 4 commits, 9 files: “grpc: move rustls support to grpc-rustls crate (\#2934)”; “grpc: Expose unstable functions in \_\_unstable (\#2990)”; “grpc: Sealed, Internal, Unstable, oh my! (\#2968)”; and 1 more (refs \#2934, \#2990, \#2968, \#2971).

grpc-rustls · medium confidence · unverified

4 commits (0 fixes) modifying protoc-gen-grpc-rust

A change to existing behaviour in protoc-gen-grpc-rust — 4 commits, 11 files: “Upgrade to Protobuf 36.2 (\#2956)”; “protoc-gen-grpc-rust: downgrade abseil (\#2982)”; “protoc-gen-grpc-rust: include absl version in CMAKE\_BINDARY\_DIR (\#2989)”; and 1 more (refs \#2956, \#2982, \#2989, \#2955).

protoc-gen-grpc-rust · medium confidence · unverified

Add gRPC timeout enforcement and refactor TLS service layer

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

Generated code now uses v1 reflection protocol definitions

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

Hello World example now displays client connection address

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

Metadata module rewritten with type-safe ASCII and Binary variants

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

New connection metadata API and improved server error handling

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

New gRPC Protobuf client call builders for all RPC types

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

Refactored HTTP/2 channel transport to use Tower service layers

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

Refactored codec internals with new buffer and streaming abstractions

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

Refactored transport channel into modular components

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

Refactored transport error handling and TLS types

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

Regenerated examples with protobuf 4.35.1 and gRPC server support

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

Regenerated gRPC health check client with updated prost bindings

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

Reintroduce v1alpha reflection protocol support

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

Rename grpc-google to grpc-google-cloud-auth

The grpc-google library has been renamed to grpc-google-cloud-auth. This change reflects a rebranding or restructuring of the authentication component within the gRPC ecosystem, ensuring clearer identification of its purpose related to Google Cloud authentication.

grpc-google-cloud-auth · high confidence

Rename protoc-gen-rust-grpc to protoc-gen-grpc-rust and upgrade Protobuf to 36.2

The \protoc-gen-rust-grpc\ code generator plugin has been renamed to \protoc-gen-grpc-rust\, affecting the crate name, binary name, environment variables (e.g., \PROTOC\_GEN\_GRPC\_RUST\_NO\_BUILD\), and protoc flags (e.g., \--grpc-rust\_out\). Additionally, the underlying Protobuf library has been upgraded from version 35.1 to 36.2, which changes the generated code's internal module structure (e.g., \google\_protobuf\_any\_proto::Any\) and requires regeneration of existing protobuf bindings.

grpc-protobuf/generated · high confidence

Rust RouteGuide example rewritten for modern async patterns

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

Server transport layer refactored with TLS handshake timeout and connection info injection

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

Tonic rewrites core types and removes tower-grpc dependency

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

Updated generated Google RPC types and file descriptor constants

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

Test coverage

1 commit adding/updating tests in interop/third\_party; 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 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.

Dependencies

Tonic 0.14.6 release with Rust 2024 edition and Hyper 1.0 upgrade

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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 66 → 65 (-0.9)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 77 → 74 (-3.6)
  • Architecture 96 → 96 (+0.1)
  • Maturity 69 → 69 (+0.2)
  • Readiness 53 → 52 (-1.4)
  • Security 76 → 77 (+0.9)
  • Event Sourcing 100 → 100 (+0.0)
  • Performance 91 → 91 (+0.0)

Resolved (30)

  • Duplicated block (12 lines × 2) (tonic-build/src/manual.rs)
  • Duplicated block (13 lines × 2) (tonic-reflection/src/server/v1.rs)
  • Duplicated block (16 lines × 2) (tonic-reflection/src/server/v1.rs)
  • Duplicated block (8 lines × 2) (tonic-build/src/client.rs)
  • Edited copy of a member (70 corresponding lines) (tonic-reflection/src/server/v1.rs)
  • Leaked secret: private-key (examples/data/tls/ca.key)
  • Leaked secret: private-key (examples/data/tls/client1.key)
  • Leaked secret: private-key (examples/data/tls/client2.key)
  • Leaked secret: private-key (examples/data/tls/client_ca.key)
  • Leaked secret: private-key (examples/data/tls/server.key)
  • Leaked secret: private-key (examples/data/tls/server2.key)
  • Low cohesion: TlsStream (LCOM4 7) (grpc-rustls/src/tls_stream.rs)
  • Low cohesion: XdsChannelConfig (LCOM4 4) (tonic-xds/src/client/channel.rs)
  • No ADRs found
  • Off-boarding risk: anonymized user #1
  • Off-boarding risk: anonymized user #2
  • Off-boarding risk: anonymized user #3
  • Repeated repair: tonic-xds/src/xds/resource/route_config.rs (tonic-xds/src/xds/resource/route_config.rs)
  • Secret: private-key (examples/data/tls/ca.key)
  • Secret: private-key (examples/data/tls/client1.key)
  • …and 10 more

New (80)

  • Change coupling: subchannel.rs ↔ local.rs (grpc/src/client/subchannel.rs)
  • ClassTooLong: Server (tonic/src/transport/server/mod.rs)
  • Duplicated block (6 lines × 2) (grpc-xds/src/load_balancing/cluster_manager.rs)
  • Duplicated block (69 lines × 2) (tonic-reflection/src/server/v1.rs)
  • Duplicated block (7 lines × 2) (grpc-xds/src/bootstrap/json.rs)
  • Duplicated block (8 lines × 2) (tonic-build/src/client.rs)
  • Edited copies of one member (3 members, 20+ corresponding lines) (xds-client/src/client/worker.rs)
  • Edited copies of one member (3 members, 7+ corresponding lines) (tonic/src/transport/server/service/io.rs)
  • Edited copies of one member (4 members, 10+ corresponding lines) (tonic/src/metadata/map.rs)
  • Edited copy of a member (10 corresponding lines) (grpc-protobuf/src/client/bidi.rs)
  • Edited copy of a member (10 corresponding lines) (grpc/src/client/load_balancing/pick_first.rs)
  • Edited copy of a member (10 corresponding lines) (tonic/src/transport/channel/endpoint.rs)
  • Edited copy of a member (11 corresponding lines) (interop/src/client.rs)
  • Edited copy of a member (11 corresponding lines) (tonic/src/transport/channel/mod.rs)
  • Edited copy of a member (12 corresponding lines) (grpc/src/client/name_resolution/unix.rs)
  • Edited copy of a member (13 corresponding lines) (tonic/src/transport/channel/endpoint.rs)
  • Edited copy of a member (14 corresponding lines) (tonic-reflection/src/server/mod.rs)
  • Edited copy of a member (14 corresponding lines) (tonic-web/src/call.rs)
  • Edited copy of a member (15 corresponding lines) (grpc/src/metadata/key.rs)
  • Edited copy of a member (15 corresponding lines) (grpc/src/metadata/map.rs)
  • …and 60 more

Changes since last survey

  • 54 commits — 50 feature/other, 4 fixes

By area

  • grpc/src — 18 commits
  • grpc-xds/src — 10 commits
  • tonic-xds/src — 9 commits
  • xds-client/src — 6 commits
  • grpc-rustls/Cargo.toml — 2 commits
  • protoc-gen-grpc-rust/src — 2 commits
  • tonic/src — 2 commits
  • grpc-benchmark/third_party — 1 commit
  • grpc-rustls/src — 1 commit
  • interop/data — 1 commit
  • interop/src — 1 commit
  • tonic-web/Cargo.toml — 1 commit

Notable commits

  • fix: fix(server): set a timer on HTTP/1 connections so hyper's header read timeout applies (#2980)
  • fix: fix(tonic-web): fix dropped trailers in combined streaming call. (#2474)
  • fix: grpc-xds: Fix import for new protobuf-generated module (#3021)
  • fix: xds-client: retry the ADS stream indefinitely and fix backoff overflow panic (#2995)
  • change: xds-client: make watch registration synchronous (#2945)
  • change: Move grpc-proto files to third_party dirs (#2998)
  • change: Wire A32 circuit breaking into xDS channels (#2712)
  • change: chore: release v0.14.8 (#2966)
  • change: chore: release v0.14.9 (#2979)
  • change: feat(grpc): add a hyper-based HTTP/2 server transport (#2913)
  • change: feat(grpc): add interop tests for the grpc server (#2915)
  • change: feat(grpc): propagate listener and connection errors from the server (#2912)
  • change: feat(tonic-xds): add XdsClientPool to share xDS clients across channels (#2978)
  • change: feat(tonic-xds): expose ADS keepalive knob in config (#2973)
  • change: feat(tonic-xds): support custom control-plane connectors (#2843)
  • change: feat(transport): expose h2 reset stream settings on Endpoint (#2972)
  • change: gprx-xds/load_balancing: Make test utilities available to grpc-xds crate. (#3003)
  • change: grpc-rustls: use adapters to implement GrpcEndpoint (#2971)
  • change: grpc-xds/load_balancing: WRR Locality LB implementation (#2950)
  • change: grpc-xds/load_balancing: Weighted Target LB implementation. (#2931)
  • …and 34 more

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit eee0da29f12750660c6fbd67c8a2632c0b506e9a — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.