RI-6363 include server_name to telemetry

Author: kchepikava

redisinsight/api/src/modules/database/models/database-overview.ts

@@ -4,54 +4,60 @@ export class DatabaseOverview {
   @ApiProperty({
     description: 'Redis database version',
     type: String,
-  })
+    })
   version: string;
 
   @ApiPropertyOptional({
     description: 'Total number of bytes allocated by Redis primary shards',
     type: Number,
-  })
+    })
   usedMemory?: number;
 
   @ApiPropertyOptional({
     description: 'Total number of keys inside Redis primary shards',
     type: Number,
-  })
+    })
   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,
-  })
+    })
   connectedClients?: number;
 
   @ApiPropertyOptional({
     description: 'Sum of current commands per second in the all shards',
     type: Number,
-  })
+    })
   opsPerSecond?: number;
 
   @ApiPropertyOptional({
     description: 'Sum of current network input in the all shards (kbps)',
     type: Number,
-  })
+    })
   networkInKbps?: number;
 
   @ApiPropertyOptional({
     description: 'Sum of current network out in the all shards (kbps)',
     type: Number,
-  })
+    })
   networkOutKbps?: number;
 
   @ApiPropertyOptional({
     description: 'Sum of current cpu usage in the all shards (%)',
     type: Number,
-  })
+    })
   cpuUsagePercentage?: number;
+
+  @ApiProperty({
+    description: 'Database server name',
+    type: String,
+    })
+  serverName?: string;
 }

redisinsight/api/src/modules/database/providers/database-overview.provider.spec.ts

@@ -55,6 +55,7 @@ const mockGetTotalResponse1 = 1;
 
 export const mockDatabaseOverview: DatabaseOverview = {
   version: mockServerInfo.redis_version,
+  serverName: null,
   usedMemory: 1,
   totalKeys: 2,
   totalKeysPerDb: {
@@ -110,6 +111,28 @@ describe('OverviewService', () => {
           networkOutKbps: undefined,
         });
       });
+      it('should return overview with serverName if server_name is present in redis info', async () => {
+        const redisInfoReplyWithServerName = `${mockStandaloneRedisInfoReply.slice(0, 11)}server_name:valkey\r\n${mockStandaloneRedisInfoReply.slice(11)}`;
+        when(standaloneClient.sendCommand)
+          .calledWith(['info'], { replyEncoding: 'utf8' })
+          .mockResolvedValue(redisInfoReplyWithServerName);
+
+        const result = await service.getOverview(mockClientMetadata, standaloneClient, mockCurrentKeyspace);
+
+        expect(result).toEqual({
+          ...mockDatabaseOverview,
+          version: '6.0.5',
+          serverName: 'valkey',
+          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,

redisinsight/api/src/modules/database/providers/database-overview.provider.ts

@@ -55,6 +55,7 @@ export class DatabaseOverviewProvider {
 
     return {
       version: this.getVersion(nodesInfo),
+      serverName: this.getServerName(nodesInfo),
       totalKeys,
       totalKeysPerDb,
       usedMemory: this.calculateUsedMemory(nodesInfo),
@@ -126,6 +127,15 @@ export class DatabaseOverviewProvider {
     return get(nodes, [0, 'server', 'redis_version'], null);
   }
 
+  /**
+   * Get server_name from the first shard in the list
+   * @param nodes
+   * @private
+   */
+  private getServerName(nodes = []): string {
+    return get(nodes, [0, 'server', 'server_name'], null);
+  }
+
   /**
    * Sum of current ops per second (instantaneous_ops_per_sec) for all shards
    * @param nodes

redisinsight/api/test/api/database/GET-databases-id-overview.test.ts

@@ -7,6 +7,7 @@ const endpoint = (id = constants.TEST_INSTANCE_ID) =>
 
 const responseSchema = Joi.object().keys({
   version: Joi.string().required(),
+  serverName: Joi.string().allow(null),
   totalKeys: Joi.number().integer().allow(null),
   totalKeysPerDb: Joi.object().allow(null),
   usedMemory: Joi.number().integer().allow(null),

redisinsight/ui/src/slices/interfaces/instances.ts

@@ -307,6 +307,7 @@ export interface DatabaseConfigInfo {
   networkInKbps?: Nullable<number>
   networkOutKbps?: Nullable<number>
   cpuUsagePercentage?: Nullable<number>
+  serverName?: Nullable<string>
 }
 
 export interface InitialStateInstances {

redisinsight/ui/src/telemetry/telemetryUtils.ts

@@ -20,41 +20,53 @@ import {
 import { TelemetryEvent } from './events'
 import { checkIsAnalyticsGranted } from './checkAnalytics'
 
-export const getProvider = (dbId: string): Maybe<string> => {
+export const getProviderData = (dbId: string): {
+  provider: Maybe<string>,
+  serverName: Maybe<string>
+} => {
+  let provider
+  let serverName
   const instance = get(store.getState(), 'connections.instances.connectedInstance')
-  return (instance.id === dbId) ? instance.provider : undefined
+  if (instance.id === dbId) {
+    provider = instance?.provider
+    const instanceOverview = get(store.getState(), 'connections.instances.instanceOverview')
+    serverName = instanceOverview?.serverName || undefined
+  }
+  return { provider, serverName }
 }
 
 const TELEMETRY_EMPTY_VALUE = 'none'
 
 const sendEventTelemetry = async ({ event, eventData = {}, traits = {} }: ITelemetrySendEvent) => {
+  let providerData
   try {
     const isAnalyticsGranted = checkIsAnalyticsGranted()
     if (!isAnalyticsGranted) {
       return
     }
 
-    if (!eventData.provider && eventData.databaseId) {
-      eventData.provider = getProvider(eventData.databaseId)
+    if (eventData.databaseId) {
+      providerData = getProviderData(eventData.databaseId)
     }
     await apiService.post(`${ApiEndpoints.ANALYTICS_SEND_EVENT}`,
-      { event, eventData, traits })
+      { event, eventData: { ...providerData, ...eventData }, traits })
   } catch (e) {
     // continue regardless of error
   }
 }
 
 const sendPageViewTelemetry = async ({ name, eventData = {} }: ITelemetrySendPageView) => {
   try {
+    let providerData
     const isAnalyticsGranted = checkIsAnalyticsGranted()
     if (!isAnalyticsGranted) {
       return
     }
-    if (!eventData.provider && eventData.databaseId) {
-      eventData.provider = getProvider(eventData.databaseId)
+    if (eventData.databaseId) {
+      providerData = getProviderData(eventData.databaseId)
     }
     await apiService.post(`${ApiEndpoints.ANALYTICS_SEND_PAGE}`,
-      { event: name, eventData })
+      { event: name, eventData: { ...providerData, ...eventData } })
   } catch (e) {
     // continue regardless of error
   }