feat(infra): d.i. config and provider in in-memory provider service

packages/application-generic/src/services/in-memory-provider/cache-in-memory-provider.service.ts

@@ -10,6 +10,7 @@ import {
 import {
   InMemoryProviderEnum,
   InMemoryProviderClient,
+  IProviderClusterConfigOptions,
   ScanStream,
 } from './types';
 
@@ -30,16 +31,27 @@ export class CacheInMemoryProviderService {
 
     this.loadedProvider = this.selectProvider();
 
-    const enableAutoPipelining =
-      process.env.REDIS_CACHE_ENABLE_AUTOPIPELINING === 'true';
-
     this.inMemoryProviderService = new InMemoryProviderService(
       this.loadedProvider,
-      this.isCluster,
-      enableAutoPipelining
+      this.loadedProvider.getConfig(this.getCacheConfigOptions()),
+      this.isCluster
     );
   }
 
+  private getCacheConfigOptions(): IProviderClusterConfigOptions {
+    const enableAutoPipelining =
+      process.env.REDIS_CACHE_ENABLE_AUTOPIPELINING === 'true';
+    /*
+     *  Disabled in Prod as affects performance
+     */
+    const showFriendlyErrorStack = process.env.NODE_ENV !== 'production';
+
+    return {
+      enableAutoPipelining,
+      showFriendlyErrorStack,
+    };
+  }
+
   /**
    * Rules for the provider selection:
    * - For our self hosted users we assume all of them have a single node Redis
@@ -51,17 +63,26 @@ export class CacheInMemoryProviderService {
    */
   private selectProvider(): IProviderCluster | IProviderRedis {
     if (this.isClusterMode()) {
-      const providers = [
+      const providerIds = [
         InMemoryProviderEnum.ELASTICACHE,
         InMemoryProviderEnum.REDIS_CLUSTER,
       ];
 
-      const selectedProvider = providers.find((provider) =>
-        getClusterProvider(provider)?.validate()
-      );
+      let selectedProvider = undefined;
+      for (const providerId of providerIds) {
+        const clusterProvider = getClusterProvider(providerId);
+        const clusterProviderConfig = clusterProvider.getConfig(
+          this.getCacheConfigOptions()
+        );
+
+        if (clusterProvider.validate(clusterProviderConfig)) {
+          selectedProvider = clusterProvider;
+          break;
+        }
+      }
 
       if (selectedProvider) {
-        return getClusterProvider(selectedProvider);
+        return selectedProvider;
       }
     }
 

packages/application-generic/src/services/in-memory-provider/in-memory-provider.service.spec.ts

@@ -10,7 +10,11 @@ let inMemoryProviderService: InMemoryProviderService;
 describe('In-memory Provider Service', () => {
   describe('Non cluster mode', () => {
     beforeEach(async () => {
-      inMemoryProviderService = new InMemoryProviderService(redis, false);
+      inMemoryProviderService = new InMemoryProviderService(
+        redis,
+        redis.getConfig({ showFriendlyErrorStack: false }),
+        false
+      );
 
       await inMemoryProviderService.delayUntilReadiness();
 
@@ -42,6 +46,9 @@ describe('In-memory Provider Service', () => {
         expect(inMemoryProviderConfig.password).toEqual(undefined);
         expect(inMemoryProviderConfig.ttl).toEqual(7_200);
         expect(inMemoryProviderConfig.tls).toEqual(undefined);
+        expect(inMemoryProviderConfig.options.showFriendlyErrorStack).toEqual(
+          false
+        );
       });
 
       it('should instantiate the provider properly', async () => {
@@ -82,7 +89,11 @@ describe('In-memory Provider Service', () => {
 
   describe('Cluster mode', () => {
     beforeEach(async () => {
-      inMemoryProviderService = new InMemoryProviderService(redisCluster, true);
+      inMemoryProviderService = new InMemoryProviderService(
+        redisCluster,
+        redisCluster.getConfig({ showFriendlyErrorStack: false }),
+        true
+      );
       await inMemoryProviderService.delayUntilReadiness();
 
       expect(inMemoryProviderService.getStatus()).toEqual('ready');
@@ -92,16 +103,23 @@ describe('In-memory Provider Service', () => {
       await inMemoryProviderService.shutdown();
     });
 
-    describe('TEMP: Check if enableAutoPipelining true is set properly in Cluster', () => {
+    describe('Check if enableAutoPipelining true is set properly in Cluster', () => {
       it('enableAutoPipelining is enabled', async () => {
         const clusterWithPipelining = new InMemoryProviderService(
           redisCluster,
-          true,
+          redisCluster.getConfig({
+            enableAutoPipelining: true,
+            showFriendlyErrorStack: false,
+          }),
           true
         );
         await clusterWithPipelining.delayUntilReadiness();
 
         expect(clusterWithPipelining.getStatus()).toEqual('ready');
+        expect(
+          clusterWithPipelining.inMemoryProviderConfig.options
+            .showFriendlyErrorStack
+        ).toEqual(false);
         expect(
           clusterWithPipelining.inMemoryProviderClient.options
             .enableAutoPipelining

packages/application-generic/src/services/in-memory-provider/in-memory-provider.service.ts

@@ -20,24 +20,25 @@ const LOG_CONTEXT = 'InMemoryProviderService';
 
 export class InMemoryProviderService {
   public inMemoryProviderClient: InMemoryProviderClient;
-  public inMemoryProviderConfig: InMemoryProviderConfig;
-
   public isProviderClientReady: (string) => boolean;
 
   constructor(
-    private loadedProvider: IProviderRedis | IProviderCluster,
-    private isCluster: boolean,
-    private enableAutoPipelining?: boolean
+    private loadedProvider: IProviderCluster | IProviderRedis,
+    private config: InMemoryProviderConfig,
+    private isCluster: boolean
   ) {
     Logger.log(
       this.descriptiveLogMessage('In-memory provider service initialized'),
       LOG_CONTEXT
     );
     this.isProviderClientReady = loadedProvider.isClientReady;
-    this.inMemoryProviderConfig = loadedProvider.getConfig();
     this.inMemoryProviderClient = this.inMemoryProviderSetup();
   }
 
+  public get inMemoryProviderConfig(): InMemoryProviderConfig {
+    return this.config;
+  }
+
   protected descriptiveLogMessage(message) {
     return `[Provider: ${this.loadedProvider.provider} | Cluster: ${
       this.isCluster ? 'Yes' : 'No'
@@ -115,14 +116,10 @@ export class InMemoryProviderService {
 
     const { getClient } = this.loadedProvider;
 
-    const inMemoryProviderClient = getClient(
-      this.isCluster && this.enableAutoPipelining
-    );
-    if (this.inMemoryProviderConfig.host && inMemoryProviderClient) {
+    const inMemoryProviderClient = getClient(this.config);
+    if (this.config.host && inMemoryProviderClient) {
       Logger.log(
-        this.descriptiveLogMessage(
-          `Connecting at ${this.inMemoryProviderConfig.host}`
-        ),
+        this.descriptiveLogMessage(`Connecting at ${this.config.host}`),
         LOG_CONTEXT
       );