cloudwego/hertz

Features

• High-Performance HTTP Servers - Provides a high-performance Go framework optimized for low-latency, high-throughput web service and RESTful API delivery.
• Memory Reference Counting - Implements zero-copy memory management using reference counting to handle high-concurrency traffic with minimal memory overhead.
• Kernel-Level Data Splicing - Uses zero-copy APIs to send and receive data between processes and the kernel, avoiding memory buffer duplication.
• Interface Definition Code Generation - Generates server skeletons and client stubs from Thrift or Protobuf IDL files to ensure type safety.
• Server Boilerplate Generators - Automatically generates server-side boilerplate code from API schema definitions to ensure type safety.
• Thrift Service Implementations - Implements server-side service logic to process remote procedure calls using the Apache Thrift protocol.
• High-Concurrency Networking - Utilizes non-blocking I/O and asynchronous calls to process massive volumes of concurrent network requests with minimal latency.
• High-Performance Networking - Optimizes throughput and latency using non-blocking I/O, zero-copy data transfer, and customizable network libraries.
• gRPC Service Implementations - Implements gRPC services for defining and executing high-efficiency remote procedure calls.
• Reactor Pattern Event Distribution - Employs a reactor-based event loop to distribute network events to a worker pool for high-performance request handling.
• URI Handlers - Matches URIs to handler functions using a high-performance routing tree with parameter matching.
• Network Event Monitoring Schedulers - Implements a high-performance event monitoring scheduler to trigger asynchronous network I/O operations.
• Asynchronous Middleware Engines - Implements an asynchronous middleware engine to process requests through a sequence of non-blocking functions.
• Interceptor Middleware - Implements a pluggable pipeline for injecting cross-cutting concerns like authentication and logging into the request lifecycle.
• Reference-Counted Memory Blocks - Uses memory blocks and reference counting to move data between the network and application without duplicating buffers.
• Microservice Architectures - Provides a toolkit for building scalable backend systems with support for gRPC, Thrift, and service discovery.
• Custom Middleware Implementations - Allows inserting custom processing steps before and after handlers using an onion-model architecture.
• Go Web Frameworks - Acts as a high-performance Go web framework for building scalable microservices and AI applications.
• Microservices Frameworks - Provides a comprehensive toolkit for high-efficiency remote procedure calls using gRPC and Thrift protocols.
• Onion-Model Pipelines - Utilizes an onion-model architecture where requests and responses flow through concentric middleware layers.
• REST API Frameworks - Provides a framework for mapping HTTP routes to handlers with integrated request validation and automated Swagger documentation.
• Trie-Based Routing Engines - Employs a high-performance routing engine that organizes path patterns into trie structures for efficient URI matching.
• HTTP Routing - Directs incoming HTTP traffic to specific handlers using static routes, parameter-based routes, and priorities.
• AI Application Frameworks - Provides a structured framework to organize model logic and data processing for building AI-native applications.
• Data Serialization and Parsing - Processes Thrift and Protobuf definitions for high-performance structured data serialization.
• Graceful Shutdowns - Ensures clean termination by allowing all in-flight requests to complete before shutting down the server process.
• Pluggable Transport Layers - Provides a modular interface for swapping underlying network transport libraries and protocols to optimize performance.
• Connection Multiplexing - Simulates multiple virtual connections over a single persistent connection to reduce scheduling overhead and increase efficiency.
• Custom Protocol Implementations - Provides a pluggable interface to register and implement custom communication protocols.
• Dynamic Service Discovery - Provides mechanisms for mapping logical service names to physical network addresses to enable dynamic microservices communication.
• Protocol Version Selectors - Supports various versions of the HTTP protocol and allows for custom protocol extensions.
• Multi-Protocol - Supports multiple communication protocols simultaneously to enable interaction across different service architectures.
• Service Governance - Coordinates service discovery, registration, and load balancing to maintain stability within a microservices environment.
• Incremental Stream Processing - Processes large payloads and proxy requests incrementally to reduce memory overhead and latency.
• Request Authentication Middleware - Features an asynchronous middleware engine that intercepts requests to enforce authentication via tokens and API keys.
• Automated API Documentation - Automatically generates technical API specifications and documentation from source code using the Swagger standard.
• Reactor Pattern Event Loops - Distributes network events to a worker pool using a reactor-based event monitoring scheduler to handle high concurrency.
• Request Interception Middleware - Implements architectural patterns for routing traffic through security and logging layers before core business processing.
• Request Middleware - Provides reusable middleware components to handle cross-cutting concerns like logging and error recovery.
• Request Validation - Provides utilities for validating incoming HTTP request parameters, queries, and cookies against defined schemas.
• Application Performance Monitoring - Tracks execution metrics to monitor the health and response times of service requests.
• Distributed Tracing - Traces requests across microservice boundaries using telemetry standards to identify system bottlenecks.
• Metric and Performance Monitors - Monitors system health by tracking metrics, traces, and logs using industry-standard tools.
• Observability Tool Integrations - Injects custom providers for logging, tracing, and metrics via a standardized observability interface.
• Service Observability Integrations - Integrates distributed tracing, performance metrics, and structured logging to monitor the health of Go services.
• Custom Log Writers - Provides a custom logging interface to control how system events and errors are recorded and formatted.
• Network-Bypass - Tests request handlers using internal interfaces to bypass the network stack and increase execution speed.
• Payload Type Mapping - Maps incoming request payloads to structured data types for consistent processing and validation.
• Response Formatting - Produces output in multiple formats, including JSON, HTML, and Protobuf, to meet diverse client requirements.
• Response Rendering - Transforms internal data structures into formatted responses for delivery via a unified rendering interface.
• Static Asset Serving - Provides web server capabilities optimized for delivering static files and assets directly to clients.

Star history