UTAPI-116: Fix node22 warning DEP0174 promisify

It floods the stderr logs of cloudserver and utapi

```
(node:4634) [DEP0174] DeprecationWarning: Calling promisify on a function that returns a Promise is likely a mistake.
```

Author: BourgoisMickael

libV2/redis.js

@@ -1,5 +1,5 @@
 const EventEmitter = require('events');
-const { callbackify, promisify } = require('util');
+const { callbackify } = require('util');
 const IORedis = require('ioredis');
 const { jsutil } = require('arsenal');
 const BackOff = require('backo');
@@ -15,6 +15,49 @@ const moduleLogger = new LoggerContext({
 const COMMAND_TIMEOUT = 10000;
 const CONNECTION_TIMEOUT = 30000;
 
+/**
+ * Promisifies a function. If the function already returns a promise,
+ * it returns it as is. Handles both callbacks and promises.
+ *
+ * @param {Function} originalFn The function to promisify.
+ * @returns {Function} A function that returns a promise.
+ */
+function flexiblePromisify(originalFn) {
+    // Check if the function provides a custom promise-based version.
+    // This is the same mechanism Node's util.promisify uses.
+    const customPromisified = originalFn[Symbol.for('nodejs.util.promisify.custom')];
+    if (typeof customPromisified === 'function') {
+        return customPromisified;
+    }
+
+    // Return the new promise-based wrapper function.
+    return function flexiblePromisifiedWrapper(...args) {
+        const thisCtx = this;
+
+        return new Promise((resolve, reject) => {
+            // 1. Callback will be used if `originalFn` is a callback-style function.
+            function callback(err, result) {
+                if (err) {
+                    return reject(err);
+                }
+                return resolve(result);
+            }
+
+            // 2. Call the originalFn, with user's args AND our custom callback.
+            const potentialPromise = originalFn.apply(thisCtx, [...args, callback]);
+
+            // 3. If originalFn returned a promise, we use its result and ignore the callback.
+            if (potentialPromise && typeof potentialPromise.then === 'function') {
+                // The function returned a promise. We'll trust it as the source of truth.
+                potentialPromise.then(resolve, reject);
+            }
+
+            // If the function did NOT return a promise (i.e., it's a standard callback function),
+            // then our promise is already wired up to be resolved or rejected by the `callback` we passed in.
+        });
+    };
+}
+
 /**
 * Creates a new Redis client instance
 * @param {object} conf - redis configuration
@@ -201,7 +244,9 @@ class RedisClient extends EventEmitter {
         if (callback !== undefined) {
             // If a callback is provided `func` is assumed to also take a callback
             // and is converted to a promise using promisify
-            return callbackify(this._call.bind(this))(promisify(func), callback);
+            // Note (DEP0174): flexiblePromisify avoids promisifying a function that already returns a promise
+            // With redisClientV2 func returns a promise even if there is a callback
+            return callbackify(this._call.bind(this))(flexiblePromisify(func), callback);
         }
         return this._call(func);
     }