feat(redis): implement Redis client info reporting (#21)

  Adds proper Redis client identification using SET_CLIENT_INFO for both synchronous and asynchronous clients. Includes graceful fallback to echo when the command is not
  available and comprehensive tests for both checkpoint and store components.

Author: bsbodden

langgraph/checkpoint/redis/aio.py

@@ -116,6 +116,10 @@ def create_indexes(self) -> None:
     async def __aenter__(self) -> AsyncRedisSaver:
         """Async context manager enter."""
         await self.asetup()
+
+        # Set client info once Redis is set up
+        await self.aset_client_info()
+
         return self
 
     async def __aexit__(

langgraph/checkpoint/redis/ashallow.py

@@ -117,6 +117,12 @@ def __init__(
         self.loop = asyncio.get_running_loop()
 
     async def __aenter__(self) -> AsyncShallowRedisSaver:
+        """Async context manager enter."""
+        await self.asetup()
+
+        # Set client info once Redis is set up
+        await self.aset_client_info()
+
         return self
 
     async def __aexit__(

langgraph/checkpoint/redis/base.py

@@ -132,6 +132,41 @@ def configure_client(
     ) -> None:
         """Configure the Redis client."""
         pass
+        
+    def set_client_info(self) -> None:
+        """Set client info for Redis monitoring."""
+        from redis.exceptions import ResponseError
+        from langgraph.checkpoint.redis.version import __full_lib_name__
+        
+        try:
+            # Try to use client_setinfo command if available
+            self._redis.client_setinfo("LIB-NAME", __full_lib_name__)  # type: ignore
+        except (ResponseError, AttributeError):
+            # Fall back to a simple echo if client_setinfo is not available
+            try:
+                self._redis.echo(__full_lib_name__)
+            except Exception:
+                # Silently fail if even echo doesn't work
+                pass
+                
+    async def aset_client_info(self) -> None:
+        """Set client info for Redis monitoring asynchronously."""
+        from redis.exceptions import ResponseError
+        from langgraph.checkpoint.redis.version import __full_lib_name__
+        
+        try:
+            # Try to use client_setinfo command if available
+            await self._redis.client_setinfo("LIB-NAME", __full_lib_name__)  # type: ignore
+        except (ResponseError, AttributeError):
+            # Fall back to a simple echo if client_setinfo is not available
+            try:
+                # Call with await to ensure it's an async call
+                echo_result = self._redis.echo(__full_lib_name__)
+                if hasattr(echo_result, "__await__"):
+                    await echo_result
+            except Exception:
+                # Silently fail if even echo doesn't work
+                pass
 
     def setup(self) -> None:
         """Initialize the indices in Redis."""

langgraph/checkpoint/redis/shallow.py

@@ -386,6 +386,9 @@ def configure_client(
         self._redis = redis_client or RedisConnectionFactory.get_redis_connection(
             redis_url, **connection_args
         )
+        
+        # Set client info for Redis monitoring
+        self.set_client_info()
 
     def create_indexes(self) -> None:
         self.checkpoints_index = SearchIndex.from_dict(

langgraph/store/redis/__init__.py

@@ -98,7 +98,11 @@ def from_conn_string(
         client = None
         try:
             client = RedisConnectionFactory.get_redis_connection(conn_string)
-            yield cls(client, index=index, ttl=ttl)
+            store = cls(client, index=index, ttl=ttl)
+            # Client info will already be set in __init__, but we set it up here
+            # to make the method behavior consistent with AsyncRedisStore
+            store.set_client_info()
+            yield store
         finally:
             if client:
                 client.close()

langgraph/store/redis/aio.py

@@ -275,6 +275,8 @@ async def from_conn_string(
         """Create store from Redis connection string."""
         async with cls(redis_url=conn_string, index=index, ttl=ttl) as store:
             await store.setup()
+            # Set client information after setup
+            await store.aset_client_info()
             yield store
 
     def create_indexes(self) -> None:
@@ -289,6 +291,9 @@ def create_indexes(self) -> None:
 
     async def __aenter__(self) -> AsyncRedisStore:
         """Async context manager enter."""
+        # Client info was already set in __init__, 
+        # but we'll set it again here to be consistent with checkpoint code
+        await self.aset_client_info()
         return self
 
     async def __aexit__(

langgraph/store/redis/base.py

@@ -244,6 +244,44 @@ def __init__(
             self.vector_index = SearchIndex.from_dict(
                 vector_schema, redis_client=self._redis
             )
+            
+        # Set client information in Redis
+        self.set_client_info()
+        
+    def set_client_info(self) -> None:
+        """Set client info for Redis monitoring."""
+        from redis.exceptions import ResponseError
+        from langgraph.checkpoint.redis.version import __full_lib_name__
+        
+        try:
+            # Try to use client_setinfo command if available
+            self._redis.client_setinfo("LIB-NAME", __full_lib_name__)  # type: ignore
+        except (ResponseError, AttributeError):
+            # Fall back to a simple echo if client_setinfo is not available
+            try:
+                self._redis.echo(__full_lib_name__)
+            except Exception:
+                # Silently fail if even echo doesn't work
+                pass
+                
+    async def aset_client_info(self) -> None:
+        """Set client info for Redis monitoring asynchronously."""
+        from redis.exceptions import ResponseError
+        from langgraph.checkpoint.redis.version import __full_lib_name__
+        
+        try:
+            # Try to use client_setinfo command if available
+            await self._redis.client_setinfo("LIB-NAME", __full_lib_name__)  # type: ignore
+        except (ResponseError, AttributeError):
+            # Fall back to a simple echo if client_setinfo is not available
+            try:
+                # Call with await to ensure it's an async call
+                echo_result = self._redis.echo(__full_lib_name__)
+                if hasattr(echo_result, "__await__"):
+                    await echo_result
+            except Exception:
+                # Silently fail if even echo doesn't work
+                pass
 
     def _get_batch_GET_ops_queries(
         self,

tests/test_async.py

@@ -278,6 +278,98 @@ async def test_from_conn_string_cleanup(redis_url: str) -> None:
         assert await ext_client.ping()  # Should still work
     finally:
         await ext_client.aclose()  # type: ignore[attr-defined]
+        
+        
+@pytest.mark.asyncio
+async def test_async_client_info_setting(redis_url: str, monkeypatch) -> None:
+    """Test that async client_setinfo is called with correct library information."""
+    from langgraph.checkpoint.redis.version import __full_lib_name__
+    
+    # Track if client_setinfo was called with the right parameters
+    client_info_called = False
+    
+    # Store the original method
+    original_client_setinfo = Redis.client_setinfo
+    
+    # Create a mock function for client_setinfo
+    async def mock_client_setinfo(self, key, value):
+        nonlocal client_info_called
+        # Note: RedisVL might call this with its own lib name first
+        # We only track calls with our full lib name
+        if key == "LIB-NAME" and __full_lib_name__ in value:
+            client_info_called = True
+        # Call original method to ensure normal function
+        return await original_client_setinfo(self, key, value)
+    
+    # Apply the mock
+    monkeypatch.setattr(Redis, "client_setinfo", mock_client_setinfo)
+    
+    # Test client info setting when creating a new saver with async context manager
+    async with AsyncRedisSaver.from_conn_string(redis_url) as saver:
+        await saver.asetup()
+        # __aenter__ should have called aset_client_info
+    
+    # Verify client_setinfo was called with our library info
+    assert client_info_called, "client_setinfo was not called with our library name"
+
+
+@pytest.mark.asyncio
+async def test_async_client_info_fallback_to_echo(redis_url: str, monkeypatch) -> None:
+    """Test that async client_setinfo falls back to echo when not available."""
+    from langgraph.checkpoint.redis.version import __full_lib_name__
+    from redis.exceptions import ResponseError
+    
+    # Remove client_setinfo to simulate older Redis version
+    async def mock_client_setinfo(self, key, value):
+        raise ResponseError("ERR unknown command")
+    
+    # Track if echo was called as fallback
+    echo_called = False
+    original_echo = Redis.echo
+    
+    # Create mock for echo
+    async def mock_echo(self, message):
+        nonlocal echo_called
+        echo_called = True
+        assert message == __full_lib_name__
+        return await original_echo(self, message)
+    
+    # Apply the mocks
+    monkeypatch.setattr(Redis, "client_setinfo", mock_client_setinfo)
+    monkeypatch.setattr(Redis, "echo", mock_echo)
+    
+    # Test client info setting with fallback
+    async with AsyncRedisSaver.from_conn_string(redis_url) as saver:
+        await saver.asetup()
+        # __aenter__ should have called aset_client_info with fallback to echo
+    
+    # Verify echo was called as fallback
+    assert echo_called, "echo was not called as fallback when async client_setinfo failed"
+
+
+@pytest.mark.asyncio
+async def test_async_client_info_graceful_failure(redis_url: str, monkeypatch) -> None:
+    """Test that async client info setting fails gracefully when all methods fail."""
+    from redis.exceptions import ResponseError
+    
+    # Simulate failures for both methods
+    async def mock_client_setinfo(self, key, value):
+        raise ResponseError("ERR unknown command")
+    
+    async def mock_echo(self, message):
+        raise ResponseError("ERR connection broken")
+    
+    # Apply the mocks
+    monkeypatch.setattr(Redis, "client_setinfo", mock_client_setinfo)
+    monkeypatch.setattr(Redis, "echo", mock_echo)
+    
+    # Should not raise any exceptions when both methods fail
+    try:
+        async with AsyncRedisSaver.from_conn_string(redis_url) as saver:
+            await saver.asetup()
+            # __aenter__ should handle failures gracefully
+    except Exception as e:
+        assert False, f"aset_client_info did not handle failure gracefully: {e}"
 
 
 @pytest.mark.asyncio

tests/test_async_store.py

@@ -464,3 +464,95 @@ async def test_async_store_with_memory_persistence() -> None:
     Note: This test is skipped by default as it requires special setup.
     """
     pytest.skip("Skipping in-memory Redis test")
+
+
+@pytest.mark.asyncio
+async def test_async_redis_store_client_info(redis_url: str, monkeypatch) -> None:
+    """Test that AsyncRedisStore sets client info correctly."""
+    from redis.asyncio import Redis
+    from langgraph.checkpoint.redis.version import __full_lib_name__
+    
+    # Track if client_setinfo was called with the right parameters
+    client_info_called = False
+    
+    # Store the original method
+    original_client_setinfo = Redis.client_setinfo
+    
+    # Create a mock function for client_setinfo
+    async def mock_client_setinfo(self, key, value):
+        nonlocal client_info_called
+        # Note: RedisVL might call this with its own lib name first
+        # We only track calls with our full lib name
+        if key == "LIB-NAME" and __full_lib_name__ in value:
+            client_info_called = True
+        # Call original method to ensure normal function
+        return await original_client_setinfo(self, key, value)
+    
+    # Apply the mock
+    monkeypatch.setattr(Redis, "client_setinfo", mock_client_setinfo)
+    
+    # Test client info setting when creating a new async store
+    async with AsyncRedisStore.from_conn_string(redis_url) as store:
+        await store.setup()
+    
+    # Verify client_setinfo was called with our library info
+    assert client_info_called, "client_setinfo was not called with our library name"
+
+
+@pytest.mark.asyncio
+async def test_async_redis_store_client_info_fallback(redis_url: str, monkeypatch) -> None:
+    """Test that AsyncRedisStore falls back to echo when client_setinfo is not available."""
+    from redis.asyncio import Redis
+    from redis.exceptions import ResponseError
+    from langgraph.checkpoint.redis.version import __full_lib_name__
+    
+    # Remove client_setinfo to simulate older Redis version
+    async def mock_client_setinfo(self, key, value):
+        raise ResponseError("ERR unknown command")
+    
+    # Track if echo was called as fallback
+    echo_called = False
+    original_echo = Redis.echo
+    
+    # Create mock for echo
+    async def mock_echo(self, message):
+        nonlocal echo_called
+        echo_called = True
+        assert message == __full_lib_name__
+        return await original_echo(self, message)
+    
+    # Apply the mocks
+    monkeypatch.setattr(Redis, "client_setinfo", mock_client_setinfo)
+    monkeypatch.setattr(Redis, "echo", mock_echo)
+    
+    # Test client info setting with fallback
+    async with AsyncRedisStore.from_conn_string(redis_url) as store:
+        await store.setup()
+    
+    # Verify echo was called as fallback
+    assert echo_called, "echo was not called as fallback when client_setinfo failed in AsyncRedisStore"
+
+
+@pytest.mark.asyncio
+async def test_async_redis_store_graceful_failure(redis_url: str, monkeypatch) -> None:
+    """Test that async store client info setting fails gracefully when all methods fail."""
+    from redis.asyncio import Redis
+    from redis.exceptions import ResponseError
+    
+    # Simulate failures for both methods
+    async def mock_client_setinfo(self, key, value):
+        raise ResponseError("ERR unknown command")
+    
+    async def mock_echo(self, message):
+        raise ResponseError("ERR connection broken")
+    
+    # Apply the mocks
+    monkeypatch.setattr(Redis, "client_setinfo", mock_client_setinfo)
+    monkeypatch.setattr(Redis, "echo", mock_echo)
+    
+    # Should not raise any exceptions when both methods fail
+    try:
+        async with AsyncRedisStore.from_conn_string(redis_url) as store:
+            await store.setup()
+    except Exception as e:
+        assert False, f"aset_client_info did not handle failure gracefully: {e}"