[IOPLT-945] Update redis client with appinsights tracing (#1182)

* Update redis client with appinsights tracing

* Add redis trace wrapper tests
Add appinsights mock

Author: robbcocco

src/utils/__mocks__/appinsights.mocks.ts

@@ -0,0 +1,10 @@
+import * as appInsights from "applicationinsights";
+
+// TODO: Add types when appinsights lib will be added
+export const mockTrackEvent = jest.fn();
+export const mockTrackDependency = jest.fn();
+
+export const mockedAppinsightsTelemetryClient = {
+  trackEvent: mockTrackEvent,
+  trackDependency: mockTrackDependency,
+} as any as appInsights.TelemetryClient;

src/utils/__tests__/redis-trace-wrapper.spec.ts

@@ -0,0 +1,82 @@
+import { createWrappedRedisClusterClient } from "../redis-trace-wrapper";
+import { mockedAppinsightsTelemetryClient, mockTrackDependency } from "../__mocks__/appinsights.mocks";
+
+
+const mockedAppInsightsClient = mockedAppinsightsTelemetryClient;
+
+const mockGet = jest.fn(async () => "42");
+
+jest.mock("redis", () => ({
+  createCluster: () => ({
+    get: mockGet,
+  }),
+}));
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("createWrappedRedisClusterClient |> trace enabled", () => {
+  const wrappedClient = createWrappedRedisClusterClient(
+    {} as any,
+    "TEST",
+    mockedAppInsightsClient,
+  );
+
+  it("should call `trackDependency` when the request completed successfully", async () => {
+    const result = await wrappedClient.get("TEST");
+
+    expect(result).toEqual("42");
+    expect(mockTrackDependency).toHaveBeenCalledWith({
+      target: "Redis Cluster - TEST",
+      name: "get",
+      data: "",
+      resultCode: "",
+      duration: expect.any(Number),
+      success: true,
+      dependencyTypeName: "REDIS",
+    });
+  });
+
+  test("should call `trackDependency` when the request failed", async () => {
+    mockGet.mockRejectedValueOnce({});
+
+    try {
+      await wrappedClient.get("TEST");
+    } catch (e) {}
+
+    expect(mockTrackDependency).toHaveBeenCalledWith({
+      target: "Redis Cluster - TEST",
+      name: "get",
+      data: "",
+      resultCode: "ERROR",
+      duration: expect.any(Number),
+      success: false,
+      dependencyTypeName: "REDIS",
+    });
+  });
+});
+
+describe("createWrappedRedisClusterClient |> trace disabled", () => {
+  const wrappedClient = createWrappedRedisClusterClient(
+    {} as any,
+    "TEST",
+  );
+
+  test("should NOT call `trackDependency` when the request completed successfully", async () => {
+    const result = await wrappedClient.get("TEST");
+
+    expect(result).toEqual("42");
+    expect(mockTrackDependency).not.toHaveBeenCalled();
+  });
+
+  test("should NOT call `trackDependency` when the request failed", async () => {
+    mockGet.mockRejectedValueOnce({});
+
+    try {
+      await wrappedClient.get("TEST");
+    } catch (e) {}
+
+    expect(mockTrackDependency).not.toHaveBeenCalled();
+  });
+});

src/utils/redis-trace-wrapper.ts

@@ -0,0 +1,83 @@
+import commands from "@redis/client/dist/lib/cluster/commands";
+import * as appInsights from "applicationinsights";
+import * as redis from "redis";
+
+function wrapAsyncFunctionWithAppInsights<
+  K extends keyof redis.RedisClusterType,
+  T extends redis.RedisClusterType[K]
+>(
+  redisClient: redis.RedisClusterType,
+  originalFunction: T,
+  functionName: string,
+  clientName: string,
+  appInsightsClient: appInsights.TelemetryClient
+): T {
+  return async function (...args: Array<unknown>) {
+    const startTime = Date.now();
+
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const result = await (originalFunction as any).apply(redisClient, args);
+      const duration = Date.now() - startTime;
+
+      // Do not log any argument or result,
+      // as they can contain personal information
+      appInsightsClient.trackDependency({
+        target: `Redis Cluster - ${clientName}`,
+        name: functionName,
+        data: "",
+        resultCode: "",
+        duration,
+        success: true,
+        dependencyTypeName: "REDIS"
+      });
+
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      appInsightsClient.trackDependency({
+        target: `Redis Cluster - ${clientName}`,
+        name: functionName,
+        data: "",
+        resultCode: "ERROR",
+        duration,
+        success: false,
+        dependencyTypeName: "REDIS"
+      });
+      throw error;
+    }
+  } as T;
+}
+
+function wrapRedisClusterClient(
+  client: redis.RedisClusterType,
+  clientName: string,
+  appInsightsClient: appInsights.TelemetryClient
+) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const clientAsObject = client as Record<any, any>;
+  for (const functionName of Object.keys(commands)) {
+    if (typeof clientAsObject[functionName] === "function") {
+      clientAsObject[functionName] = wrapAsyncFunctionWithAppInsights(
+        client,
+        clientAsObject[functionName],
+        functionName,
+        clientName,
+        appInsightsClient
+      );
+    }
+  }
+
+  return client;
+}
+
+export function createWrappedRedisClusterClient(
+  options: redis.RedisClusterOptions,
+  clientName: string,
+  appInsightsClient?: appInsights.TelemetryClient
+) {
+  const cluster = redis.createCluster(options);
+  return appInsightsClient
+    ? wrapRedisClusterClient(cluster, clientName, appInsightsClient)
+    : cluster;
+}

src/utils/redis.ts

@@ -6,6 +6,7 @@ import * as redis from "redis";
 
 import { keyPrefixes } from "../services/redisSessionStorage";
 import { log } from "./logger";
+import { createWrappedRedisClusterClient } from "./redis-trace-wrapper";
 
 export const obfuscateTokensInfo = (message: string) =>
   pipe(
@@ -36,29 +37,30 @@ export const createClusterRedisClient =
     const redisPort: number = parseInt(port || DEFAULT_REDIS_PORT, 10);
     log.info("Creating CLUSTER redis client", { url: completeRedisUrl });
 
-    const redisClient = redis.createCluster<
-      Record<string, never>,
-      Record<string, never>,
-      Record<string, never>
-    >({
-      defaults: {
-        legacyMode: false,
-        password,
-        socket: {
-          // TODO: We can add a whitelist with all the IP addresses of the redis clsuter
-          // eslint-disable-next-line @typescript-eslint/no-unused-vars
-          checkServerIdentity: (_hostname, _cert) => undefined,
-          keepAlive: 2000,
-          tls: enableTls
-        }
+    const redisClient = createWrappedRedisClusterClient(
+      {
+        defaults: {
+          legacyMode: false,
+          password,
+          socket: {
+            // TODO: We can add a whitelist with all the IP addresses of the redis clsuter
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            checkServerIdentity: (_hostname, _cert) => undefined,
+            keepAlive: 2000,
+            tls: enableTls
+          }
+        },
+        rootNodes: [
+          {
+            url: `${completeRedisUrl}:${redisPort}`
+          }
+        ],
+        useReplicas
       },
-      rootNodes: [
-        {
-          url: `${completeRedisUrl}:${redisPort}`
-        }
-      ],
-      useReplicas
-    });
+      useReplicas ? "FAST" : "SAFE",
+      appInsightsClient
+    );
+
     redisClient.on("error", (err) => {
       log.error("[REDIS Error] an error occurs on redis client: %s", err);
       appInsightsClient?.trackEvent({