splitio
diff --git a/‎src/__tests__/testUtils/index.ts‎
Lines changed: 14 additions & 0 deletions b/‎src/__tests__/testUtils/index.ts‎
Lines changed: 14 additions & 0 deletions
diff --git a/‎src/trackers/__tests__/telemetryTracker.spec.ts‎
Lines changed: 4 additions & 3 deletions b/‎src/trackers/__tests__/telemetryTracker.spec.ts‎
Lines changed: 4 additions & 3 deletions
diff --git a/‎src/trackers/telemetryTracker.ts‎
Lines changed: 6 additions & 7 deletions b/‎src/trackers/telemetryTracker.ts‎
Lines changed: 6 additions & 7 deletions
@@ -0,0 +1,14 @@
+const DEFAULT_ERROR_MARGIN = 50; // 0.05 secs if numbers are timestamps in milliseconds
+
+/**
+ * Assert if an `actual` and `expected` numeric values are nearly equal.
+ *
+ * @param {number} actual actual time lapse in millis
+ * @param {number} expected expected time lapse in millis
+ * @param {number} epsilon error margin in millis
+ * @returns {boolean} whether the absolute difference is minor to epsilon value or not
+ */
+export function nearlyEqual(actual: number, expected: number, epsilon = DEFAULT_ERROR_MARGIN) {
+  const diff = Math.abs(actual - expected);
+  return diff <= epsilon;
+}
@@ -1,4 +1,5 @@
 import { EXCEPTION, SDK_NOT_READY } from '../../utils/labels';
+import { nearlyEqual } from '../../__tests__/testUtils';
 import { telemetryTrackerFactory } from '../telemetryTracker';
 
 describe('Telemetry Tracker', () => {
@@ -9,7 +10,7 @@ describe('Telemetry Tracker', () => {
     recordException: jest.fn(),
     recordNonReadyUsage: jest.fn(),
   };
-  // @ts-ignore
+
   const tracker = telemetryTrackerFactory(fakeTelemetryCache, fakeNow);
 
   test('trackEval', async () => {
@@ -25,15 +26,15 @@ describe('Telemetry Tracker', () => {
 
     stopTracker = tracker.trackEval('tcs');
 
-    await new Promise(res => setTimeout(res, 50));
+    await new Promise(res => setTimeout(res, 100));
     stopTracker();
 
     expect(fakeTelemetryCache.recordException).toBeCalledTimes(1);
     expect(fakeTelemetryCache.recordNonReadyUsage).toBeCalledTimes(1);
     expect(fakeTelemetryCache.recordLatency).toBeCalledTimes(3);
 
     const latency = fakeTelemetryCache.recordLatency.mock.calls[2][1];
-    expect(latency >= 50 && latency < 100).toBeTruthy(); // last tracked latency is around 200 ms
+    expect(nearlyEqual(latency, 100)).toBeTruthy(); // last tracked latency is around 100 ms
   });
 
 });
 
@@ -1,5 +1,4 @@
 import { TelemetryCacheSync, TelemetryCacheAsync } from '../storages/types';
-import { Method } from '../sync/submitters/types';
 import { EXCEPTION, SDK_NOT_READY } from '../utils/labels';
 import { ITelemetryTracker } from './types';
 import { timer } from '../utils/timeTracker/timer';
@@ -12,26 +11,26 @@ export function telemetryTrackerFactory(
   if (telemetryCache && now) {
 
     return {
-      trackEval(method: Method) {
-        const stopTimer = timer(now);
+      trackEval(method) {
+        const evalTime = timer(now);
 
-        return (label?: string) => {
+        return (label) => {
           switch (label) {
             case EXCEPTION:
               telemetryCache.recordException(method);
               return; // Don't track latency on exceptions
             case SDK_NOT_READY: // @ts-ignore. TelemetryCacheAsync doesn't implement the method
               telemetryCache?.recordNonReadyUsage();
           }
-          telemetryCache.recordLatency(method, stopTimer());
+          telemetryCache.recordLatency(method, evalTime());
         };
-      }
+      },
     };
 
   } else { // If there is not `telemetryCache` or `now` time tracker, return a no-op telemetry tracker
     const noopTrack = () => () => { };
     return {
-      trackEval: noopTrack
+      trackEval: noopTrack,
     };
   }
 }