support client pass through lib_name on connection

Author: tylerhutcherson

redisvl/index/index.py

@@ -84,25 +84,27 @@ def _process(doc: "Document") -> Dict[str, Any]:
     return [_process(doc) for doc in results.docs]
 
 
-def check_modules_present():
+def setup_redis():
     def decorator(func):
         @wraps(func)
         def wrapper(self, *args, **kwargs):
             result = func(self, *args, **kwargs)
-            RedisConnectionFactory.validate_redis_modules(self._redis_client)
+            RedisConnectionFactory.validate_redis(self._redis_client, self._lib_name)
             return result
 
         return wrapper
 
     return decorator
 
 
-def check_async_modules_present():
+def setup_async_redis():
     def decorator(func):
         @wraps(func)
         def wrapper(self, *args, **kwargs):
             result = func(self, *args, **kwargs)
-            RedisConnectionFactory.validate_async_redis_modules(self._redis_client)
+            RedisConnectionFactory.validate_async_redis(
+                self._redis_client, self._lib_name
+            )
             return result
 
         return wrapper
@@ -175,6 +177,9 @@ def __init__(
 
         self.schema = schema
 
+        # set custom lib name
+        self._lib_name: Optional[str] = kwargs.pop("lib_name", None)
+
         # set up redis connection
         self._redis_client: Optional[Union[redis.Redis, aredis.Redis]] = None
         if redis_client is not None:
@@ -350,11 +355,13 @@ def connect(self, redis_url: Optional[str] = None, **kwargs):
             index.connect(redis_url="redis://localhost:6379")
 
         """
-        client = RedisConnectionFactory.connect(redis_url, use_async=False, **kwargs)
+        client = RedisConnectionFactory.connect(
+            redis_url=redis_url, use_async=False, **kwargs
+        )
         return self.set_client(client)
 
-    @check_modules_present()
-    def set_client(self, client: redis.Redis):
+    @setup_redis()
+    def set_client(self, client: redis.Redis, **kwargs):
         """Manually set the Redis client to use with the search index.
 
         This method configures the search index to use a specific Redis or
@@ -729,10 +736,12 @@ def connect(self, redis_url: Optional[str] = None, **kwargs):
             index.connect(redis_url="redis://localhost:6379")
 
         """
-        client = RedisConnectionFactory.connect(redis_url, use_async=True, **kwargs)
+        client = RedisConnectionFactory.connect(
+            redis_url=redis_url, use_async=True, **kwargs
+        )
         return self.set_client(client)
 
-    @check_async_modules_present()
+    @setup_async_redis()
     def set_client(self, client: aredis.Redis):
         """Manually set the Redis client to use with the search index.
 

redisvl/redis/connection.py

@@ -13,6 +13,7 @@
 
 from redisvl.redis.constants import REDIS_REQUIRED_MODULES
 from redisvl.redis.utils import convert_bytes
+from redisvl.version import __version__
 
 
 def get_address_from_env() -> str:
@@ -26,6 +27,20 @@ def get_address_from_env() -> str:
     return os.environ["REDIS_URL"]
 
 
+def make_lib_name(*args) -> str:
+    """Build the lib name to be reported through the Redis client setinfo
+    command.
+
+    Returns:
+        str: Redis client library name
+    """
+    custom_libs = f"redisvl_v{__version__}"
+    for arg in args:
+        if arg:
+            custom_libs += f";{arg}"
+    return f"redis-py({custom_libs})"
+
+
 class RedisConnectionFactory:
     """Builds connections to a Redis database, supporting both synchronous and
     asynchronous clients.
@@ -108,8 +123,10 @@ def get_async_redis_connection(url: Optional[str] = None, **kwargs) -> AsyncRedi
         return AsyncRedis.from_url(get_address_from_env(), **kwargs)
 
     @staticmethod
-    def validate_redis_modules(
-        client: Redis, redis_required_modules: Optional[List[Dict[str, Any]]] = None
+    def validate_redis(
+        client: Redis,
+        lib_name: Optional[str] = None,
+        redis_required_modules: Optional[List[Dict[str, Any]]] = None,
     ) -> None:
         """Validates if the required Redis modules are installed.
 
@@ -119,13 +136,18 @@ def validate_redis_modules(
         Raises:
             ValueError: If required Redis modules are not installed.
         """
-        RedisConnectionFactory._validate_redis_modules(
+        # set client library name
+        client.client_setinfo("LIB-NAME", make_lib_name(lib_name))
+
+        # validate available modules
+        RedisConnectionFactory._validate_modules(
             convert_bytes(client.module_list()), redis_required_modules
         )
 
     @staticmethod
-    def validate_async_redis_modules(
+    def validate_async_redis(
         client: AsyncRedis,
+        lib_name: Optional[str] = None,
         redis_required_modules: Optional[List[Dict[str, Any]]] = None,
     ) -> None:
         """
@@ -150,12 +172,12 @@ def validate_async_redis_modules(
                 **client.connection_pool.connection_kwargs,
             )
         )
-        RedisConnectionFactory.validate_redis_modules(
-            temp_client, redis_required_modules
+        RedisConnectionFactory.validate_redis(
+            temp_client, lib_name, redis_required_modules
         )
 
     @staticmethod
-    def _validate_redis_modules(
+    def _validate_modules(
         installed_modules, redis_required_modules: Optional[List[Dict[str, Any]]] = None
     ) -> None:
         """