avo-inspector 3.2.3-alpha.1 → 4.0.0-alpha.1

package/README.md

@@ -70,6 +70,8 @@ let inspector = new Inspector.AvoInspector({
 
 Logs are enabled by default in the dev mode and disabled in prod mode.
 
+Since 4.0.0 the setting is shared by every inspector created from the same copy of the SDK, and creating an inspector no longer resets it. Remove any leftover `enableLogging(true)` before upgrading, or production pages keep printing logs.
+
 ```javascript
 inspector.enableLogging(true);
 ```

package/dist/AvoInspector.d.ts

@@ -23,6 +23,7 @@ export declare class AvoInspector {
     private static _batchFlushSeconds;
     static get batchFlushSeconds(): number;
     private static _shouldLog;
+    private static _shouldLogSetByUser;
     static get shouldLog(): boolean;
     static set shouldLog(enable: boolean);
     private static _networkTimeout;

package/dist/AvoStorage.d.ts

@@ -1,5 +1,6 @@
+import { type ShouldLogFlag } from "./utils";
 declare abstract class PlatformAvoStorage {
-    abstract init(shouldLog: boolean, suffix: string): void;
+    abstract init(shouldLog: ShouldLogFlag, suffix: string): void;
     abstract getItemAsync<T>(key: string): Promise<T | null>;
     abstract getItem<T>(key: string): T | null;
     abstract setItem<T>(key: string, value: T): void;
@@ -11,7 +12,7 @@ declare abstract class PlatformAvoStorage {
 export declare class AvoStorage {
     Platform: string | null;
     storageImpl: PlatformAvoStorage;
-    constructor(shouldLog: boolean, suffix?: string);
+    constructor(shouldLog: ShouldLogFlag, suffix?: string);
     isInitialized(): boolean;
     getItemAsync<T>(key: string): Promise<T | null>;
     getItem<T>(key: string): T | null;

package/dist/AvoStorage.js

@@ -52,6 +52,16 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvoStorage = void 0;
+var utils_1 = require("./utils");
+// A failed write means the persisted event queue (and stream id) won't survive
+// a page unload — a data-delivery error — so the first write failure is printed
+// regardless of the logging flag. Repeats are gated, since once storage is full
+// every event's write fails and that would be per-event noise. Module-scoped so
+// every BrowserAvoStorage in one loaded copy of the SDK shares the "first"
+// (a page with two inspectors logs it once, not twice); a separately bundled
+// copy, the lite build, or an iframe copy each load this module afresh and so
+// keep their own flag. See AVO-3079 review.
+var reportedWriteFailure = false;
 var PlatformAvoStorage = /** @class */ (function () {
     function PlatformAvoStorage() {
     }
@@ -73,12 +83,14 @@ var BrowserAvoStorage = /** @class */ (function (_super) {
         _this.fallbackStorage = {};
         _this.storageInitialized = false;
         _this.onStorageInitFuncs = [];
-        _this.shouldLog = false;
+        // Reads the current logging flag live so a later enableLogging() /
+        // AvoInspector.shouldLog change is reflected without re-pushing. See AVO-3079.
+        _this.shouldLog = function () { return false; };
         _this.suffix = "";
         return _this;
     }
     BrowserAvoStorage.prototype.init = function (shouldLog, suffix) {
-        this.shouldLog = shouldLog;
+        this.shouldLog = (0, utils_1.toShouldLogGetter)(shouldLog);
         this.suffix = suffix;
         this.initializeStorageWeb(this.isLocalStorageAvailable());
     };
@@ -128,7 +140,7 @@ var BrowserAvoStorage = /** @class */ (function (_super) {
                                             maybeItem = window.localStorage.getItem(key + _this.suffix);
                                         }
                                         catch (error) {
-                                            if (_this.shouldLog) {
+                                            if (_this.shouldLog()) {
                                                 console.error("Avo Inspector Storage getItemAsync error:", error);
                                             }
                                             resolve(null);
@@ -160,7 +172,7 @@ var BrowserAvoStorage = /** @class */ (function (_super) {
                     maybeItem = window.localStorage.getItem(key + this.suffix);
                 }
                 catch (error) {
-                    if (this.shouldLog) {
+                    if (this.shouldLog()) {
                         console.error("Avo Inspector Storage getItem error:", error);
                     }
                 }
@@ -180,7 +192,10 @@ var BrowserAvoStorage = /** @class */ (function (_super) {
                         window.localStorage.setItem(key + _this.suffix, JSON.stringify(value));
                     }
                     catch (error) {
-                        if (_this.shouldLog) {
+                        // Print the first write failure unconditionally (it means the queue
+                        // may not survive unload); gate the repeats. See AVO-3079 review.
+                        if (!reportedWriteFailure || _this.shouldLog()) {
+                            reportedWriteFailure = true;
                             console.error("Avo Inspector Storage setItem error:", error);
                         }
                     }
@@ -200,7 +215,7 @@ var BrowserAvoStorage = /** @class */ (function (_super) {
                         window.localStorage.removeItem(key + _this.suffix);
                     }
                     catch (error) {
-                        if (_this.shouldLog) {
+                        if (_this.shouldLog()) {
                             console.error("Avo Inspector Storage removeItem error:", error);
                         }
                     }

package/dist/eventSpec/AvoEventSpecCache.d.ts

@@ -1,4 +1,5 @@
 import type { EventSpecResponse, EventSpecCoordinates } from "./AvoEventSpecFetchTypes";
+import { type ShouldLogFlag } from "../utils";
 /**
  * EventSpecCache implements a dual-condition cache with LRU eviction.
  *
@@ -24,9 +25,12 @@ export declare class EventSpecCache {
     private readonly MAX_EVENT_COUNT;
     /** Global cache hit counter to track when to rotate cache */
     private globalEventCount;
-    /** Whether to log debug information */
-    private readonly shouldLog;
-    constructor(shouldLog?: boolean);
+    /**
+     * Reads the current logging flag live, so a later enableLogging() /
+     * AvoInspector.shouldLog change is reflected without re-pushing. See AVO-3079.
+     */
+    private shouldLog;
+    constructor(shouldLog?: ShouldLogFlag);
     /**
      * Generates a cache key from the provided parameters.
      */

package/dist/eventSpec/AvoEventSpecFetchTypes.d.ts

@@ -1,8 +1,3 @@
-/**
- * This file is generated. Internal development changes should be made in the generator
- * and the file should be re-generated. External contributions are welcome to submit
- * changes directly to this file, and we'll apply them to the generator internally.
- */
 /**
  * Wire format - Property constraints with short field names.
  * At most one constraint type will be present per property.

package/dist/eventSpec/AvoEventSpecFetchTypes.js

@@ -1,7 +1,2 @@
 "use strict";
-/**
- * This file is generated. Internal development changes should be made in the generator
- * and the file should be re-generated. External contributions are welcome to submit
- * changes directly to this file, and we'll apply them to the generator internally.
- */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/eventSpec/AvoEventSpecFetcher.d.ts

@@ -1,9 +1,5 @@
-/**
- * This file is generated. Internal development changes should be made in the generator
- * and the file should be re-generated. External contributions are welcome to submit
- * changes directly to this file, and we'll apply them to the generator internally.
- */
 import type { EventSpecResponse, FetchEventSpecParams } from "./AvoEventSpecFetchTypes";
+import { type ShouldLogFlag } from "../utils";
 /**
  * EventSpecFetcher handles fetching event specifications from the Avo API.
  *
@@ -17,11 +13,14 @@ export declare class AvoEventSpecFetcher {
     private readonly timeout;
     /** In-flight requests to prevent duplicate fetches */
     private inFlightRequests;
-    /** Whether to log debug information */
-    private readonly shouldLog;
+    /**
+     * Reads the current logging flag live, so a later enableLogging() /
+     * AvoInspector.shouldLog change is reflected without re-pushing. See AVO-3079.
+     */
+    private shouldLog;
     /** Environment name */
     private readonly env;
-    constructor(timeout: number | undefined, shouldLog: boolean | undefined, env: string, baseUrl?: string);
+    constructor(timeout: number | undefined, shouldLog: ShouldLogFlag | undefined, env: string, baseUrl?: string);
     /**
      * Generates a unique key for tracking in-flight requests, matching the spec
      * cache key. The API key tells gateways apart, and gateway coordinates are