redis/rueidis

Features

• Redis Clients - Provides a high-performance Redis client with connection pooling, multiplexing, and automatic pipelining.
• RDMA Clients - Provides a high-performance Redis client with specialized RDMA connectivity to minimize latency and CPU overhead.
• Client-Side Cache Invalidations - Implements client-side caching that synchronizes state using invalidation notifications to minimize network round trips.
• Command Pipelining - Groups concurrent non-blocking commands into a single network request to increase throughput.
• Redis - Manages the lifecycle of Redis connections, including pooling, multiplexing, and pipelining.
• Protocol Implementations - Implements the full Redis serialization protocol for high-performance message encoding and decoding.
• Connection Pools - Maintains a pool of reusable database connections to limit resource usage and reduce overhead.
• Protocol Serialization Encoders - Implements the encoding of complex data structures into compliant byte sequences for Redis transmission.
• High-Level Query APIs - Provides a high-level API adapter that simplifies command construction and reduces code verbosity for Redis clients.
• Local Caching Layers - Stores server responses in local memory-resident caches to reduce network latency and server load.
• Data Structure Operations - Manages complex data types including Bloom filters, bitmaps, and JSON documents for efficient search.
• PubSub Interfaces - Implements event-driven interfaces for publishing and subscribing to real-time message channels.
• Distributed Task Coordination - Coordinates shared resource access across processes using majority-based locks and session management.
• Distributed Locks - Provides a distributed lock manager implementing majority-based locking and optimistic concurrency control.
• Publish-Subscribe Messaging - Implements a publish-subscribe model to send messages to specified channels for all active subscribers.
• Connection Multiplexing - Distributes requests across multiple pipeline connections to optimize throughput and reduce contention.
• Connection Pooling - Manages a pool of multiplexed connections to distribute requests and optimize network throughput.
• High-Performance Networking - Reduces latency and CPU overhead through RDMA connectivity and optimized binary protocol parsing.
• Protocol Parsers - Implements a parser to decode Redis Serialization Protocol (RESP) messages from byte streams into Go data types.
• Pub-Sub Messaging - Implements a high-performance pub-sub messaging system for decoupling message producers and consumers.
• RDMA Networking - Utilizes Remote Direct Memory Access for high-performance transport to reduce latency and CPU overhead.
• RDMA Protocol Implementations - Provides high-performance connectivity using Remote Direct Memory Access to reduce latency and CPU overhead.
• Majority-Based Distributed Locks - Provides a distributed lock manager that requires a majority of keys to coordinate access to shared resources.
• Request Pipelines - Supports manual batching of multiple database commands into a single network request.
• Client-Side Caching - Reduces network round trips by mirroring server responses locally and using invalidation signals.
• Cache Operation Tracing - Provides telemetry spans to trace the performance of key-value store operations.
• Bitmap-Based Membership Tracking - Provides bitmap manipulation capabilities to track boolean states and efficient set memberships.
• Lua Scripting - Supports the execution of server-side Lua scripts for atomic state transitions and performance optimization.
• Stampede Mitigation - Implements request coordination during cache misses to prevent redundant backend load (cache stampede).
• Command Buffering - Implements a flow buffer to queue database commands for managed write sequences and response handling.
• JSON Handling Utilities - Supports storing and retrieving raw bytes and JSON strings without unnecessary data conversions.
• Optimistic Locking - Implements optimistic locking using WATCH/MULTI/EXEC to prevent lost updates during concurrent modifications.
• Probabilistic Membership Filters - Offers memory-efficient probabilistic filters for membership queries and sliding window tracking.
• Bloom Filters - Provides space-efficient Bloom filters for probabilistic membership testing.
• Counting - Implements counting Bloom filters that track element frequency and support element removal.
• Sliding Window - Provides sliding window Bloom filters to monitor item membership over a specific duration.
• Read Replicas - Includes logic to route read operations across replica nodes to distribute load away from the primary node.
• Object-to-Redis Mappers - Implements object mapping to persist application structures as Redis hashes or JSON documents.
• Search Indexing - Provides indexing capabilities to enable efficient querying and retrieval of object repositories.
• Response Body Streaming - Processes large server responses as streams to avoid high memory allocation for the response body.
• Response Streaming - Enables incremental reading of server response streams to optimize memory usage during large data transfers.
• PubSub Channel Subscriptions - A mechanism to listen for messages on specific channels and trigger callbacks upon arrival.
• PubSub Channel Unsubscriptions - The ability to stop listening for messages on a specific channel to cease receiving updates.
• Exponential Backoff Retries - Automatically reapplies failed commands using an exponential backoff strategy to prevent server overloading.
• Transactional Row Locking - Provides transactional row locking through dedicated connections to prevent command interleaving during optimistic locking sequences.
• Cache Aside Patterns - Implements a cache-aside pattern with proactive invalidation to minimize redundant network calls.
• Idempotent Operation Retries - Implements automatic retries for read-only or idempotent write commands upon failure until a specified timeout.
• Ring Buffers - Uses a circular ring-buffer for efficient queuing of requests and retrieval of command results.
• Cache Efficiency Metrics - Tracks cache hit/miss rates and efficiency metrics for local client-side caching.
• Command Performance Tracing - Uses histograms to measure command execution durations and error rates to identify slow queries.
• Request Deduplication - Suppresses duplicate concurrent requests for the same resource to prevent redundant processing.

Star history