@resolveio/server-lib 22.3.13 → 22.3.14

package/src/util/slow-query-reporter.ts

@@ -0,0 +1,216 @@
+import { createHash } from 'crypto';
+import { Document } from 'mongodb';
+import { hostname } from 'os';
+import { ResolveIOServer } from '../resolveio-server-app';
+import { SlowQueryReportPayload } from '../types/slow-query-report';
+import { deepCopy } from './common';
+
+const DEFAULT_SLOW_QUERY_THRESHOLD_MS = 1000;
+
+interface SlowQueryReportParams {
+	collection: string;
+	filter?: Document;
+	pipeline?: any[];
+	options?: Document;
+	durationMs: number;
+	queryType: 'find' | 'findOne' | 'aggregate' | 'countDocuments';
+	notes?: string;
+	queryHash?: string;
+	sourceApp?: string;
+	serverUrl?: string;
+	publication?: string;
+	subscriptionData?: any[];
+	userId?: string;
+}
+
+export class SlowQueryReporter {
+	public static async reportSlowQuery(params: SlowQueryReportParams): Promise<void> {
+		if (!this.isReportingEnabled()) {
+			return;
+		}
+
+		const thresholdMs = this.getThresholdMs();
+		if (thresholdMs <= 0 || params.durationMs < thresholdMs) {
+			return;
+		}
+
+		const manager = ResolveIOServer['SlowQueryManager'];
+		if (!manager || typeof manager.ingestSlowQuery !== 'function') {
+			console.error('SlowQueryReporter skipped: local SlowQueryManager is not available');
+			return;
+		}
+		if (typeof manager.isReady === 'function' && !manager.isReady()) {
+			return;
+		}
+
+		const queryHash = params.queryHash || this.generateQueryHash(params);
+		const payload: SlowQueryReportPayload = {
+			queryHash,
+			collection: params.collection,
+			pipeline: params.pipeline ? deepCopy(params.pipeline) : undefined,
+			filter: params.filter ? deepCopy(params.filter) : undefined,
+			options: params.options ? deepCopy(params.options) : undefined,
+			durationMs: params.durationMs,
+			thresholdMs,
+			clientSlug: ResolveIOServer.getClientName(),
+			clientName: this.getClientName(),
+			sourceApp: params.sourceApp || 'mongo-manager',
+			environment: this.getEnvironment(),
+			nodeHostname: hostname(),
+			notes: params.notes,
+			server_url: params.serverUrl || this.getServerUrl(),
+			publication: params.publication,
+			subscription_data: params.subscriptionData,
+			userId: params.userId
+		};
+
+		try {
+			await manager.ingestSlowQuery(payload);
+		}
+		catch (err) {
+			console.error('SlowQueryReporter failed', err);
+		}
+	}
+
+	public static reportSlowQueryFireAndForget(params: SlowQueryReportParams): void {
+		// eslint-disable-next-line no-restricted-syntax, promise/prefer-await-to-then
+		void this.reportSlowQuery(params).catch(err => {
+			console.error('SlowQueryReporter fire-and-forget error', err);
+		});
+	}
+
+	private static isReportingEnabled(): boolean {
+		const config = ResolveIOServer.getServerConfig();
+		const envValue = process.env.SLOW_QUERY_ENABLED;
+		if (typeof envValue === 'string' && envValue.length) {
+			const normalized = envValue.trim().toLowerCase();
+			if (['true', '1', 'yes'].includes(normalized)) {
+				return true;
+			}
+			else if (['false', '0', 'no'].includes(normalized)) {
+				return false;
+			}
+		}
+
+		const slowQueryConfig = (config && (config.slowQuery || config.SLOW_QUERY)) || null;
+		const configValue = typeof slowQueryConfig?.enabled !== 'undefined'
+			? slowQueryConfig.enabled
+			: config?.SLOW_QUERY_ENABLED;
+
+		if (typeof configValue === 'boolean') {
+			return configValue;
+		}
+
+		if (typeof configValue === 'string' && configValue.length) {
+			const normalized = configValue.trim().toLowerCase();
+			if (['true', '1', 'yes'].includes(normalized)) {
+				return true;
+			}
+			else if (['false', '0', 'no'].includes(normalized)) {
+				return false;
+			}
+		}
+
+		if (typeof configValue === 'number') {
+			return configValue !== 0;
+		}
+
+		return true;
+	}
+
+	private static getThresholdMs(): number {
+		const config = ResolveIOServer.getServerConfig();
+		const envValue = process.env.SLOW_QUERY_THRESHOLD_MS;
+		if (envValue && !Number.isNaN(Number(envValue))) {
+			return Number.parseInt(envValue, 10);
+		}
+
+		const configValue = config?.SLOW_QUERY_THRESHOLD_MS;
+		if (typeof configValue === 'number') {
+			return configValue;
+		}
+
+		if (typeof configValue === 'string' && configValue.length && !Number.isNaN(Number(configValue))) {
+			return Number.parseInt(configValue, 10);
+		}
+
+		return DEFAULT_SLOW_QUERY_THRESHOLD_MS;
+	}
+
+	private static getEnvironment(): string {
+		const config = ResolveIOServer.getServerConfig();
+		return (
+			config?.RESOLVEIO_ENV ||
+			config?.ENVIRONMENT ||
+			config?.ROOT_URL ||
+			process.env.RESOLVEIO_ENV ||
+			process.env.NODE_ENV ||
+			'unknown'
+		);
+	}
+
+	private static getClientName(): string | undefined {
+		const config = ResolveIOServer.getServerConfig();
+		return config?.CLIENT_NAME || ResolveIOServer.getClientName();
+	}
+
+	private static generateQueryHash(params: SlowQueryReportParams): string {
+		try {
+			const normalized = this.normalizeForHash({
+				collection: params.collection,
+				filter: params.filter || null,
+				pipeline: params.pipeline || null,
+				options: params.options || null,
+				queryType: params.queryType
+			});
+			const digest = createHash('sha256').update(JSON.stringify(normalized)).digest('hex').slice(0, 16);
+			return `${params.collection}-${digest}`;
+		}
+		catch (err) {
+			console.error('SlowQueryReporter hash generation failed', err);
+			return `${params.collection}-${Date.now()}`;
+		}
+	}
+
+	private static getServerUrl(): string | undefined {
+		const config = ResolveIOServer.getServerConfig();
+		if (config?.ROOT_URL) {
+			return `${config.ROOT_URL}`.trim();
+		}
+
+		if (process.env.ROOT_URL) {
+			return process.env.ROOT_URL.trim();
+		}
+
+		return undefined;
+	}
+
+	private static normalizeForHash(value: any): any {
+		if (value === null || value === undefined) {
+			return value;
+		}
+
+		if (Array.isArray(value)) {
+			return value.map(item => this.normalizeForHash(item));
+		}
+
+		if (value instanceof RegExp) {
+			return value.toString();
+		}
+
+		if (typeof value === 'object') {
+			if (typeof (value as any).toHexString === 'function') {
+				return (value as any).toHexString();
+			}
+
+			const ordered: Record<string, any> = {};
+			Object.keys(value).sort().forEach(key => {
+				ordered[key] = this.normalizeForHash(value[key]);
+			});
+			return ordered;
+		}
+
+		return value;
+	}
+
+}