accept arrays in item size calculation

Author: s1gr1d

packages/node/src/utils/redisCache.ts

@@ -69,13 +69,22 @@ export function shouldConsiderForCache(redisCommand: string, key: string, prefix
 
 /** Calculates size based on the cache response value */
 export function calculateCacheItemSize(response: unknown): number | undefined {
-  try {
-    if (Buffer.isBuffer(response)) return response.byteLength;
-    else if (typeof response === 'string') return response.length;
-    else if (typeof response === 'number') return response.toString().length;
-    else if (response === null || response === undefined) return 0;
-    return JSON.stringify(response).length;
-  } catch (e) {
-    return undefined;
-  }
+  const getSize = (value: unknown): number | undefined => {
+    try {
+      if (Buffer.isBuffer(value)) return value.byteLength;
+      else if (typeof value === 'string') return value.length;
+      else if (typeof value === 'number') return value.toString().length;
+      else if (value === null || value === undefined) return 0;
+      return JSON.stringify(value).length;
+    } catch (e) {
+      return undefined;
+    }
+  };
+
+  return Array.isArray(response)
+    ? response.reduce((acc: number | undefined, curr) => {
+        const size = getSize(curr);
+        return typeof size === 'number' ? (acc !== undefined ? acc + size : size) : acc;
+      }, 0)
+    : getSize(response);
 }

packages/node/test/integrations/tracing/redis.test.ts

@@ -180,4 +180,50 @@ describe('Redis', () => {
       });
     });
   });
+
+  describe('calculateCacheItemSize', () => {
+    it('should return byte length for Buffer input', () => {
+      const buffer = Buffer.from('test');
+      const result = calculateCacheItemSize(buffer);
+      expect(result).toBe(4);
+    });
+
+    it('should return string length for string input', () => {
+      const str = 'test';
+      const result = calculateCacheItemSize(str);
+      expect(result).toBe(4);
+    });
+
+    it('should return number length for number input', () => {
+      const num = 1234;
+      const result = calculateCacheItemSize(num);
+      expect(result).toBe(4);
+    });
+
+    it('should return 0 for null or undefined input', () => {
+      const resultForNull = calculateCacheItemSize(null);
+      const resultForUndefined = calculateCacheItemSize(undefined);
+      expect(resultForNull).toBe(0);
+      expect(resultForUndefined).toBe(0);
+    });
+
+    it('should return total size for array input', () => {
+      const arr = ['test', Buffer.from('test'), 1234];
+      const result = calculateCacheItemSize(arr);
+      expect(result).toBe(12);
+    });
+
+    it('should return JSON string length for object input', () => {
+      const obj = { key: 'value' };
+      const result = calculateCacheItemSize(obj);
+      expect(result).toBe(15);
+    });
+
+    it('should return undefined for circular objects', () => {
+      const circularObject: { self?: any } = {};
+      circularObject.self = circularObject; // This creates a circular reference
+      const result = calculateCacheItemSize(circularObject);
+      expect(result).toBeUndefined();
+    });
+  });
 });