apm-optima 0.0.1

package/dist/adapters/http.adapter.d.ts

@@ -0,0 +1,12 @@
+export type RequestRequiredData = Readonly<{
+    method: string;
+    endpoint: string;
+    clientIp?: string;
+}>;
+export type ResponseRequiredData = Readonly<{
+    statusCode: number;
+}>;
+export interface HttpAdapter<TRequest, TResponse> {
+    getRequest(request: TRequest): RequestRequiredData;
+    getResponse(response: TResponse): ResponseRequiredData;
+}

package/dist/adapters/http.adapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/adapters/websocket.adapter.d.ts

@@ -0,0 +1,5 @@
+export interface WebSocketAdapter {
+    init(): void;
+    broadcast(event: string, data: unknown): void;
+    disconnect(): void;
+}

package/dist/adapters/websocket.adapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/config.manager.d.ts

@@ -0,0 +1,12 @@
+import { ConfigOptions, ReadonlyConfig } from './config.types';
+export declare class ConfigManager {
+    private static instance;
+    private config;
+    private readonly defaultConfig;
+    private constructor();
+    static getInstance(): ConfigManager;
+    initialize(userOptions?: ConfigOptions): ReadonlyConfig;
+    get(): ReadonlyConfig;
+    private validateAndSanitize;
+}
+export declare const getConfig: () => ReadonlyConfig;

package/dist/config/config.manager.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = exports.ConfigManager = void 0;
+class ConfigManager {
+    static instance;
+    config;
+    defaultConfig = Object.freeze({
+        dashboardPath: '/optima-metrics',
+        simulation: {
+            intervalMs: 100,
+            requestsPerTick: 20,
+        },
+        publisher: {
+            intervalMs: 1000,
+            slowLatencyThresholdMs: 500,
+            eventLoopLagThresholdMs: 100,
+            eventLoopResolutionMs: 20,
+        },
+        tickIntervalMs: 250,
+        excludePaths: [
+            '/_next/*',
+            '/_next/**',
+            '*.map',
+            '*.js',
+            '*.css',
+            '/favicon.ico',
+            '/metrics_pack',
+            '/',
+            '/health',
+            '/optima-metrics/**',
+            '/optima-metrics/*',
+        ], //! OPTIMIZE THIS
+        consoleLog: true,
+        ringBufferSize: 60,
+        alertBufferSize: 100,
+    });
+    constructor() {
+        this.config = this.defaultConfig;
+    }
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    initialize(userOptions) {
+        const validated = this.validateAndSanitize(userOptions);
+        this.config = Object.freeze({
+            ...this.defaultConfig,
+            ...validated
+        });
+        return this.config;
+    }
+    get() {
+        return this.config;
+    }
+    validateAndSanitize(options) {
+        if (!options) {
+            return {};
+        }
+        const sanitized = {};
+        if (options.dashboardPath !== undefined) {
+            if (options.dashboardPath === false) {
+                sanitized.dashboardPath = false;
+            }
+            else {
+                sanitized.dashboardPath = String(options.dashboardPath);
+            }
+        }
+        if (options.simulation !== undefined) {
+            if (typeof options.simulation === 'boolean') {
+                sanitized.simulation = options.simulation;
+            }
+            else {
+                sanitized.simulation = {
+                    intervalMs: Math.max(1, options.simulation.intervalMs),
+                    requestsPerTick: Math.max(1, options.simulation.requestsPerTick),
+                };
+            }
+        }
+        if (options.publisher !== undefined) {
+            sanitized.publisher = {
+                intervalMs: Math.max(1, options.publisher.intervalMs),
+                slowLatencyThresholdMs: Math.max(1, options.publisher.slowLatencyThresholdMs),
+                eventLoopLagThresholdMs: Math.max(1, options.publisher.eventLoopLagThresholdMs),
+                eventLoopResolutionMs: options.publisher.eventLoopResolutionMs !== undefined
+                    ? Math.max(1, options.publisher.eventLoopResolutionMs)
+                    : undefined,
+            };
+        }
+        if (options.tickIntervalMs !== undefined) {
+            sanitized.tickIntervalMs = Math.max(1, options.tickIntervalMs);
+        }
+        if (Array.isArray(options.excludePaths)) {
+            sanitized.excludePaths = options.excludePaths.filter(path => typeof path === 'string');
+        }
+        if (options.consoleLog !== undefined) {
+            sanitized.consoleLog = Boolean(options.consoleLog);
+        }
+        if (options.ringBufferSize !== undefined) {
+            sanitized.ringBufferSize = Math.max(1, options.ringBufferSize);
+        }
+        if (options.alertBufferSize !== undefined) {
+            sanitized.alertBufferSize = Math.max(1, options.alertBufferSize);
+        }
+        return sanitized;
+    }
+}
+exports.ConfigManager = ConfigManager;
+const getConfig = () => ConfigManager.getInstance().get();
+exports.getConfig = getConfig;

package/dist/config/config.types.d.ts

@@ -0,0 +1,19 @@
+export interface ConfigOptions {
+    dashboardPath?: string | false;
+    simulation?: false | {
+        intervalMs: number;
+        requestsPerTick: number;
+    };
+    publisher?: {
+        intervalMs: number;
+        slowLatencyThresholdMs: number;
+        eventLoopLagThresholdMs: number;
+        eventLoopResolutionMs?: number;
+    };
+    tickIntervalMs?: number;
+    excludePaths?: string[];
+    consoleLog?: boolean;
+    ringBufferSize?: number;
+    alertBufferSize?: number;
+}
+export type ReadonlyConfig = Readonly<Required<ConfigOptions>>;

package/dist/config/config.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './config.types';
+export * from './config.manager';

package/dist/config/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config.types"), exports);
+__exportStar(require("./config.manager"), exports);

package/dist/core/delivery/index.d.ts

@@ -0,0 +1,2 @@
+export * from './metrics.publisher';
+export * from './websocket.events';

package/dist/core/delivery/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./metrics.publisher"), exports);
+__exportStar(require("./websocket.events"), exports);

package/dist/core/delivery/metrics.publisher.d.ts

@@ -0,0 +1,18 @@
+import type { WebSocketAdapter } from "../../adapters/websocket.adapter";
+import type { SystemStaticInfo, AnalyticsData, DashboardData, HealthData } from "../domain";
+export interface MetricsDataProvider {
+    getSystemStaticInfo(): SystemStaticInfo;
+    getDashboardData(): DashboardData;
+    getAnalyticsData(): AnalyticsData;
+    getHealthData(): HealthData;
+}
+export declare class MetricsPublisher {
+    private readonly provider;
+    private readonly websocket;
+    private readonly intervalMs;
+    private interval?;
+    constructor(provider: MetricsDataProvider, websocket: WebSocketAdapter, intervalMs?: number);
+    start(): void;
+    stop(): void;
+    private publish;
+}

package/dist/core/delivery/metrics.publisher.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsPublisher = void 0;
+const websocket_events_1 = require("./websocket.events");
+class MetricsPublisher {
+    provider;
+    websocket;
+    intervalMs;
+    interval;
+    constructor(provider, websocket, intervalMs = 1000) {
+        this.provider = provider;
+        this.websocket = websocket;
+        this.intervalMs = intervalMs;
+    }
+    start() {
+        if (this.interval)
+            return;
+        this.interval = setInterval(() => {
+            this.publish();
+        }, this.intervalMs);
+    }
+    stop() {
+        if (!this.interval)
+            return;
+        clearInterval(this.interval);
+        this.interval = undefined;
+    }
+    publish() {
+        //? consider sending only the changed data instead of sending all data every time
+        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_SYSTEM_DATA, this.provider.getSystemStaticInfo());
+        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_DASHBOARD_DATA, this.provider.getDashboardData());
+        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_ANALYTICS_DATA, this.provider.getAnalyticsData());
+        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_HEALTH_DATA, this.provider.getHealthData());
+    }
+}
+exports.MetricsPublisher = MetricsPublisher;

package/dist/core/delivery/websocket.events.d.ts

@@ -0,0 +1,12 @@
+export declare enum WebSocketEvents {
+    REQUEST_CONFIGURATION = "request-configuration",
+    RESPONSE_CONFIGURATION = "response-configuration",
+    REQUEST_SYSTEM_DATA = "request-system-data",
+    RESPONSE_SYSTEM_DATA = "response-system-data",
+    REQUEST_DASHBOARD_DATA = "request-dashboard-data",
+    RESPONSE_DASHBOARD_DATA = "response-dashboard-data",
+    REQUEST_ANALYTICS_DATA = "request-analytics-data",
+    RESPONSE_ANALYTICS_DATA = "response-analytics-data",
+    REQUEST_HEALTH_DATA = "request-health-data",
+    RESPONSE_HEALTH_DATA = "response-health-data"
+}

package/dist/core/delivery/websocket.events.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketEvents = void 0;
+var WebSocketEvents;
+(function (WebSocketEvents) {
+    WebSocketEvents["REQUEST_CONFIGURATION"] = "request-configuration";
+    WebSocketEvents["RESPONSE_CONFIGURATION"] = "response-configuration";
+    WebSocketEvents["REQUEST_SYSTEM_DATA"] = "request-system-data";
+    WebSocketEvents["RESPONSE_SYSTEM_DATA"] = "response-system-data";
+    WebSocketEvents["REQUEST_DASHBOARD_DATA"] = "request-dashboard-data";
+    WebSocketEvents["RESPONSE_DASHBOARD_DATA"] = "response-dashboard-data";
+    WebSocketEvents["REQUEST_ANALYTICS_DATA"] = "request-analytics-data";
+    WebSocketEvents["RESPONSE_ANALYTICS_DATA"] = "response-analytics-data";
+    WebSocketEvents["REQUEST_HEALTH_DATA"] = "request-health-data";
+    WebSocketEvents["RESPONSE_HEALTH_DATA"] = "response-health-data";
+})(WebSocketEvents || (exports.WebSocketEvents = WebSocketEvents = {}));

package/dist/core/domain/common.types.d.ts

@@ -0,0 +1,44 @@
+export type ConnectionStatus = 'ONLINE' | 'OFFLINE' | 'CONNECTING' | 'DISCONNECTED';
+export type HealthStatus = 'HEALTHY' | 'DEGRADED' | 'UNHEALTHY' | 'UNKNOWN';
+export type SeverityLevel = 'info' | 'advisory' | 'warning' | 'critical';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
+export type StatusCategory = '2xx' | '3xx' | '4xx' | '5xx' | 'unknown';
+/**
+ * Represents a network route with its associated HTTP method and path.
+ * @property {HttpMethod | string} method - The HTTP method for the route (e.g., GET, POST).
+ * @property {string} route - The path of the route (e.g., '/api/users').
+ */
+export interface EndpointRoute {
+    method: HttpMethod | string;
+    route: string;
+}
+/**
+ * Represents an alert message with a title, timestamp, and severity level.
+ * @property {string} title - The title or summary of the alert.
+ * @property {string} timestamp - The timestamp when the alert was generated (ISO 8601 format).
+ * @property {SeverityLevel} severity - The severity level of the alert (info, advisory, warning, critical).
+ */
+export interface AlertMessage {
+    title: string;
+    timestamp: string;
+    severity: SeverityLevel;
+}
+/**
+ * Represents pagination metadata for paginated data responses.
+ * @property {number} page - The current page number.
+ * @property {number} pageSize - The actual number of items returned on the current page.
+ * @property {number} perPageCount - The number of items per page.
+ * @property {number} totalCount - The total number of items available across all pages.
+ */
+export interface PaginationMeta {
+    page: number;
+    pageSize: number;
+    perPageCount: number;
+    totalCount: number;
+}
+/**
+ * Categorizes an HTTP status code into a broader status category.
+ * @param statusCode - The HTTP status code to categorize.
+ * @returns A string representing the status category: '2xx', '3xx', '4xx', '5xx', or 'unknown'.
+ */
+export declare function categorizeStatusCode(statusCode: number): StatusCategory;

package/dist/core/domain/common.types.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.categorizeStatusCode = categorizeStatusCode;
+/**
+ * Categorizes an HTTP status code into a broader status category.
+ * @param statusCode - The HTTP status code to categorize.
+ * @returns A string representing the status category: '2xx', '3xx', '4xx', '5xx', or 'unknown'.
+ */
+function categorizeStatusCode(statusCode) {
+    if (statusCode >= 200 && statusCode < 300)
+        return '2xx';
+    else if (statusCode >= 300 && statusCode < 400)
+        return '3xx';
+    else if (statusCode >= 400 && statusCode < 500)
+        return '4xx';
+    else if (statusCode >= 500 && statusCode < 600)
+        return '5xx';
+    else
+        return 'unknown';
+}

package/dist/core/domain/dashboard.types.d.ts

@@ -0,0 +1,108 @@
+import type { AlertMessage, PaginationMeta } from './common.types';
+import type { CpuMetrics, MemoryMetrics, EventLoopMetrics, GCMetrics, LibuvHandles, HistoricTimeSeries } from './metrics.types';
+import type { V8RuntimeInfo } from './system.types';
+import type { EndpointTelemetry, EndpointLatencyDistribution, EndpointVolume } from './endpoints.types';
+/**
+ * Represents the complete dashboard data structure, including current metrics, historical data, impacted endpoints, alerts, and chart configurations.
+ * @property {object} current - Current instantaneous values for various metrics.
+ * @property {HistoricTimeSeries} history - Historical time series data for various metrics.
+ * @property {EndpointTelemetry[]} impactEndpoints - List of impacted endpoints with their telemetry data.
+ * @property {AlertMessage[]} alerts - List of alert messages.
+ * @property {object} charts - Explicit chart configuration maps matching chart configurations directly.
+ * @property {object} charts.throughputAndLatency - Chart data for throughput and latency metrics.
+ * @property {object} charts.runtimePerformance - Chart data for runtime performance metrics.
+ */
+export interface DashboardData {
+    current: {
+        rps: number;
+        latency: number;
+        errorRate: number;
+        eventLoopLag: number;
+        heapUsage: number;
+        heapSize: number;
+    };
+    history: HistoricTimeSeries;
+    impactEndpoints: EndpointTelemetry[];
+    alerts: AlertMessage[];
+    charts: {
+        throughput: {
+            rps: number[];
+            errorClient: number[];
+            errorServer: number[];
+            totalCount: number;
+        };
+        percentiles: {
+            p50: number[];
+            p95: number[];
+            p99: number[];
+            totalCount: number;
+        };
+        runtimePerformance: {
+            heapUsage: number[];
+            heapSize: number[];
+            lag: number[];
+            totalCount: number;
+        };
+    };
+}
+/**
+ * Represents the analytics data structure, including summary statistics, latency distribution, request volume, and a paginated table of endpoint telemetry data.
+ * @property {object} summary - Summary statistics for the analytics data.
+ * @property {number} summary.totalEndpoints - Total number of endpoints analyzed.
+ * @property {number} summary.healthyEndpoints - Number of healthy endpoints.
+ * @property {number} summary.slowEndpoints - Number of slow endpoints.
+ * @property {number} summary.slowEndpointsThreshold - Threshold for determining slow endpoints.
+ * @property {number} summary.errorEndpoints - Number of endpoints with errors.
+ * @property {EndpointLatencyDistribution[]} latencyDistribution - Array of latency distribution data for each endpoint.
+ * @property {EndpointVolume[]} requestVolume - Array of request volume data for each endpoint.
+ * @property {object} endpointsTable - Paginated table of endpoint telemetry data.
+ * @property {EndpointTelemetry[]} endpointsTable.data - Array of endpoint telemetry data for the current page.
+ * @property {PaginationMeta} endpointsTable.pagination - Pagination metadata for the endpoints table.
+ */
+export interface AnalyticsData {
+    summary: {
+        totalEndpoints: number;
+        healthyEndpoints: number;
+        slowEndpoints: number;
+        slowEndpointsThreshold: number;
+        errorEndpoints: number;
+    };
+    latencyDistribution: EndpointLatencyDistribution[];
+    requestVolume: EndpointVolume[];
+    endpointsTable: {
+        data: EndpointTelemetry[];
+        pagination: PaginationMeta;
+    };
+    history: EndpointTelemetry[][];
+}
+/**
+ * Represents the health data structure, including CPU metrics, memory metrics, event loop metrics, libuv handle metrics, garbage collection metrics, V8 runtime information, and historical data for event loop lag and memory breakdown.
+ * @property {CpuMetrics} cpu - CPU metrics data.
+ * @property {MemoryMetrics} memory - Memory metrics data.
+ * @property {EventLoopMetrics} eventLoop - Event loop metrics data.
+ * @property {LibuvHandles} handles - Libuv handle metrics data.
+ * @property {GCMetrics} garbageCollection - Garbage collection metrics data.
+ * @property {V8RuntimeInfo} runtime - V8 runtime information data.
+ * @property {object} history - Historical data for event loop lag and memory breakdown.
+ * @property {number[]} history.eventLoopLag - Array of historical event loop lag values.
+ * @property {object} history.memoryBreakdown - Historical memory breakdown data.
+ * @property {number[]} history.memoryBreakdown.usedHeap - Array of historical used heap memory values.
+ * @property {number[]} history.memoryBreakdown.totalHeap - Array of historical total heap memory values.
+ * @property {number[]} history.memoryBreakdown.rssMemory - Array of historical resident set size (RSS) memory values.
+ */
+export interface HealthData {
+    cpu: CpuMetrics;
+    memory: MemoryMetrics;
+    eventLoop: EventLoopMetrics;
+    handles: LibuvHandles;
+    garbageCollection: GCMetrics;
+    runtime: V8RuntimeInfo;
+    history: {
+        eventLoopLag: number[];
+        memoryBreakdown: {
+            usedHeap: number[];
+            totalHeap: number[];
+            rssMemory: number[];
+        };
+    };
+}

package/dist/core/domain/dashboard.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/domain/endpoints.types.d.ts

@@ -0,0 +1,43 @@
+import type { EndpointRoute } from './common.types';
+/**
+ * Represents telemetry data for a specific endpoint, including request rate, latency percentiles, error rate, and optional status information.
+ * @property {number} rps - Requests per second for the endpoint.
+ * @property {number} p95 - 95th percentile latency for the endpoint.
+ * @property {number} [p99] - Optional 99th percentile latency for the endpoint.
+ * @property {number} errorRate - Error rate for the endpoint (as a percentage).
+ * @property {string} [status] - Optional status of the endpoint (e.g., 'HEALTHY', 'UNHEALTHY').
+ * @property {number} [requestCount] - Optional total number of requests made to the endpoint.
+ * @property {number} [averageLatency] - Optional average latency for the endpoint.
+ */
+export interface EndpointTelemetry extends EndpointRoute {
+    rps: number;
+    p95: number;
+    p99?: number;
+    errorRate: number;
+    status?: string;
+    requestCount?: number;
+    averageLatency?: number;
+}
+/**
+ * Represents the latency distribution for a specific endpoint, including the 50th, 95th, and 99th percentile latencies.
+ * @property {string} endpoint - The endpoint path (e.g., '/api/users').
+ * @property {number} p50 - 50th percentile latency for the endpoint.
+ * @property {number} p95 - 95th percentile latency for the endpoint.
+ * @property {number} p99 - 99th percentile latency for the endpoint.
+ */
+export interface EndpointLatencyDistribution {
+    endpoint: string;
+    p50: number;
+    p95: number;
+    p99: number;
+}
+/**
+ * Represents the request volume for a specific endpoint, including the total number of requests made to that endpoint.
+ * @property {string} endpoint - The endpoint path (e.g., '/api/users').
+ * @property {number} volume - The total number of requests made to the endpoint.
+ */
+export interface EndpointVolume {
+    endpoint: string;
+    volume: number;
+    rps: number;
+}

package/dist/core/domain/endpoints.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/domain/index.d.ts

@@ -0,0 +1,6 @@
+export * from './common.types';
+export * from './system.types';
+export * from './metrics.types';
+export * from './endpoints.types';
+export * from './dashboard.types';
+export * from './telemetry.types';

package/dist/core/domain/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common.types"), exports);
+__exportStar(require("./system.types"), exports);
+__exportStar(require("./metrics.types"), exports);
+__exportStar(require("./endpoints.types"), exports);
+__exportStar(require("./dashboard.types"), exports);
+__exportStar(require("./telemetry.types"), exports);