apache/brpc

Features

• Remote Procedure Calls - Provides a high-performance framework to call functions on a remote server as if they were local.
• Multi-Protocol Hosting - Hosts diverse communication protocols including gRPC, Thrift, HTTP, Redis, and Memcached on a single TCP port.
• RPC Frameworks - Provides a high-performance C++ framework for executing remote procedures with support for Protobuf, gRPC, and Thrift.
• Single-Port Multi-Protocol Support - Handles HTTP, gRPC, Redis, Memcached, and Thrift on a single communication port with automatic protocol detection.
• Event-Driven Message Dispatching - Handles binary data concurrently using an event dispatcher to minimize long-tail latency.
• Protocol Buffers - Transmits requests and responses using the Protocol Buffers wire format for efficient binary communication.
• Consensus Algorithms - Coordinates state across a distributed cluster using consensus algorithms to ensure high availability and consistency.
• Request Pipeline Parallelization - Parallelizes message reading, parsing, and writing to maximize throughput and prevent network blocking.
• Load-Balanced Cluster Access - Connects to servers via a naming service and load balancer to distribute outgoing requests.
• Apache Thrift Integrations - Uses the Thrift protocol to send synchronous or asynchronous requests to remote servers.
• Bi-directional Streaming RPC - Creates full-duplex connections to transmit large datasets as an ordered sequence of messages.
• Cluster Discovery Services - Identifies available server nodes through naming services to facilitate discovery across distributed clusters.
• Communication Protocols and Standards - Supports multiple wire formats including binary standards, HTTP, gRPC, Thrift, Redis, and Memcached.
• Raft Consensus Implementations - Implements the Raft algorithm to maintain a consistent and highly available state across distributed nodes.
• gRPC Interfaces - Communicates with gRPC clients and servers using the gRPC-over-HTTP2 protocol.
• High-Performance Transport Layers - Implements high-throughput transport using RDMA and zero-copy buffers to minimize CPU and memory overhead.
• Message Serialization Protocols - Converts protobuf messages to and from buffered data using zero-copy streams for efficient transmission.
• Multi-Cluster Service Connectivity - Resolves service names to server lists and distributes requests across clusters using load balancing.
• Multi-Protocol Interoperability - Interoperates with industry-standard protocols including gRPC, HTTP, Thrift, Redis, and Memcached.
• Multi-Protocol Routing - Accepts connections using various protocols on one port and detects the protocol automatically.
• Single-Port Protocol Detection - Detects and handles multiple communication protocols on a single TCP port by analyzing data patterns.
• Single Port Protocol Multiplexing - Hosts and automatically detects multiple protocols including HTTP, Redis, and Memcached on a single TCP port.
• RDMA Networking - Bypasses the kernel TCP stack using RDMA to move data between systems with reduced CPU overhead.
• Interface Definitions - Implements request and response interfaces using protobuf to define remote call contracts.
• Remote Procedure Execution - Facilitates high-performance communication between distributed nodes like databases and storage engines.
• Multi-Protocol - Functions as an RPC server that simultaneously handles gRPC, Thrift, HTTP, Redis, and Memcached on one port.
• Service Address Resolution - Resolves logical service names to network addresses using backends like DNS, ZooKeeper, and etcd.
• Service Discovery - Maps service names to dynamic server addresses and balances traffic across clusters using naming services like Consul and DNS.
• Service Discovery Integrations - Integrates custom naming services like DNS and etcd for dynamic service discovery.
• Traffic Distribution - Balances network traffic across backend servers using round-robin, random, and consistent hashing strategies.
• Asynchronous RPC Execution - Supports non-blocking RPC execution using callbacks to handle concurrent requests efficiently.
• Dynamic Service Discovery - Maps service names to dynamic server addresses using backends like Consul, Nacos, or DNS.
• Tail Latency Measurement - Calculates percentiles and distribution functions to identify and monitor long-tail latency.
• Unary RPC Execution - Provides blocking request-response patterns where the calling thread waits for a server response or timeout.
• Zero-Copy Buffers - Uses non-contiguous buffers and registered memory regions to eliminate data duplication during transmission.
• Latency Monitoring - Automatically tracks request timing to derive throughput and latency percentiles.
• Metric Collection - Collects low-overhead numerical data and distributions for high-frequency functions to monitor performance.
• Multi-Protocol Servers - Hosts diverse communication protocols on a single port to enable varied client access.
• Zero-Copy Buffers - Eliminates data duplication by reading and writing directly from registered memory buffers.
• Distributed Monitoring - Provides observability for distributed architectures, including request latency tracking, throughput metrics, and Prometheus integration.
• Memcached - Implements binary protocol operations for high-performance interaction with Memcached caching systems.
• Network Programming Libraries - Provides a C++ toolkit for low-latency networking with zero-copy buffers and asynchronous I/O.
• JSON-Protobuf Mapping - Converts JSON request bodies into protobuf messages and serializes responses back to JSON.
• Incremental Data Streaming - Sends and receives data in continuous streams to handle large datasets efficiently.
• JSON Data Exchange - Serializes requests and responses as JSON over HTTP to ensure interoperability with web clients.
• Stream Message Boundary Preservation - Writes and reads messages across a stream while preserving order and message boundaries.
• Parallel Provider Calls - Sends requests to multiple channels simultaneously and merges responses based on success thresholds.
• Flow Control - Pauses data transmission when remote buffers are full to prevent data overflow.
• RESTful - Functions as an HTTP server and client with RESTful URL mapping and JSON conversion.
• Request Retries - Implements automatic re-attempting of failed network requests to improve overall system reliability.
• Partition Migration - Shifts traffic between partitioning methods or server capacities without interrupting service.
• Workload Partitioning - Organizes sub-channels using naming service tags to segregate traffic and route requests to specific partitions.
• Hedged - Sends requests to backup replicas if the primary attempt fails or exceeds the timeout limit.
• Thrift Message Dispatching - Dispatches incoming Thrift protocol messages to specific service methods for processing.
• Connection Pooling - Configures short-lived, pooled, or long-term TCP connections to optimize the balance between throughput and CPU usage.
• Custom Protocol Implementations - Allows registering custom parsing, serialization, and processing functions to support new communication formats.
• HTTP/2 Support - Implements the HTTP/2 protocol to support multiplexed requests and responses for high-performance RPC communication.
• Load Balancer Endpoint Filtering - Excludes specific servers from the load balancer based on criteria like server tags.
• Sub-Channel Distribution - Distributes requests among internal sub-channels using algorithms to manage traffic between groups.
• Error Signaling - Sets error codes and metadata to notify remote peers of call failures.
• Protocol Detection - Analyzes initial data patterns on a single TCP port to automatically dispatch traffic to the correct protocol handler.
• Latency-Based Ranking - Optimizes response times by directing traffic to servers based on measured real-time latency.
• Request Routing - Forwards incoming calls to destination services using routing logic, enabling interaction without stubs.
• Asynchronous Call Synchronization - Blocks the current thread until asynchronous calls and their associated callbacks finish executing.
• Remote Call Cancellation - Can terminate a pending remote procedure call using a unique call identifier.
• Circuit Breakers - Utilizes circuit breakers to isolate unhealthy nodes and stop requests to failing services.
• Transmission Rate Regulation - Regulates transmission rates using explicit acknowledgments to prevent overwhelming slow receivers.
• Preallocated Memory Pools - Allocates and registers large contiguous memory regions to minimize the overhead of frequent RDMA registration.
• Resource Recycling - Tracks file descriptors with reference counting to safely recycle sockets across asynchronous operations.
• Authentication Clients - Authenticates clients upon the first request using custom authenticators and security contexts.
• Connection Authentication Mechanisms - Verifies client identities using per-request credentials or connection-level handshakes to secure the RPC channel.
• SSL/TLS Certificate Management - Manages SSL/TLS certificates with support for Server Name Indication and dynamic runtime updates.
• Security & HTTPS - Automatically establishes secure encrypted connections when the request URI uses the HTTPS scheme.
• Request Size Limiters - Protects server resources by rejecting incoming requests that exceed defined byte limits.
• Backlog Limiting - Limits backlogged requests during spikes to ensure fast recovery when volume normalizes.
• Service Isolation - Restricts access to internal management services by isolating them on separate ports.
• Asynchronous Event Dispatchers - Processes incoming binary messages concurrently via an event dispatcher to minimize long-tail latency.
• Deadline Management - Enforces maximum wait times for remote operations to prevent resources from being held indefinitely.
• Consistent Hashing - Distributes requests across a cluster using consistent hashing algorithms like Ketama to minimize scaling disruption.
• Wait-Free Transmission Queues - Queues binary data for transmission using a wait-free list to resolve write contentions.
• Binary Payload Attachments - Allows sending raw binary data alongside RPC messages to bypass serialization overhead for large payloads.
• Lock-Free Concurrent Queues - Utilizes wait-free lists for outgoing binary data to resolve write contentions between concurrent threads.
• RPC Execution Tracing - Monitors and traces active RPC requests to debug communication and performance between distributed services.
• Request Hedging - Implements request hedging by sending redundant requests to alternative servers and accepting the fastest result.
• Dynamic Concurrency Tuning - Limits simultaneous requests to a service and adjusts limits dynamically to prevent overload.
• Deferred Response Definitions - Enables defining services that return immediately and defer the final response until a closure executes.
• Lifecycle Management - Uses reference counting to track and safely recycle socket file descriptors in multi-threaded environments.
• Application Performance Monitoring - Tracks request counts, error rates, and concurrency per method to monitor distributed service performance.
• Global Metric Registries - Registers internal variables into a global registry to make them searchable and accessible by monitoring tools.
• Microservices Health Monitoring - Tracks the operational status and health of distributed service instances using periodic pings and heartbeats.
• Memory-Efficient Log Buffering - Records complex objects by streaming them to thread-local buffers to eliminate frequent memory allocations.
• Metrics Exporters - Collects internal performance variables and exposes them to external monitoring tools for analysis.
• Distributed Tracing - Implements 64-bit request identifiers to trace sessions and execution flow across multiple distributed services.
• Server Metrics - Exposes real-time internal metrics, connection statistics, and versioning via plain text or HTML endpoints.
• Metric Aggregators - Aggregates high-performance runtime statistics, such as counters and averages, for system monitoring.
• System Usage Monitoring - Tracks worker thread utilization and CPU consumption via a built-in web-based monitoring interface.
• Thread-Local Aggregation - Records performance statistics in thread-local storage to eliminate write contention in multi-threaded environments.
• Thread-Local Metric Aggregation - Tracks statistics using thread-local storage to minimize write contention in high-concurrency environments.
• Performance Profiling Tools - Provides HTTP-based CPU, heap, and contention profilers to analyze system health and identify bottlenecks.
• Prometheus Exporters - Exposes application metrics via a dedicated HTTP endpoint specifically for Prometheus scraping.
• Request Tracing - Visualizes time spent in different processing phases to pinpoint blocking calls or delays.
• Server Health Checks - Provides a dedicated reporting endpoint to return application-specific health status and server availability.
• System Inspection Utilities - Provides built-in admin services to inspect server health, variables, and active network connections.
• Response Streaming - Sends large bodies incrementally using progressive attachments to support Server-Sent Events.
• Service Method Mapping - Maps remote service methods to HTTP endpoints using naming conventions or custom RESTful URL patterns.
• DevOps & Infrastructure - Industrial-grade RPC framework
• Inter-process Communication - Industrial-grade RPC framework for high-performance systems.

Star history