@memberjunction/server 2.127.0 → 2.129.0

package/dist/resolvers/TelemetryResolver.js

@@ -0,0 +1,731 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Arg, Ctx, Field, InputType, Int, ObjectType, Query, Resolver, Float } from 'type-graphql';
+import { TelemetryManager } from '@memberjunction/core';
+let MemorySnapshotGQL = class MemorySnapshotGQL {
+    heapUsed;
+    heapTotal;
+    timestamp;
+};
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MemorySnapshotGQL.prototype, "heapUsed", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MemorySnapshotGQL.prototype, "heapTotal", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MemorySnapshotGQL.prototype, "timestamp", void 0);
+MemorySnapshotGQL = __decorate([
+    ObjectType()
+], MemorySnapshotGQL);
+export { MemorySnapshotGQL };
+let TelemetryEventGQL = class TelemetryEventGQL {
+    id;
+    category;
+    operation;
+    fingerprint;
+    startTime;
+    endTime;
+    elapsedMs;
+    userId;
+    params;
+    tags;
+    stackTrace;
+    memoryBefore;
+    memoryAfter;
+    parentEventId;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryEventGQL.prototype, "id", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryEventGQL.prototype, "category", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryEventGQL.prototype, "operation", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryEventGQL.prototype, "fingerprint", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], TelemetryEventGQL.prototype, "startTime", void 0);
+__decorate([
+    Field(() => Float, { nullable: true }),
+    __metadata("design:type", Number)
+], TelemetryEventGQL.prototype, "endTime", void 0);
+__decorate([
+    Field(() => Float, { nullable: true }),
+    __metadata("design:type", Number)
+], TelemetryEventGQL.prototype, "elapsedMs", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryEventGQL.prototype, "userId", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryEventGQL.prototype, "params", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], TelemetryEventGQL.prototype, "tags", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryEventGQL.prototype, "stackTrace", void 0);
+__decorate([
+    Field(() => MemorySnapshotGQL, { nullable: true }),
+    __metadata("design:type", MemorySnapshotGQL)
+], TelemetryEventGQL.prototype, "memoryBefore", void 0);
+__decorate([
+    Field(() => MemorySnapshotGQL, { nullable: true }),
+    __metadata("design:type", MemorySnapshotGQL)
+], TelemetryEventGQL.prototype, "memoryAfter", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryEventGQL.prototype, "parentEventId", void 0);
+TelemetryEventGQL = __decorate([
+    ObjectType()
+], TelemetryEventGQL);
+export { TelemetryEventGQL };
+let CallerLocationGQL = class CallerLocationGQL {
+    location;
+    count;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CallerLocationGQL.prototype, "location", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], CallerLocationGQL.prototype, "count", void 0);
+CallerLocationGQL = __decorate([
+    ObjectType()
+], CallerLocationGQL);
+export { CallerLocationGQL };
+let TelemetryPatternGQL = class TelemetryPatternGQL {
+    fingerprint;
+    category;
+    operation;
+    sampleParams;
+    count;
+    totalElapsedMs;
+    avgElapsedMs;
+    minElapsedMs;
+    maxElapsedMs;
+    callerLocations;
+    firstSeen;
+    lastSeen;
+    windowStartTime;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryPatternGQL.prototype, "fingerprint", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryPatternGQL.prototype, "category", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryPatternGQL.prototype, "operation", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryPatternGQL.prototype, "sampleParams", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], TelemetryPatternGQL.prototype, "count", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], TelemetryPatternGQL.prototype, "totalElapsedMs", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], TelemetryPatternGQL.prototype, "avgElapsedMs", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], TelemetryPatternGQL.prototype, "minElapsedMs", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], TelemetryPatternGQL.prototype, "maxElapsedMs", void 0);
+__decorate([
+    Field(() => [CallerLocationGQL]),
+    __metadata("design:type", Array)
+], TelemetryPatternGQL.prototype, "callerLocations", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], TelemetryPatternGQL.prototype, "firstSeen", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], TelemetryPatternGQL.prototype, "lastSeen", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], TelemetryPatternGQL.prototype, "windowStartTime", void 0);
+TelemetryPatternGQL = __decorate([
+    ObjectType()
+], TelemetryPatternGQL);
+export { TelemetryPatternGQL };
+let TelemetryInsightGQL = class TelemetryInsightGQL {
+    id;
+    severity;
+    analyzerName;
+    category;
+    title;
+    message;
+    suggestion;
+    relatedEventIds;
+    entityName;
+    metadata;
+    timestamp;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryInsightGQL.prototype, "id", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryInsightGQL.prototype, "severity", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryInsightGQL.prototype, "analyzerName", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryInsightGQL.prototype, "category", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryInsightGQL.prototype, "title", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryInsightGQL.prototype, "message", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetryInsightGQL.prototype, "suggestion", void 0);
+__decorate([
+    Field(() => [String]),
+    __metadata("design:type", Array)
+], TelemetryInsightGQL.prototype, "relatedEventIds", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryInsightGQL.prototype, "entityName", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryInsightGQL.prototype, "metadata", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], TelemetryInsightGQL.prototype, "timestamp", void 0);
+TelemetryInsightGQL = __decorate([
+    ObjectType()
+], TelemetryInsightGQL);
+export { TelemetryInsightGQL };
+let CategoryStatsGQL = class CategoryStatsGQL {
+    category;
+    events;
+    avgMs;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CategoryStatsGQL.prototype, "category", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], CategoryStatsGQL.prototype, "events", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], CategoryStatsGQL.prototype, "avgMs", void 0);
+CategoryStatsGQL = __decorate([
+    ObjectType()
+], CategoryStatsGQL);
+export { CategoryStatsGQL };
+let TelemetryStatsGQL = class TelemetryStatsGQL {
+    totalEvents;
+    totalPatterns;
+    totalInsights;
+    activeEvents;
+    byCategory;
+};
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], TelemetryStatsGQL.prototype, "totalEvents", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], TelemetryStatsGQL.prototype, "totalPatterns", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], TelemetryStatsGQL.prototype, "totalInsights", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], TelemetryStatsGQL.prototype, "activeEvents", void 0);
+__decorate([
+    Field(() => [CategoryStatsGQL]),
+    __metadata("design:type", Array)
+], TelemetryStatsGQL.prototype, "byCategory", void 0);
+TelemetryStatsGQL = __decorate([
+    ObjectType()
+], TelemetryStatsGQL);
+export { TelemetryStatsGQL };
+let CategoryOverrideGQL = class CategoryOverrideGQL {
+    category;
+    enabled;
+    level;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CategoryOverrideGQL.prototype, "category", void 0);
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], CategoryOverrideGQL.prototype, "enabled", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], CategoryOverrideGQL.prototype, "level", void 0);
+CategoryOverrideGQL = __decorate([
+    ObjectType()
+], CategoryOverrideGQL);
+export { CategoryOverrideGQL };
+let AutoTrimSettingsGQL = class AutoTrimSettingsGQL {
+    enabled;
+    maxEvents;
+    maxAgeMs;
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], AutoTrimSettingsGQL.prototype, "enabled", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], AutoTrimSettingsGQL.prototype, "maxEvents", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], AutoTrimSettingsGQL.prototype, "maxAgeMs", void 0);
+AutoTrimSettingsGQL = __decorate([
+    ObjectType()
+], AutoTrimSettingsGQL);
+export { AutoTrimSettingsGQL };
+let DuplicateDetectionSettingsGQL = class DuplicateDetectionSettingsGQL {
+    enabled;
+    windowMs;
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], DuplicateDetectionSettingsGQL.prototype, "enabled", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], DuplicateDetectionSettingsGQL.prototype, "windowMs", void 0);
+DuplicateDetectionSettingsGQL = __decorate([
+    ObjectType()
+], DuplicateDetectionSettingsGQL);
+export { DuplicateDetectionSettingsGQL };
+let AnalyzerSettingsGQL = class AnalyzerSettingsGQL {
+    enabled;
+    dedupeWindowMs;
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], AnalyzerSettingsGQL.prototype, "enabled", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], AnalyzerSettingsGQL.prototype, "dedupeWindowMs", void 0);
+AnalyzerSettingsGQL = __decorate([
+    ObjectType()
+], AnalyzerSettingsGQL);
+export { AnalyzerSettingsGQL };
+let TelemetrySettingsGQL = class TelemetrySettingsGQL {
+    enabled;
+    level;
+    categoryOverrides;
+    autoTrim;
+    duplicateDetection;
+    analyzers;
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], TelemetrySettingsGQL.prototype, "enabled", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TelemetrySettingsGQL.prototype, "level", void 0);
+__decorate([
+    Field(() => [CategoryOverrideGQL]),
+    __metadata("design:type", Array)
+], TelemetrySettingsGQL.prototype, "categoryOverrides", void 0);
+__decorate([
+    Field(() => AutoTrimSettingsGQL),
+    __metadata("design:type", AutoTrimSettingsGQL)
+], TelemetrySettingsGQL.prototype, "autoTrim", void 0);
+__decorate([
+    Field(() => DuplicateDetectionSettingsGQL),
+    __metadata("design:type", DuplicateDetectionSettingsGQL)
+], TelemetrySettingsGQL.prototype, "duplicateDetection", void 0);
+__decorate([
+    Field(() => AnalyzerSettingsGQL),
+    __metadata("design:type", AnalyzerSettingsGQL)
+], TelemetrySettingsGQL.prototype, "analyzers", void 0);
+TelemetrySettingsGQL = __decorate([
+    ObjectType()
+], TelemetrySettingsGQL);
+export { TelemetrySettingsGQL };
+let TelemetryEventFilterInput = class TelemetryEventFilterInput {
+    category;
+    operation;
+    minElapsedMs;
+    since;
+    limit;
+};
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryEventFilterInput.prototype, "category", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryEventFilterInput.prototype, "operation", void 0);
+__decorate([
+    Field(() => Float, { nullable: true }),
+    __metadata("design:type", Number)
+], TelemetryEventFilterInput.prototype, "minElapsedMs", void 0);
+__decorate([
+    Field(() => Float, { nullable: true }),
+    __metadata("design:type", Number)
+], TelemetryEventFilterInput.prototype, "since", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], TelemetryEventFilterInput.prototype, "limit", void 0);
+TelemetryEventFilterInput = __decorate([
+    InputType()
+], TelemetryEventFilterInput);
+export { TelemetryEventFilterInput };
+let TelemetryPatternFilterInput = class TelemetryPatternFilterInput {
+    category;
+    minCount;
+    sortBy;
+};
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryPatternFilterInput.prototype, "category", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], TelemetryPatternFilterInput.prototype, "minCount", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryPatternFilterInput.prototype, "sortBy", void 0);
+TelemetryPatternFilterInput = __decorate([
+    InputType()
+], TelemetryPatternFilterInput);
+export { TelemetryPatternFilterInput };
+let TelemetryInsightFilterInput = class TelemetryInsightFilterInput {
+    severity;
+    category;
+    entityName;
+    limit;
+};
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryInsightFilterInput.prototype, "severity", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryInsightFilterInput.prototype, "category", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], TelemetryInsightFilterInput.prototype, "entityName", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], TelemetryInsightFilterInput.prototype, "limit", void 0);
+TelemetryInsightFilterInput = __decorate([
+    InputType()
+], TelemetryInsightFilterInput);
+export { TelemetryInsightFilterInput };
+let TelemetryResolver = class TelemetryResolver {
+    GetServerTelemetrySettings(_context) {
+        const tm = TelemetryManager.Instance;
+        const settings = tm.Settings;
+        const categoryOverrides = [];
+        if (settings.categoryOverrides) {
+            for (const [category, override] of Object.entries(settings.categoryOverrides)) {
+                if (override) {
+                    categoryOverrides.push({
+                        category,
+                        enabled: override.enabled,
+                        level: override.level
+                    });
+                }
+            }
+        }
+        return {
+            enabled: settings.enabled,
+            level: settings.level,
+            categoryOverrides,
+            autoTrim: {
+                enabled: settings.autoTrim.enabled,
+                maxEvents: settings.autoTrim.maxEvents,
+                maxAgeMs: settings.autoTrim.maxAgeMs
+            },
+            duplicateDetection: {
+                enabled: settings.duplicateDetection.enabled,
+                windowMs: settings.duplicateDetection.windowMs
+            },
+            analyzers: {
+                enabled: settings.analyzers.enabled,
+                dedupeWindowMs: settings.analyzers.dedupeWindowMs
+            }
+        };
+    }
+    GetServerTelemetryStats(_context) {
+        const tm = TelemetryManager.Instance;
+        const stats = tm.GetStats();
+        const byCategory = Object.entries(stats.byCategory).map(([category, data]) => ({
+            category,
+            events: data.events,
+            avgMs: data.avgMs
+        }));
+        return {
+            totalEvents: stats.totalEvents,
+            totalPatterns: stats.totalPatterns,
+            totalInsights: stats.totalInsights,
+            activeEvents: stats.activeEvents,
+            byCategory
+        };
+    }
+    GetServerTelemetryEvents(_context, filter) {
+        const tm = TelemetryManager.Instance;
+        const events = tm.GetEvents({
+            category: filter?.category,
+            operation: filter?.operation,
+            minElapsedMs: filter?.minElapsedMs ?? undefined,
+            since: filter?.since ?? undefined,
+            limit: filter?.limit ?? undefined
+        });
+        return events.map(e => ({
+            id: e.id,
+            category: e.category,
+            operation: e.operation,
+            fingerprint: e.fingerprint,
+            startTime: e.startTime,
+            endTime: e.endTime,
+            elapsedMs: e.elapsedMs,
+            userId: e.userId,
+            params: JSON.stringify(e.params),
+            tags: e.tags,
+            stackTrace: e.stackTrace,
+            memoryBefore: e.memoryBefore,
+            memoryAfter: e.memoryAfter,
+            parentEventId: e.parentEventId
+        }));
+    }
+    GetServerTelemetryPatterns(_context, filter) {
+        const tm = TelemetryManager.Instance;
+        const patterns = tm.GetPatterns({
+            category: filter?.category,
+            minCount: filter?.minCount ?? undefined,
+            sortBy: filter?.sortBy
+        });
+        return patterns.map(p => {
+            const callerLocations = [];
+            p.callerLocations.forEach((count, location) => {
+                callerLocations.push({ location, count });
+            });
+            return {
+                fingerprint: p.fingerprint,
+                category: p.category,
+                operation: p.operation,
+                sampleParams: JSON.stringify(p.sampleParams),
+                count: p.count,
+                totalElapsedMs: p.totalElapsedMs,
+                avgElapsedMs: p.avgElapsedMs,
+                minElapsedMs: p.minElapsedMs === Infinity ? 0 : p.minElapsedMs,
+                maxElapsedMs: p.maxElapsedMs,
+                callerLocations,
+                firstSeen: p.firstSeen,
+                lastSeen: p.lastSeen,
+                windowStartTime: p.windowStartTime
+            };
+        });
+    }
+    GetServerTelemetryInsights(_context, filter) {
+        const tm = TelemetryManager.Instance;
+        const insights = tm.GetInsights({
+            severity: filter?.severity,
+            category: filter?.category,
+            entityName: filter?.entityName,
+            limit: filter?.limit ?? undefined
+        });
+        return insights.map(i => ({
+            id: i.id,
+            severity: i.severity,
+            analyzerName: i.analyzerName,
+            category: i.category,
+            title: i.title,
+            message: i.message,
+            suggestion: i.suggestion,
+            relatedEventIds: i.relatedEventIds,
+            entityName: i.entityName,
+            metadata: i.metadata ? JSON.stringify(i.metadata) : undefined,
+            timestamp: i.timestamp
+        }));
+    }
+    GetServerTelemetryDuplicates(_context, minCount) {
+        const tm = TelemetryManager.Instance;
+        const patterns = tm.GetDuplicates(minCount);
+        return patterns.map(p => {
+            const callerLocations = [];
+            p.callerLocations.forEach((count, location) => {
+                callerLocations.push({ location, count });
+            });
+            return {
+                fingerprint: p.fingerprint,
+                category: p.category,
+                operation: p.operation,
+                sampleParams: JSON.stringify(p.sampleParams),
+                count: p.count,
+                totalElapsedMs: p.totalElapsedMs,
+                avgElapsedMs: p.avgElapsedMs,
+                minElapsedMs: p.minElapsedMs === Infinity ? 0 : p.minElapsedMs,
+                maxElapsedMs: p.maxElapsedMs,
+                callerLocations,
+                firstSeen: p.firstSeen,
+                lastSeen: p.lastSeen,
+                windowStartTime: p.windowStartTime
+            };
+        });
+    }
+    GetServerTelemetryActiveEvents(_context) {
+        const tm = TelemetryManager.Instance;
+        const events = tm.GetActiveEvents();
+        return events.map(e => ({
+            id: e.id,
+            category: e.category,
+            operation: e.operation,
+            fingerprint: e.fingerprint,
+            startTime: e.startTime,
+            endTime: e.endTime,
+            elapsedMs: e.elapsedMs,
+            userId: e.userId,
+            params: JSON.stringify(e.params),
+            tags: e.tags,
+            stackTrace: e.stackTrace,
+            memoryBefore: e.memoryBefore,
+            memoryAfter: e.memoryAfter,
+            parentEventId: e.parentEventId
+        }));
+    }
+};
+__decorate([
+    Query(() => TelemetrySettingsGQL),
+    __param(0, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", TelemetrySettingsGQL)
+], TelemetryResolver.prototype, "GetServerTelemetrySettings", null);
+__decorate([
+    Query(() => TelemetryStatsGQL),
+    __param(0, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", TelemetryStatsGQL)
+], TelemetryResolver.prototype, "GetServerTelemetryStats", null);
+__decorate([
+    Query(() => [TelemetryEventGQL]),
+    __param(0, Ctx()),
+    __param(1, Arg('filter', () => TelemetryEventFilterInput, { nullable: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, TelemetryEventFilterInput]),
+    __metadata("design:returntype", Array)
+], TelemetryResolver.prototype, "GetServerTelemetryEvents", null);
+__decorate([
+    Query(() => [TelemetryPatternGQL]),
+    __param(0, Ctx()),
+    __param(1, Arg('filter', () => TelemetryPatternFilterInput, { nullable: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, TelemetryPatternFilterInput]),
+    __metadata("design:returntype", Array)
+], TelemetryResolver.prototype, "GetServerTelemetryPatterns", null);
+__decorate([
+    Query(() => [TelemetryInsightGQL]),
+    __param(0, Ctx()),
+    __param(1, Arg('filter', () => TelemetryInsightFilterInput, { nullable: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, TelemetryInsightFilterInput]),
+    __metadata("design:returntype", Array)
+], TelemetryResolver.prototype, "GetServerTelemetryInsights", null);
+__decorate([
+    Query(() => [TelemetryPatternGQL]),
+    __param(0, Ctx()),
+    __param(1, Arg('minCount', () => Int, { defaultValue: 2 })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number]),
+    __metadata("design:returntype", Array)
+], TelemetryResolver.prototype, "GetServerTelemetryDuplicates", null);
+__decorate([
+    Query(() => [TelemetryEventGQL]),
+    __param(0, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Array)
+], TelemetryResolver.prototype, "GetServerTelemetryActiveEvents", null);
+TelemetryResolver = __decorate([
+    Resolver()
+], TelemetryResolver);
+export { TelemetryResolver };
+//# sourceMappingURL=TelemetryResolver.js.map