Adding a log if we are not able to send the data to the collector

Signed-off-by: Thomas Poignant <[email protected]>

Author: thomaspoignant

libs/providers/go-feature-flag/src/lib/go-feature-flag-provider.spec.ts

@@ -17,6 +17,7 @@ import {UnknownError} from './errors/unknownError';
 import {Unauthorized} from './errors/unauthorized';
 import {GoFeatureFlagProvider} from './go-feature-flag-provider';
 import {GoFeatureFlagProxyResponse} from './model';
+import TestLogger from './test-logger';
 
 describe('GoFeatureFlagProvider', () => {
   const endpoint = 'http://go-feature-flag-relay-proxy.local:1031/';
@@ -35,12 +36,15 @@ describe('GoFeatureFlagProvider', () => {
     },
     cacheable: true,
   };
+
   let goff: GoFeatureFlagProvider;
+  const testLogger = new TestLogger();
 
   afterEach(async () => {
     await OpenFeature.close();
     await axiosMock.reset();
     await axiosMock.resetHistory();
+    testLogger.reset();
   });
 
   beforeEach(async () => {
@@ -907,5 +911,31 @@ describe('GoFeatureFlagProvider', () => {
 
       expect(collectorCalls.length).toBe(0);
     });
+
+    it('should have a log when data collector is not available', async () => {
+      const flagName = 'random-flag';
+      const targetingKey = 'user-key';
+      const dns = `${endpoint}v1/feature/${flagName}/eval`;
+
+      axiosMock.onPost(dns).reply(200, validBoolResponse);
+      axiosMock.onPost(dataCollectorEndpoint).reply(500, {});
+
+      const goff = new GoFeatureFlagProvider({
+        endpoint,
+        flagCacheTTL: 3000,
+        flagCacheSize: 100,
+        dataFlushInterval: 2000, // in milliseconds
+      }, testLogger)
+      const providerName = expect.getState().currentTestName || 'test';
+      OpenFeature.setProvider(providerName, goff);
+      const cli = OpenFeature.getClient(providerName);
+      await cli.getBooleanDetails(flagName, false, {targetingKey});
+      await cli.getBooleanDetails(flagName, false, {targetingKey});
+      await OpenFeature.close();
+
+      console.log(testLogger)
+      expect(testLogger.inMemoryLogger['error'].length).toBe(1);
+      expect(testLogger.inMemoryLogger['error']).toContain('impossible to send the data to the collector: Error: Request failed with status code 500')
+    });
   });
 });

libs/providers/go-feature-flag/src/lib/go-feature-flag-provider.ts

@@ -3,6 +3,7 @@ import {
   EvaluationContext,
   FlagNotFoundError,
   JsonValue,
+  Logger,
   Provider,
   ResolutionDetails,
   StandardResolutionReasons,
@@ -59,16 +60,20 @@ export class GoFeatureFlagProvider implements Provider {
 
   // dataFlushInterval interval time (in millisecond) we use to call the relay proxy to collect data.
   private readonly dataFlushInterval: number;
-  
+
   // disableDataCollection set to true if you don't want to collect the usage of flags retrieved in the cache.
   private readonly disableDataCollection: boolean;
 
-  constructor(options: GoFeatureFlagProviderOptions) {
+  // logger is the Open Feature logger to use
+  private logger?: Logger;
+
+  constructor(options: GoFeatureFlagProviderOptions, logger?: Logger) {
     this.timeout = options.timeout || 0; // default is 0 = no timeout
     this.endpoint = options.endpoint;
     this.cacheTTL = options.flagCacheTTL !== undefined && options.flagCacheTTL !== 0 ? options.flagCacheTTL : 1000 * 60;
     this.dataFlushInterval = options.dataFlushInterval || 1000 * 60;
     this.disableDataCollection = options.disableDataCollection || false;
+    this.logger = logger;
 
     // Add API key to the headers
     if (options.apiKey) {
@@ -131,7 +136,7 @@ export class GoFeatureFlagProvider implements Provider {
         timeout: this.timeout,
       });
     } catch (e) {
-      // TODO : add a log here
+      this.logger?.error(`impossible to send the data to the collector: ${e}`)
       // if we have an issue calling the collector we put the data back in the buffer
       this.dataCollectorBuffer = [...this.dataCollectorBuffer, ...dataToSend]
     }

libs/providers/go-feature-flag/src/lib/test-logger.ts

@@ -0,0 +1,33 @@
+export default class TestLogger {
+  public inMemoryLogger: Record<string, string[]> = {
+    error: [],
+    warn: [],
+    info: [],
+    debug: [],
+  };
+
+  error(...args: unknown[]): void {
+    this.inMemoryLogger['error'].push(args.join(' '));
+  }
+
+  warn(...args: unknown[]): void {
+    this.inMemoryLogger['warn'].push(args.join(' '));
+  }
+
+  info(...args: unknown[]): void {
+    this.inMemoryLogger['info'].push(args.join(' '));
+  }
+
+  debug(...args: unknown[]): void {
+    this.inMemoryLogger['debug'].push(args.join(' '));
+  }
+
+  reset() {
+    this.inMemoryLogger = {
+      error: [],
+      warn: [],
+      info: [],
+      debug: [],
+    };
+  }
+}