@memberjunction/core 2.128.0 → 2.130.0

package/dist/generic/telemetryManager.js

@@ -0,0 +1,1011 @@
+"use strict";
+/**
+ * TelemetryManager - Lightweight instrumentation system for tracking operation performance,
+ * detecting patterns, and surfacing optimization opportunities.
+ *
+ * Features:
+ * - Session-level event tracking for RunView, RunQuery, Engine, AI, Cache operations
+ * - Pattern detection for identifying duplicate calls and optimization opportunities
+ * - Pluggable analyzer system for custom analysis rules
+ * - WarningManager integration for debounced console output
+ * - Configurable via local storage for per-client settings
+ * - Strongly-typed parameter interfaces for each telemetry category
+ *
+ * @example
+ * ```typescript
+ * const tm = TelemetryManager.Instance;
+ *
+ * // Enable telemetry
+ * tm.SetEnabled(true);
+ *
+ * // Track a RunView operation with typed params
+ * const eventId = tm.StartEvent('RunView', 'ProviderBase.RunView', {
+ *     EntityName: 'Users',
+ *     ExtraFilter: 'IsActive = 1',
+ *     ResultType: 'entity_object'
+ * });
+ * // ... perform operation
+ * tm.EndEvent(eventId, { cacheHit: false, resultCount: 50 });
+ *
+ * // Get patterns for analysis
+ * const patterns = tm.GetPatterns({ category: 'RunView', minCount: 2 });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryManager = exports.isNetworkParams = exports.isCacheParams = exports.isAIParams = exports.isEngineParams = exports.isBatchRunQueryParams = exports.isSingleRunQueryParams = exports.isSingleRunViewParams = exports.isBatchRunViewParams = exports.TelemetryLevelValue = void 0;
+const global_1 = require("@memberjunction/global");
+/**
+ * Numeric mapping for level comparisons
+ */
+exports.TelemetryLevelValue = {
+    'off': 0,
+    'basic': 1, // Timing only (operation, elapsed ms)
+    'standard': 2, // Timing + key params (entity, filter, etc.)
+    'verbose': 3, // + stack traces (cleaned)
+    'debug': 4 // + memory snapshots before/after
+};
+// ============================================================================
+// TYPE GUARDS
+// ============================================================================
+/**
+ * Type guard to check if params represent a batch RunViews operation
+ */
+function isBatchRunViewParams(params) {
+    return typeof params === 'object' &&
+        params !== null &&
+        'Entities' in params &&
+        Array.isArray(params.Entities);
+}
+exports.isBatchRunViewParams = isBatchRunViewParams;
+/**
+ * Type guard to check if params represent a single RunView operation
+ */
+function isSingleRunViewParams(params) {
+    return typeof params === 'object' &&
+        params !== null &&
+        !isBatchRunViewParams(params) &&
+        ('EntityName' in params || 'ViewID' in params || 'ViewName' in params);
+}
+exports.isSingleRunViewParams = isSingleRunViewParams;
+/**
+ * Type guard to check if params represent a single RunQuery operation
+ */
+function isSingleRunQueryParams(params) {
+    return typeof params === 'object' &&
+        params !== null &&
+        !isBatchRunQueryParams(params) &&
+        ('QueryID' in params || 'QueryName' in params);
+}
+exports.isSingleRunQueryParams = isSingleRunQueryParams;
+/**
+ * Type guard to check if params represent a batch RunQueries operation
+ */
+function isBatchRunQueryParams(params) {
+    return typeof params === 'object' &&
+        params !== null &&
+        'Queries' in params &&
+        Array.isArray(params.Queries);
+}
+exports.isBatchRunQueryParams = isBatchRunQueryParams;
+/**
+ * Type guard to check if params represent an Engine operation
+ */
+function isEngineParams(params) {
+    return typeof params === 'object' &&
+        params !== null &&
+        'engineClass' in params &&
+        'operation' in params;
+}
+exports.isEngineParams = isEngineParams;
+/**
+ * Type guard to check if params represent an AI operation
+ */
+function isAIParams(params) {
+    return typeof params === 'object' &&
+        params !== null &&
+        ('modelID' in params || 'modelName' in params || 'promptID' in params);
+}
+exports.isAIParams = isAIParams;
+/**
+ * Type guard to check if params represent a Cache operation
+ */
+function isCacheParams(params) {
+    return typeof params === 'object' &&
+        params !== null &&
+        'cacheType' in params &&
+        'operation' in params;
+}
+exports.isCacheParams = isCacheParams;
+/**
+ * Type guard to check if params represent a Network operation
+ */
+function isNetworkParams(params) {
+    return typeof params === 'object' &&
+        params !== null &&
+        ('method' in params || 'url' in params || 'statusCode' in params);
+}
+exports.isNetworkParams = isNetworkParams;
+// ============================================================================
+// BUILT-IN ANALYZERS
+// ============================================================================
+/**
+ * Detects when RunView is called for an entity already loaded by an engine.
+ * Suggests using the engine's cached data instead.
+ *
+ * Note: Skips RunView calls marked with _fromEngine=true, as these are
+ * engine-initiated calls (e.g., BaseEngine loading its config entities).
+ */
+class EngineOverlapAnalyzer {
+    constructor() {
+        this.name = 'EngineOverlapAnalyzer';
+        this.category = 'Optimization';
+    }
+    analyze(event, context) {
+        if (event.category !== 'RunView')
+            return null;
+        const params = event.params;
+        // Skip engine-initiated RunView calls to avoid false positives
+        if (params._fromEngine)
+            return null;
+        // Only check single RunView operations, not batches
+        if (!isSingleRunViewParams(params))
+            return null;
+        const entityName = params.EntityName;
+        if (!entityName)
+            return null;
+        const loadedEntities = context.getEngineLoadedEntities();
+        const engines = loadedEntities.get(entityName);
+        if (engines && engines.length > 0) {
+            return {
+                id: `engine-overlap-${event.id}`,
+                severity: 'optimization',
+                analyzerName: this.name,
+                category: this.category,
+                title: 'Entity Already in Engine',
+                entityName,
+                message: `RunView for "${entityName}" called, but this entity is already loaded by: ${engines.join(', ')}`,
+                suggestion: `Consider using ${engines[0]} cached data instead of a separate RunView call`,
+                relatedEventIds: [event.id],
+                timestamp: Date.now()
+            };
+        }
+        return null;
+    }
+}
+/**
+ * Detects when the same entity is queried multiple times with different filters.
+ * Suggests creating an engine to centralize access.
+ */
+class SameEntityMultipleCallsAnalyzer {
+    constructor() {
+        this.name = 'SameEntityMultipleCallsAnalyzer';
+        this.category = 'Optimization';
+    }
+    analyze(event, context) {
+        if (event.category !== 'RunView')
+            return null;
+        const params = event.params;
+        if (!isSingleRunViewParams(params))
+            return null;
+        const entityName = params.EntityName;
+        if (!entityName)
+            return null;
+        // Count distinct RunViews for same entity in recent events
+        const entityEvents = context.recentEvents.filter(e => {
+            if (e.category !== 'RunView')
+                return false;
+            const p = e.params;
+            return isSingleRunViewParams(p) && p.EntityName === entityName;
+        });
+        // Get unique fingerprints (different filter/orderBy combinations)
+        const uniqueFingerprints = new Set(entityEvents.map(e => e.fingerprint));
+        if (uniqueFingerprints.size >= 3) {
+            return {
+                id: `multi-call-${entityName}-${Date.now()}`,
+                severity: 'optimization',
+                analyzerName: this.name,
+                category: this.category,
+                title: 'Multiple Queries for Same Entity',
+                entityName,
+                message: `Entity "${entityName}" queried ${entityEvents.length} times with ${uniqueFingerprints.size} different filter combinations`,
+                suggestion: `Consider creating a dedicated engine to load and cache ${entityName} data centrally`,
+                relatedEventIds: entityEvents.map(e => e.id),
+                metadata: {
+                    totalCalls: entityEvents.length,
+                    uniqueVariations: uniqueFingerprints.size
+                },
+                timestamp: Date.now()
+            };
+        }
+        return null;
+    }
+}
+/**
+ * Detects sequential RunView calls that could be batched with RunViews.
+ */
+class ParallelizationOpportunityAnalyzer {
+    constructor() {
+        this.name = 'ParallelizationOpportunityAnalyzer';
+        this.category = 'Performance';
+        this.SEQUENCE_THRESHOLD_MS = 100;
+    }
+    analyze(event, context) {
+        if (event.category !== 'RunView')
+            return null;
+        // Find RunView events that completed just before this one started
+        const recentSequential = context.recentEvents.filter(e => {
+            if (e.category !== 'RunView')
+                return false;
+            if (e.id === event.id)
+                return false;
+            if (!e.endTime)
+                return false;
+            // Check if previous event ended shortly before this one started
+            const gap = event.startTime - e.endTime;
+            return gap >= 0 && gap < this.SEQUENCE_THRESHOLD_MS;
+        });
+        if (recentSequential.length >= 2) {
+            const allEvents = [...recentSequential, event];
+            const entities = allEvents.map(e => {
+                const p = e.params;
+                return isSingleRunViewParams(p) ? p.EntityName : 'batch';
+            });
+            return {
+                id: `parallel-${event.id}`,
+                severity: 'optimization',
+                analyzerName: this.name,
+                category: this.category,
+                title: 'Sequential Queries Could Be Parallelized',
+                message: `${allEvents.length} RunView calls executed sequentially`,
+                suggestion: `Use RunViews (batch) to execute these queries in parallel for better performance`,
+                relatedEventIds: allEvents.map(e => e.id),
+                metadata: { entities },
+                timestamp: Date.now()
+            };
+        }
+        return null;
+    }
+}
+/**
+ * Detects exact duplicate RunView calls (same fingerprint).
+ */
+class DuplicateRunViewAnalyzer {
+    constructor() {
+        this.name = 'DuplicateRunViewAnalyzer';
+        this.category = 'Redundancy';
+    }
+    analyze(event, context) {
+        if (event.category !== 'RunView')
+            return null;
+        const pattern = context.patterns.get(event.fingerprint);
+        if (pattern && pattern.count >= 2) {
+            const params = event.params;
+            // Handle both single RunView (EntityName) and batch RunViews (Entities array)
+            const entityName = isSingleRunViewParams(params)
+                ? params.EntityName || 'Unknown'
+                : isBatchRunViewParams(params)
+                    ? params.Entities.join(', ')
+                    : 'Unknown';
+            return {
+                id: `duplicate-${event.fingerprint}-${Date.now()}`,
+                severity: 'warning',
+                analyzerName: this.name,
+                category: this.category,
+                title: 'Duplicate RunView Detected',
+                entityName,
+                message: `Identical RunView (${entityName}, same filter/orderBy) called ${pattern.count} times`,
+                suggestion: `Cache the result or use an engine to avoid redundant database queries`,
+                relatedEventIds: [event.id],
+                metadata: {
+                    callCount: pattern.count,
+                    totalTimeMs: pattern.totalElapsedMs,
+                    avgTimeMs: pattern.avgElapsedMs
+                },
+                timestamp: Date.now()
+            };
+        }
+        return null;
+    }
+}
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+const TELEMETRY_SETTINGS_KEY = '__MJ_TELEMETRY_SETTINGS__';
+const DEFAULT_SETTINGS = {
+    enabled: false,
+    level: 'standard',
+    categoryOverrides: {},
+    autoTrim: {
+        enabled: true,
+        maxEvents: 10000,
+        maxAgeMs: 30 * 60 * 1000 // 30 minutes
+    },
+    duplicateDetection: {
+        enabled: true,
+        windowMs: 60 * 1000 // 1 minute
+    },
+    analyzers: {
+        enabled: true,
+        dedupeWindowMs: 30000 // 30 seconds
+    }
+};
+// ============================================================================
+// TELEMETRY MANAGER
+// ============================================================================
+/**
+ * Singleton manager for telemetry tracking and analysis.
+ *
+ * Provides:
+ * - Event recording for various operation types with strongly-typed parameters
+ * - Pattern detection for identifying optimization opportunities
+ * - Pluggable analyzer system for custom rules
+ * - Integration with WarningManager for console output
+ */
+class TelemetryManager extends global_1.BaseSingleton {
+    /**
+     * Returns the singleton instance of TelemetryManager
+     */
+    static get Instance() {
+        return super.getInstance();
+    }
+    constructor() {
+        super();
+        this._events = [];
+        this._patterns = new Map();
+        this._activeEvents = new Map();
+        // Analyzer infrastructure
+        this._analyzers = [];
+        this._insights = [];
+        this._insightDedupeWindow = new Map();
+        this._settings = this.loadSettings();
+        this.registerBuiltInAnalyzers();
+    }
+    // ========== CONFIGURATION ==========
+    /**
+     * Get a copy of current settings
+     */
+    get Settings() {
+        return { ...this._settings };
+    }
+    /**
+     * Update telemetry settings
+     */
+    UpdateSettings(settings) {
+        this._settings = { ...this._settings, ...settings };
+        this.saveSettings();
+    }
+    /**
+     * Check if telemetry is globally enabled
+     */
+    get IsEnabled() {
+        return this._settings.enabled;
+    }
+    /**
+     * Enable or disable telemetry globally
+     */
+    SetEnabled(enabled) {
+        this._settings.enabled = enabled;
+        this.saveSettings();
+    }
+    /**
+     * Check if a specific category is enabled
+     */
+    IsCategoryEnabled(category) {
+        if (!this._settings.enabled)
+            return false;
+        const override = this._settings.categoryOverrides[category];
+        return override?.enabled ?? true;
+    }
+    /**
+     * Get the telemetry level for a specific category
+     */
+    GetLevelForCategory(category) {
+        const override = this._settings.categoryOverrides[category];
+        return override?.level ?? this._settings.level;
+    }
+    /**
+     * Get the numeric value for a telemetry level
+     */
+    GetLevelValue(level) {
+        return exports.TelemetryLevelValue[level];
+    }
+    /**
+     * Start tracking an event. Returns event ID for later completion, or null if disabled.
+     * Uses strongly-typed params based on the category.
+     */
+    StartEvent(category, operation, params, userId) {
+        if (!this.IsCategoryEnabled(category))
+            return null;
+        const level = this.GetLevelForCategory(category);
+        const levelValue = this.GetLevelValue(level);
+        const event = {
+            id: this.generateId(),
+            category,
+            operation,
+            fingerprint: this.generateFingerprint(category, params),
+            startTime: this.getTimestamp(),
+            userId,
+            params: levelValue >= exports.TelemetryLevelValue['standard'] ? params : {},
+            stackTrace: levelValue >= exports.TelemetryLevelValue['verbose'] ? this.captureStackTrace() : undefined,
+            memoryBefore: levelValue >= exports.TelemetryLevelValue['debug'] ? this.captureMemory() : undefined
+        };
+        this._activeEvents.set(event.id, event);
+        return event.id;
+    }
+    /**
+     * Complete an event that was started with StartEvent
+     * @param eventId - The event ID returned from StartEvent
+     * @param additionalParams - Optional additional parameters to merge into the event's params
+     *                           Useful for adding context like cacheHit, resultCount, etc.
+     */
+    EndEvent(eventId, additionalParams) {
+        if (!eventId)
+            return null;
+        const event = this._activeEvents.get(eventId);
+        if (!event)
+            return null;
+        this._activeEvents.delete(eventId);
+        // Merge additional params if provided
+        if (additionalParams) {
+            event.params = { ...event.params, ...additionalParams };
+        }
+        event.endTime = this.getTimestamp();
+        event.elapsedMs = event.endTime - event.startTime;
+        const level = this.GetLevelForCategory(event.category);
+        if (this.GetLevelValue(level) >= exports.TelemetryLevelValue['debug']) {
+            event.memoryAfter = this.captureMemory();
+        }
+        this._events.push(event);
+        this.updatePattern(event);
+        this.runAnalyzers(event);
+        this.trimIfNeeded();
+        return event;
+    }
+    /**
+     * Convenience method for recording a completed event directly with strong typing
+     */
+    RecordEvent(category, operation, params, elapsedMs, userId) {
+        if (!this.IsCategoryEnabled(category))
+            return;
+        const level = this.GetLevelForCategory(category);
+        const levelValue = this.GetLevelValue(level);
+        const now = this.getTimestamp();
+        const event = {
+            id: this.generateId(),
+            category,
+            operation,
+            fingerprint: this.generateFingerprint(category, params),
+            startTime: now - elapsedMs,
+            endTime: now,
+            elapsedMs,
+            userId,
+            params: levelValue >= exports.TelemetryLevelValue['standard'] ? params : {},
+            stackTrace: levelValue >= exports.TelemetryLevelValue['verbose'] ? this.captureStackTrace() : undefined
+        };
+        this._events.push(event);
+        this.updatePattern(event);
+        this.runAnalyzers(event);
+        this.trimIfNeeded();
+    }
+    // ========== PATTERN DETECTION ==========
+    updatePattern(event) {
+        if (!this._settings.duplicateDetection.enabled)
+            return;
+        let pattern = this._patterns.get(event.fingerprint);
+        const now = this.getTimestamp();
+        if (!pattern) {
+            pattern = {
+                fingerprint: event.fingerprint,
+                category: event.category,
+                operation: event.operation,
+                sampleParams: event.params,
+                count: 0,
+                totalElapsedMs: 0,
+                avgElapsedMs: 0,
+                minElapsedMs: Infinity,
+                maxElapsedMs: 0,
+                callerLocations: new Map(),
+                firstSeen: now,
+                lastSeen: now,
+                windowStartTime: now
+            };
+            this._patterns.set(event.fingerprint, pattern);
+        }
+        // Reset window if expired
+        if (now - pattern.windowStartTime > this._settings.duplicateDetection.windowMs) {
+            pattern.count = 0;
+            pattern.totalElapsedMs = 0;
+            pattern.callerLocations.clear();
+            pattern.windowStartTime = now;
+        }
+        // Update stats
+        pattern.count++;
+        pattern.lastSeen = now;
+        if (event.elapsedMs != null) {
+            pattern.totalElapsedMs += event.elapsedMs;
+            pattern.avgElapsedMs = pattern.totalElapsedMs / pattern.count;
+            pattern.minElapsedMs = Math.min(pattern.minElapsedMs, event.elapsedMs);
+            pattern.maxElapsedMs = Math.max(pattern.maxElapsedMs, event.elapsedMs);
+        }
+        // Track call sites
+        if (event.stackTrace) {
+            const location = this.extractCallerLocation(event.stackTrace);
+            pattern.callerLocations.set(location, (pattern.callerLocations.get(location) || 0) + 1);
+        }
+    }
+    // ========== QUERIES ==========
+    /**
+     * Get events matching the filter criteria
+     */
+    GetEvents(filter) {
+        let results = [...this._events];
+        if (filter?.category) {
+            results = results.filter(e => e.category === filter.category);
+        }
+        if (filter?.operation) {
+            results = results.filter(e => e.operation === filter.operation);
+        }
+        if (filter?.minElapsedMs != null) {
+            results = results.filter(e => (e.elapsedMs ?? 0) >= filter.minElapsedMs);
+        }
+        if (filter?.since != null) {
+            results = results.filter(e => e.startTime >= filter.since);
+        }
+        if (filter?.limit) {
+            results = results.slice(-filter.limit);
+        }
+        return results;
+    }
+    /**
+     * Get patterns matching the filter criteria
+     */
+    GetPatterns(filter) {
+        let results = [...this._patterns.values()];
+        if (filter?.category) {
+            results = results.filter(p => p.category === filter.category);
+        }
+        if (filter?.minCount != null) {
+            results = results.filter(p => p.count >= filter.minCount);
+        }
+        const sortBy = filter?.sortBy ?? 'count';
+        results.sort((a, b) => {
+            switch (sortBy) {
+                case 'count': return b.count - a.count;
+                case 'totalTime': return b.totalElapsedMs - a.totalElapsedMs;
+                case 'avgTime': return b.avgElapsedMs - a.avgElapsedMs;
+            }
+        });
+        return results;
+    }
+    /**
+     * Get patterns with duplicate calls (count >= minCount)
+     */
+    GetDuplicates(minCount = 2) {
+        return this.GetPatterns({ minCount, sortBy: 'count' });
+    }
+    /**
+     * Get active events that haven't completed yet
+     */
+    GetActiveEvents() {
+        return [...this._activeEvents.values()];
+    }
+    // ========== ANALYZER SYSTEM ==========
+    registerBuiltInAnalyzers() {
+        this.RegisterAnalyzer(new EngineOverlapAnalyzer());
+        this.RegisterAnalyzer(new SameEntityMultipleCallsAnalyzer());
+        this.RegisterAnalyzer(new ParallelizationOpportunityAnalyzer());
+        this.RegisterAnalyzer(new DuplicateRunViewAnalyzer());
+    }
+    /**
+     * Register a custom analyzer
+     */
+    RegisterAnalyzer(analyzer) {
+        this._analyzers.push(analyzer);
+    }
+    /**
+     * Unregister an analyzer by name
+     */
+    UnregisterAnalyzer(name) {
+        this._analyzers = this._analyzers.filter(a => a.name !== name);
+    }
+    /**
+     * Get all registered analyzers
+     */
+    GetAnalyzers() {
+        return [...this._analyzers];
+    }
+    /**
+     * Get insights matching the filter criteria
+     */
+    GetInsights(filter) {
+        let results = [...this._insights];
+        if (filter?.severity) {
+            results = results.filter(i => i.severity === filter.severity);
+        }
+        if (filter?.category) {
+            results = results.filter(i => i.category === filter.category);
+        }
+        if (filter?.entityName) {
+            results = results.filter(i => i.entityName === filter.entityName);
+        }
+        if (filter?.limit) {
+            results = results.slice(-filter.limit);
+        }
+        return results;
+    }
+    runAnalyzers(event) {
+        if (!this._settings.analyzers.enabled)
+            return;
+        const context = this.buildAnalyzerContext();
+        for (const analyzer of this._analyzers) {
+            try {
+                const insight = analyzer.analyze(event, context);
+                if (insight && this.shouldEmitInsight(insight)) {
+                    this._insights.push(insight);
+                    this.emitInsightWarning(insight);
+                }
+            }
+            catch (error) {
+                // Don't let analyzer errors break telemetry
+                console.warn(`Telemetry analyzer ${analyzer.name} error:`, error);
+            }
+        }
+    }
+    buildAnalyzerContext() {
+        return {
+            recentEvents: this._events.slice(-1000),
+            patterns: this._patterns,
+            getEngineLoadedEntities: () => {
+                // Integration with BaseEngineRegistry
+                const g = (0, global_1.GetGlobalObjectStore)();
+                if (g && g.__MJ_ENGINE_REGISTRY__) {
+                    return g.__MJ_ENGINE_REGISTRY__.GetEntityLoadTracking?.() || new Map();
+                }
+                return new Map();
+            }
+        };
+    }
+    shouldEmitInsight(insight) {
+        // Dedupe similar insights within a time window
+        const dedupeKey = `${insight.analyzerName}:${insight.entityName || ''}:${insight.title}`;
+        const lastEmit = this._insightDedupeWindow.get(dedupeKey);
+        const now = Date.now();
+        if (lastEmit && now - lastEmit < this._settings.analyzers.dedupeWindowMs) {
+            return false;
+        }
+        this._insightDedupeWindow.set(dedupeKey, now);
+        return true;
+    }
+    emitInsightWarning(insight) {
+        // Emit through WarningManager for console output
+        this.recordTelemetryInsightToWarningManager(insight);
+    }
+    /**
+     * Record a telemetry insight to the warning manager for debounced output
+     */
+    recordTelemetryInsightToWarningManager(insight) {
+        const config = global_1.WarningManager.Instance.GetConfig();
+        if (config.DisableWarnings)
+            return;
+        const severityIcon = {
+            'info': 'ℹ️',
+            'warning': '⚠️',
+            'optimization': '💡'
+        }[insight.severity];
+        const message = `${severityIcon} [Telemetry/${insight.category}] ${insight.title}\n` +
+            `   ${insight.message}\n` +
+            `   💡 ${insight.suggestion}`;
+        // Use console.info for telemetry insights to distinguish from warnings
+        console.info(message);
+    }
+    // ========== FINGERPRINT GENERATION WITH TYPE GUARDS ==========
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+    }
+    /**
+     * Generate a fingerprint for duplicate detection using type guards
+     */
+    generateFingerprint(category, params) {
+        let keyParams;
+        switch (category) {
+            case 'RunView':
+                keyParams = this.generateRunViewFingerprint(params);
+                break;
+            case 'RunQuery':
+                keyParams = this.generateRunQueryFingerprint(params);
+                break;
+            case 'Engine':
+                keyParams = this.generateEngineFingerprint(params);
+                break;
+            case 'AI':
+                keyParams = this.generateAIFingerprint(params);
+                break;
+            case 'Cache':
+                keyParams = this.generateCacheFingerprint(params);
+                break;
+            case 'Network':
+                keyParams = this.generateNetworkFingerprint(params);
+                break;
+            default:
+                keyParams = params;
+        }
+        return `${category}:${JSON.stringify(keyParams)}`;
+    }
+    /**
+     * Generate fingerprint for RunView operations
+     */
+    generateRunViewFingerprint(params) {
+        if (isBatchRunViewParams(params)) {
+            // Batch operation - create fingerprint from sorted entity list
+            const sortedEntities = [...params.Entities]
+                .map(e => e?.toLowerCase().trim())
+                .filter(Boolean)
+                .sort();
+            // Use a hash for long entity lists to keep fingerprint manageable
+            const entityKey = sortedEntities.length > 5
+                ? this.simpleHash(sortedEntities.join('|'))
+                : sortedEntities.join('|');
+            return {
+                batch: true,
+                batchSize: params.BatchSize,
+                entities: entityKey
+            };
+        }
+        else {
+            // Single operation
+            return {
+                entity: params.EntityName?.toLowerCase().trim(),
+                filter: params.ExtraFilter?.toLowerCase().trim(),
+                orderBy: params.OrderBy?.toLowerCase().trim(),
+                resultType: params.ResultType
+            };
+        }
+    }
+    /**
+     * Generate fingerprint for RunQuery operations
+     */
+    generateRunQueryFingerprint(params) {
+        if (isBatchRunQueryParams(params)) {
+            // Batch operation - create fingerprint from sorted query list
+            const sortedQueries = [...params.Queries]
+                .map(q => q?.toLowerCase().trim())
+                .filter(Boolean)
+                .sort();
+            const queryKey = sortedQueries.length > 5
+                ? this.simpleHash(sortedQueries.join('|'))
+                : sortedQueries.join('|');
+            return {
+                batch: true,
+                batchSize: params.BatchSize,
+                queries: queryKey
+            };
+        }
+        else {
+            return {
+                queryId: params.QueryID,
+                queryName: params.QueryName?.toLowerCase().trim(),
+                categoryPath: params.CategoryPath?.toLowerCase().trim()
+            };
+        }
+    }
+    /**
+     * Generate fingerprint for Engine operations
+     */
+    generateEngineFingerprint(params) {
+        return {
+            engine: params.engineClass,
+            operation: params.operation
+        };
+    }
+    /**
+     * Generate fingerprint for AI operations
+     */
+    generateAIFingerprint(params) {
+        return {
+            modelId: params.modelID,
+            modelName: params.modelName?.toLowerCase().trim(),
+            promptId: params.promptID,
+            promptName: params.promptName?.toLowerCase().trim(),
+            operationType: params.operationType
+        };
+    }
+    /**
+     * Generate fingerprint for Cache operations
+     */
+    generateCacheFingerprint(params) {
+        return {
+            cacheType: params.cacheType,
+            operation: params.operation,
+            entityName: params.entityName?.toLowerCase().trim(),
+            fingerprint: params.fingerprint
+        };
+    }
+    /**
+     * Generate fingerprint for Network operations
+     */
+    generateNetworkFingerprint(params) {
+        return {
+            method: params.method,
+            url: params.url
+        };
+    }
+    /**
+     * Simple hash function for creating short fingerprints from long strings.
+     * Not cryptographic, just for deduplication purposes.
+     */
+    simpleHash(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        // Convert to hex and ensure positive
+        return (hash >>> 0).toString(16);
+    }
+    captureStackTrace() {
+        const stack = new Error().stack || '';
+        return this.cleanStackTrace(stack);
+    }
+    cleanStackTrace(stack) {
+        const lines = stack.split('\n');
+        return lines
+            .filter(line => {
+            // Filter out noise
+            if (line.includes('TelemetryManager'))
+                return false;
+            if (line.includes('node_modules'))
+                return false;
+            if (line.includes('webpack'))
+                return false;
+            if (line.includes('zone.js'))
+                return false;
+            if (line.includes('<anonymous>'))
+                return false;
+            return true;
+        })
+            .slice(0, 10) // Limit depth
+            .join('\n');
+    }
+    extractCallerLocation(stack) {
+        const lines = stack.split('\n');
+        // Return first meaningful line
+        return lines[0] || 'unknown';
+    }
+    captureMemory() {
+        // Node.js
+        if (typeof process !== 'undefined' && process.memoryUsage) {
+            const mem = process.memoryUsage();
+            return {
+                heapUsed: mem.heapUsed,
+                heapTotal: mem.heapTotal,
+                timestamp: Date.now()
+            };
+        }
+        // Browser (Chrome only)
+        if (typeof performance !== 'undefined') {
+            const perfWithMemory = performance;
+            if (perfWithMemory.memory) {
+                return {
+                    heapUsed: perfWithMemory.memory.usedJSHeapSize,
+                    heapTotal: perfWithMemory.memory.totalJSHeapSize,
+                    timestamp: Date.now()
+                };
+            }
+        }
+        return { heapUsed: 0, heapTotal: 0, timestamp: Date.now() };
+    }
+    getTimestamp() {
+        // Use performance.now() if available for better precision
+        if (typeof performance !== 'undefined' && performance.now) {
+            return performance.now();
+        }
+        return Date.now();
+    }
+    trimIfNeeded() {
+        if (!this._settings.autoTrim.enabled)
+            return;
+        const { maxEvents, maxAgeMs } = this._settings.autoTrim;
+        const now = this.getTimestamp();
+        // Trim by age
+        if (maxAgeMs) {
+            this._events = this._events.filter(e => now - e.startTime < maxAgeMs);
+        }
+        // Trim by count
+        if (maxEvents && this._events.length > maxEvents) {
+            this._events = this._events.slice(-maxEvents);
+        }
+    }
+    loadSettings() {
+        try {
+            // Use localStorage if available (browser), otherwise use global store
+            if (typeof localStorage !== 'undefined') {
+                const stored = localStorage.getItem(TELEMETRY_SETTINGS_KEY);
+                if (stored) {
+                    return { ...DEFAULT_SETTINGS, ...JSON.parse(stored) };
+                }
+            }
+        }
+        catch {
+            // Ignore storage errors
+        }
+        return { ...DEFAULT_SETTINGS };
+    }
+    saveSettings() {
+        try {
+            if (typeof localStorage !== 'undefined') {
+                localStorage.setItem(TELEMETRY_SETTINGS_KEY, JSON.stringify(this._settings));
+            }
+        }
+        catch {
+            // Ignore storage errors
+        }
+    }
+    // ========== CLEAR / RESET ==========
+    /**
+     * Clear all recorded events and patterns
+     */
+    Clear() {
+        this._events = [];
+        this._patterns.clear();
+        this._activeEvents.clear();
+    }
+    /**
+     * Clear only patterns (keeps events)
+     */
+    ClearPatterns() {
+        this._patterns.clear();
+    }
+    /**
+     * Clear insights
+     */
+    ClearInsights() {
+        this._insights = [];
+        this._insightDedupeWindow.clear();
+    }
+    /**
+     * Reset everything including settings
+     */
+    Reset() {
+        this.Clear();
+        this.ClearInsights();
+        this._settings = { ...DEFAULT_SETTINGS };
+        this.saveSettings();
+    }
+    // ========== STATISTICS ==========
+    /**
+     * Get summary statistics
+     */
+    GetStats() {
+        const byCategory = {
+            RunView: { events: 0, totalMs: 0 },
+            RunQuery: { events: 0, totalMs: 0 },
+            Engine: { events: 0, totalMs: 0 },
+            Network: { events: 0, totalMs: 0 },
+            AI: { events: 0, totalMs: 0 },
+            Cache: { events: 0, totalMs: 0 },
+            Custom: { events: 0, totalMs: 0 }
+        };
+        for (const event of this._events) {
+            byCategory[event.category].events++;
+            byCategory[event.category].totalMs += event.elapsedMs || 0;
+        }
+        const byCategoryWithAvg = {};
+        for (const cat of Object.keys(byCategory)) {
+            const data = byCategory[cat];
+            byCategoryWithAvg[cat] = {
+                events: data.events,
+                avgMs: data.events > 0 ? data.totalMs / data.events : 0
+            };
+        }
+        return {
+            totalEvents: this._events.length,
+            totalPatterns: this._patterns.size,
+            totalInsights: this._insights.length,
+            activeEvents: this._activeEvents.size,
+            byCategory: byCategoryWithAvg
+        };
+    }
+}
+exports.TelemetryManager = TelemetryManager;
+//# sourceMappingURL=telemetryManager.js.map