Merge pull request #2439 from RedisInsight/feature/RI-4806-sso-feature-flag

#RI-4806 sso feature flag

Author: vlad-dargel

redisinsight/api/config/features-config.json

@@ -16,6 +16,33 @@
           "cond": "eq"
         }
       ]
+    },
+    "cloudSso": {
+      "flag": true,
+      "perc": [[0,100]],
+      "filters": [
+        {
+          "name": "config.server.buildType",
+          "value": "ELECTRON",
+          "cond": "eq"
+        }
+      ],
+      "data": {
+        "selectPlan": {
+          "components": {
+            "triggersAndFunctions": [
+              {
+                "provider": "AWS",
+                "regions": ["ap-southeast-1"]
+              },
+              {
+                "provider": "GCP",
+                "regions": ["asia-northeast1"]
+              }
+            ]
+          }
+        }
+      }
     }
   }
 }

redisinsight/api/migration/1691476419592-feature-sso.ts

@@ -0,0 +1,20 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class FeatureSso1691476419592 implements MigrationInterface {
+    name = 'FeatureSso1691476419592'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TABLE "temporary_features" ("name" varchar PRIMARY KEY NOT NULL, "flag" boolean NOT NULL, "strategy" varchar, "data" text)`);
+        await queryRunner.query(`INSERT INTO "temporary_features"("name", "flag") SELECT "name", "flag" FROM "features"`);
+        await queryRunner.query(`DROP TABLE "features"`);
+        await queryRunner.query(`ALTER TABLE "temporary_features" RENAME TO "features"`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "features" RENAME TO "temporary_features"`);
+        await queryRunner.query(`CREATE TABLE "features" ("name" varchar PRIMARY KEY NOT NULL, "flag" boolean NOT NULL)`);
+        await queryRunner.query(`INSERT INTO "features"("name", "flag") SELECT "name", "flag" FROM "temporary_features"`);
+        await queryRunner.query(`DROP TABLE "temporary_features"`);
+    }
+
+}

redisinsight/api/migration/index.ts

@@ -37,6 +37,7 @@ import { DatabaseRecommendationUnique1687435940110 } from './1687435940110-datab
 import { CloudDatabaseDetails1687166457712 } from './1687166457712-cloud-database-details';
 import { FreeCloudDatabase1688989337247 } from './1688989337247-freeCloudDatabase';
 import { CloudCapiKeys1691061058385 } from './1691061058385-cloud-capi-keys';
+import { FeatureSso1691476419592 } from './1691476419592-feature-sso';
 
 export default [
   initialMigration1614164490968,
@@ -78,4 +79,5 @@ export default [
   CloudDatabaseDetails1687166457712,
   FreeCloudDatabase1688989337247,
   CloudCapiKeys1691061058385,
+  FeatureSso1691476419592,
 ];

redisinsight/api/src/__mocks__/feature.ts

@@ -11,6 +11,7 @@ import { FeatureEntity } from 'src/modules/feature/entities/feature.entity';
 import { mockAppSettings } from 'src/__mocks__/app-settings';
 import config from 'src/utils/config';
 import { KnownFeatures } from 'src/modules/feature/constants';
+import { CloudSsoFeatureStrategy } from 'src/modules/cloud/cloud-sso.feature.flag';
 import * as defaultConfig from '../../config/features-config.json';
 
 export const mockFeaturesConfigId = '1';
@@ -160,6 +161,28 @@ export const mockFeature = Object.assign(new Feature(), {
   flag: true,
 });
 
+export const mockFeatureSso = Object.assign(new Feature(), {
+  name: KnownFeatures.CloudSso,
+  flag: true,
+  strategy: CloudSsoFeatureStrategy.DeepLink,
+  data: {
+    selectPlan: {
+      components: {
+        triggersAndFunctions: [
+          {
+            provider: 'AWS',
+            regions: ['ap-southeast-1'],
+          },
+          {
+            provider: 'GCP',
+            regions: ['asia-northeast1'],
+          },
+        ],
+      },
+    },
+  },
+});
+
 export const mockUnknownFeature = Object.assign(new Feature(), {
   name: 'unknown',
   flag: true,
@@ -186,7 +209,7 @@ export const mockFeaturesConfigRepository = jest.fn(() => ({
 export const mockFeatureRepository = jest.fn(() => ({
   get: jest.fn().mockResolvedValue(mockFeature),
   upsert: jest.fn().mockResolvedValue({ updated: 1 }),
-  list: jest.fn().mockResolvedValue([mockFeature]),
+  list: jest.fn().mockResolvedValue([mockFeature, mockFeatureSso]),
   delete: jest.fn().mockResolvedValue({ deleted: 1 }),
 }));
 
@@ -210,10 +233,10 @@ export const mockFeatureAnalytics = jest.fn(() => ({
 }));
 
 export const mockInsightsRecommendationsFlagStrategy = {
-  calculate: jest.fn().mockResolvedValue(true),
+  calculate: jest.fn().mockResolvedValue(mockFeature),
 };
 
 export const mockFeatureFlagProvider = jest.fn(() => ({
   getStrategy: jest.fn().mockResolvedValue(mockInsightsRecommendationsFlagStrategy),
-  calculate: jest.fn().mockResolvedValue(true),
+  calculate: jest.fn().mockResolvedValue(mockFeature),
 }));

redisinsight/api/src/modules/feature/constants/known-features.ts

@@ -1,14 +1,14 @@
 import { FeatureStorage, IFeatureFlag, KnownFeatures } from 'src/modules/feature/constants/index';
 import { CloudSsoFeatureFlag } from 'src/modules/cloud/cloud-sso.feature.flag';
 
-export const knownFeatures: IFeatureFlag[] = [
-  {
+export const knownFeatures: Record<KnownFeatures, IFeatureFlag> = {
+  [KnownFeatures.InsightsRecommendations]: {
     name: KnownFeatures.InsightsRecommendations,
     storage: FeatureStorage.Database,
   },
-  {
+  [KnownFeatures.CloudSso]: {
     name: KnownFeatures.CloudSso,
-    storage: FeatureStorage.Custom,
+    storage: FeatureStorage.Database,
     factory: CloudSsoFeatureFlag.getFeature,
   },
-];
+};

redisinsight/api/src/modules/feature/entities/feature.entity.ts

@@ -2,6 +2,7 @@ import {
   Column, Entity, PrimaryColumn,
 } from 'typeorm';
 import { Expose } from 'class-transformer';
+import { DataAsJsonString } from 'src/common/decorators';
 
 @Entity('features')
 export class FeatureEntity {
@@ -12,4 +13,13 @@ export class FeatureEntity {
   @Expose()
   @Column()
   flag: boolean;
+
+  @Expose()
+  @Column({ nullable: true })
+  strategy?: string;
+
+  @Expose()
+  @Column({ nullable: true, type: 'text' })
+  @DataAsJsonString()
+  data?: string;
 }

redisinsight/api/src/modules/feature/feature.service.spec.ts

@@ -4,8 +4,8 @@ import {
   mockFeature, mockFeatureAnalytics, mockFeatureFlagProvider, mockFeatureRepository,
   mockFeaturesConfig,
   mockFeaturesConfigJson,
-  mockFeaturesConfigRepository,
-  MockType, mockUnknownFeature,
+  mockFeaturesConfigRepository, mockFeatureSso,
+  MockType, mockUnknownFeature
 } from 'src/__mocks__';
 import { FeaturesConfigRepository } from 'src/modules/feature/repositories/features-config.repository';
 import { EventEmitter2 } from '@nestjs/event-emitter';
@@ -82,24 +82,17 @@ describe('FeatureService', () => {
       expect(await service.list())
         .toEqual({
           features: {
-            [KnownFeatures.InsightsRecommendations]: {
-              name: KnownFeatures.InsightsRecommendations,
-              flag: true,
-            },
-            [KnownFeatures.CloudSso]: {
-              name: KnownFeatures.CloudSso,
-              flag: true,
-              strategy: CloudSsoFeatureStrategy.DeepLink,
-            },
+            [KnownFeatures.InsightsRecommendations]: mockFeature,
+            [KnownFeatures.CloudSso]: mockFeatureSso,
           },
         });
     });
   });
 
   describe('recalculateFeatureFlags', () => {
     it('should recalculate flags (1 update an 1 delete)', async () => {
-      repository.list.mockResolvedValueOnce([mockFeature, mockUnknownFeature]);
-      repository.list.mockResolvedValueOnce([mockFeature]);
+      repository.list.mockResolvedValueOnce([mockFeature, mockFeatureSso, mockUnknownFeature]);
+      repository.list.mockResolvedValueOnce([mockFeature, mockFeatureSso]);
       configsRepository.getOrCreate.mockResolvedValueOnce(mockFeaturesConfig);
 
       await service.recalculateFeatureFlags();
@@ -114,15 +107,8 @@ describe('FeatureService', () => {
       expect(analytics.sendFeatureFlagRecalculated).toHaveBeenCalledWith({
         configVersion: mockFeaturesConfig.data.version,
         features: {
-          [KnownFeatures.InsightsRecommendations]: {
-            name: KnownFeatures.InsightsRecommendations,
-            flag: true,
-          },
-          [KnownFeatures.CloudSso]: {
-            name: KnownFeatures.CloudSso,
-            flag: true,
-            strategy: CloudSsoFeatureStrategy.DeepLink,
-          },
+          [KnownFeatures.InsightsRecommendations]: mockFeature,
+          [KnownFeatures.CloudSso]: mockFeatureSso,
         },
       });
     });

redisinsight/api/src/modules/feature/feature.service.ts

@@ -1,4 +1,4 @@
-import { find } from 'lodash';
+import { find, forEach } from 'lodash';
 import { Injectable, Logger } from '@nestjs/common';
 import { FeatureRepository } from 'src/modules/feature/repositories/feature.repository';
 import { FeatureServerEvents, FeatureStorage } from 'src/modules/feature/constants';
@@ -7,6 +7,7 @@ import { FeatureFlagProvider } from 'src/modules/feature/providers/feature-flag/
 import { EventEmitter2, OnEvent } from '@nestjs/event-emitter';
 import { FeatureAnalytics } from 'src/modules/feature/feature.analytics';
 import { knownFeatures } from 'src/modules/feature/constants/known-features';
+import { Feature } from 'src/modules/feature/model/feature';
 
 @Injectable()
 export class FeatureService {
@@ -38,14 +39,14 @@ export class FeatureService {
   /**
    * Returns list of features flags
    */
-  async list() {
+  async list(): Promise<{ features: Record<string, Feature> }> {
     this.logger.log('Getting features list');
 
     const features = {};
 
     const featuresFromDatabase = await this.repository.list();
 
-    knownFeatures.forEach((feature) => {
+    forEach(knownFeatures, (feature) => {
       // todo: implement various storage strategies support with next features
       switch (feature?.storage) {
         case FeatureStorage.Database: {
@@ -54,6 +55,8 @@ export class FeatureService {
             features[feature.name] = {
               name: dbFeature.name,
               flag: dbFeature.flag,
+              strategy: dbFeature.strategy || undefined,
+              data: dbFeature.data || undefined,
             };
           }
           break;
@@ -66,14 +69,6 @@ export class FeatureService {
       }
     });
 
-    try {
-      this.analytics.sendFeatureFlagRecalculated({
-        configVersion: (await this.featuresConfigRepository.getOrCreate())?.data?.version,
-        features,
-      });
-    } catch (e) {
-      // ignore telemetry error
-    }
     return { features };
   }
 
@@ -97,10 +92,11 @@ export class FeatureService {
       this.logger.debug('Recalculating features flags for new config', featuresConfig);
 
       await Promise.all(Array.from(featuresConfig?.data?.features || new Map(), async ([name, feature]) => {
-        actions.toUpsert.push({
-          name,
-          flag: await this.featureFlagProvider.calculate(name, feature),
-        });
+        if (knownFeatures[name]) {
+          actions.toUpsert.push({
+            ...(await this.featureFlagProvider.calculate(knownFeatures[name], feature)),
+          });
+        }
       }));
 
       // calculate to delete features
@@ -115,7 +111,17 @@ export class FeatureService {
         `Features flags recalculated. Updated: ${actions.toUpsert.length} deleted: ${actions.toDelete.length}`,
       );
 
-      this.eventEmitter.emit(FeatureServerEvents.FeaturesRecalculated, await this.list());
+      const list = await this.list();
+      this.eventEmitter.emit(FeatureServerEvents.FeaturesRecalculated, list);
+
+      try {
+        this.analytics.sendFeatureFlagRecalculated({
+          configVersion: (await this.featuresConfigRepository.getOrCreate())?.data?.version,
+          features: list.features,
+        });
+      } catch (e) {
+        // ignore telemetry error
+      }
     } catch (e) {
       this.logger.error('Unable to recalculate features flags', e);
     }

redisinsight/api/src/modules/feature/model/feature.ts

@@ -9,4 +9,7 @@ export class Feature {
 
   @Expose()
   strategy?: string;
+
+  @Expose()
+  data?: any;
 }

redisinsight/api/src/modules/feature/providers/feature-flag/feature-flag.provider.spec.ts

@@ -1,5 +1,6 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import {
+  mockFeature,
   mockFeaturesConfig,
   mockFeaturesConfigService, mockInsightsRecommendationsFlagStrategy, mockSettingsService,
 } from 'src/__mocks__';
@@ -11,6 +12,7 @@ import {
   InsightsRecommendationsFlagStrategy,
 } from 'src/modules/feature/providers/feature-flag/strategies/insights-recommendations.flag.strategy';
 import { DefaultFlagStrategy } from 'src/modules/feature/providers/feature-flag/strategies/default.flag.strategy';
+import { knownFeatures } from 'src/modules/feature/constants/known-features';
 
 describe('FeatureFlagProvider', () => {
   let service: FeatureFlagProvider;
@@ -55,10 +57,11 @@ describe('FeatureFlagProvider', () => {
         .mockReturnValue(mockInsightsRecommendationsFlagStrategy as unknown as InsightsRecommendationsFlagStrategy);
 
       expect(await service.calculate(
-        KnownFeatures.InsightsRecommendations,
+        knownFeatures[KnownFeatures.InsightsRecommendations],
         mockFeaturesConfig[KnownFeatures.InsightsRecommendations],
-      )).toEqual(true);
+      )).toEqual(mockFeature);
       expect(mockInsightsRecommendationsFlagStrategy.calculate).toHaveBeenCalledWith(
+        knownFeatures[KnownFeatures.InsightsRecommendations],
         mockFeaturesConfig[KnownFeatures.InsightsRecommendations],
       );
     });