microsoft/garnet

Microsoft Garnet is a high-performance, in-memory key-value store designed as a Redis-compatible server with a focus on scalability and extensibility. It provides robust cluster support featuring diskless replication, parallel AOF replay, and range index migration, while offering advanced data structures like Vector Sets, Roaring Bitmaps, and JSON via a modular plugin architecture. The system includes comprehensive tooling for performance benchmarking, fuzz testing, and Kubernetes deployment, ensuring reliability through rigorous validation of its core storage engine and network protocols.

100 changes.

The project upgraded its build target to .NET 10 and adopted the new .slnx solution format, while significantly refactoring the cluster subsystem to support asynchronous migration, diskless replication, and granular failover control. This period also introduced extensive new features including Lua scripting, ETag-based conditional operations, and a .NET module loading infrastructure, alongside comprehensive updates to the client API and benchmarking tools.

53 changes.

This period focused on expanding Garnet's data model with new types like JSON, Roaring Bitmaps, and RangeIndex, while significantly enhancing cluster replication through diskless sync and parallel AOF replay. Concurrently, the codebase underwent substantial internal refactoring, including the introduction of a unified storage session, a centralized task manager, and improved AOF recovery mechanisms to boost throughput and reliability.

The samples/ETag directory now includes C\# code illustrating how to use Garnet's ETag commands (SETWITHETAG, GETIFNOTMATCH, GETWITHETAG, SETIFMATCH) for two scenarios: reducing network bandwidth in cache-hit paths and implementing lock-free optimistic concurrency control (OCC) for concurrent updates. The sample provides an ETagAbstractions helper class, a caching simulation (Caching.cs), and an OCC simulation (OccSimulation.cs) with an interactive REPL.

samples/ETag · high confidence

Added a new benchmark suite in the BDN Lua module to measure Lua scripting performance, including script execution, compilation, and cache lookup operations. The benchmarks now support configurable memory management modes (Native, Tracked, Managed) and optional per-script memory limits, allowing users to evaluate the impact of these settings on performance. Additionally, the suite includes benchmarks for Lua script timeouts, measuring the overhead of enforcing execution time limits.

benchmark/BDN.benchmark/Lua · high confidence

Introduces the RangeIndex data type, backed by a BfTree structure, enabling users to store and query range-based data. This change adds full lifecycle management for RangeIndex keys, including locking, stub serialization, and disk-based persistence. It also implements disk-based replication and cluster migration capabilities, allowing RangeIndex data to be streamed and reassembled across nodes using chunked AOF entries and xxHash64 checksums for integrity.

libs/server/Resp/RangeIndex · high confidence

The server now supports the SLOWLOG command suite (GET, LEN, RESET, HELP), allowing users to inspect and manage a log of slow operations. This feature introduces a thread-safe container that records command details—including ID, timestamp, duration, arguments, and client information—for operations exceeding a configurable threshold. Users can retrieve the most recent entries, check the log size, or clear the log entirely, providing visibility into performance bottlenecks directly through the RESP protocol.

libs/server/Metrics/Slowlog · high confidence

The benchmark tool now supports testing Redis Cluster topologies by discovering primary and replica nodes via CLUSTER NODES, validating full slot coverage, and routing operations to primaries or replicas based on configurable percentages. It introduces both online mode (generating requests on-the-fly with support for mixed workloads and probabilistic replica reads) and offline mode (pre-generating request buffers to reduce overhead and allow shared workload distribution across workers). The implementation includes dedicated providers for LightClient, GarnetClient, GarnetClientSession, and StackExchange.Redis, along with worker pool support for scalable multi-threaded execution.

benchmark/Resp.benchmark/ClusterBench · high confidence

The benchmark suite now includes a new \Embedded\ project that provides the necessary components to benchmark the embedded Garnet server with its internal network stack. This adds \EmbeddedNetworkHandler\ and \GarnetServerEmbedded\ to manage connection lifecycle and TLS handling within the benchmark context, replaces the previous \DummyNetworkSender\ with a more complete \EmbeddedNetworkSender\ that implements the full \INetworkSender\ interface, and updates \EmbeddedRespServer\ to support direct RESP session creation and pub/sub broker integration for realistic embedded performance testing.

benchmark/BDN.benchmark/Embedded · high confidence

Added a new set of benchmarks in the \benchmark/BDN.benchmark/Network\ directory to measure the performance of the embedded RESP server. This includes a base class (\NetworkBase\) that configures an \EmbeddedRespServer\ with a batch size of 1 to stress the network layer, and specific benchmark classes for basic operations like \InlinePing\ and raw string operations such as \SET\, \GET\, \INCR\, and \DECR\.

benchmark/BDN.benchmark/Network · high confidence

The benchmark suite now includes new files for GeoHash performance testing (GeoHash.cs) and general utility helpers (BenchUtils.cs). The GeoHash benchmark measures the performance of coordinate-to-integer conversion, integer-to-coordinate retrieval, and GeoHash string generation. The utility class provides a method for generating random byte sequences using ASCII characters, likely to support other benchmarks.

benchmark/BDN.benchmark/Geo, benchmark/BDN.benchmark/Utils · high confidence

A new standalone executable, LightEpochLitmus, has been added to the playground to detect use-after-free races in the LightEpoch implementation. The harness runs a controlled stress test on native hardware (Windows or Linux) where a reader thread and a reclaimer thread contend over page lifecycles, using poison sentinels to detect if a reader accesses a recycled page. It includes a control mode to verify detector liveness, supports comparison against a frozen 'buggy' version of the algorithm via the --buggy flag, and refuses to run under emulation to ensure memory-ordering results are valid.

playground/LightEpochLitmus · high confidence

The \libs/resources\ library now includes \RespCommandsDocs.json\ and \RespCommandsInfo.json\, which provide structured documentation and metadata (such as arity, flags, ACL categories, and key specifications) for server commands like ACL, APPEND, ASKING, and ASYNC. Additionally, the \ResourceUtils.cs\ file was moved from the storage layer and simplified to serve as a marker for the new resources assembly.

libs/resources · high confidence

The benchmark suite now includes two new custom procedure implementations, CustomProcSet and CustomTxnSet, to support performance testing of specific SET workloads. CustomProcSet introduces a non-transactional command (CPROCSET) that sets four key-value pairs, while CustomTxnSet provides a transactional command (CTXNSET) that performs the same four SET operations within an exclusive lock context. These additions allow users to benchmark the performance characteristics of these specific custom operation patterns.

benchmark/BDN.benchmark/Custom · high confidence

The OfflineBench benchmark now supports an in-process client mode (ClientType.InProc) that runs the Garnet server directly within the benchmark process, eliminating network overhead. This change introduces the GarnetServerInstance helper to manage the embedded server and session configuration, and updates the benchmark runner to initialize and drive these in-process sessions. Additionally, when running in this mode, the benchmark now tracks and reports total bytes consumed and bytes consumed per second (in GiB/sec), providing insight into storage throughput alongside standard operations-per-second metrics.

benchmark/Resp.benchmark/OfflineBench · high confidence

The JSON module now uses a custom JSONPath engine instead of the previous library. This change enables support for advanced JSONPath features including array slicing (e.g., .\[1:5:2\]), multiple index selection (e.g., .\[0,1,2\]), and recursive descent queries (e.g., ..\[?(@.name == 'value')\]). Users can now query JSON data with more complex filtering and selection patterns.

modules/GarnetJSON/JSONPath · high confidence

The Garnet server's custom command registration API has been updated to allow clients to discover command details (such as arity, flags, and ACL categories) via the COMMAND and COMMAND INFO protocol. Existing commands like SETIFPM, MYDICTSET, and MYDICTGET now include this metadata, while others (SETWPIFPGT, DELIFM) have been simplified to remove explicit arity parameters. Additionally, new registration methods have been introduced: NewProcedure for non-transactional stored procedures (e.g., SUM, SETMAINANDOBJECT) and NewTransactionProc without arity arguments for transactional procedures (e.g., MSETPX, MGETIFPM), expanding the ways users can extend the server with custom logic.

main/GarnetServer · high confidence

The benchmark suite now includes dedicated benchmarks for BfTree point and scan operations (comparing span-based vs pinned memory paths), RESP command parsing tiers (SIMD fast path, scalar, and hash table lookup), and a broader set of operations including basic commands, hashes, JSON module commands, custom procedures/transactions, and object operations. It also introduces a larger-than-memory (LTM) raw string benchmark that exercises the device IO path with a tiny in-memory log, and adds support for running benchmarks with AAD authentication, ACLs, and AOF enabled via a new OperationParams configuration.

benchmark/BDN.benchmark/Operations · high confidence

The Set object implementation now supports additional Redis commands (SMOVE, SRANDMEMBER, SISMEMBER, SMISMEMBER, SUNION, SUNIONSTORE, SDIFF, SDIFFSTORE, SINTER, SINTERSTORE) and stabilizes persisted enum values for AOF compatibility. On .NET 9, the implementation uses HashSet's AlternateLookup to reduce allocations during set operations.

libs/server/Objects/Set · high confidence

Users can now host the Garnet server as a Windows Service. This change introduces a new worker project that registers a background service using the .NET Generic Host, configuring the service name as 'Microsoft Garnet Server'. The worker initializes and starts the GarnetServer instance on startup and ensures proper disposal during graceful shutdown.

hosting · high confidence

The GarnetClient API now supports Redis list operations, adding synchronous and asynchronous wrappers for LPUSH, RPUSH, LRANGE, and LLEN. Internally, the client library has been refactored to improve async behavior by adding ConfigureAwait(false) to all await calls and replacing Encoding.ASCII.GetBytes with UTF-8 string literals for command definitions.

libs/client/GarnetClientAPI · high confidence

The server now supports the GEOSEARCH command, allowing users to find members within a sorted set based on circular (BYRADIUS) or rectangular (BYBOX) areas, with options for distance units (meters, kilometers, miles, feet), sorting, and returning coordinates, hashes, or distances. This change also significantly improves geospatial performance by replacing the previous geohash encoding/decoding logic with a faster, SIMD-optimized implementation that is 40-100x quicker, and refactors the underlying object implementation to remove unsafe code and improve memory efficiency.

libs/server/Objects/SortedSetGeo · high confidence

Hash objects now support setting and managing Time-To-Live (TTL) on individual fields via the new HEXPIRE, HPEXPIRE, HEXPIREAT, HPEXPIREAT, HTTL, HPTTL, HEXPIRETIME, HPEXPIRETIME, and HPERSIST commands, as well as the HCOLLECT command. The HSTRLEN command has been added to return the string length of a hash value. Internally, the implementation has been refactored to use a more efficient output writing mechanism (replacing the deleted ObjectUtils), and the HashOperation enum has been updated to include these new operations.

libs/server/Objects/Hash · high confidence

This change introduces the first version (0.2.2) of the official Helm chart for Microsoft Garnet, enabling users to deploy the Garnet key-value store on Kubernetes via \helm upgrade --install\. The chart includes a StatefulSet configuration with support for persistence, configurable service ports (default 6379), and options for custom image tags and pull policies. It also provides mechanisms for Garnet configuration via \garnet.conf\ content or an existing Kubernetes secret, along with standard Kubernetes features like liveness/readiness probes, security contexts, and volume claim templates.

charts/garnet, charts/garnet/templates · high confidence

This change adds the core infrastructure for loading custom .NET assemblies (modules) at runtime. It introduces the \ModuleBase\ abstract class that modules must inherit, along with \ModuleLoadContext\ to allow modules to register custom commands, transactions, procedures, and object types with the server. The \ModuleRegistrar\ singleton manages module instantiation, while \ModuleUtils\ provides logic to parse module specifications (including paths with spaces) and load only the specific dependencies required by a module, rather than loading all DLLs in a directory.

libs/server/Module · high confidence

Adds a new BfTree-based range index implementation to the native layer, exposing a Rust FFI library (bftree\_garnet) and a C\# wrapper (BfTreeService) for point operations (insert, read, delete), zero-allocation scans, and CPR snapshot/recovery. The index supports both disk-backed and memory-only storage backends, allowing users to leverage this high-performance native structure for range queries.

libs/native · high confidence

A new developer tool (\playground/CommandInfoUpdater\) has been added to automatically regenerate Garnet's \RespCommandsInfo.json\ and \RespCommandsDocs.json\ resource files. The tool queries a live RESP server (such as Valkey) to fetch standard command metadata and merges it with Garnet-specific overrides defined in \GarnetCommandsInfo.json\ and \GarnetCommandsDocs.json\, ensuring that command info (arity, flags, ACL categories) and docs (summaries, groups, complexity) remain synchronized with the server's actual capabilities.

playground/CommandInfoUpdater · high confidence

The GarnetJSON module is now available, registering the \JSON.SET\ and \JSON.GET\ commands. This implementation uses a custom \GarnetJsonObject\ type to store and retrieve JSON data, supporting JSONPath expressions for targeted access. The module includes optimized serialization paths for GET operations to reduce memory allocations, allowing users to store and query JSON documents directly within Garnet.

modules/GarnetJSON · high confidence

The NoOpModule now provides a set of no-operation command and object implementations for testing and extension purposes. It registers read and read-modify-write commands (NOOPCMDREAD, NOOPCMDRMW, NOOPOBJREAD, NOOPOBJRMW), a transaction procedure (NOOPTXN), and a custom procedure (NOOPPROC). The module also includes a DummyObject type with a factory, serializer, and no-op read/RMW functions, replacing previous disposal and serialization logic in the core storage layer.

modules/NoOpModule · high confidence

This change adds a new Roaring Bitmap custom object type to Garnet, enabling efficient storage and manipulation of large bitmaps using a compressed array/bitmap hybrid structure. Users can now load the module and use the new RESP commands: R.SETBIT to set or clear bits, R.GETBIT to read bit values, R.BITCOUNT to get the number of set bits, and R.BITPOS to find the position of the first set or unset bit. The implementation includes serialization support and integrates with Garnet's object store for persistence and memory usage tracking.

modules/RoaringBitmap · high confidence

The server now includes a TaskManager component that centralizes the lifecycle management of background maintenance tasks. This new system allows tasks to be registered, started, and cancelled with specific placement constraints (Primary, Replica, or All), ensuring that operations like AOF size monitoring, scheduled checkpoints, log compaction, and vector replication replay run on the appropriate node types. The implementation provides a unified registry to track task status and handles cleanup and cancellation via linked cancellation tokens.

libs/server/TaskManager · high confidence

Added the core components for diskless replication in the primary node's replication pipeline. The new ReplicaSyncSession, ReplicationSyncManager, and ReplicationSnapshotIterator classes enable streaming checkpoint snapshots and AOF logs directly to replicas over the network, bypassing local disk I/O. This change supports parallel replication sessions and includes logic for handling large objects via chunked serialization, ensuring replicas stay in lockstep during the sync process.

libs/cluster/Server/Replication/PrimaryOps/DisklessReplication · high confidence

Vector Set search now supports filtering by JSON attributes using a new, zero-allocation expression engine. This change adds a lightweight JSON field extractor, a shunting-yard expression compiler, and a stack-based VM runner that operate entirely on byte spans without heap allocations. Users can now apply complex filter expressions (e.g., \.year \>= 2000 and .rating \> 7\) to narrow down vector search results, with the system handling field extraction and evaluation efficiently during the search process.

libs/server/Resp/Vector · high confidence

Adds new methods to the \StorageSession\ class for interacting with the Unified Store, including GET, SET, EXISTS, DELETE, DELIFEXPIM, and EXPIRE/EXPIREAT operations. These methods provide a consistent interface for reading, writing, and managing key expiration within the unified storage context, handling pending operations and metrics tracking internally.

libs/server/Storage/Session/UnifiedStore · high confidence

The AOF subsystem now supports large object values by splitting them into chunks during write and reassembling them during replay via the new AofChunkHeader and AofChunkedRecordReader components, eliminating the need for contiguous memory allocation for large records. Additionally, a new AofBackpressure mechanism has been added to the primary side of replication; it monitors the lag between the AOF tail and the shipped watermark to replicas, stalling append operations if the lag exceeds the configured AofSyncMaxLagBytes budget to prevent data loss during replication delays.

libs/server/AOF · high confidence

The List object implementation now uses explicit byte values for all ListOperation enums (e.g., LPOP=0, LPUSH=1) to ensure stable serialization and append-only AOF compatibility, preventing issues from reordering. This change also introduces support for three new list commands: LSET (to set a list element at a specified index), BRPOP and BLPOP (blocking pop operations), and LPOS (to find the position of an element). Additionally, the internal implementation has been refactored to use a managed \ObjectInput\/\ObjectOutput\ interface instead of unsafe pointer-based parsing, improving safety and consistency across list operations.

libs/server/Objects/List · high confidence

The main store now supports native ETags, introducing conditional commands SETIFGREATER, SETIFMATCH, DELIFGREATER, GETWITHETAG, and GETIFNOTMATCH that allow clients to perform operations based on version identifiers. This feature is implemented via new ETag-specific callback methods in the main store's read and RMW (Read-Modify-Write) logic. Concurrently, the main store's internal architecture has been refactored from the legacy SpanByte-based IFunctions interface to the modern StringInput/StringOutput-based ISessionFunctions interface, improving type safety and performance for string operations.

libs/server/Storage/Functions/MainStore · high confidence

This change introduces a native Linux storage backend for Tsavorite, including C++ source files for portable filesystem and libaio compatibility, a script to build the native shared libraries, and a C\# solution file to organize the project. It also adds a new lean Tsavorite KV throughput benchmark (BDN-Tsavorite.Benchmark) with tests for epoch operations, iteration, and basic CRUD operations, alongside a device-level benchmark for measuring I/O performance across different device types and configurations.

libs/storage · high confidence

Adds a new offline benchmark suite (AofBench) to measure Append-Only File performance. The suite supports multiple modes: AOF replay (with and without RESP parsing), direct in-process replay bypassing the network layer, and sharded or random AOF enqueue operations. It provides detailed throughput metrics including bytes per second, records replayed/enqueued per second, and total pages processed, allowing users to evaluate the impact of configuration options like cluster settings and sublog counts on AOF write and replay speeds.

benchmark/Resp.benchmark/OfflineBench/AOFBench · high confidence

The server now includes a dedicated read-consistency layer in the AOF subsystem to maintain consistent reads across virtual sublogs on replicas. This change introduces a ReadConsistencyManager that tracks per-key and per-sublog sequence numbers, a ReplayAlignBarrier to synchronize replay threads and bound inter-sublog drift, and session contexts (ReplicaReadSessionContext) that cache sublog maxima and manage waiters for consistent reads. Users benefit from improved read consistency guarantees when replaying append-only logs across multiple virtual sublogs, with configurable drift-check thresholds and timeouts to control synchronization behavior.

libs/server/AOF/ReadConsistency · high confidence

Adds the \benchmark/Azure.benchmark\ directory containing the initial orchestration tools for the Azure benchmarking environment. This includes \01-resources/\ scripts and Bicep templates to deploy shared infrastructure (VNet, NSG, Proximity Placement Group, Storage, Key Vault) and manage SSH/TLS certificates, and \02-platform/\ assets to provision and manage VM Scale Sets (VMSS) with cloud-init configurations. The change introduces PowerShell automation for resource deployment, key management, and tools delivery via SAS URLs, along with documentation and configuration files to support the benchmarking workflow.

benchmark/Azure.benchmark · high confidence

Added a new benchmark suite under benchmark/BDN.benchmark/Cluster to measure cluster-specific performance. This includes ClusterOperations for standard commands (GET, SET, MGET, MSET, CTXNSET) with configurable slot verification and AOF settings, ClusterMigrate for slot migration scenarios, and EpochBumpContention to compare legacy busy-spin versus jittered self-poll wait strategies under thread contention.

benchmark/BDN.benchmark/Cluster · high confidence

This change introduces a new Lua scripting implementation for Garnet, replacing the previous version. It adds a sandboxed execution environment that restricts access to unsafe functions (e.g., \import\, \os.execute\) and provides a \redis\ table with supported commands like \call\, \pcall\, \log\, and \sha1hex\. The engine now supports configurable memory management modes (Native, Tracked, Managed) and per-script memory limits to prevent resource exhaustion. It also implements Redis-compatible data structures for \KEYS\ and \ARGV\ as native Lua tables, supports \struct.pack\/\unpack\ for binary data handling, and includes a script cache with configurable size limits. Error handling has been improved to return specific error codes (e.g., \NOSCRIPT\, \NOPERM\) and support status replies.

libs/server/Lua · high confidence

A new benchmarking and migration utility has been added to the playground/MigrateBench directory. This tool enables users to migrate data between Garnet cluster nodes using two distinct modes: direct key/slot migration via MigrateRequest (supporting KEYS, SLOTS, and SLOTSRANGE request types) and a slot-walking approach via MigrateSlotWalk for multi-node transfers. The utility includes a custom BenchmarkLoggerProvider for structured, high-performance logging of migration operations and timing, configurable endpoints, timeouts, and logging levels via command-line options.

playground/MigrateBench · high confidence

This change introduces a new internal infrastructure for managing RESP command metadata, including classes for command arguments, documentation, and data providers that support importing/exporting command specs via JSON. It also adds a new \AsyncProcessor\ to handle asynchronous network GET commands that go pending, allowing the server to continue processing other requests while waiting for storage I/O. Additionally, new ETag-based commands are implemented: \GETWITHETAG\, \GETIFNOTMATCH\, \DELIFGREATER\, \SETIFMATCH\, \SETIFGREATER\, and \SETWITHETAG\, enabling conditional reads and writes based on entity tags. The \CLIENT LIST\ command is enhanced to support filtering by client type (e.g., REPLICA, MASTER, PUBSUB, NORMAL) and by specific client IDs. A new \PURGEBP\ debug command is added to purge buffer pools for specific managers (MigrationManager, ReplicationManager, ServerListener). The \MGET\ command is optimized with a scatter-gather read batch implementation (\MGetReadArgBatch\_SG\) that attempts to write results directly to the output buffer for synchronous operations and buffers results for asynchronous ones.

libs/server/Resp · high confidence

A new SampleModule has been added to the playground that registers several custom capabilities: a custom command (SampleModule.SETIFPM), a custom transaction (SampleModule.READWRITETX), a custom procedure (SampleModule.SUM), and a custom type with associated commands (SampleModule.MYDICTSET and SampleModule.MYDICTGET). This module serves as a reference implementation for how users can extend the server with custom logic.

playground/SampleModule · high confidence

The libs/common library introduces a suite of new utility classes and networking primitives to support core Garnet operations. This includes ASCII parsing helpers (AsciiUtils), asynchronous task blocking utilities (AsyncUtils), a bit-vector structure (BitVector), a coarse-grained cached time provider (CoarseTimeProvider), and a CRC64 implementation ported from Redis. It also adds robust enum parsing and aliasing utilities (EnumExtensions, EnumUtils), exception handling helpers (ExceptionUtils), and key-comparison logic for the storage engine (FixedSpanByteKey, GarnetKeyComparer, HashSlotUtils). Additionally, a lightweight TCP client for testing and command execution (LightClientRequest) and configurable network buffer settings (NetworkBufferSettings) are provided.

libs/common · high confidence

The server now exposes detailed per-command usage statistics (calls, failures, and rejections) via the new \CommandStats\ class, following the Redis COMMANDSTATS convention. Additionally, \GarnetSessionMetrics\ now tracks transaction-specific data, including the number of transaction commands received and the number that failed execution. The metrics infrastructure has also been refactored to support multiple server instances and uses a \TimeSpan\-based sampling frequency instead of a raw delay integer.

libs/server/Metrics · high confidence

A new \ReadOptimizedConcurrentSet\ collection has been added to the common library, designed for read-mostly scenarios such as pub/sub logic. It uses a single-writer/multi-reader lock strategy to optimize read performance while maintaining thread safety for add, remove, and iteration operations. Additionally, the \ElasticCircularBuffer\ class has been moved into this new Collections directory.

libs/common/Collections · high confidence

The Synchronization library has been expanded with several new concurrency utilities: ActiveWorkerMonitor for tracking and draining active workers, CooperativeDisposeGuard for non-blocking disposal coordination, CountingEventSlim for count-based signaling, DoubleTurnstileBarrier for synchronized multi-participant work pages, and LeaderBarrier for leader-based synchronization. Additionally, ReadOptimizedLock introduces a cache-aware read-optimized locking scheme with exclusive-lock starvation prevention, and SingleWriterMultiReaderLock now supports upgrading read locks to write locks, downgrading write locks, and a close-lock mechanism.

libs/common/Synchronization · high confidence

Replicas can now replay the Append-Only File (AOF) stream in parallel using multiple background tasks, coordinated by a rendezvous barrier. This change introduces a new replay driver architecture that supports both synchronous (single-threaded) and asynchronous (multi-threaded) replay modes, allowing replicas to keep up with high-throughput primary streams more efficiently.

libs/cluster/Server/Replication/ReplicaOps/AOFReplay · high confidence

The authentication configuration logic in libs/server/Auth/Settings has been reorganized to support distinct authentication modes. The previous monolithic AuthenticationSettings.cs was split into specific setting classes: NoAuthSettings, PasswordAuthenticationSettings, AadAuthenticationSettings, and a new hierarchy for ACL-based authentication (AclAuthenticationSettings, AclAuthenticationPasswordSettings, and AclAuthenticationAadSettings). This change introduces support for ACL authentication using Microsoft Entra (AAD) tokens, allowing users to validate connections and commands against configured ACL users and access rules using AAD principals. The enum GarnetAuthenticationMode now includes 'AclWithAad' to enable this specific combination. Additionally, the AAD authentication settings now support an optional 'validateUsername' flag to control whether the username is validated against claims.

libs/server/Auth/Settings · high confidence

The benchmark tool now supports cluster workloads via the new --cluster-bench mode, which distributes operations across shards and allows routing a percentage of reads to replicas (--replica-ops-percent). It also introduces an AOF benchmark mode (--aof-bench) to measure replay performance at replicas, with configurable commit frequencies and memory/page sizes. For storage-bound scenarios, the tool now includes a dedicated NVMe RAID-0 matrix script (scripts/nvme-raid0-matrix.sh) that automates throughput testing across Libaio/Uring backends and NUMA pinning configurations. Additionally, the default connection port has been updated to 6379, and the tool now supports loading TLS certificate passwords from a file (--cert-password-file) and specifying an issuer certificate path (--issuer-certificate-path) for enhanced TLS validation.

benchmark/Resp.benchmark · high confidence

The server now supports dynamic adjustment of numerous runtime options through the CONFIG GET and CONFIG SET commands. Administrators can modify settings such as AOF commit frequency, replication timeouts, compaction parameters, and slowlog thresholds without restarting the server. The system distinguishes between fully runtime-adjustable options, those requiring background task restarts (like AOF commit frequency), and read-only parameters derived from startup options (such as directory paths or cluster enablement). This provides a centralized, type-safe mechanism for tuning server behavior and monitoring configuration state in real time.

libs/server/Config · high confidence

The Sorted Set object now explicitly assigns integer values to all operations (e.g., ZADD=0, ZCARD=1) to ensure the Append-Only File (AOF) format is stable and append-only, preventing breakage from future reordering. This change also introduces member-level expiration (TTL) support, adding new operations like ZEXPIRE, ZTTL, and ZPERSIST, and updating the internal storage to track expiration times and queues. Additionally, the ZADD command now supports standard Redis options (XX, NX, LT, GT, CH, INCR) with proper validation and RESP3 compatibility.

libs/server/Objects/SortedSet · high confidence

The primary node now includes RangeIndex checkpoint files (.bftree) when shipping snapshots to replicas. This change introduces a new set of components in the disk-based replication pipeline—specifically \RangeIndexSnapshotReader\, \RangeIndexFileDataSource\, and \RangeIndexFileTransmitSource\—which enumerate and stream these index files alongside the main store data. The transmission protocol was extended to handle a metadata header containing the key hash and logical address, ensuring replicas can correctly reconstruct the RangeIndex structure during recovery.

libs/cluster/Server/Replication/PrimaryOps/DiskbasedReplication, libs/cluster/Server/Replication/ReplicaOps/DiskbasedReplication · high confidence

The server API in libs/server/API has been refactored to use a unified context (TUnifiedContext) alongside the existing string and object contexts, enabling a consistent interface for operations like MEMORYUSAGE, OBJECT, TYPE, TTL, EXPIRETIME, and EXISTS. This change introduces native ETag support with new SET\_ETagConditional and DEL\_ETagConditional methods for optimistic concurrency, adds the GETEX command for key expiration and value retrieval, and implements RENAMENX for conditional key renaming. Additionally, the API now exposes the LCS command for longest common subsequence calculations and introduces a WRONGTYPE status to handle type-mismatch errors more explicitly.

libs/server/API · high confidence

The storage layer now uses a new \UnifiedSessionFunctions\ implementation in the \UnifiedStore\ area to handle all key-value operations. This change introduces dedicated methods for reading, upserting, deleting, and read-modify-write (RMW) operations, along with support for variable-length inputs. It enables consistent handling of data types including strings, heap objects, vector sets, and range indexes, while integrating expiration logic, AOF logging, and watch-version tracking into the core store functions.

libs/server/Storage/Functions/UnifiedStore · high confidence

The ClusterStress benchmark application and its supporting components have been removed from the codebase. This includes the main entry point, cluster-specific options, request generation logic for sharded and online benchmarks, and utility classes for key generation and buffer handling. Users relying on this specific stress-testing tool for cluster scenarios will no longer have access to it.

playground/ClusterStress · high confidence

The memory subsystem now enforces a process-wide budget for network buffers held by live connections, dynamically shrinking the base buffer size as connection count rises to prevent unbounded memory growth. This is supported by a new \NetworkBufferBudget\ class and updated \LimitedFixedBufferPool\ logic that respects these adaptive caps. Additionally, the \PooledArrayMemoryPool\ now recycles \IMemoryOwner\ wrapper objects to reduce garbage collection pressure, and \PoolEntry\ no longer uses \GCHandle\ for pinning, simplifying the pinning mechanism.

libs/common/Memory · high confidence

The networking layer now supports per-connection adaptive buffer budgets that dynamically adjust send and receive buffer sizes based on process-wide memory pressure, helping to cap aggregate memory usage without blocking large requests. Connection handling has been hardened with explicit local endpoint tracking, atomic close semantics to prevent race conditions during teardown, and graceful TCP shutdown (shutdown then close) to ensure resources are released cleanly. TLS authentication is now explicitly blocked until completion to prevent race conditions, and internal buffer pools are cleaned up more rigorously to avoid memory leaks from pinned entries.

libs/common/Networking · high confidence

The benchmark utility library has been reorganized into a Common folder and expanded to support more rigorous testing scenarios. TLS configuration now supports optional issuer certificate validation for secure environments, replacing the previous permissive validation. Script-based operations (SCRIPT SET, GET, RETKEY) and Pub/Sub commands are now explicitly supported operation types. The Zipf random generator has been optimized with a thread-safe constant cache to improve performance, and a new InProc client type has been added to the benchmark client options.

benchmark/Resp.benchmark/Common · high confidence

The Bitmap playground's bit-counting logic has been simplified by removing custom software implementations of population count (popc) and the preprocessor directives that selected between them. The code now exclusively uses the built-in System.Numerics.Popcnt.X64.PopCount method, which is available starting with .NET 5.0. This change removes support for older .NET versions (such as .NET Core 3.1 or .NET Framework) for this specific component, as the fallback logic has been deleted.

playground/Bitmap · high confidence

Bitmap operations now enforce stricter offset and value validation, rejecting invalid arguments (such as negative offsets or non-integer bit values) with appropriate error messages instead of crashing or producing undefined results. The BITFIELD command parsing has been refactored to use strongly-typed command enums, improving reliability and maintainability. Underlying bitmap logic has been optimized for performance and cross-platform compatibility by replacing architecture-specific intrinsics (like Popcnt.X64) with standard library equivalents (BitOperations) and leveraging SIMD/Tensor primitives for bitwise operations, ensuring consistent behavior across different CPU architectures.

libs/server/Resp/Bitmap · high confidence

The Azure DevOps CI pipelines now target .NET 10.0 alongside .NET 8.0, replacing previous support for .NET 6.0 and 7.0. The main build pipeline has been restructured to run Garnet, Tsavorite, and Garnet Cluster tests in a single consolidated job per platform (Windows and Ubuntu) rather than separate jobs, and it now includes a Rust toolchain installation step required for building the bftree native library. Additionally, the nightly test pipeline has been added to run these same .NET 8.0 and .NET 10.0 test matrices on ADO, and the solution file reference has been updated from Garnet.sln to Garnet.slnx.

.azure · high confidence

The libs directory now includes GlobalUsings.cs, which defines global type aliases for the various Garnet API contexts (such as BasicContext, TransactionalContext, and ConsistentReadContext) across the Main, Object, Unified, and Vector stores. This change standardizes the type definitions used by the server, test, cluster, and host projects, ensuring consistent usage of GarnetRecordTriggers and the underlying Tsavorite core components without requiring explicit imports in every file.

libs · high confidence

The GarnetClient constructor now accepts an EndPoint instead of separate address and port, and supports optional client name identification via CLIENT SETNAME. Response parsing has been refactored into RespReadResponseUtils to handle nested arrays and null values more safely, while connection teardown and disposal are now coordinated via a drain lock to prevent hanging waiters. The client also introduces configurable network buffer settings, shared LightEpoch support for thread protection, and improved metrics reporting with proper histogram lifecycle management.

libs/client · high confidence

The client session API has been refactored to use a unified EndPoint instead of separate address and port, and now supports setting a client name for server-side identification. A new incremental send mechanism has been added to efficiently handle large data migrations by chunking records and supporting Vector Set and RangeIndex serialization formats. Additionally, cluster-related commands have been renamed to explicitly include 'Cluster' in their names, and the underlying network handling has been updated to use configurable buffer settings.

libs/client/ClientSession · high confidence

The cluster subsystem introduces new data structures for replication state and checkpoint metadata, including \CheckpointMetadata\ (storing store version, tokens, and AOF addresses) and \RoleInfo\ (tracking replication offset, lag, and state). The \IClusterProvider\ and \IClusterSession\ interfaces are significantly expanded to support finer-grained control over replication and session behavior: new methods like \SetInternalWriteSession\, \PreventRoleChange\, and \AllowRoleChange\ manage replica write permissions and role stability, while \GetPrimaryInfo\ and \GetReplicaInfo\ expose detailed replication metrics. Slot verification logic is refactored to use \ClusterSlotVerificationInput\ and \SessionParseState\ for iterative verification, and the \CreateClusterSession\ factory now accepts specific context types (\BasicContext\, \VectorBasicContext\) instead of a generic API object.

libs/server/Cluster · high confidence

The cluster configuration serialization format now includes a version byte (v1 and v2 supported), allowing the system to read older configs while writing v2 payloads that include explicit ClusterAddress and ClusterPort fields for better endpoint metadata. Additionally, the logic for determining if a slot is local has been updated: slots in the MIGRATING state are now consistently treated as local to the original owner, and replica read permissions are explicitly controlled by the enableReplicaReads parameter rather than a generic readCommand flag. The cluster config file path has also been normalized to use a 'cluster' subdirectory descriptor for backend-neutral storage.

libs/cluster/Server · high confidence

The cluster epoch barrier no longer burns CPU while waiting for sessions to quiesce. The new \GarnetEpoch\ implementation replaces the legacy cooperative busy-spin with a short adaptive spin followed by a jittered, capped exponential-backoff self-poll (defaulting to a 1 ms base and 50 ms cap). This eliminates core-pinning during epoch transitions, reduces scheduler overhead, and ensures liveness even if a session is stuck, while keeping the hot path for releasing sessions untouched. To support benchmarking this change, a new \CpuDiagnoser\ was added to BenchmarkDotNet to report per-operation kernel and user CPU time, and a \MeanPenaltyColumn\ relabels the mean latency as 'Waiter penalty' or 'Waker penalty' for clearer benchmark reports.

benchmark/BDN.benchmark/Diagnostics, libs/cluster/Server/Epochs, libs/common/Waiting · high confidence

The Azure AD authentication component now allows users to disable automatic token refresh by setting the new \refreshTokens\ parameter to false when creating an \IssuerSigningTokenProvider\. Additionally, the internal logic for fetching configuration has been updated to use a dedicated blocking wait utility (\AsyncUtils.BlockingWait\) instead of direct async-result awaiting, and collection expressions are used for cleaner syntax.

libs/server/Auth/Aad · high confidence

The host configuration layer has been migrated from Newtonsoft.Json to System.Text.Json, enabling the serialization of configuration files to include only non-default values (reducing file size and noise) and supporting the deserialization of JSON into existing objects. This change introduces new command-line and configuration options for cluster advertising (cluster-announce-port, cluster-announce-ip, cluster-announce-hostname, cluster-preferred-endpoint-type) and refactors memory management settings (renaming memory-related options to explicitly reference the main log, adding read cache configuration, and introducing native allocator and buffer pool budget options). It also adds validation for module file paths and supports trailing commas in configuration files.

libs/host/Configuration · high confidence

The website now gates Microsoft Clarity analytics cookies behind the user's WCP consent choice, ensuring that tracking scripts only load and store data after explicit user permission is granted. Additionally, the site's visual presentation has been updated with high-contrast fixes, including specific color overrides for code syntax highlighting and navbar search placeholders in both light and dark themes, while the homepage meta description has been updated to accurately describe Garnet.

website/src · high confidence

The extension APIs for custom procedures and raw string commands have been updated to use \ref\ parameters for input arguments (e.g., \CustomProcedureInput\, \StringInput\) and \RespMemoryWriter\ for output, replacing the previous \ArgSlice\ and \IMemoryOwner\-based signatures. This change standardizes how extension developers access command inputs and write responses, requiring updates to existing custom commands and procedures to align with the new interface.

main/GarnetServer/Extensions · high confidence

The embedded performance test now strictly requires both OpPercent and OpWorkload options to be provided, throwing an exception if either is missing, rather than allowing null arrays. Additionally, the code has been updated to use C\# collection expressions (e.g., \[.. opts.OpPercent\]) and static logging templates to comply with CA2254 warnings, while unnecessary usings have been removed.

playground/Embedded.perftest · high confidence

The INFO command now exposes additional metrics sections including MODULES, BPSTATS, CINFO, HLOGSCAN, and COMMANDSTATS, while removing the previously available OBJECTSTORE, OBJECTSTOREHASHTABLE, and OBJECTSTOREREVIV sections. The underlying enum definitions in InfoMetricsType and LatencyMetricsType have been updated to reflect these changes, and the code generation for info sections has been refactored to use modern C\# collection expressions. A new comment in the enum files highlights that any future value changes must be synchronized with their respective parsers in SessionParseStateExtensions.

libs/common/Metrics · high confidence

The Redis host configuration now supports several new settings, including protected mode, enabling/disabling the DEBUG and module commands, Unix socket paths and permissions, slowlog thresholds, and the number of databases. Additionally, command statistics tracking has been added, and the bind address option has been simplified to accept a single string instead of an array. Internal configuration classes have been sealed to improve type safety, and logging warnings for unsupported options have been corrected to properly interpolate variables.

libs/host/Configuration/Redis · high confidence

The FailoverManager now exposes the status of the last completed or aborted failover via a new GetLastFailoverStatus method, allowing users to distinguish between successful completion and abortion. Internally, failover sessions are now executed asynchronously via Task.Run with proper await handling, replacing the previous fire-and-forget async void pattern to ensure errors are captured and the session state is correctly updated. The FailoverSession constructor has been refactored to accept a shared LightEpoch instance and an isReplicaSession flag, enabling better resource management and connection initialization logic specific to the failover type. Additionally, new failover status codes (FAILOVER\_COMPLETED, FAILOVER\_ABORTED) have been added to provide more granular feedback on the outcome of failover operations.

libs/cluster/Server/Failover · high confidence

The FileLoggerProvider has been updated to append full exception stack traces to log messages when an exception is present, improving diagnostic visibility. Additionally, the implementation simplifies the internal logging logic by removing the periodic flush interval mechanism and ensuring the stream writer is disposed directly, while also cleaning up unused imports.

libs/common/Logging · high confidence

The GarnetClientSample has been updated to align its API usage with SE.Redis conventions. The sample now uses a unified EndPoint for connection configuration instead of separate address and port strings, and the default connection port has been updated to 6379. Additionally, the sample demonstrates several new GarnetClient commands including StringIncrement, StringDecrement, KeyExists, and KeyDelete, while also correcting previous logging messages in the SE.Redis compatibility layer to accurately reflect the operations performed.

samples/GarnetClientSample · high confidence

HyperLogLog operations now enforce stricter validation on sparse stream structures, ensuring opcodes are well-formed and register coverage is exact to prevent malformed payload misuse. Additionally, the command handling layer has been refactored to use the modern StringInput/StringOutput types, replacing the previous raw pointer and ArgSlice-based parsing for PFADD, PFCOUNT, and PFMERGE.

libs/server/Resp/HyperLogLog · high confidence

The INFO command now supports multi-database environments, reporting memory and store metrics per database rather than globally. New informational sections have been added, including COMMANDSTATS (per-command success rates), HLOGSCAN (hybrid log distribution), PERSISTENCE (checkpoint and AOF stats), CLIENTS, and MODULES. The KEYSPACE section is now excluded from default/ALL/EVERYTHING queries to avoid expensive full scans, requiring an explicit INFO KEYSPACE call. Uptime reporting has been fixed to use Stopwatch for accuracy, and the server\_name field is now included in the SERVER section. The command parser has been refactored to use span-based parsing for better performance and compatibility.

libs/server/Metrics/Info · high confidence

The database manager layer now provides clearer visibility into checkpoint and recovery outcomes. Checkpoint operations return a \CheckpointStatus\ (Success, AlreadyInProgress, or Failed) and a \CheckpointResult\ that distinguishes between completed and failed saves, preventing failed checkpoints from being incorrectly reported as successful saves. Recovery logic has been enhanced to detect when checkpoint tokens exist on disk but cannot be read, allowing the system to distinguish between a fresh start and a corrupted or incomplete checkpoint prefix. This ensures that servers can fail startup appropriately when data integrity cannot be guaranteed, rather than silently continuing with incomplete state.

libs/server/Databases · high confidence

Latency metrics now handle server shutdown gracefully by checking for null metrics arrays, preventing crashes during disposal. Resource usage is optimized by lazily allocating histogram buffers only when a session records its first value and automatically reclaiming them after a session remains quiet for a configurable number of monitor windows. Additionally, numeric formatting in latency reports now uses invariant culture to ensure consistent output across different system locales.

libs/server/Metrics/Latency · high confidence

The CacheSizeTracker now delegates heap-size accounting to the Tsavorite store itself, removing the need for manual size tracking calls from application code. The tracker's API has changed: methods like AddTrackedSize are replaced by AddHeapSize, and initialization now uses a dedicated Initialize method with separate target sizes for the main log and read cache. The tracker also exposes IsStarted, IsStopped, and IsInitialized states, and uses Interlocked operations for thread-safe start/stop lifecycle management.

libs/server/Storage/SizeTracker · high confidence

The server now uses a dedicated ReplayCoordinator to manage Append-Only File (AOF) replay. This change introduces a new context and coordinator that buffer transaction groups and handle the AOF 'fuzzy region' (the period between checkpoint start and end markers) by deferring new-version entries until the checkpoint completes. It also adds support for chunked record replay and ensures proper cleanup of pooled buffers during replay teardown.

libs/server/AOF/ReplayCoordinator · high confidence

This change adds \GarnetRecordTriggers\, a new component that implements \IRecordTriggers\ to manage the lifecycle of RangeIndex (BfTree) and Vector Set records. It ensures that external resources, such as BfTree files and DiskANN index pointers, are correctly cleaned up or invalidated during record deletion, eviction, disk reads, and checkpointing. Additionally, the update refactors \FunctionsState\ to use a per-session \GarnetObjectSerializer\ for thread-safe streaming operations and introduces \SessionFunctionsUtils\ to standardize expiration logic (supporting NX, XX, GT, LT options) and in-place value updates across session functions.

libs/server/Storage/Functions · high confidence

The Garnet server host now supports binding to multiple endpoints and advertises Redis protocol version 7.4.3. The default listening port has changed from 3278 to 6379. Configuration defaults have been significantly revised: the main log page size is now 16 MB (down from 32 MB), the AOF memory buffer is 128 MB, and the AOF page size is 32 MB. New configuration options have been introduced for native memory allocation, buffer pool budgets, read caching, and granular AOF replay tuning, while the incremental snapshot feature has been removed.

libs/host · high confidence

The MainStore session layer has been refactored to replace the generic SpanByte/SpanByteAndMemory types with the new StringInput and StringOutput types. This change updates core storage operations (GET, RMW, Read) and specific data-type handlers (Bitmap, HyperLogLog, Vector Set, Range Index) to use these new types, improving type safety and reducing allocations. The refactoring also introduces explicit WRONGTYPE handling in read paths and adds a specialized Read\_RangeIndex method to suppress automatic copy-to-tail behavior, preventing potential deadlocks during RangeIndex stub promotion.

libs/server/Storage/Session/MainStore · high confidence

The project has upgraded its build target from .NET 8 to .NET 10, with all Dockerfiles (Alpine, Ubuntu, Azure Linux, Chiseled, and NanoServer) now using the .NET 10 SDK and runtime images. To support this, the legacy .sln solution file has been replaced by the new .slnx format, and the old architecture-specific Dockerfiles (ubuntu-x64, nanoserver-x64) have been removed in favor of the new multi-arch aware Dockerfiles. The version has been bumped to 2.2.1.

(repo-wide) · high confidence

The AOF replication sync mechanism has been restructured into a new \AofSyncDriver\ and \AofSyncTask\ architecture that supports parallel replication across multiple physical sublogs. This change introduces per-sublog sync tasks that ship AOF records concurrently, enabling features like drift-barrier throttling, inline tail-witness pulses, and AOF shipping backpressure. The new driver manages connection health, start/previous addresses, and shipped watermarks for each sublog, while the \AofSyncDriverStore\ handles safe AOF truncation by coordinating with active sync tasks to prevent data loss during log shifts.

libs/cluster/Server/Replication/PrimaryOps/AofOperations · high confidence

The server now uses a dedicated CollectionItemBroker to manage blocking operations (such as BLPOP, BRPOP, and related commands). This component introduces an asynchronous event-driven architecture that decouples the notification of collection updates from the waiting client sessions, replacing previous synchronous or less scalable patterns. For users, this change improves the scalability and responsiveness of blocking commands by allowing the server to handle a higher volume of concurrent blocking requests without blocking the main storage threads.

libs/server/Objects/ItemBroker · high confidence

The Object Store session API has been refactored to use strongly-typed input/output structures (ObjectInput/ObjectOutput) and pinned byte spans instead of raw SpanByte/ArgSlice buffers. This change improves type safety and performance by reducing allocations and simplifying the internal handling of Redis commands. Additionally, the RMW and Read operations now explicitly check for and return WRONGTYPE errors when the stored object does not match the expected type, ensuring consistent error reporting for users.

libs/server/Storage/Session/ObjectStore · high confidence

The ObjectStore functions have been refactored from the legacy \IFunctions\ interface to the new \ISessionFunctions\ interface, aligning with the internalization of heap-size tracking into Tsavorite. This change updates the object store's read, write, and delete operations to use \ObjectInput\ and \ObjectOutput\ types instead of raw \SpanByte\ and \GarnetObjectStoreOutput\, and replaces direct AOF logging calls with epoch-aware \LogRecord\ and \NeedAofLog\ flags. The migration also introduces \PostInitialWriter\, \PostInitialDeleter\, and \PostUpsertOperation\ hooks to handle AOF logging and cache tracking after the core Tsavorite operations complete, ensuring consistent behavior with the new session-based storage engine.

libs/server/Storage/Functions/ObjectStore · high confidence

The RESP parser now uses a SIMD-accelerated fast path for common short commands (e.g., GET, SET, DEL) and an O(1) cache-friendly hash table for command name resolution, significantly reducing parsing latency. This change also introduces a new SessionParseState and ScratchBufferAllocator to manage parsing state and memory more efficiently, and expands the RespCommand enum to ushort to support a larger set of commands while maintaining stable numeric values for write operations persisted to disk.

libs/server/Resp/Parser · high confidence

The HdrHistogram metrics component now uses the .NET BCL BitOperations class for leading zero calculations, replacing a custom implementation to improve performance. Additionally, LongHistogram instances now rent their internal counts arrays from the shared ArrayPool instead of allocating new ones, significantly reducing garbage collection pressure. This change introduces new lifecycle methods (Return, Release, TryCopy) to manage the pooled arrays safely in concurrent scenarios, ensuring data integrity when histograms are copied or released.

metrics/HdrHistogram · high confidence

The TLS subsystem now supports loading certificates from PEM-encoded files (in addition to PKCS\#12/PFX), detecting the format by inspecting file contents rather than relying on the file extension. For client connections, server certificate validation is now stricter: it requires a target host name and validates the server's certificate subject name against that host, while also supporting an optional issuer certificate for chain validation. Additionally, error messages in certificate update operations now use a consistent 'errorMessage' parameter name, and logging for certificate refresh failures has been corrected to use a static template string.

libs/server/TLS · high confidence

The AOF recovery process now supports parallel replay of log records across multiple physical sublogs and within individual pages, significantly reducing recovery time for large append-only files. This change introduces a new recovery architecture in the AOF/Recover module that coordinates multiple background tasks using a barrier synchronization mechanism to ensure that replay respects prefix consistency boundaries (stopping at a specific sequence number) without committing log metadata beyond the intended point. Users benefit from faster database startup and recovery times, especially in multi-log configurations, while maintaining data integrity through the new single-physical-log path that fixes previous race conditions during parallel replay.

libs/server/AOF/Recover · high confidence

The server now enforces a process-wide limit on simultaneous client connections via the \maxclients\ configuration parameter, shared across all bound endpoints (TCP and Unix sockets) rather than applying per-listener. It also introduces adaptive network buffer budgets that cap per-connection memory usage and limit total live connection buffers across the process, preventing memory exhaustion under load. Connection admission is checked on every accept, and rejected connections are tracked in metrics.

libs/server/Servers · high confidence

The GarnetServer publish profiles in Properties/PublishProfiles have been updated to target both net8.0 and net10.0. This change adds new profiles for linux-arm64, linux-x64, osx-arm64, osx-x64, win-arm64, and win-x64 architectures, ensuring that builds for the new .NET 10 runtime are generated in addition to existing .NET 8 outputs. The win-x64-based-readytorun profile also includes specific logic to copy Garnet.worker dependencies and clean up redundant files during the publish process.

main/GarnetServer/Properties · high confidence

The ArgSlice component has been refactored to replace the previous \ArgSlice\ struct and \ScratchBufferManager\ with a new memory management strategy using \ScratchBufferAllocator\ and \ScratchBufferBuilder\. This change introduces two distinct allocation modes: \ScratchBufferAllocator\ manages multiple independent scratch buffers to support scenarios where previously returned \PinnedSpanByte\ slices must remain valid (e.g., during enumeration), while \ScratchBufferBuilder\ consolidates data into a single continuous buffer for simpler, sequential allocation patterns. A new \ArgSliceVector\ class has been added to efficiently manage collections of these slices, supporting optional namespace prefixes. This refactoring aims to reduce allocations and improve memory safety by providing more granular control over buffer lifetimes and reuse within sessions.

libs/server/ArgSlice · high confidence

The authentication system has been refactored to use an abstract base class (GarnetACLAuthenticator) with specific implementations for password and Microsoft Entra ID (AAD) authentication, replacing the previous monolithic logic. For AAD authentication, the system now supports validating usernames against Object IDs or Azure AD Groups, caches token validity ticks for performance, and uses a TimeProvider for better testability. Password authentication now uses constant-time comparison to prevent timing attacks, and the API exposes UserHandle objects instead of direct User references for better abstraction.

libs/server/Auth · high confidence

The cluster gossip implementation has been reorganized into a dedicated \libs/cluster/Server/Gossip\ directory, introducing new files for connection tracking (\ConnectionInfo.cs\), client extensions (\GarnetClientExtensions.cs\), node management (\GarnetServerNode.cs\), gossip logic (\Gossip.cs\), and statistics (\GossipStats.cs\). The \GarnetClusterConnectionStore\ has been moved and significantly refactored: it now accepts a \LightEpoch\ instance, uses a dictionary for O(1) node lookups instead of linear array searches, and exposes asynchronous methods like \AddConnectionAsync\ and \CloseAll\ to improve concurrency and resource management. These changes provide better observability through detailed gossip metrics and more robust handling of cluster node connections.

libs/cluster/Server/Gossip · high confidence

The primary node's replica synchronization logic has been restructured to replace the previous \AofTaskStore\ and \AofSyncTaskInfo\ components with a new \AofSyncDriverStore\ and \AofSyncDriver\ model. This change consolidates AOF streaming and checkpoint delivery into a unified \PrimarySync\ class, which now handles both diskless and disk-based sync modes via \TryBeginDisklessSyncAsync\ and \TryBeginDiskbasedSyncAsync\. The refactoring simplifies the connection lifecycle, improves error handling by returning explicit error spans, and removes the legacy \ReplicaSyncSession\ and \PrimarySendCheckpoint\ files in favor of a more streamlined session management approach within \ReplicaSyncSessionTaskStore\.

libs/cluster/Server/Replication/PrimaryOps · high confidence

The pub/sub broker has been refactored to remove the dependency on the Tsavorite KV store (deleting \SubscribeKVBroker\ and \SpanByteKeySerializer\) and now operates as a standalone \SubscribeBroker\. This change introduces native support for pattern subscriptions via a new \PatternSubscriptionEntry\ structure, allowing clients to subscribe to channels matching specific patterns. The broker's internal logic has been simplified to use \ReadOptimizedConcurrentSet\ for managing subscriptions and \PinnedSpanByte\ for efficient broadcasting, eliminating the previous overhead of serializing keys and inputs through the KV store.

libs/server/PubSub · high confidence

The replica synchronization logic has been refactored to introduce explicit support for diskless replication, allowing replicas to receive checkpoint data directly over the network without writing to local disk first. The previous monolithic synchronous implementation has been replaced with dedicated asynchronous handlers for both disk-based and diskless sync paths, improving responsiveness and resource usage. Additionally, the refactoring addresses stability issues by ensuring the VectorManager's background cleanup is paused during store resets to prevent access violations, and by consolidating error handling and recovery state management across the new sync flows.

libs/cluster/Server/Replication/ReplicaOps · high confidence

The server's storage layer output types have been refactored: the previous \SpanByteFunctionsForServer\ and \SpanByteServerSerializer\ classes are removed and replaced with dedicated output structs (\StringOutput\, \VectorOutput\, and \UnifiedOutput\) that manage their own memory and serialization logic. \UnifiedOutput\ specifically supports large-object migration by accumulating out-of-line record pieces (overflow keys, deep-copied values, and chunked object values) to allow asynchronous network sends without holding store epochs. Additionally, the server now supports runtime management of eligible server options via \CONFIG GET\ and \CONFIG SET\, allowing dynamic updates to memory limits, TLS certificates, and cluster authentication without a restart.

libs/server · high confidence

The transaction manager's key tracking has been refactored to use SessionParseState and ScratchBufferAllocator instead of raw pointers and separate buffers. This change ensures that key bytes are copied into dedicated allocators during command processing, preventing use-after-free bugs when network receive buffers are resized or compacted. The refactoring also unifies key handling across main, object, and unified stores, simplifying locking and slot verification logic.

libs/server/Transaction · high confidence

The Access Control List implementation has been significantly restructured to move from a simple category-based model to a granular, per-command permission system. Users can now be granted or denied access to specific commands and subcommands (e.g., +GET, -SET) rather than just broad categories like 'admin' or 'read'. This change introduces \CommandPermissionSet\ to manage these permissions atomically, allowing for thread-safe updates via \UserHandle\ which uses compare-and-swap operations to ensure consistency during concurrent modifications. Additionally, the system now supports fine-grained control over custom (extension) commands, allowing administrators to explicitly allow or deny specific custom command names. Security has also been improved by replacing standard string comparisons with constant-time equality checks for password hashes to mitigate timing side-channel attacks.

libs/server/ACL · high confidence

The cluster library now uses dedicated extension methods in SessionParseStateExtensions to parse slot states and failover options, replacing previous inline parsing logic. Internode communication strings have been consolidated, and error responses are now standardized using a new set of generic RESP error constants in CmdStrings, improving consistency in how cluster errors are reported to clients.

libs/cluster · high confidence

The cluster migration logic in \libs/cluster/Server/Migration\ has been significantly restructured to support migrating RangeIndex and Vector Set data types alongside standard keys. The previous synchronous, blocking implementation (found in deleted files like \MigrateSessionSend.cs\) has been replaced by an asynchronous, state-machine-driven architecture using a \Sketch\ (Bloom filter) to track key migration status (\INITIALIZING\, \TRANSMITTING\, \DELETING\, \MIGRATED\). This new design allows write operations to proceed safely during the \INITIALIZING\ and \MIGRATED\ phases, while delaying writes during \TRANSMITTING\ and \DELETING\ to ensure data consistency. The refactoring introduces dedicated components for scanning (\MigrateScanFunctions\), transmitting data (\MigrateOperation\), and handling specific types like RangeIndex (\MigrateSession.RangeIndex.cs\) and Vector Sets, along with detailed activity tracing for performance monitoring.

libs/cluster/Server/Migration · high confidence

The cluster replication subsystem has been refactored to unify checkpoint metadata handling and improve recovery safety. A new \GarnetClusterCheckpointManager\ now manages checkpoint cleanup with reader-safety checks, replacing the previous \ReplicationLogCheckpointManager\ and \ReplicationDevice\ classes. Checkpoint metadata serialization has been updated to embed a cookie (including the primary replication ID and safe AOF address) directly within the \HybridLogRecoveryInfo\, ensuring backward compatibility with legacy single-log formats while supporting multi-log structures. The \CheckpointEntry\ model has been restructured to use a dedicated \CheckpointMetadata\ object, and the \CheckpointStore\ now defers orphan checkpoint purging until after recovery initialization to prevent accidental data loss. Additionally, new types like \RecoveryStatus\ and \ReplicateSyncOptions\ expose detailed recovery states and configuration options for replica synchronization.

libs/cluster/Server/Replication · high confidence

The cluster session logic has been reorganized to improve maintainability and support large-object migrations. Command handlers for CLUSTER operations (such as BUMPEPOCH, FORGET, MEET, FAILOVER, MIGRATE, and slot management) have been extracted from the main ClusterSession class into dedicated files (e.g., RespClusterBasicCommands.cs, RespClusterMigrateCommands.cs). Additionally, a new ChunkedRecordReassembler component was introduced to handle the reassembly of large migration records that span multiple network chunks, enabling support for object values exceeding 2 GB by streaming them directly to the deserializer without intermediate copying.

libs/cluster/Session · high confidence

The cluster slot verification logic has been reorganized into a new \SlotVerification\ subdirectory, splitting the implementation across \ClusterSlotVerify.cs\ (core verification logic for single and multi-key operations), \RespClusterIterativeSlotVerify.cs\ (iterative verification with caching for network requests), and \RespClusterSlotVerify.cs\ (RESP protocol message generation and network I/O). This change moves the verification logic out of the main \ClusterSession\ class into focused components, improving code maintainability and separation of concerns without altering the external cluster behavior.

libs/cluster/Session/SlotVerification · high confidence

The custom command subsystem has been restructured to support a more flexible registration and execution model. Custom commands now use an expandable map for ID management, allowing for a larger and more dynamic registration space. The registration API has been updated to include optional command info and documentation, enabling better introspection and help generation. Additionally, the execution path has been optimized with session-specific caching for custom procedures and transactions, reducing overhead during command processing. The underlying data structures have been renamed and refactored for clarity, with \CustomFunctions\ becoming \CustomProcedureBase\ and \CustomCommand\ becoming \CustomRawStringCommand\.

libs/server/Custom · high confidence

The implementation of Hash, List, Set, Sorted Set, and Geo commands in the RESP server session has been refactored to replace manual pointer arithmetic and session-level counters with a centralized \parseState\-based argument parsing model. This change removes the need for manual buffer management and partial-operation tracking (such as \hashItemsDoneCount\ or \listOpsCount\), simplifying the command execution flow and improving consistency across object types.

libs/server/Resp/Objects · high confidence

The object store's serialization and output mechanisms have been refactored to integrate with the Tsavorite storage layer. A new \ObjectOutput\ struct and \ObjectOutputFlags\ enum replace the previous output handling, allowing explicit flags for operations like removing a key or detecting wrong types. The \IGarnetObject\ interface now inherits from \IHeapObject\ and uses \ObjectInput\/\ObjectOutput\ for operations, simplifying the API. Serialization is now handled by a \GarnetObjectSerializer\ that supports both legacy binary formats and new thread-safe methods, with explicit versioning checks to prevent reading incompatible data. Additionally, \GarnetObjectType\ values are now explicitly assigned and stabilized to ensure persistence compatibility, and the \GarnetObjectBase\ class now inherits from \HeapObjectBase\.

libs/server/Objects/Types · high confidence

The online benchmark files (OnlineReqGen.cs and RespOnlineBench.cs) have been reorganized into the OnlineBench directory and refactored to improve key generation and connection handling. The benchmark now uses a unified EndPoint for client connections instead of separate address and port fields, simplifying the initialization of GarnetClient and LightClient instances. Additionally, the request generator now prefixes string keys with 'S' and object keys with 'O' to prevent collisions between the two key types, and the separate ObjectDbSize parameter has been removed in favor of using DbSize directly for object key generation.

benchmark/Resp.benchmark/OnlineBench · high confidence

The test runner in playground/TstRunner now instantiates ClusterReplicationBaseTests instead of the previous ClusterReplicationTests class. Additionally, the runner executes only a specific subset of the replication unit tests by slicing the test list starting from index 39, and it explicitly sets the log text writer on the test group instance before running setup.

playground/TstRunner · high confidence

The WriterReaderPhaser utility now uses native thread operations instead of wrapping async tasks for blocking behavior. Specifically, spin-waiting now calls Thread.Yield() directly rather than awaiting Task.Yield(), and timed waiting uses Thread.Sleep() instead of Task.Delay(). This change eliminates the overhead of creating and awaiting Task instances for simple synchronization waits, resulting in more efficient resource usage within the HdrHistogram metrics component.

metrics/HdrHistogram/Utilities · high confidence

The session provider implementation has been refactored to remove the unused SubscribeKV broker and decouple the provider from direct store management. TsavoriteKVProviderBase now relies on a StoreWrapper for store access rather than holding a direct reference, and the Recover method has been replaced with an asynchronous RecoverAsync operation. Additionally, session creation now assigns a unique session ID to each new session, and the provider base class has been simplified by removing generic type parameters for functions and serializers, relying instead on the StoreWrapper and StoreFunctions/Allocator types.

libs/server/Providers · high confidence

The storage session implementation has been restructured to support multi-database environments and a unified context model. Instead of managing separate, monolithic sessions for main and object stores, the session now initializes distinct contexts (Basic, Transactional, ConsistentRead) for String, Object, Unified, and Vector stores, allowing operations to target specific databases via a new \dbId\ parameter. This change introduces a \UnifiedBasicContext\ and \UnifiedTransactionalContext\ to handle unified store operations, while also integrating \VectorManager\ and \RuntimeServerConfig\ for enhanced runtime management. The refactoring replaces the previous \ScratchBufferManager\ with a \ScratchBufferBuilder\ and \ScratchBufferAllocator\, and adds support for RESP protocol version updates via \UpdateRespProtocolVersion\.

libs/server/Storage/Session · high confidence

The GarnetClientStress tool now defaults to port 6379 instead of 3278 and constructs connections using IPEndPoint for more robust address handling. TLS certificate loading has been updated to use the modern X509CertificateLoader on .NET 9+, ensuring compatibility with newer runtime versions. Additionally, latency histograms are now copied and returned to the pool to reduce garbage collection pressure during stress tests, and legacy ServicePointManager configurations have been removed in favor of modern defaults.

playground/GarnetClientStress · high confidence

The benchmark runner now provides a structured entry point that allows users to filter benchmarks by target framework (.NET 8 or .NET 10) and by specific operation parameters (ACL, AOF, AAD). It introduces a custom result orderer that groups benchmarks by namespace and type for clearer reporting, and configures the environment to use workstation GC for more deterministic allocation measurements.

benchmark/BDN.benchmark · high confidence

The SCAN command now uses a unified store iterator instead of separate main and object store iterators, simplifying iteration logic and supporting type filtering for strings. The implementation also adds dedicated iterators for INFO KEYSPACE statistics, expired key deletion, and cluster slot key deletion, while removing deprecated main/object store iteration methods.

libs/server/Storage/Session/Common · high confidence

The MetricsMonitor sample now defaults to port 6379 for Redis connections instead of the previous 3278. Additionally, the tool's command filtering logic has been updated to use the RESP commands info for determining which commands to monitor, and the help text for the info-metrics-type option has been adjusted to reflect the available metric types.

samples/MetricsMonitor · high confidence

The website now disables npm/yarn postinstall scripts via .npmrc and .yarnrc to harden supply chain security. For compliance, a 'Consumer Health Privacy' link and a 'Cookie Preferences' toggle (powered by Microsoft WCP consent) have been added to the footer, and the copyright year is updated to 2026. Documentation has been significantly expanded with new sidebar sections for Azure Managed Offering, research, memory, compaction, range index, vector sets, JSON, and detailed Tsavorite internals, alongside a new 'news' item. Usability improvements include a local search plugin, GitHub codeblock links, C\# syntax highlighting, a new diamond logo, and a neutral/dark Mermaid theme.

website · high confidence

Resolves a data corruption issue in Vector Sets where modifying the size of vector elements (growing or shrinking) could lead to invalid state. The update ensures that value spans are correctly resized and copied during in-place updates, preventing overflow or stale byte retention that previously compromised Vector Set attributes.

libs/server/Storage/Functions/VectorStore · high confidence

Added BDN performance regression testing infrastructure; Added Docker image validation test suite; Added JSONPath benchmark suite; Added benchmark for AAD authenticator time-source performance; Added benchmarks for RESP integer and double parsing/writing; Added benchmarks for bitmap binary and unary operations; Added comprehensive test coverage for Vector Sets; Added comprehensive unit and integration tests for Garnet's ACL system; Added comprehensive unit tests for Garnet collection types; Added consistent read benchmarks for Garnet cluster multilog mode; Added regression and unit tests for RESP parsing and command caching; Added test coverage for Lua scripting, AOF chunking, and module loading; Added test coverage for cache size tracking, cooperative disposal, JSONPath, and DiskANN recall; Added tests for BfTree interop and native FFI guards; Added tests for authentication invalidation behavior; Expanded internal assembly visibility for new test and benchmark projects; Expanded test coverage for RangeIndex, AOF recovery, checkpoint failures, and connection limits; Grant internal access to Garnet fuzzing assembly; New bitmap and HyperLogLog test coverage; New cluster test suites for RangeIndex migration, slot verification, and diskless replication; New fuzzing harness for RESP parsing, Lua compilation, and end-to-end server; New testing infrastructure for exception injection and test logging; Removal of legacy cluster test suite; Removed obsolete ACL test files from Garnet.Resp tests; Removed obsolete test infrastructure and legacy test suites; Updated test certificates and added PEM support documentation.

The project now uses a centralized package versioning system via the new \Directory.Packages.props\ file, which defines specific versions for key dependencies such as Azure SDKs, BenchmarkDotNet, Microsoft.Extensions libraries, and StackExchange.Redis. This change enables transitive dependency pinning to improve build stability and security compliance, while individual \.csproj\ files are updated to reference packages by name only, relying on the central definitions.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 51.

• Code Health 52
• Architecture 96
• Maturity 64
• Readiness 77
• Security 38
• Performance 78

• 300 commits — 214 feature/other, 86 fixes

• libs/server — 89 commits
• libs/storage — 52 commits
• website/yarn.lock — 38 commits
• (root) — 27 commits
• libs/cluster — 18 commits
• test/standalone — 14 commits
• .github/workflows — 11 commits
• test/cluster — 10 commits
• libs/native — 7 commits
• website/package.json — 7 commits
• website/docs — 5 commits
• libs/host — 4 commits
• libs/common — 3 commits
• benchmark/BDN.benchmark — 2 commits
• libs/client — 2 commits
• .azure/pipelines — 1 commit
• benchmark/Azure.benchmark — 1 commit
• benchmark/Resp.benchmark — 1 commit
• charts/garnet — 1 commit
• modules/RoaringBitmap — 1 commit

• fix: Add tests (and fix bugs) for commands WRONGTYPE'ing appropriately against Vector Sets (#1935)
• fix: Bugfix: MurmurHash3: 1) wrong suffixLen; 2) should cast to ulong before shift (#1864)
• fix: Bump rand 0.9.2 → 0.9.3 in bftree-garnet to fix [GHSA redacted] (#1878)
• fix: Fix #1944: give each CI matrix job's trx file a unique name (#1946)
• fix: Fix AOF page/memory size defaults and validation (#1811) (#1838)
• fix: Fix AOF recovery crash on torn-tail commit record (#1910)
• fix: Fix Allure wiring: remove duplicate attributes and fix CI check for transitive dependencies (#1784)
• fix: Fix BITCOUNT ... BIT throwing PlatformNotSupportedException on ARM64 (#2008)
• fix: Fix BITFIELD session disposal on empty subcommand list and max-offset GET (#2120)
• fix: Fix BITFIELD signed 64-bit overflow detection for OVERFLOW SAT/FAIL (#1968)
• fix: Fix BITOP failures in MULTI/EXEC transactions (#1954) (#1966)
• fix: Fix BLMPOP writing two replies when force-unblocked (#2030)
• fix: Fix CI BDN allocation flakiness (#1989)
• fix: Fix ClusterRangeIndexCheckpointSyncWithEviction test: force flush.bftree generation (#1848)
• fix: Fix CompletionEvent disposal and reset bugs, and coalesce LogSizeTracker signals (#2198)
• fix: Fix ComputeSublogAccessVector to use keyEntries (#1939)
• fix: Fix Dependabot alerts: bump dompurify to 3.4.13 (#2053)
• fix: Fix EXPIRE family emitting two replies for incompatible options (#2037)
• fix: Fix GEOHASH last character to always output '0' (52-bit precision) (#1635)
• fix: Fix GETEX tearing down the session on an out-of-range expiry (#2094)
• …and 280 more

• 19 containers · 1 bounded contexts · 0 dependency edges (baseline)

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

microsoft/garnet 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.