node-avo-inspector 1.0.3-beta.0 → 1.1.1

package/dist/AvoDeduplicator.js

@@ -46,7 +46,7 @@ class AvoDeduplicator {
             if (eventsStorage.hasOwnProperty(otherEventName)) {
                 if (otherEventName === eventName) {
                     const otherParams = eventsStorage[eventName];
-                    if (otherParams && utils_1.deepEquals(params, otherParams)) {
+                    if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
                         return true;
                     }
                 }
@@ -72,7 +72,7 @@ class AvoDeduplicator {
         for (const otherEventName in eventsStorage) {
             if (eventsStorage.hasOwnProperty(otherEventName)) {
                 const otherParams = eventsStorage[otherEventName];
-                if (otherParams && utils_1.deepEquals(params, otherParams)) {
+                if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
                     return true;
                 }
             }

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");
@@ -9,9 +18,15 @@ const utils_1 = require("./utils");
 const AvoGuid_1 = require("./AvoGuid");
 const libVersion = require("../package.json").version;
 class AvoInspector {
+    static get shouldLog() {
+        return this._shouldLog;
+    }
+    static set shouldLog(enable) {
+        this._shouldLog = enable;
+    }
     constructor(options) {
         // the constructor does aggressive null/undefined checking because same code paths will be accessible from JS
-        if (utils_1.isValueEmpty(options.env)) {
+        if ((0, utils_1.isValueEmpty)(options.env)) {
             this.environment = AvoInspectorEnv_1.AvoInspectorEnv.Dev;
             console.warn("[Avo Inspector] No environment provided. Defaulting to dev.");
         }
@@ -22,13 +37,13 @@ class AvoInspector {
         else {
             this.environment = options.env;
         }
-        if (utils_1.isValueEmpty(options.apiKey)) {
+        if ((0, utils_1.isValueEmpty)(options.apiKey)) {
             throw new Error("[Avo Inspector] No API key provided. Inspector can't operate without API key.");
         }
         else {
             this.apiKey = options.apiKey;
         }
-        if (utils_1.isValueEmpty(options.version)) {
+        if ((0, utils_1.isValueEmpty)(options.version)) {
             throw new Error("[Avo Inspector] No version provided. Many features of Inspector rely on versioning. Please provide comparable string version, i.e. integer or semantic.");
         }
         else {
@@ -43,12 +58,6 @@ class AvoInspector {
         this.avoNetworkCallsHandler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler(this.apiKey, this.environment.toString(), options.appName || "", this.version, libVersion);
         this.avoDeduplicator = new AvoDeduplicator_1.AvoDeduplicator();
     }
-    static get shouldLog() {
-        return this._shouldLog;
-    }
-    static set shouldLog(enable) {
-        this._shouldLog = enable;
-    }
     trackSchemaFromEvent(eventName, eventProperties) {
         try {
             if (this.avoDeduplicator.shouldRegisterEvent(eventName, eventProperties, false)) {
@@ -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/AvoInspectorEnv.d.ts

@@ -3,5 +3,5 @@ export declare const AvoInspectorEnv: {
     readonly Dev: "dev";
     readonly Staging: "staging";
 };
-export declare type AvoInspectorEnvType = typeof AvoInspectorEnv;
-export declare type AvoInspectorEnvValueType = AvoInspectorEnvType[keyof AvoInspectorEnvType];
+export type AvoInspectorEnvType = typeof AvoInspectorEnv;
+export type AvoInspectorEnvValueType = AvoInspectorEnvType[keyof AvoInspectorEnvType];

package/dist/AvoNetworkCallsHandler.js

@@ -50,7 +50,7 @@ class AvoNetworkCallsHandler {
                     "Content-Length": Buffer.byteLength(data),
                 },
             };
-            var req = https_1.request(options, (res) => {
+            var req = (0, https_1.request)(options, (res) => {
                 const chunks = [];
                 res.on("data", (data) => chunks.push(data));
                 res.on("end", () => {

package/dist/AvoSchemaParser.d.ts

@@ -7,5 +7,6 @@ export declare class AvoSchemaParser {
         children?: any;
     }>;
     private static removeDuplicates;
+    private static getBasicPropType;
     private static getPropValueType;
 }

package/dist/AvoSchemaParser.js

@@ -56,7 +56,7 @@ class AvoSchemaParser {
             }
         });
     }
-    static getPropValueType(propValue) {
+    static getBasicPropType(propValue) {
         let propType = typeof propValue;
         if (propValue == null) {
             return "null";
@@ -76,15 +76,26 @@ class AvoSchemaParser {
             return "boolean";
         }
         else if (propType === "object") {
-            if (isArray(propValue)) {
-                return "list";
+            return "object";
+        }
+        else {
+            return "unknown";
+        }
+    }
+    static getPropValueType(propValue) {
+        if (isArray(propValue)) {
+            //we now know that propValue is an array. get first element in propValue array
+            let propElement = propValue[0];
+            if (propElement == null) {
+                return "list(string)"; // Default to list(string) if the list is empty.
             }
             else {
-                return "object";
+                let propElementType = this.getBasicPropType(propElement);
+                return `list(${propElementType})`;
             }
         }
         else {
-            return "unknown";
+            return this.getBasicPropType(propValue);
         }
     }
 }

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 = {
@@ -28,10 +31,10 @@ describe("Deduplicator", () => {
             2: [["str", true]],
             3: { avo: [1.1, 2.2, 3.3] },
         };
-        expect(utils_1.deepEquals(testObject, secondObject)).toBe(true);
-        expect(utils_1.deepEquals(testObject, Object.assign(Object.assign({}, secondObject), { "4": "4" }))).toBe(false);
-        expect(utils_1.deepEquals(testObject, Object.assign(Object.assign({}, secondObject), { 3: Object.assign(Object.assign({}, secondObject[3]), { avo: [1.1] }) }))).toBe(false);
-        expect(utils_1.deepEquals(testObject, Object.assign(Object.assign({}, secondObject), { 0: "other string" }))).toBe(false);
+        expect((0, utils_1.deepEquals)(testObject, secondObject)).toBe(true);
+        expect((0, utils_1.deepEquals)(testObject, Object.assign(Object.assign({}, secondObject), { "4": "4" }))).toBe(false);
+        expect((0, utils_1.deepEquals)(testObject, Object.assign(Object.assign({}, secondObject), { 3: Object.assign(Object.assign({}, secondObject[3]), { avo: [1.1] }) }))).toBe(false);
+        expect((0, utils_1.deepEquals)(testObject, Object.assign(Object.assign({}, secondObject), { 0: "other string" }))).toBe(false);
     });
     test(`Detects duplications when track in avo and then manually`, () => {
         const shouldRegisterFromAvo = deduplicator.shouldRegisterEvent("Test", testObject, true);

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/dist/__tests__/TestParsing.js

@@ -52,7 +52,7 @@ describe("Schema Parsing", () => {
                 propertyType: constants_1.type.STRING,
             },
         ]);
-        expect(res[7].propertyType).toBe(constants_1.type.LIST);
+        expect(res[7].propertyType).toBe(constants_1.type.STRINGLIST);
         expect(res[7].children).toMatchObject([
             constants_1.type.STRING,
             [
@@ -77,13 +77,7 @@ describe("Schema Parsing", () => {
         // When
         const res = inspector.extractSchema(eventProperties);
         // Then
-        expect(res[0].propertyType).toBe(constants_1.type.LIST);
-        expect(res[0].children).toMatchObject([
-            constants_1.type.STRING,
-            constants_1.type.BOOL,
-            constants_1.type.INT,
-            constants_1.type.FLOAT,
-        ]);
+        expect(res[0].propertyType).toBe(constants_1.type.STRINGLIST);
     });
     test("Empty and falsy values are set correctly", () => {
         // Given
@@ -108,7 +102,27 @@ describe("Schema Parsing", () => {
         expect(res[5].propertyType).toBe(constants_1.type.NULL);
         expect(res[6].propertyType).toBe(constants_1.type.OBJECT);
         expect(res[6].children).toMatchObject([]);
-        expect(res[7].propertyType).toBe(constants_1.type.LIST);
+        expect(res[7].propertyType).toBe(constants_1.type.STRINGLIST);
         expect(res[7].children).toMatchObject([]);
     });
+    test("List of string returns list(string)", () => {
+        // Given
+        const eventProperties = {
+            prop0: ["a", "b", "c"],
+        };
+        // When
+        const res = inspector.extractSchema(eventProperties);
+        // Then
+        expect(res[0].propertyType).toBe(constants_1.type.STRINGLIST);
+    });
+    test("List of multiple types returns list(`firstType`)", () => {
+        // Given
+        const eventProperties = {
+            prop0: [1.2, "two", { "three": 3 }],
+        };
+        // When
+        const res = inspector.extractSchema(eventProperties);
+        // Then
+        expect(res[0].propertyType).toBe(constants_1.type.FLOATLIST);
+    });
 });

package/dist/__tests__/constants.d.ts

@@ -26,12 +26,17 @@ declare const trackingEndpoint = "https://api.avo.app/inspector/v1/track";
 declare const sessionTimeMs: number;
 declare const type: {
     STRING: string;
+    STRINGLIST: string;
     INT: string;
+    INTLIST: string;
     OBJECT: string;
+    OBJECTLIST: string;
     FLOAT: string;
-    LIST: string;
+    FLOATLIST: string;
     BOOL: string;
+    BOOLLIST: string;
     NULL: string;
     UNKNOWN: string;
+    UNKNOWNLIST: string;
 };
 export { defaultOptions, error, mockedReturns, networkCallType, requestMsg, sessionTimeMs, type, trackingEndpoint, };

package/dist/__tests__/constants.js

@@ -37,12 +37,17 @@ const sessionTimeMs = 5 * 60 * 1000;
 exports.sessionTimeMs = sessionTimeMs;
 const type = {
     STRING: "string",
+    STRINGLIST: "list(string)",
     INT: "int",
+    INTLIST: "list(int)",
     OBJECT: "object",
+    OBJECTLIST: "list(object)",
     FLOAT: "float",
-    LIST: "list",
+    FLOATLIST: "list(float)",
     BOOL: "boolean",
+    BOOLLIST: "list(boolean)",
     NULL: "null",
     UNKNOWN: "unknown",
+    UNKNOWNLIST: "list(unknown)",
 };
 exports.type = type;

package/dist/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deepEquals = exports.isValueEmpty = void 0;
+exports.isValueEmpty = void 0;
+exports.deepEquals = deepEquals;
 const isValueEmpty = (value) => {
     return value === null || value === undefined || value.trim().length == 0;
 };
@@ -39,4 +40,3 @@ function deepEquals(x, y) {
     }
     return true;
 }
-exports.deepEquals = deepEquals;

package/examples/node-inspector-js/yarn.lock

@@ -3,4 +3,4 @@
 
 
 "node-avo-inspector@file:../..":
-  version "0.1.0"
+  version "1.0.4-beta.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-avo-inspector",
-  "version": "1.0.3-beta.0",
+  "version": "1.1.1",
   "description": "Avo Inspector for Node.js",
   "main": "dist/index.js",
   "repository": "https://github.com/avohq/node-avo-inspector",
@@ -36,11 +36,11 @@
     ]
   },
   "devDependencies": {
-    "@types/jest": "^26.0.15",
-    "@types/node": "^14.14.10",
-    "jest": "^26.6.3",
-    "ts-jest": "^26.4.4",
-    "typescript": "^4.1.2"
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.3.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.4",
+    "typescript": "*"
   },
   "dependencies": {}
 }

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/AvoSchemaParser.ts

@@ -71,7 +71,8 @@ export class AvoSchemaParser {
     });
   }
 
-  private static getPropValueType(propValue: any): string {
+
+  private static getBasicPropType(propValue: any): string {
     let propType = typeof propValue;
     if (propValue == null) {
       return "null";
@@ -86,13 +87,29 @@ export class AvoSchemaParser {
     } else if (propType === "boolean") {
       return "boolean";
     } else if (propType === "object") {
-      if (isArray(propValue)) {
-        return "list";
-      } else {
-        return "object";
+      return "object"
+  }
+  else {
+  return "unknown";
+  }
+}
+
+  private static getPropValueType(propValue: any): string {
+    if (isArray(propValue)){
+
+      //we now know that propValue is an array. get first element in propValue array
+      let propElement = propValue[0];
+
+      if (propElement == null) {
+        return "list(string)"; // Default to list(string) if the list is empty.
+      }
+      else {
+      let propElementType = this.getBasicPropType(propElement);
+      return `list(${propElementType})`
       }
-    } else {
-      return "unknown";
+    }
+    else {
+      return this.getBasicPropType(propValue);
     }
   }
 }

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.');
+  });
 });

package/src/__tests__/TestParsing.ts

@@ -60,7 +60,7 @@ describe("Schema Parsing", () => {
       },
     ]);
 
-    expect(res[7].propertyType).toBe(type.LIST);
+    expect(res[7].propertyType).toBe(type.STRINGLIST);
     expect(res[7].children).toMatchObject([
       type.STRING,
       [
@@ -88,13 +88,7 @@ describe("Schema Parsing", () => {
     const res = inspector.extractSchema(eventProperties);
 
     // Then
-    expect(res[0].propertyType).toBe(type.LIST);
-    expect(res[0].children).toMatchObject([
-      type.STRING,
-      type.BOOL,
-      type.INT,
-      type.FLOAT,
-    ]);
+    expect(res[0].propertyType).toBe(type.STRINGLIST);
   });
 
   test("Empty and falsy values are set correctly", () => {
@@ -124,7 +118,36 @@ describe("Schema Parsing", () => {
     expect(res[6].propertyType).toBe(type.OBJECT);
     expect(res[6].children).toMatchObject([]);
 
-    expect(res[7].propertyType).toBe(type.LIST);
+    expect(res[7].propertyType).toBe(type.STRINGLIST);
     expect(res[7].children).toMatchObject([]);
   });
+
+  test("List of string returns list(string)", () => {
+    // Given
+    const eventProperties = {
+      prop0: ["a", "b", "c"],
+    };
+
+    // When
+    const res = inspector.extractSchema(eventProperties);
+
+    // Then
+    expect(res[0].propertyType).toBe(type.STRINGLIST);
+  });
+
+
+  test("List of multiple types returns list(`firstType`)", () => {
+    // Given
+    const eventProperties = {
+      prop0: [1.2, "two", {"three": 3}],
+    };
+
+    // When
+    const res = inspector.extractSchema(eventProperties);
+
+    // Then
+    expect(res[0].propertyType).toBe(type.FLOATLIST);
+  });
+
+
 });

package/src/__tests__/constants.ts

@@ -37,13 +37,18 @@ const sessionTimeMs = 5 * 60 * 1000;
 
 const type = {
   STRING: "string",
+  STRINGLIST: "list(string)",
   INT: "int",
+  INTLIST: "list(int)",
   OBJECT: "object",
+  OBJECTLIST: "list(object)",
   FLOAT: "float",
-  LIST: "list",
+  FLOATLIST: "list(float)",
   BOOL: "boolean",
+  BOOLLIST: "list(boolean)",
   NULL: "null",
   UNKNOWN: "unknown",
+  UNKNOWNLIST: "list(unknown)",
 };
 
 export {