Merge pull request #761 from RedisInsight/feature/RI-2642-total-keys-per-db

#RI-3038 BE return total keys per database if dbN > 1

Author: arthosofteq

redisinsight/api/src/modules/instances/dto/database-overview.dto.ts

@@ -19,6 +19,12 @@ export class DatabaseOverview {
   })
   totalKeys?: number;
 
+  @ApiPropertyOptional({
+    description: 'Nested object with total number of keys per logical database',
+    type: Number,
+  })
+  totalKeysPerDb?: Record<string, number>;
+
   @ApiPropertyOptional({
     description: 'Median for connected clients in the all shards',
     type: Number,

redisinsight/api/src/modules/shared/services/instances-business/overview.service.spec.ts

@@ -41,7 +41,7 @@ const mockClientsInfo = {
 const mockKeyspace = {
   db0: 'keys=1,expires=0,avg_ttl=0',
   db1: 'keys=0,expires=0,avg_ttl=0',
-  db2: 'keys=0,expires=0,avg_ttl=0',
+  db2: 'keys=1,expires=0,avg_ttl=0',
 };
 const mockNodeInfo = {
   host: 'localhost',
@@ -59,7 +59,11 @@ const databaseId = mockStandaloneDatabaseEntity.id;
 export const mockDatabaseOverview: DatabaseOverview = {
   version: mockServerInfo.redis_version,
   usedMemory: 1,
-  totalKeys: 1,
+  totalKeys: 2,
+  totalKeysPerDb: {
+    db0: 1,
+    db2: 1,
+  },
   connectedClients: 1,
   opsPerSecond: 1,
   networkInKbps: 1,
@@ -94,13 +98,28 @@ describe('OverviewService', () => {
           version: '6.0.5',
           connectedClients: 1,
           totalKeys: 1,
+          totalKeysPerDb: undefined,
           usedMemory: 1000000,
           cpuUsagePercentage: undefined,
           opsPerSecond: undefined,
           networkInKbps: undefined,
           networkOutKbps: undefined,
         });
       });
+      it('should return total 0 and empty total per db object', async () => {
+        spyGetNodeInfo.mockResolvedValueOnce({
+          ...mockNodeInfo,
+          keyspace: {
+            db0: 'keys=0,expires=0,avg_ttl=0',
+          },
+        });
+
+        expect(await service.getOverview(databaseId, mockClient)).toEqual({
+          ...mockDatabaseOverview,
+          totalKeys: 0,
+          totalKeysPerDb: undefined,
+        });
+      });
       it('check for cpu on second attempt', async () => {
         spyGetNodeInfo.mockResolvedValueOnce(mockNodeInfo);
         spyGetNodeInfo.mockResolvedValueOnce({
@@ -205,7 +224,11 @@ describe('OverviewService', () => {
         expect(await service.getOverview(databaseId, mockCluster)).toEqual({
           ...mockDatabaseOverview,
           connectedClients: 1,
-          totalKeys: 3,
+          totalKeys: 6,
+          totalKeysPerDb: {
+            db0: 3,
+            db2: 3,
+          },
           usedMemory: 3,
           networkInKbps: 6,
           networkOutKbps: 6,
@@ -256,7 +279,11 @@ describe('OverviewService', () => {
         expect(await service.getOverview(databaseId, mockCluster)).toEqual({
           ...mockDatabaseOverview,
           connectedClients: 1,
-          totalKeys: 3,
+          totalKeys: 6,
+          totalKeysPerDb: {
+            db0: 3,
+            db2: 3,
+          },
           usedMemory: 3,
           networkInKbps: 6,
           networkOutKbps: 6,

redisinsight/api/src/modules/shared/services/instances-business/overview.service.ts

@@ -34,9 +34,11 @@ export class OverviewService {
       nodesInfo = [await this.getNodeInfo(client)];
     }
 
+    const [totalKeys, totalKeysPerDb] = this.calculateTotalKeys(nodesInfo);
     return {
       version: this.getVersion(nodesInfo),
-      totalKeys: this.calculateTotalKeys(nodesInfo),
+      totalKeys,
+      totalKeysPerDb,
       usedMemory: this.calculateUsedMemory(nodesInfo),
       connectedClients: this.calculateConnectedClients(nodesInfo),
       opsPerSecond: this.calculateOpsPerSec(nodesInfo),
@@ -192,27 +194,44 @@ export class OverviewService {
    * @param nodes
    * @private
    */
-  private calculateTotalKeys(nodes = []): number {
+  private calculateTotalKeys(nodes = []): [number, Record<string, number>] {
     if (!this.isMetricsAvailable(nodes, 'keyspace', [undefined])) {
-      return undefined;
+      return [undefined, undefined];
     }
 
     try {
       const masterNodes = filter(nodes, (node) => ['master', undefined].includes(
         get(node, 'replication.role'),
       ));
 
-      return sumBy(masterNodes, (node) => sum(
+      const totalKeysPerDb = {};
+
+      masterNodes.forEach((node) => {
         map(
           get(node, 'keyspace', {}),
-          (dbKeys): number => {
+          (dbKeys, dbNumber): void => {
             const { keys } = convertBulkStringsToObject(dbKeys, ',', '=');
-            return parseInt(keys, 10);
+
+            if (!totalKeysPerDb[dbNumber]) {
+              totalKeysPerDb[dbNumber] = 0;
+            }
+
+            totalKeysPerDb[dbNumber] += parseInt(keys, 10);
           },
-        ),
-      ));
+        );
+      });
+
+      // filter 0 values
+      Object.keys(totalKeysPerDb).forEach((key) => {
+        if (!totalKeysPerDb[key]) {
+          delete totalKeysPerDb[key];
+        }
+      });
+
+      const totalKeys = totalKeysPerDb ? sum(Object.values(totalKeysPerDb)) : undefined;
+      return [totalKeys, Object.keys(totalKeysPerDb).length > 1 ? totalKeysPerDb : undefined];
     } catch (e) {
-      return null;
+      return [null, null];
     }
   }
 

redisinsight/api/test/api/instance/GET-instance-id-overview.test.ts

@@ -8,6 +8,7 @@ const endpoint = (instanceId = constants.TEST_INSTANCE_ID) =>
 const responseSchema = Joi.object().keys({
   version: Joi.string().required(),
   totalKeys: Joi.number().integer().allow(null),
+  totalKeysPerDb: Joi.object().allow(null),
   usedMemory: Joi.number().integer().allow(null),
   connectedClients: Joi.number().allow(null),
   opsPerSecond: Joi.number().allow(null),
@@ -68,6 +69,7 @@ describe('GET /instance/:instanceId/overview', () => {
           expect(body.version).to.eql(rte.env.version);
           expect(body.cpuUsagePercentage).to.eql(undefined)
           expect(body.totalKeys).to.not.eql(undefined)
+          expect(body.totalKeysPerDb).to.eql(undefined)
           expect(body.connectedClients).to.not.eql(undefined)
           expect(body.opsPerSecond).to.not.eql(undefined)
           expect(body.networkInKbps).to.not.eql(undefined)