connectrpc/connect-go

Features

• Multi-Protocol Support - Serves requests using several different protocols simultaneously on a single HTTP handler.
• Remote Procedure Calls - Implements a type-safe remote procedure call framework for exchanging structured messages between clients and servers.
• Single-Port Multi-Protocol Support - Allows a single server handler to host and automatically detect multiple communication protocols on a single port.
• Structured Message Serialization - Converts data structures to binary or JSON formats for service communication.
• Request-Response Middleware - Provides middleware for intercepting the request-response cycle to implement logging, authentication, and telemetry.
• Protobuf RPC Frameworks - Provides a full communication framework leveraging Protocol Buffers for both interface definition and serialization.
• Wire-Compatible Handlers - Builds handlers and clients that maintain wire-compatibility across various communication protocols.
• Client-to-Server Streaming - Implements a formal RPC pattern where the client sends a sequence of messages for a single response.
• gRPC and Connect RPC Frameworks - Provides a complete framework for building type-safe RPC services wire-compatible with gRPC and HTTP.
• HTTP Client Integrations - Enables service method invocation using standard HTTP clients to receive structured responses.
• Single Port Protocol Multiplexing - Detects and handles multiple communication protocols on a single port by inspecting content types and paths.
• gRPC Service Implementations - Provides a full implementation of gRPC services for high-performance remote procedure calls.
• Service Consumption - Provides generated clients to invoke methods and process responses from remote services.
• Remote Procedure Invocation Systems - Supports unary, streaming, and bidirectional remote procedure invocation patterns.
• Multi-Protocol - Implements an RPC server capable of handling multiple distinct communication protocols simultaneously on a single port.
• Server-to-Client Response Streaming - Enables the server to send a sequence of messages incrementally to the client.
• Service Schema Definitions - Implements service schemas that define the communication patterns for unary and streaming RPC calls.
• Strongly Typed RPC Interfaces - Provides strongly typed interfaces for executing remote procedure calls with compile-time safety.
• Type-Safe Client Generators - Generates idiomatic, type-safe clients from API specifications supporting multiple transports and streaming.
• Connect RPC Implementations - Defines and serves API endpoints that communicate using the Connect protocol to handle requests.
• Bidirectional Streams - Supports full-duplex bidirectional message streaming between clients and servers.
• Request Interception Middlewares - Injects logic into requests to implement logging, authentication, or telemetry via middleware.
• Content Negotiation - Selects between binary and JSON encoding for payloads based on request and response headers.
• Type-Safe API Clients - Provides type-safe clients for sending requests to remote services and processing returned responses.
• Length-Delimited Message Framing - Wraps bytes in protocol-specific framing using length prefixes and flags.
• gRPC Error Metadata - Attaches machine-readable codes and diagnostic metadata to errors for structured communication.
• Request Retries - Automatically replays requests when a connection close error occurs using the request body.
• Byte Stream Framing - Converts structured data to and from byte streams for network transmission using protocol framing.
• Buffer Recycling - Reuses memory slices for network packet operations to minimize garbage collection overhead.
• Payload Compressions - Reduces the size of serialized data payloads to optimize network usage.
• Compression Wrappers - Reduces the size of transmitted data using reusable wrappers to optimize network bandwidth.
• Transport Protocol Switching - Allows clients to toggle between different transport protocols for the same service.
• RPC Server Integration - Integrates schema-based network services with standard HTTP handlers for flexible request processing.
• Schema-Based Server Generation - Generates server-side routing and content negotiation code directly from protobuf schemas.
• Bidirectional Stream Establishment - Establishes persistent, multiplexed bidirectional data streams over a single network connection.
• Data Compression and Decompression - Configures outgoing message compression algorithms and registers compatible decompression methods.
• Structured Error Responses - Writes error responses in standardized formats that clients interpret as structured codes and messages.
• Data Encoders and Decoders - Selects between binary and JSON encodings for requests and responses based on standard mapping.
• Semantic Error Code Mappings - Translates internal service failures into semantic error codes and metadata compatible with RPC standards.
• Request Interception Middleware - Implements an architectural pattern for intercepting requests to provide logging and authentication.
• Request Validation - Verifies that incoming requests use supported protocols by checking content-type headers and versions.
• RPC Path Parsing - Extracts package, service, and method names from a URL path to identify the target procedure.
• RPC URL Parsing - Extracts the canonical service and method path from full web addresses or rooted paths.
• Server Reflection - Allows clients to discover available services and method signatures dynamically at runtime.
• Panic Recovery - Intercepts unexpected panics during execution and converts them into structured error responses.
• Schema-Based Path Parsing - Provides a predictable naming convention to parse package, service, and method names from HTTP request paths.
• Real-Time Communication - Provides technologies for persistent, bidirectional data streaming for real-time communication.
• Panic Recovery Middleware - Traps unexpected runtime panics in handlers to return controlled error messages to the client.
• Request Metadata - Allows retrieval of request headers, peer information, and HTTP methods from the active request context.
• Microservices and RPC - Interoperable Protobuf RPC implementation.

Star history