Merge branch 'main' into fix/issue-4814-zscan-flake

Author: xShinnRyuu

.github/workflows/npm-cd.yml

@@ -326,7 +326,6 @@ jobs:
                   node-version: latest
                   registry-url: "https://registry.npmjs.org"
                   scope: "@valkey"
-                  token: ${{ secrets.NPM_AUTH_TOKEN }}
                   cache: "npm"
                   cache-dependency-path: node/package.json
 
@@ -426,13 +425,13 @@ jobs:
               shell: bash
               working-directory: ./node/npm/glide
               env:
-                  NODE_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }}
                   NPM_TAG: ${{ needs.get-build-parameters.outputs.npm_tag }}
+                  NPM_CONFIG_PROVENANCE: true
               run: |
                   package_name=$(cat package.json | jq -r .name)
                   version=$(cat package.json | jq -r .version)
                   echo "Publishing base package ${package_name}@${version} with tag ${NPM_TAG}"
-                  npm publish --tag ${NPM_TAG} --access public --scope=@valkey
+                  npm publish --tag ${NPM_TAG} --access public --provenance --scope=@valkey
 
                   # Check if the publish was successful
                   if [ $? -ne 0 ]; then
@@ -564,7 +563,6 @@ jobs:
               with:
                   node-version: latest
                   registry-url: "https://registry.npmjs.org"
-                  token: ${{ secrets.NPM_AUTH_TOKEN }}
                   scope: "@valkey"
 
             - name: Deprecate Published Packages

CHANGELOG.md

@@ -1,8 +1,23 @@
+## 2.3
+
+#### Changes
+
+* JAVA: Add EVAL_RO, EVALSHA_RO, and SCRIPT DEBUG commands ([#5125](https://github.com/valkey-io/valkey-glide/pull/5125))
+* CORE: Add client certificate and private key support for mTLS ([#5092](https://github.com/valkey-io/valkey-glide/issues/5092))
+* Python: Add client certificate and private key support for mTLS ([5123](https://github.com/valkey-io/valkey-glide/issues/5123))
+
+#### Fixes
+* CORE: Enforce connection_timeout for initial standalone connection failures  ([#4991](https://github.com/valkey-io/valkey-glide/issues/4991))
+* CORE: Rust Lint is failing due to unmaintained advisory detected (RUSTSEC-2025-0141)  ([#5136](https://github.com/valkey-io/valkey-glide/issues/5136))
+* Node: Fixed `Failed to convert napi value Undefined into rust type u32` error  ([#5128](https://github.com/valkey-io/valkey-glide/pull/5128))
+
+#### Operational Enhancements
+
 ## 2.2
 
 #### Changes
 
-* Added in documentation to how to use Lua scripts with Glide 
+* Added in documentation to how to use Lua scripts with Glide
 * JAVA: Add refreshTopologyFromInitialNodes Configuration Option ([#4870](https://github.com/valkey-io/valkey-glide/pull/4870))
 * GO: add RefreshTopologyFromInitialNodes configuration option ([#4871](https://github.com/valkey-io/valkey-glide/pull/4871))
 * Node: add refreshTopologyFromInitialNodes configuration option ([#4872](https://github.com/valkey-io/valkey-glide/pull/4872))
@@ -45,7 +60,7 @@
 * PYTHON: Add MOVE command support for cluster clients ([#4751](https://github.com/valkey-io/valkey-glide/pull/4751))
 * JAVA: Add cluster support for Move command ([#4749])(https://github.com/valkey-io/valkey-glide/pull/4749)
 
-#### Fixes 
+#### Fixes
 
 * CORE: Fix SELECT Command Database Persistence Across Reconnections ([#4764](https://github.com/valkey-io/valkey-glide/issues/4764))
 * Rust: Updates the `install-rust-and-protoc` action to explicitly include the `rustfmt` and `clippy` components. ([#4816](https://github.com/valkey-io/valkey-glide/issues/4816))

README.md

@@ -118,6 +118,7 @@ Valkey GLIDE has a growing ecosystem of integrations and extensions that enhance
 - **[aiocache](https://pypi.org/project/aiocache/)** - Python async caching framework with Valkey GLIDE backend support for high-performance distributed caching
 - **[aws-lambda-powertools-typescript](https://github.com/aws-powertools/powertools-lambda-typescript)** - AWS Lambda Powertools for TypeScript with Valkey GLIDE integration in the idempotency feature (more integrations planned)
 - **[aws-lambda-powertools-python](https://github.com/aws-powertools/powertools-lambda-python)** - AWS Lambda Powertools for Python with Valkey GLIDE support in the idempotency feature (more integrations planned)
+- **[redlock-universal](https://www.npmjs.com/package/redlock-universal)** - Distributed lock library for Node.js with native GLIDE adapter, featuring auto-extension and atomic batch acquisition
 
 ## Getting Help
 

deny.toml

@@ -22,9 +22,10 @@ yanked = "deny"
 # A list of advisory IDs to ignore. Note that ignored advisories will still
 # output a note when they are encountered.
 ignore = [
-    # suppress this validation until #3226 not resolved
-    # https://github.com/valkey-io/valkey-glide/issues/3226
-    "RUSTSEC-2025-0007",
+    # bincode is unmaintained but only used as a transitive dev dependency
+    # via iai-callgrind for benchmarking. No security impact.
+    # https://rustsec.org/advisories/RUSTSEC-2025-0141
+    "RUSTSEC-2025-0141",
 ]
 # Threshold for security vulnerabilities, any vulnerability with a CVSS score
 # lower than the range specified will be ignored. Note that ignored advisories

glide-core/redis-rs/redis/src/aio/connection.rs

@@ -419,12 +419,13 @@ where
 pub(crate) async fn connect_simple<T: RedisRuntime>(
     connection_info: &ConnectionInfo,
     _socket_addr: Option<SocketAddr>,
+    tcp_nodelay: bool,
 ) -> RedisResult<(T, Option<IpAddr>)> {
     Ok(match connection_info.addr {
         ConnectionAddr::Tcp(ref host, port) => {
             if let Some(socket_addr) = _socket_addr {
                 return Ok::<_, RedisError>((
-                    <T>::connect_tcp(socket_addr).await?,
+                    <T>::connect_tcp(socket_addr, tcp_nodelay).await?,
                     Some(socket_addr.ip()),
                 ));
             }
@@ -433,7 +434,7 @@ pub(crate) async fn connect_simple<T: RedisRuntime>(
                 log_conn_creation("TCP", format!("{host}:{port}"), Some(socket_addr.ip()));
                 Box::pin(async move {
                     Ok::<_, RedisError>((
-                        <T>::connect_tcp(socket_addr).await?,
+                        <T>::connect_tcp(socket_addr, tcp_nodelay).await?,
                         Some(socket_addr.ip()),
                     ))
                 })
@@ -450,7 +451,8 @@ pub(crate) async fn connect_simple<T: RedisRuntime>(
         } => {
             if let Some(socket_addr) = _socket_addr {
                 return Ok::<_, RedisError>((
-                    <T>::connect_tcp_tls(host, socket_addr, insecure, tls_params).await?,
+                    <T>::connect_tcp_tls(host, socket_addr, insecure, tls_params, tcp_nodelay)
+                        .await?,
                     Some(socket_addr.ip()),
                 ));
             }
@@ -463,7 +465,8 @@ pub(crate) async fn connect_simple<T: RedisRuntime>(
                 );
                 Box::pin(async move {
                     Ok::<_, RedisError>((
-                        <T>::connect_tcp_tls(host, socket_addr, insecure, tls_params).await?,
+                        <T>::connect_tcp_tls(host, socket_addr, insecure, tls_params, tcp_nodelay)
+                            .await?,
                         Some(socket_addr.ip()),
                     ))
                 })

glide-core/redis-rs/redis/src/aio/mod.rs

@@ -29,14 +29,15 @@ pub mod tokio;
 #[async_trait]
 pub(crate) trait RedisRuntime: AsyncStream + Send + Sync + Sized + 'static {
     /// Performs a TCP connection
-    async fn connect_tcp(socket_addr: SocketAddr) -> RedisResult<Self>;
+    async fn connect_tcp(socket_addr: SocketAddr, tcp_nodelay: bool) -> RedisResult<Self>;
 
     // Performs a TCP TLS connection
     async fn connect_tcp_tls(
         hostname: &str,
         socket_addr: SocketAddr,
         insecure: bool,
         tls_params: &Option<TlsConnParams>,
+        tcp_nodelay: bool,
     ) -> RedisResult<Self>;
 
     /// Performs a UNIX connection

glide-core/redis-rs/redis/src/aio/tokio.rs

@@ -25,8 +25,9 @@ use crate::tls::TlsConnParams;
 use super::Path;
 
 #[inline(always)]
-async fn connect_tcp(addr: &SocketAddr) -> io::Result<TcpStreamTokio> {
+async fn connect_tcp(addr: &SocketAddr, tcp_nodelay: bool) -> io::Result<TcpStreamTokio> {
     let socket = TcpStreamTokio::connect(addr).await?;
+    socket.set_nodelay(tcp_nodelay)?;
     #[cfg(feature = "keep-alive")]
     {
         //For now rely on system defaults
@@ -111,23 +112,26 @@ impl AsyncRead for Tokio {
 
 #[async_trait]
 impl RedisRuntime for Tokio {
-    async fn connect_tcp(socket_addr: SocketAddr) -> RedisResult<Self> {
-        Ok(connect_tcp(&socket_addr).await.map(Tokio::Tcp)?)
+    async fn connect_tcp(socket_addr: SocketAddr, tcp_nodelay: bool) -> RedisResult<Self> {
+        Ok(connect_tcp(&socket_addr, tcp_nodelay)
+            .await
+            .map(Tokio::Tcp)?)
     }
 
     async fn connect_tcp_tls(
         hostname: &str,
         socket_addr: SocketAddr,
         insecure: bool,
         tls_params: &Option<TlsConnParams>,
+        tcp_nodelay: bool,
     ) -> RedisResult<Self> {
         let config = create_rustls_config(insecure, tls_params.clone())?;
         let tls_connector = TlsConnector::from(Arc::new(config));
 
         Ok(tls_connector
             .connect(
                 rustls_pki_types::ServerName::try_from(hostname)?.to_owned(),
-                connect_tcp(&socket_addr).await?,
+                connect_tcp(&socket_addr, tcp_nodelay).await?,
             )
             .await
             .map(|con| Tokio::TcpTls(Box::new(con)))?)

glide-core/redis-rs/redis/src/client.rs

@@ -96,6 +96,9 @@ pub struct GlideConnectionOptions {
     pub connection_timeout: Option<Duration>,
     /// Retry strategy configuration for reconnect attempts.
     pub connection_retry_strategy: Option<RetryStrategy>,
+    /// TCP_NODELAY socket option. When true, disables Nagle's algorithm for lower latency.
+    /// When false, enables Nagle's algorithm to reduce network overhead.
+    pub tcp_nodelay: bool,
 }
 
 /// To enable async support you need to enable the feature: `tokio-comp`
@@ -115,7 +118,10 @@ impl Client {
         let (con, _ip) = match Runtime::locate() {
             #[cfg(feature = "tokio-comp")]
             Runtime::Tokio => {
-                self.get_simple_async_connection::<crate::aio::tokio::Tokio>(None)
+                // Note: tcp_nodelay is hardcoded to true (default) since this deprecated API
+                // doesn't accept GlideConnectionOptions. Modern code should use
+                // get_multiplexed_async_connection which allows configuring tcp_nodelay.
+                self.get_simple_async_connection::<crate::aio::tokio::Tokio>(None, true)
                     .await?
             }
         };
@@ -427,7 +433,9 @@ impl Client {
     where
         T: crate::aio::RedisRuntime,
     {
-        let (con, ip) = self.get_simple_async_connection::<T>(socket_addr).await?;
+        let (con, ip) = self
+            .get_simple_async_connection::<T>(socket_addr, glide_connection_options.tcp_nodelay)
+            .await?;
         crate::aio::MultiplexedConnection::new_with_response_timeout(
             &self.connection_info,
             con,
@@ -441,6 +449,7 @@ impl Client {
     async fn get_simple_async_connection<T>(
         &self,
         socket_addr: Option<SocketAddr>,
+        tcp_nodelay: bool,
     ) -> RedisResult<(
         Pin<Box<dyn crate::aio::AsyncStream + Send + Sync>>,
         Option<IpAddr>,
@@ -449,7 +458,8 @@ impl Client {
         T: crate::aio::RedisRuntime,
     {
         let (conn, ip) =
-            crate::aio::connect_simple::<T>(&self.connection_info, socket_addr).await?;
+            crate::aio::connect_simple::<T>(&self.connection_info, socket_addr, tcp_nodelay)
+                .await?;
         Ok((conn.boxed(), ip))
     }
 
@@ -519,11 +529,11 @@ impl Client {
     ///
     ///     let mut con = client.get_async_connection(None).await?;
     ///
-    ///     con.set("key1", b"foo").await?;
+    ///     con.set::<_, _, ()>("key1", b"foo").await?;
     ///
     ///     redis::cmd("SET")
     ///         .arg(&["key2", "bar"])
-    ///         .query_async(&mut con)
+    ///         .query_async::<_, ()>(&mut con)
     ///         .await?;
     ///
     ///     let result = redis::cmd("MGET")

glide-core/redis-rs/redis/src/cluster_async/connections_logic.rs

@@ -193,6 +193,7 @@ where
             discover_az,
             connection_timeout: Some(params.connection_timeout),
             connection_retry_strategy: None,
+            tcp_nodelay: params.tcp_nodelay,
         },
     )
     .await

glide-core/redis-rs/redis/src/cluster_async/mod.rs

@@ -1132,6 +1132,7 @@ where
             discover_az,
             connection_timeout: Some(cluster_params.connection_timeout),
             connection_retry_strategy: Some(connection_retry_strategy),
+            tcp_nodelay: cluster_params.tcp_nodelay,
         };
 
         let connections = Self::create_initial_connections(