@amplitude/analytics-core 2.24.1 → 2.26.0

package/lib/esm/diagnostics/diagnostics-storage.d.ts

@@ -0,0 +1,123 @@
+import { ILogger } from '../logger';
+import { HistogramStats } from './diagnostics-client';
+export declare const TABLE_NAMES: {
+    readonly TAGS: "tags";
+    readonly COUNTERS: "counters";
+    readonly HISTOGRAMS: "histograms";
+    readonly EVENTS: "events";
+    readonly INTERNAL: "internal";
+};
+export declare const INTERNAL_KEYS: {
+    readonly LAST_FLUSH_TIMESTAMP: "last_flush_timestamp";
+};
+export interface TagRecord {
+    key: string;
+    value: string;
+}
+export interface CounterRecord {
+    key: string;
+    value: number;
+}
+export interface HistogramRecord {
+    key: string;
+    count: number;
+    min: number;
+    max: number;
+    sum: number;
+}
+export interface EventRecord {
+    id?: number;
+    event_name: string;
+    time: number;
+    event_properties: Record<string, any>;
+}
+export interface InternalRecord {
+    key: string;
+    value: string;
+}
+export interface IDiagnosticsStorage {
+    /**
+     * Set multiple tags in a single transaction (batch operation)
+     * Promise never rejects - errors are logged and operation continues gracefully
+     */
+    setTags(tags: Record<string, string>): Promise<void>;
+    /**
+     * Increment multiple counters in a single transaction (batch operation)
+     * Uses read-modify-write pattern to accumulate with existing values
+     * Promise never rejects - errors are logged and operation continues gracefully
+     */
+    incrementCounters(counters: Record<string, number>): Promise<void>;
+    /**
+     * Set multiple histogram stats in a single transaction (batch operation)
+     * Uses read-modify-write pattern to accumulate count/sum and update min/max with existing values
+     * Promise never rejects - errors are logged and operation continues gracefully
+     */
+    setHistogramStats(histogramStats: Record<string, {
+        count: number;
+        min: number;
+        max: number;
+        sum: number;
+    }>): Promise<void>;
+    /**
+     * Add multiple event records in a single transaction (batch operation)
+     * Promise never rejects - errors are logged and operation continues gracefully
+     */
+    addEventRecords(events: Array<{
+        event_name: string;
+        time: number;
+        event_properties: Record<string, any>;
+    }>): Promise<void>;
+    setLastFlushTimestamp(timestamp: number): Promise<void>;
+    getLastFlushTimestamp(): Promise<number | undefined>;
+    /**
+     * Get all data except internal data from storage and clear it
+     */
+    getAllAndClear(): Promise<{
+        tags: TagRecord[];
+        counters: CounterRecord[];
+        histogramStats: HistogramRecord[];
+        events: EventRecord[];
+    }>;
+}
+/**
+ * Purpose-specific IndexedDB storage for diagnostics data
+ * Provides optimized methods for each type of diagnostics data
+ */
+export declare class DiagnosticsStorage implements IDiagnosticsStorage {
+    dbPromise: Promise<IDBDatabase> | null;
+    dbName: string;
+    logger: ILogger;
+    constructor(apiKey: string, logger: ILogger);
+    /**
+     * Check if IndexedDB is supported in the current environment
+     * @returns true if IndexedDB is available, false otherwise
+     */
+    static isSupported(): boolean;
+    getDB(): Promise<IDBDatabase>;
+    openDB(): Promise<IDBDatabase>;
+    createTables(db: IDBDatabase): void;
+    setTags(tags: Record<string, string>): Promise<void>;
+    incrementCounters(counters: Record<string, number>): Promise<void>;
+    setHistogramStats(histogramStats: Record<string, HistogramStats>): Promise<void>;
+    addEventRecords(events: Array<{
+        event_name: string;
+        time: number;
+        event_properties: Record<string, any>;
+    }>): Promise<void>;
+    setInternal(key: string, value: string): Promise<void>;
+    getInternal(key: string): Promise<InternalRecord | undefined>;
+    getLastFlushTimestamp(): Promise<number | undefined>;
+    setLastFlushTimestamp(timestamp: number): Promise<void>;
+    clearTable(transaction: IDBTransaction, tableName: string): Promise<void>;
+    getAllAndClear(): Promise<{
+        tags: TagRecord[];
+        counters: CounterRecord[];
+        histogramStats: HistogramRecord[];
+        events: EventRecord[];
+    }>;
+    /**
+     * Helper method to get all records from a store within a transaction
+     */
+    private getAllFromStore;
+}
+//# sourceMappingURL=diagnostics-storage.d.ts.map

package/lib/esm/diagnostics/diagnostics-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics-storage.d.ts","sourceRoot":"","sources":["../../../src/diagnostics/diagnostics-storage.ts"],"names":[],"mappings":"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"}

package/lib/esm/diagnostics/diagnostics-storage.js

@@ -0,0 +1,489 @@
+import { __awaiter, __generator, __read } from "tslib";
+import { getGlobalScope } from '../global-scope';
+var MAX_PERSISTENT_STORAGE_EVENTS_COUNT = 10;
+// Database configuration
+var DB_VERSION = 1;
+// Table names for different diagnostics types
+export var TABLE_NAMES = {
+    TAGS: 'tags',
+    COUNTERS: 'counters',
+    HISTOGRAMS: 'histograms',
+    EVENTS: 'events',
+    INTERNAL: 'internal', // New table for internal storage like flush timestamps
+};
+// Keys for internal storage table
+export var INTERNAL_KEYS = {
+    LAST_FLUSH_TIMESTAMP: 'last_flush_timestamp',
+};
+/**
+ * Purpose-specific IndexedDB storage for diagnostics data
+ * Provides optimized methods for each type of diagnostics data
+ */
+var DiagnosticsStorage = /** @class */ (function () {
+    function DiagnosticsStorage(apiKey, logger) {
+        this.dbPromise = null;
+        this.logger = logger;
+        this.dbName = "AMP_diagnostics_".concat(apiKey.substring(0, 10));
+    }
+    /**
+     * Check if IndexedDB is supported in the current environment
+     * @returns true if IndexedDB is available, false otherwise
+     */
+    DiagnosticsStorage.isSupported = function () {
+        var _a;
+        return ((_a = getGlobalScope()) === null || _a === void 0 ? void 0 : _a.indexedDB) !== undefined;
+    };
+    DiagnosticsStorage.prototype.getDB = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.dbPromise) {
+                    this.dbPromise = this.openDB();
+                }
+                return [2 /*return*/, this.dbPromise];
+            });
+        });
+    };
+    DiagnosticsStorage.prototype.openDB = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var request = indexedDB.open(_this.dbName, DB_VERSION);
+            request.onerror = function () {
+                // Clear dbPromise when it rejects for the first time
+                _this.dbPromise = null;
+                reject(new Error('Failed to open IndexedDB'));
+            };
+            request.onsuccess = function () {
+                var db = request.result;
+                // Clear dbPromise when connection was on but went off later
+                db.onclose = function () {
+                    _this.dbPromise = null;
+                    _this.logger.debug('DiagnosticsStorage: DB connection closed.');
+                };
+                db.onerror = function (event) {
+                    _this.logger.debug('DiagnosticsStorage: A global database error occurred.', event);
+                    db.close();
+                };
+                resolve(db);
+            };
+            request.onupgradeneeded = function (event) {
+                var db = event.target.result;
+                _this.createTables(db);
+            };
+        });
+    };
+    DiagnosticsStorage.prototype.createTables = function (db) {
+        // Create tags table
+        if (!db.objectStoreNames.contains(TABLE_NAMES.TAGS)) {
+            db.createObjectStore(TABLE_NAMES.TAGS, { keyPath: 'key' });
+        }
+        // Create counters table
+        if (!db.objectStoreNames.contains(TABLE_NAMES.COUNTERS)) {
+            db.createObjectStore(TABLE_NAMES.COUNTERS, { keyPath: 'key' });
+        }
+        // Create histograms table for storing histogram stats (count, min, max, sum)
+        if (!db.objectStoreNames.contains(TABLE_NAMES.HISTOGRAMS)) {
+            db.createObjectStore(TABLE_NAMES.HISTOGRAMS, {
+                keyPath: 'key',
+            });
+        }
+        // Create events table
+        if (!db.objectStoreNames.contains(TABLE_NAMES.EVENTS)) {
+            var eventsStore = db.createObjectStore(TABLE_NAMES.EVENTS, {
+                keyPath: 'id',
+                autoIncrement: true,
+            });
+            // Create index on time for chronological queries
+            eventsStore.createIndex('time_idx', 'time', { unique: false });
+        }
+        // Create internal table for storing internal data like flush timestamps
+        if (!db.objectStoreNames.contains(TABLE_NAMES.INTERNAL)) {
+            db.createObjectStore(TABLE_NAMES.INTERNAL, { keyPath: 'key' });
+        }
+    };
+    DiagnosticsStorage.prototype.setTags = function (tags) {
+        return __awaiter(this, void 0, void 0, function () {
+            var db, transaction_1, store_1, error_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        if (Object.entries(tags).length === 0) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.getDB()];
+                    case 1:
+                        db = _a.sent();
+                        transaction_1 = db.transaction([TABLE_NAMES.TAGS], 'readwrite');
+                        store_1 = transaction_1.objectStore(TABLE_NAMES.TAGS);
+                        return [2 /*return*/, new Promise(function (resolve) {
+                                var entries = Object.entries(tags);
+                                transaction_1.oncomplete = function () {
+                                    resolve();
+                                };
+                                transaction_1.onabort = function (event) {
+                                    _this.logger.debug('DiagnosticsStorage: Failed to set tags', event);
+                                    resolve();
+                                };
+                                entries.forEach(function (_a) {
+                                    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                                    var putRequest = store_1.put({ key: key, value: value });
+                                    putRequest.onerror = function (event) {
+                                        _this.logger.debug('DiagnosticsStorage: Failed to set tag', key, value, event);
+                                    };
+                                });
+                            })];
+                    case 2:
+                        error_1 = _a.sent();
+                        this.logger.debug('DiagnosticsStorage: Failed to set tags', error_1);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DiagnosticsStorage.prototype.incrementCounters = function (counters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var db, transaction_2, store_2, error_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        if (Object.entries(counters).length === 0) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.getDB()];
+                    case 1:
+                        db = _a.sent();
+                        transaction_2 = db.transaction([TABLE_NAMES.COUNTERS], 'readwrite');
+                        store_2 = transaction_2.objectStore(TABLE_NAMES.COUNTERS);
+                        return [2 /*return*/, new Promise(function (resolve) {
+                                var entries = Object.entries(counters);
+                                transaction_2.oncomplete = function () {
+                                    resolve();
+                                };
+                                transaction_2.onabort = function (event) {
+                                    _this.logger.debug('DiagnosticsStorage: Failed to increment counters', event);
+                                    resolve();
+                                };
+                                // Read existing values and update them
+                                entries.forEach(function (_a) {
+                                    var _b = __read(_a, 2), key = _b[0], incrementValue = _b[1];
+                                    var getRequest = store_2.get(key);
+                                    getRequest.onsuccess = function () {
+                                        var existingRecord = getRequest.result;
+                                        /* istanbul ignore next */
+                                        var existingValue = existingRecord ? existingRecord.value : 0;
+                                        var putRequest = store_2.put({ key: key, value: existingValue + incrementValue });
+                                        putRequest.onerror = function (event) {
+                                            _this.logger.debug('DiagnosticsStorage: Failed to update counter', key, event);
+                                        };
+                                    };
+                                    getRequest.onerror = function (event) {
+                                        _this.logger.debug('DiagnosticsStorage: Failed to read existing counter', key, event);
+                                    };
+                                });
+                            })];
+                    case 2:
+                        error_2 = _a.sent();
+                        this.logger.debug('DiagnosticsStorage: Failed to increment counters', error_2);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DiagnosticsStorage.prototype.setHistogramStats = function (histogramStats) {
+        return __awaiter(this, void 0, void 0, function () {
+            var db, transaction_3, store_3, error_3;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        if (Object.entries(histogramStats).length === 0) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.getDB()];
+                    case 1:
+                        db = _a.sent();
+                        transaction_3 = db.transaction([TABLE_NAMES.HISTOGRAMS], 'readwrite');
+                        store_3 = transaction_3.objectStore(TABLE_NAMES.HISTOGRAMS);
+                        return [2 /*return*/, new Promise(function (resolve) {
+                                var entries = Object.entries(histogramStats);
+                                transaction_3.oncomplete = function () {
+                                    resolve();
+                                };
+                                transaction_3.onabort = function (event) {
+                                    _this.logger.debug('DiagnosticsStorage: Failed to set histogram stats', event);
+                                    resolve();
+                                };
+                                // Read existing values and update them
+                                entries.forEach(function (_a) {
+                                    var _b = __read(_a, 2), key = _b[0], newStats = _b[1];
+                                    var getRequest = store_3.get(key);
+                                    getRequest.onsuccess = function () {
+                                        var existingRecord = getRequest.result;
+                                        var updatedStats;
+                                        /* istanbul ignore next */
+                                        if (existingRecord) {
+                                            // Accumulate with existing stats
+                                            updatedStats = {
+                                                key: key,
+                                                count: existingRecord.count + newStats.count,
+                                                min: Math.min(existingRecord.min, newStats.min),
+                                                max: Math.max(existingRecord.max, newStats.max),
+                                                sum: existingRecord.sum + newStats.sum,
+                                            };
+                                        }
+                                        else {
+                                            // Create new stats
+                                            updatedStats = {
+                                                key: key,
+                                                count: newStats.count,
+                                                min: newStats.min,
+                                                max: newStats.max,
+                                                sum: newStats.sum,
+                                            };
+                                        }
+                                        var putRequest = store_3.put(updatedStats);
+                                        putRequest.onerror = function (event) {
+                                            _this.logger.debug('DiagnosticsStorage: Failed to set histogram stats', key, event);
+                                        };
+                                    };
+                                    getRequest.onerror = function (event) {
+                                        _this.logger.debug('DiagnosticsStorage: Failed to read existing histogram stats', key, event);
+                                    };
+                                });
+                            })];
+                    case 2:
+                        error_3 = _a.sent();
+                        this.logger.debug('DiagnosticsStorage: Failed to set histogram stats', error_3);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DiagnosticsStorage.prototype.addEventRecords = function (events) {
+        return __awaiter(this, void 0, void 0, function () {
+            var db, transaction_4, store_4, error_4;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        if (events.length === 0) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.getDB()];
+                    case 1:
+                        db = _a.sent();
+                        transaction_4 = db.transaction([TABLE_NAMES.EVENTS], 'readwrite');
+                        store_4 = transaction_4.objectStore(TABLE_NAMES.EVENTS);
+                        return [2 /*return*/, new Promise(function (resolve) {
+                                transaction_4.oncomplete = function () {
+                                    resolve();
+                                };
+                                /* istanbul ignore next */
+                                transaction_4.onabort = function (event) {
+                                    _this.logger.debug('DiagnosticsStorage: Failed to add event records', event);
+                                    resolve();
+                                };
+                                // First, check how many events are currently stored
+                                var countRequest = store_4.count();
+                                countRequest.onsuccess = function () {
+                                    var currentCount = countRequest.result;
+                                    // Calculate how many events we can add
+                                    var availableSlots = Math.max(0, MAX_PERSISTENT_STORAGE_EVENTS_COUNT - currentCount);
+                                    if (availableSlots < events.length) {
+                                        _this.logger.debug("DiagnosticsStorage: Only added ".concat(availableSlots, " of ").concat(events.length, " events due to storage limit"));
+                                    }
+                                    // Only add events up to the available slots (take the least recent ones)
+                                    events.slice(0, availableSlots).forEach(function (event) {
+                                        var request = store_4.add(event);
+                                        request.onerror = function (event) {
+                                            _this.logger.debug('DiagnosticsStorage: Failed to add event record', event);
+                                        };
+                                    });
+                                };
+                                countRequest.onerror = function (event) {
+                                    _this.logger.debug('DiagnosticsStorage: Failed to count existing events', event);
+                                };
+                            })];
+                    case 2:
+                        error_4 = _a.sent();
+                        this.logger.debug('DiagnosticsStorage: Failed to add event records', error_4);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DiagnosticsStorage.prototype.setInternal = function (key, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var db, transaction_5, store_5, error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.getDB()];
+                    case 1:
+                        db = _a.sent();
+                        transaction_5 = db.transaction([TABLE_NAMES.INTERNAL], 'readwrite');
+                        store_5 = transaction_5.objectStore(TABLE_NAMES.INTERNAL);
+                        return [2 /*return*/, new Promise(function (resolve, reject) {
+                                /* istanbul ignore next */
+                                transaction_5.onabort = function () { return reject(new Error('Failed to set internal value')); };
+                                var request = store_5.put({ key: key, value: value });
+                                request.onsuccess = function () { return resolve(); };
+                                /* istanbul ignore next */
+                                request.onerror = function () { return reject(new Error('Failed to set internal value')); };
+                            })];
+                    case 2:
+                        error_5 = _a.sent();
+                        /* istanbul ignore next */
+                        this.logger.debug('DiagnosticsStorage: Failed to set internal value', error_5);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DiagnosticsStorage.prototype.getInternal = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            var db, transaction_6, store_6, error_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.getDB()];
+                    case 1:
+                        db = _a.sent();
+                        transaction_6 = db.transaction([TABLE_NAMES.INTERNAL], 'readonly');
+                        store_6 = transaction_6.objectStore(TABLE_NAMES.INTERNAL);
+                        return [2 /*return*/, new Promise(function (resolve, reject) {
+                                /* istanbul ignore next */
+                                transaction_6.onabort = function () { return reject(new Error('Failed to get internal value')); };
+                                var request = store_6.get(key);
+                                request.onsuccess = function () { return resolve(request.result); };
+                                /* istanbul ignore next */
+                                request.onerror = function () { return reject(new Error('Failed to get internal value')); };
+                            })];
+                    case 2:
+                        error_6 = _a.sent();
+                        this.logger.debug('DiagnosticsStorage: Failed to get internal value', error_6);
+                        return [2 /*return*/, undefined];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DiagnosticsStorage.prototype.getLastFlushTimestamp = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var record, error_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.getInternal(INTERNAL_KEYS.LAST_FLUSH_TIMESTAMP)];
+                    case 1:
+                        record = _a.sent();
+                        return [2 /*return*/, record ? parseInt(record.value, 10) : undefined];
+                    case 2:
+                        error_7 = _a.sent();
+                        /* istanbul ignore next */
+                        this.logger.debug('DiagnosticsStorage: Failed to get last flush timestamp', error_7);
+                        /* istanbul ignore next */
+                        return [2 /*return*/, undefined];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DiagnosticsStorage.prototype.setLastFlushTimestamp = function (timestamp) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_8;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.setInternal(INTERNAL_KEYS.LAST_FLUSH_TIMESTAMP, timestamp.toString())];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_8 = _a.sent();
+                        /* istanbul ignore next */
+                        this.logger.debug('DiagnosticsStorage: Failed to set last flush timestamp', error_8);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* istanbul ignore next */
+    DiagnosticsStorage.prototype.clearTable = function (transaction, tableName) {
+        return new Promise(function (resolve, reject) {
+            var store = transaction.objectStore(tableName);
+            var request = store.clear();
+            request.onsuccess = function () { return resolve(); };
+            request.onerror = function () { return reject(new Error("Failed to clear table ".concat(tableName))); };
+        });
+    };
+    /* istanbul ignore next */
+    DiagnosticsStorage.prototype.getAllAndClear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var db, transaction, _a, tags, counters, histogramStats, events, error_9;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 4, , 5]);
+                        return [4 /*yield*/, this.getDB()];
+                    case 1:
+                        db = _b.sent();
+                        transaction = db.transaction([TABLE_NAMES.TAGS, TABLE_NAMES.COUNTERS, TABLE_NAMES.HISTOGRAMS, TABLE_NAMES.EVENTS], 'readwrite');
+                        return [4 /*yield*/, Promise.all([
+                                this.getAllFromStore(transaction, TABLE_NAMES.TAGS),
+                                this.getAllFromStore(transaction, TABLE_NAMES.COUNTERS),
+                                this.getAllFromStore(transaction, TABLE_NAMES.HISTOGRAMS),
+                                this.getAllFromStore(transaction, TABLE_NAMES.EVENTS),
+                            ])];
+                    case 2:
+                        _a = __read.apply(void 0, [_b.sent(), 4]), tags = _a[0], counters = _a[1], histogramStats = _a[2], events = _a[3];
+                        // Clear all data in the same transaction
+                        return [4 /*yield*/, Promise.all([
+                                this.clearTable(transaction, TABLE_NAMES.COUNTERS),
+                                this.clearTable(transaction, TABLE_NAMES.HISTOGRAMS),
+                                this.clearTable(transaction, TABLE_NAMES.EVENTS),
+                            ])];
+                    case 3:
+                        // Clear all data in the same transaction
+                        _b.sent();
+                        return [2 /*return*/, { tags: tags, counters: counters, histogramStats: histogramStats, events: events }];
+                    case 4:
+                        error_9 = _b.sent();
+                        this.logger.debug('DiagnosticsStorage: Failed to get all and clear data', error_9);
+                        return [2 /*return*/, { tags: [], counters: [], histogramStats: [], events: [] }];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Helper method to get all records from a store within a transaction
+     */
+    /* istanbul ignore next */
+    DiagnosticsStorage.prototype.getAllFromStore = function (transaction, tableName) {
+        return new Promise(function (resolve, reject) {
+            var store = transaction.objectStore(tableName);
+            var request = store.getAll();
+            request.onsuccess = function () { return resolve(request.result); };
+            request.onerror = function () { return reject(new Error("Failed to get all from ".concat(tableName))); };
+        });
+    };
+    return DiagnosticsStorage;
+}());
+export { DiagnosticsStorage };
+//# sourceMappingURL=diagnostics-storage.js.map