@resolveio/server-lib 22.2.34 → 22.2.36

package/src/managers/monitor.manager.ts

@@ -1,489 +0,0 @@
-import axios from 'axios';
-import { MonitorCPUs } from '../collections/monitor-cpu.collection';
-import { MonitorFunctions } from '../collections/monitor-function.collection';
-import { MonitorMemorys } from '../collections/monitor-memory.collection';
-import { MonitorMongos } from '../collections/monitor-mongo.collection';
-import { ResolveIOServer } from '../resolveio-server-app';
-import { objectIdHexString } from '../util/common';
-import { LocalLogModel } from './local-log.manager';
-
-const os = require('os');
-const MAX_BATCH_SIZE = 8 * 1024 * 1024; // 8MB max for safety
-
-export class MonitorManager {
-	private _instanceHostname = '';
-	private _monitorData: LocalLogModel[] = [];
-
-	constructor() {}
-
-	static async create() {
-		const monitorManager = new MonitorManager();
-		await monitorManager.initialize();
-		return monitorManager;
-	}
-
-	private async initialize() {
-		this._instanceHostname = os.hostname().replace(/\./g, '-');
-		await this.setupIntervals();
-		this.setupEventLoop();
-	}
-
-	cpuAverage() {
-		var totalIdle = 0, totalTick = 0;
-		var cpus = os.cpus();
-
-		for (var i = 0, len = cpus.length; i < len; i++) {
-			var cpu = cpus[i];
-
-			for (let type in cpu.times) {
-				totalTick += cpu.times[type];
-			}
-			totalIdle += cpu.times.idle;
-		}
-
-		return {
-			idle: totalIdle / cpus.length,
-			total: totalTick / cpus.length
-		};
-	}
-
-	async setupIntervals() {
-		// Example: If not on production or localhost, do a health check
-		if (
-			ResolveIOServer.getServerConfig()['ROOT_URL'] !== 'https://resolveio.com'
-		&& ResolveIOServer.getServerConfig()['ROOT_URL'] !== 'http://localhost:4200'
-		) {
-			try {
-				let instanceId = await axios.get('http://169.254.169.254/latest/meta-data/instance-id');
-
-				setInterval(async () => {
-					try {
-						await axios.post('https://backend.resolveio.com/api/health', {
-							type: 'application',
-							id_aws_instance: instanceId.data,
-							version: typeof process.env.APP_VERSION === 'number'
-								? (<any>process.env.APP_VERSION).toString()
-								: process.env.APP_VERSION,
-							version_key: process.env.APP_VERSION_KEY
-						});
-					}
-					catch {}
-				}, 10000);
-			}
-			catch {}
-		}
-
-		let lastCPU = this.cpuAverage();
-
-		setInterval(async () => {
-			let now = new Date();
-			var endMeasure = this.cpuAverage();
-			var idleDifference = endMeasure.idle - lastCPU.idle;
-			var totalDifference = endMeasure.total - lastCPU.total;
-			var percentageCPU = 1 - idleDifference / totalDifference;
-
-			// Original local code
-			if (
-				!ResolveIOServer.shouldWriteLogsOffline()
-			) {
-				await MonitorCPUs.create({
-					_id: objectIdHexString(),
-					metadata: {
-						instance: this._instanceHostname,
-						client: ResolveIOServer.getServerConfig()['CLIENT_NAME']
-					},
-					date: now,
-					app: percentageCPU,
-					system: os.loadavg()[0]
-				});
-			}
-			else {
-				this.pushMonitorData({
-					type: 'monitor-cpu',
-					data: {
-						metadata: {
-							instance: this._instanceHostname,
-							client: ResolveIOServer.getServerConfig()['CLIENT_NAME']
-						},
-						date: now,
-						app: percentageCPU,
-						system: os.loadavg()[0]
-					}
-				});
-			}
-
-			lastCPU = endMeasure;
-
-			const memUsage = process.memoryUsage();
-
-			if (
-				!ResolveIOServer.shouldWriteLogsOffline()
-			) {
-				await MonitorMemorys.create({
-					_id: objectIdHexString(),
-					metadata: {
-						instance: this._instanceHostname,
-						client: ResolveIOServer.getServerConfig()['CLIENT_NAME']
-					},
-					date: now,
-					physical_total: memUsage.heapTotal,
-					physical_used: memUsage.heapUsed,
-					physical_free: os.freemem(),
-					virtual: memUsage.rss,
-					private: memUsage.external,
-					physical: os.totalmem()
-				});
-			}
-			else {
-				this.pushMonitorData({
-					type: 'monitor-memory',
-					data: {
-						metadata: {
-							instance: this._instanceHostname,
-							client: ResolveIOServer.getServerConfig()['CLIENT_NAME']
-						},
-						date: now,
-						physical_total: memUsage.heapTotal,
-						physical_used: memUsage.heapUsed,
-						physical_free: os.freemem(),
-						virtual: memUsage.rss,
-						private: memUsage.external,
-						physical: os.totalmem(),
-						type: 'memory'
-					}
-				});
-			}
-		}, 3000);
-	}
-
-	async addMongoTracker(data: MongoMonitorModel) {
-		if (
-			!ResolveIOServer.shouldWriteLogsOffline()
-		) {
-			if (!data.collection.startsWith('monitor-')) {
-				await MonitorMongos.create({
-					_id: objectIdHexString(),
-					metadata: {
-						instance: this._instanceHostname,
-						client: ResolveIOServer.getServerConfig()['CLIENT_NAME']
-					},
-					date: new Date(data.date),
-					method: data.method,
-					doc_collection: data.collection,
-					duration: data.duration,
-					query: Buffer.byteLength(data.query, 'utf8') < 15800000
-						? data.query
-						: 'Too Big'
-				});
-			}
-		}
-		else {
-			if (this._instanceHostname) {
-				this.pushMonitorData({
-					type: 'monitor-mongo',
-					data: {
-						metadata: {
-							instance: this._instanceHostname,
-							client: ResolveIOServer.getServerConfig()['CLIENT_NAME']
-						},
-						date: new Date(data.date),
-						method: data.method,
-						doc_collection: data.collection,
-						duration: data.duration,
-						query: Buffer.byteLength(data.query, 'utf8') < 15800000
-							? data.query
-							: 'Too Big'
-					}
-				});
-			}
-		}
-	}
-
-	async addFunctionTracker(data: MonitorFunction) {
-		if (typeof(data.data) !== 'string') {
-			data.data = JSON.stringify(data.data);
-		}
-
-		if (
-			!ResolveIOServer.shouldWriteLogsOffline()
-		) {
-			await MonitorFunctions.create({
-				_id: objectIdHexString(),
-				metadata: {
-					instance: this._instanceHostname,
-					client: ResolveIOServer.getServerConfig()['CLIENT_NAME']
-				},
-				date: new Date(data.startTime),
-				type: data.functionType,
-				name: data.functionName,
-				user: data.user,
-				duration: data.duration,
-				data: Buffer.byteLength(data.data, 'utf8') < 15800000
-					? data.data
-					: 'Too Big'
-			});
-		}
-		else {
-			if (this._instanceHostname) {
-				this.pushMonitorData({
-					type: 'monitor-function',
-					data: {
-						metadata: {
-							instance: this._instanceHostname,
-							client: ResolveIOServer.getServerConfig()['CLIENT_NAME']
-						},
-						date: new Date(data.startTime),
-						type: data.functionType,
-						name: data.functionName,
-						user: data.user,
-						duration: data.duration,
-						data: Buffer.byteLength(data.data, 'utf8') < 15800000
-							? data.data
-							: 'Too Big'
-					}
-				});
-			}
-		}
-	}
-
-	private pushMonitorData(data: LocalLogModel) {
-		this._monitorData.push(data);
-
-		// If data is huge, flush immediately to file
-		if (this.estimateBatchSize() >= MAX_BATCH_SIZE) {
-			this.flushMonitorData();
-		}
-	}
-
-	private estimateBatchSize(): number {
-		return this._monitorData.reduce((total, item) => {
-			return total + Buffer.byteLength(JSON.stringify(item));
-		}, 0);
-	}
-
-	setupEventLoop() {
-		// Flush every 2.5 seconds
-		setInterval(() => {
-			if (this._monitorData.length > 0) {
-				this.flushMonitorData();
-			}
-		}, 2500);
-	}
-
-	private flushMonitorData() {
-		const batch = [];
-		let batchSize = 0;
-
-		while (this._monitorData.length > 0 && batchSize < MAX_BATCH_SIZE) {
-			const item = this._monitorData.shift();
-			const itemSize = Buffer.byteLength(JSON.stringify(item));
-
-			if ((batchSize + itemSize) > MAX_BATCH_SIZE && batch.length > 0) {
-				// put the item back for next round
-				this._monitorData.unshift(item);
-				break;
-			}
-
-			batch.push(item);
-			batchSize += itemSize;
-		}
-
-		try {
-			// Now, instead of calling an external HTTP endpoint, we write the batch to disk:
-			ResolveIOServer.getLocalLogManager().writeLogs(batch);
-		}
-		catch (error) {
-			console.error(new Date(), 'MonitorManager', 'Failed to flush monitor data to file:', error);
-		}
-	}
-}
-
-export interface MongoMonitorModel {
-	date: Date;
-	method: string;
-	collection: string;
-	duration: number;
-	query: string;
-}
-
-export class MonitorMongo {
-	private _startTime = 0;
-	private _method = '';
-	private _collection = '';
-	private _query = '';
-
-	constructor() {}
-
-	static create(method: string, collection: string, query: string) {
-		const monitorMongo = new MonitorMongo();
-		monitorMongo.initialize(method, collection, query);
-		return monitorMongo;
-	}
-
-	private initialize(method: string, collection: string, query: string) {
-		this._startTime = Date.now();
-		this._method = method;
-		this._collection = collection;
-		this._query = query;
-	}
-
-	public async finish() {
-		let endTime = Date.now();
-
-		let mongoMonitor: MongoMonitorModel = {
-			date: new Date(endTime),
-			method: this._method,
-			collection: this._collection,
-			query: this._query,
-			duration: endTime - this._startTime
-		};
-
-		await ResolveIOServer.getMainServer().getMonitorManager().addMongoTracker(mongoMonitor);
-	}
-}
-
-export class MonitorManagerFunction {
-	private _functionCnt = 0;
-	private _functions: MonitorFunction[] = [];
-	private _functionLastCompletedWS: { [id_socket: string]: MonitorFunction; } = {};
-	private _functionLastCompleted: MonitorFunction;
-
-	constructor() {}
-
-	static create() {
-		const monitorManagerFunction = new MonitorManagerFunction();
-		monitorManagerFunction.initialize();
-		return monitorManagerFunction;
-	}
-
-	private initialize() {
-
-	}
-
-	startMonitorFunction(
-		functionType: MonitorFunctionType,
-		functionName: string,
-		user: string,
-		id_socket: string,
-		data: any
-	) {
-		let newMonitorFunction = MonitorFunction.create(
-			this._functionCnt++,
-			functionType,
-			functionName,
-			user,
-			id_socket,
-			data
-		);
-
-		this._functions.push(newMonitorFunction);
-		return newMonitorFunction.id;
-	}
-
-	async finishMonitorFunction(id: number) {
-		let monitor = this._functions.find(a => a.id === id);
-
-		if (monitor) {
-			await monitor.finish();
-			this._functionLastCompleted = monitor;
-			this._functionLastCompletedWS[monitor.id_socket] = monitor;
-			this._functions.splice(
-				this._functions.map(a => a.id).indexOf(id),
-				1
-			);
-		}
-	}
-
-	getActiveMonitorFunctions() {
-		return this._functions;
-	}
-
-	getLastCompletedMonitorFunction() {
-		return this._functionLastCompleted;
-	}
-
-	getLastCompletedMonitorFunctionWS() {
-		return this._functionLastCompletedWS;
-	}
-}
-
-export type MonitorFunctionType =
-	'Cron Method'
-	| 'Method'
-	| 'User Specific Publication'
-	| 'Publication';
-
-export class MonitorFunction {
-	private _timer: NodeJS.Timeout = null;
-	public duration = 0;
-	public functionType: MonitorFunctionType;
-	public functionName: string;
-	public user: string;
-	public data: any;
-	public startTime: Date = null;
-	public endTime: Date = null;
-	public lastTime: Date = null;
-	public id_socket = '';
-	public id = 0;
-
-	constructor() {}
-
-	static create(
-		id: number,
-		functionType: MonitorFunctionType,
-		functionName: string,
-		user: string,
-		id_socket: string,
-		data: any
-	) {
-		const monitorFunction = new MonitorFunction();
-		monitorFunction.initialize(id, functionType, functionName, user, id_socket, data);
-		return monitorFunction;
-	}
-
-	private initialize(
-		id: number,
-		functionType: MonitorFunctionType,
-		functionName: string,
-		user: string,
-		id_socket: string,
-		data: any
-	) {
-		this.id = id;
-		this.startTime = new Date();
-		this.functionType = functionType;
-		this.functionName = functionName;
-		this.user = user;
-		this.id_socket = id_socket;
-		this.data = data;
-		this.lastTime = new Date();
-
-		this._timer = setInterval(() => {
-			let diff = Date.now() - this.lastTime.getTime();
-
-			if (diff > this.duration) {
-				this.duration = diff;
-			}
-
-			this.lastTime = new Date();
-		}, 1000);
-	}
-
-	public async finish() {
-		if (this._timer) {
-			clearInterval(this._timer);
-			this._timer = null;
-		}
-
-		this.endTime = new Date();
-
-		if (this.duration >= 5000) {
-			// Optional slow function logging or email
-			await ResolveIOServer.getMainServer().getMonitorManager().addFunctionTracker(this);
-		}
-
-		// await ResolveIOServer.getMainServer().getMonitorManager().addFunctionTracker(this);
-
-		return Promise.resolve(true);
-	}
-}

package/src/managers/openai-usage-ledger.manager.ts

@@ -1,116 +0,0 @@
-import { round } from '../util/common';
-import { ResolveIOServer } from '../resolveio-server-app';
-import { OpenAIUsageLedger } from '../collections/openai-usage-ledger.collection';
-
-export interface OpenAIUsageRecordInput {
-	id_client?: string;
-	model: string;
-	input_tokens: number;
-	cached_input_tokens?: number;
-	output_tokens: number;
-	total_tokens: number;
-	billable?: boolean;
-	category?: string;
-	id_request?: string;
-	id_conversation?: string;
-	timestamp?: Date;
-	cost_estimate?: number;
-}
-
-type PricingConfig = {
-	inputPer1k: number;
-	outputPer1k: number;
-};
-
-const toNumber = (value: any): number => {
-	const parsed = Number(value);
-	return Number.isFinite(parsed) ? parsed : 0;
-};
-
-const normalizeModelKey = (value: string): string => {
-	return String(value || '').trim().toLowerCase();
-};
-
-const parsePricingJson = (raw: string): Record<string, PricingConfig> => {
-	if (!raw) {
-		return {};
-	}
-	try {
-		const parsed = JSON.parse(raw);
-		if (!parsed || typeof parsed !== 'object') {
-			return {};
-		}
-		const out: Record<string, PricingConfig> = {};
-		Object.keys(parsed).forEach((key) => {
-			const entry = parsed[key] || {};
-			const inputPer1k = toNumber(entry.inputPer1k ?? entry.input ?? entry.prompt ?? 0);
-			const outputPer1k = toNumber(entry.outputPer1k ?? entry.output ?? entry.completion ?? 0);
-			if (inputPer1k || outputPer1k) {
-				out[normalizeModelKey(key)] = { inputPer1k, outputPer1k };
-			}
-		});
-		return out;
-	}
-	catch {
-		return {};
-	}
-};
-
-const resolvePricingConfig = (): { perModel: Record<string, PricingConfig>; defaultPricing: PricingConfig } => {
-	const config = ResolveIOServer.getServerConfig() || {};
-	const rawJson = String(config['OPENAI_MODEL_PRICING'] ?? process.env.OPENAI_MODEL_PRICING ?? '').trim();
-	const defaultInput = toNumber(config['OPENAI_COST_PER_1K_INPUT_TOKENS'] ?? process.env.OPENAI_COST_PER_1K_INPUT_TOKENS ?? 0);
-	const defaultOutput = toNumber(config['OPENAI_COST_PER_1K_OUTPUT_TOKENS'] ?? process.env.OPENAI_COST_PER_1K_OUTPUT_TOKENS ?? 0);
-	return {
-		perModel: parsePricingJson(rawJson),
-		defaultPricing: { inputPer1k: defaultInput, outputPer1k: defaultOutput }
-	};
-};
-
-const estimateCost = (model: string, inputTokens: number, outputTokens: number, cachedInputTokens = 0): number => {
-	const { perModel, defaultPricing } = resolvePricingConfig();
-	const normalizedModel = normalizeModelKey(model);
-	const pricing = perModel[normalizedModel] || defaultPricing;
-	if (!pricing.inputPer1k && !pricing.outputPer1k) {
-		return 0;
-	}
-	// Cached prompt tokens are typically discounted or free; only uncached input should use full input pricing.
-	const uncachedInputTokens = Math.max(0, toNumber(inputTokens) - toNumber(cachedInputTokens));
-	const inputCost = (uncachedInputTokens / 1000) * pricing.inputPer1k;
-	const outputCost = (toNumber(outputTokens) / 1000) * pricing.outputPer1k;
-	return round(inputCost + outputCost, 6);
-};
-
-export async function recordOpenAIUsage(input: OpenAIUsageRecordInput): Promise<void> {
-	if (!input) {
-		return;
-	}
-	const idClient = String(input.id_client || '').trim();
-	const inputTokens = toNumber(input.input_tokens);
-	const cachedInputTokens = toNumber(input.cached_input_tokens);
-	const outputTokens = toNumber(input.output_tokens);
-	const totalTokens = toNumber(input.total_tokens);
-	if (!totalTokens && (!inputTokens && !outputTokens)) {
-		return;
-	}
-	const model = String(input.model || '').trim() || 'unknown';
-	const normalizedInputCostEstimate = toNumber(input.cost_estimate);
-	const costEstimate = normalizedInputCostEstimate > 0
-		? normalizedInputCostEstimate
-		: estimateCost(model, inputTokens, outputTokens, cachedInputTokens);
-
-	await OpenAIUsageLedger.insertOne({
-		id_client: idClient,
-		timestamp: input.timestamp || new Date(),
-		model,
-		input_tokens: inputTokens,
-		cached_input_tokens: cachedInputTokens,
-		output_tokens: outputTokens,
-		total_tokens: totalTokens || (inputTokens + outputTokens),
-		cost_estimate: costEstimate,
-		billable: input.billable !== false,
-		category: input.category || '',
-		id_request: input.id_request || '',
-		id_conversation: input.id_conversation || ''
-	});
-}