node-avo-inspector 1.1.0 → 1.1.1

package/dist/AvoInspector.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvoInspector = void 0;
 const AvoInspectorEnv_1 = require("./AvoInspectorEnv");
@@ -102,34 +111,35 @@ class AvoInspector {
         }
     }
     trackSchemaInternal(eventName, eventSchema, eventId, eventHash) {
-        try {
-            const seesionId = AvoGuid_1.AvoGuid.newGuid();
-            return this.avoNetworkCallsHandler
-                .callInspectorWithBatchBody([
-                this.avoNetworkCallsHandler.bodyForSessionStartedCall(seesionId),
-            ])
-                .then(() => {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const seesionId = AvoGuid_1.AvoGuid.newGuid();
+                yield this.avoNetworkCallsHandler
+                    .callInspectorWithBatchBody([
+                    this.avoNetworkCallsHandler.bodyForSessionStartedCall(seesionId),
+                ]);
                 if (AvoInspector.shouldLog) {
                     console.log("Avo Inspector: session started sent successfully.");
                 }
-                this.avoNetworkCallsHandler.callInspectorWithBatchBody([
-                    this.avoNetworkCallsHandler.bodyForEventSchemaCall(seesionId, eventName, eventSchema, eventId, eventHash),
-                ]).then(() => {
+                try {
+                    yield this.avoNetworkCallsHandler.callInspectorWithBatchBody([
+                        this.avoNetworkCallsHandler.bodyForEventSchemaCall(seesionId, eventName, eventSchema, eventId, eventHash)
+                    ]);
                     if (AvoInspector.shouldLog) {
                         console.log("Avo Inspector: schema sent successfully.");
                     }
-                });
-            })
-                .catch((err) => {
-                if (AvoInspector.shouldLog) {
-                    console.log("Avo Inspector: schema sending failed: " + err + ".");
                 }
-            });
-        }
-        catch (e) {
-            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
-            return Promise.reject();
-        }
+                catch (err) {
+                    if (AvoInspector.shouldLog) {
+                        console.log("Avo Inspector: schema sending failed: " + err + ".");
+                    }
+                }
+            }
+            catch (e) {
+                console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+                return Promise.reject();
+            }
+        });
     }
     enableLogging(enable) {
         AvoInspector._shouldLog = enable;

package/dist/__tests__/TestDeduplicator.js

@@ -13,6 +13,9 @@ const AvoDeduplicator_1 = require("../AvoDeduplicator");
 const utils_1 = require("../utils");
 const AvoInspector_1 = require("../AvoInspector");
 const constants_1 = require("./constants");
+jest
+    .useFakeTimers()
+    .setSystemTime(new Date('2020-01-01'));
 describe("Deduplicator", () => {
     const deduplicator = new AvoDeduplicator_1.AvoDeduplicator();
     const testObject = {

package/dist/__tests__/TestNetworkCallsHandlerPublic.js

@@ -14,17 +14,29 @@ const AvoNetworkCallsHandler_1 = require("../AvoNetworkCallsHandler");
 const constants_1 = require("./constants");
 describe("AvoNetworkCallsHandler", () => {
     let inspectorCallSpy;
+    let consoleLogSpy;
     let inspector;
     const { apiKey, env, version, appName } = constants_1.defaultOptions;
+    const eventName = "event name";
+    const properties = {
+        prop0: "",
+        prop2: false,
+        prop3: 0,
+        prop4: 0.0,
+    };
+    const happyPathInspectorCall = () => {
+        inspector.avoNetworkCallsHandler["samplingRate"] = 0.1;
+        return Promise.resolve();
+    };
     beforeAll(() => {
         inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-        inspector.enableLogging(false);
+        inspector.enableLogging(true);
         inspectorCallSpy = jest
             .spyOn(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler.prototype, "callInspectorWithBatchBody");
-        inspectorCallSpy.mockImplementation(() => {
-            inspector.avoNetworkCallsHandler["samplingRate"] = 0.1;
-            return Promise.resolve();
-        });
+        consoleLogSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+    });
+    beforeEach(() => {
+        inspectorCallSpy.mockImplementation(happyPathInspectorCall);
     });
     afterEach(() => {
         jest.clearAllMocks();
@@ -32,17 +44,9 @@ describe("AvoNetworkCallsHandler", () => {
         inspector.avoDeduplicator._clearEvents();
     });
     test("handleTrackSchema is called on trackSchemaFromEvent", () => __awaiter(void 0, void 0, void 0, function* () {
-        const eventName = "event name";
-        const properties = {
-            prop0: "",
-            prop2: false,
-            prop3: 0,
-            prop4: 0.0,
-        };
-        const schema = inspector.extractSchema(properties);
         yield inspector.trackSchemaFromEvent(eventName, properties);
         expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(2);
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toBeCalledWith([
+        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
             expect.objectContaining({
                 type: "sessionStarted",
                 apiKey: apiKey,
@@ -76,16 +80,8 @@ describe("AvoNetworkCallsHandler", () => {
         ]);
     }));
     test("handleTrackSchema is called on _avoFunctionTrackSchemaFromEvent", () => __awaiter(void 0, void 0, void 0, function* () {
-        const eventName = "event name";
-        const properties = {
-            prop0: "",
-            prop2: false,
-            prop3: 0,
-            prop4: 0.0,
-        };
         const eventId = "testId";
         const eventHash = "testHash";
-        const schema = inspector.extractSchema(properties);
         // @ts-ignore
         yield inspector._avoFunctionTrackSchemaFromEvent(eventName, properties, eventId, eventHash);
         expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(2);
@@ -122,4 +118,10 @@ describe("AvoNetworkCallsHandler", () => {
             }),
         ]);
     }));
+    test("an error is logged if event schema call fails and AvoInspector.shouldLog is true", () => __awaiter(void 0, void 0, void 0, function* () {
+        inspectorCallSpy.mockImplementationOnce(happyPathInspectorCall);
+        inspectorCallSpy.mockRejectedValueOnce('Network error');
+        yield inspector.trackSchemaFromEvent(eventName, properties);
+        expect(consoleLogSpy).toHaveBeenCalledWith('Avo Inspector: schema sending failed: Network error.');
+    }));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-avo-inspector",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Avo Inspector for Node.js",
   "main": "dist/index.js",
   "repository": "https://github.com/avohq/node-avo-inspector",

package/src/AvoInspector.ts

@@ -182,7 +182,7 @@ export class AvoInspector {
     }
   }
 
-  private trackSchemaInternal(
+  private async trackSchemaInternal(
     eventName: string,
     eventSchema: Array<{
       propertyName: string;
@@ -194,33 +194,31 @@ export class AvoInspector {
   ): Promise<void> {
     try {
       const seesionId = AvoGuid.newGuid();
-      return this.avoNetworkCallsHandler
+      await this.avoNetworkCallsHandler
         .callInspectorWithBatchBody([
           this.avoNetworkCallsHandler.bodyForSessionStartedCall(seesionId),
-        ])
-        .then(() => {
-          if (AvoInspector.shouldLog) {
-            console.log("Avo Inspector: session started sent successfully.");
-          }
-          this.avoNetworkCallsHandler.callInspectorWithBatchBody([
-            this.avoNetworkCallsHandler.bodyForEventSchemaCall(
-              seesionId,
-              eventName,
-              eventSchema,
-              eventId,
-              eventHash
-            ),
-          ]).then(() => {
-            if (AvoInspector.shouldLog) {
-              console.log("Avo Inspector: schema sent successfully.");
-            }
-          });
-        })
-        .catch((err) => {
-          if (AvoInspector.shouldLog) {
-            console.log("Avo Inspector: schema sending failed: " + err + ".");
-          }
-        });
+        ]);
+
+      if (AvoInspector.shouldLog) {
+        console.log("Avo Inspector: session started sent successfully.");
+      }
+      try {
+        await this.avoNetworkCallsHandler.callInspectorWithBatchBody([
+          this.avoNetworkCallsHandler.bodyForEventSchemaCall(
+            seesionId,
+            eventName,
+            eventSchema,
+            eventId,
+            eventHash
+          )]);
+        if (AvoInspector.shouldLog) {
+          console.log("Avo Inspector: schema sent successfully.");
+        }
+      } catch (err) {
+        if (AvoInspector.shouldLog) {
+          console.log("Avo Inspector: schema sending failed: " + err + ".");
+        }
+      }
     } catch (e) {
       console.error(
         "Avo Inspector: something went wrong. Please report to support@avo.app.",

package/src/__tests__/TestDeduplicator.ts

@@ -3,6 +3,10 @@ import { deepEquals } from "../utils";
 import { AvoInspector } from "../AvoInspector";
 import { defaultOptions } from "./constants";
 
+jest
+  .useFakeTimers()
+  .setSystemTime(new Date('2020-01-01'));
+
 describe("Deduplicator", () => {
   const deduplicator = new AvoDeduplicator();
 

package/src/__tests__/TestNetworkCallsHandlerPublic.ts

@@ -5,24 +5,39 @@ import { defaultOptions } from "./constants";
 
 describe("AvoNetworkCallsHandler", () => {
   let inspectorCallSpy: jest.SpyInstance<any, unknown[]>;
+  let consoleLogSpy: jest.SpyInstance<any, unknown[]>;
 
   let inspector: AvoInspector;
 
   const { apiKey, env, version, appName } = defaultOptions;
 
+  const eventName = "event name";
+  const properties = {
+    prop0: "",
+    prop2: false,
+    prop3: 0,
+    prop4: 0.0,
+  };
+
+  const happyPathInspectorCall = () => {
+    inspector.avoNetworkCallsHandler["samplingRate"] = 0.1;
+    return Promise.resolve();
+  };
+
   beforeAll(() => {
     inspector = new AvoInspector(defaultOptions);
-    inspector.enableLogging(false);
+    inspector.enableLogging(true);
 
     inspectorCallSpy = jest
       .spyOn(AvoNetworkCallsHandler.prototype as any, "callInspectorWithBatchBody");
 
-    inspectorCallSpy.mockImplementation(() => {
-        inspector.avoNetworkCallsHandler["samplingRate"] = 0.1;
-        return Promise.resolve();
-      });
+    consoleLogSpy = jest.spyOn(console, "log").mockImplementation(() => {});
   });
 
+  beforeEach(() => {
+    inspectorCallSpy.mockImplementation(happyPathInspectorCall);
+  })
+
   afterEach(() => {
     jest.clearAllMocks();
     // @ts-ignore
@@ -30,20 +45,10 @@ describe("AvoNetworkCallsHandler", () => {
   });
 
   test("handleTrackSchema is called on trackSchemaFromEvent", async () => {
-    const eventName = "event name";
-    const properties = {
-      prop0: "",
-      prop2: false,
-      prop3: 0,
-      prop4: 0.0,
-    };
-
-    const schema = inspector.extractSchema(properties);
-
     await inspector.trackSchemaFromEvent(eventName, properties);
 
     expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(2);
-    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toBeCalledWith([
+    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
       expect.objectContaining({
         type: "sessionStarted",
         apiKey: apiKey,
@@ -79,18 +84,9 @@ describe("AvoNetworkCallsHandler", () => {
   });
 
   test("handleTrackSchema is called on _avoFunctionTrackSchemaFromEvent", async () => {
-    const eventName = "event name";
-    const properties = {
-      prop0: "",
-      prop2: false,
-      prop3: 0,
-      prop4: 0.0,
-    };
     const eventId = "testId";
     const eventHash = "testHash";
 
-    const schema = inspector.extractSchema(properties);
-
     // @ts-ignore
     await inspector._avoFunctionTrackSchemaFromEvent(
       eventName,
@@ -134,4 +130,13 @@ describe("AvoNetworkCallsHandler", () => {
       }),
     ]);
   });
+
+  test("an error is logged if event schema call fails and AvoInspector.shouldLog is true", async () => {
+    inspectorCallSpy.mockImplementationOnce(happyPathInspectorCall);
+    inspectorCallSpy.mockRejectedValueOnce('Network error');
+
+    await inspector.trackSchemaFromEvent(eventName, properties);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith('Avo Inspector: schema sending failed: Network error.');
+  });
 });