@resolveio/server-lib 22.3.221 → 22.3.222

package/src/managers/monitor.manager.ts

@@ -1,507 +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() {
-		const processOnlyRuntime = this.isProcessOnlyManagerRuntime();
-
-		// Example: If not on production or localhost, do a health check
-		if (
-			!processOnlyRuntime
-		&&
-			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);
-	}
-
-	private isProcessOnlyManagerRuntime(): boolean {
-		const parseFlag = (value: any): boolean => {
-			const normalized = String(value ?? '').trim().toLowerCase();
-			return normalized === '1'
-				|| normalized === 'true'
-				|| normalized === 'yes'
-				|| normalized === 'on'
-				|| normalized === 'enabled';
-		};
-		return parseFlag(process.env.SUPPORT_CODEX_MANAGER_PROCESS_ONLY)
-			|| parseFlag(process.env.SUPPORT_AUTO_MANAGER_PROCESS_ONLY)
-			|| parseFlag(process.env.AI_ASSISTANT_CODEX_MANAGER_PROCESS_ONLY);
-	}
-
-	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,112 +0,0 @@
-import { OpenAIUsageLedger } from '../collections/openai-usage-ledger.collection';
-import {
-	OpenAIUsageCostBasis,
-	OpenAIUsageSource,
-	OpenAIUsageSurface
-} from '../models/openai-usage-ledger.model';
-import { estimateOpenAIUsageCost } from '../util/openai-usage-cost';
-export { estimateOpenAIUsageCost, OpenAIUsagePricingConfig } from '../util/openai-usage-cost';
-
-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;
-	usage_source?: OpenAIUsageSource | string;
-	usage_surface?: OpenAIUsageSurface | string;
-	usage_phase?: string;
-	cost_basis?: OpenAIUsageCostBasis | string;
-	id_run?: string;
-	id_job?: string;
-	id_app?: string;
-	id_ticket?: string;
-	is_manual?: boolean;
-	is_untracked?: boolean;
-	untracked_reason?: string;
-	metadata?: Record<string, any>;
-}
-
-const toNumber = (value: any): number => {
-	const parsed = Number(value);
-	return Number.isFinite(parsed) ? parsed : 0;
-};
-
-const cleanText = (value: any, max = 240): string => {
-	if (value === undefined || value === null) {
-		return '';
-	}
-	return String(value).trim().slice(0, max);
-};
-
-const cleanMetadata = (value: any): Record<string, any> | undefined => {
-	if (!value || typeof value !== 'object' || Array.isArray(value)) {
-		return undefined;
-	}
-	return { ...value };
-};
-
-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);
-	const normalizedInputCostEstimate = toNumber(input.cost_estimate);
-	if (!totalTokens && (!inputTokens && !outputTokens) && normalizedInputCostEstimate <= 0) {
-		return;
-	}
-	const model = String(input.model || '').trim() || 'unknown';
-	const costEstimate = normalizedInputCostEstimate > 0
-		? normalizedInputCostEstimate
-		: estimateOpenAIUsageCost(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: cleanText(input.category, 160),
-		id_request: cleanText(input.id_request, 240),
-		id_conversation: cleanText(input.id_conversation, 240),
-		usage_source: cleanText(input.usage_source, 80) || 'unknown',
-		usage_surface: cleanText(input.usage_surface, 80) || 'unknown',
-		usage_phase: cleanText(input.usage_phase, 120),
-		cost_basis: cleanText(input.cost_basis, 80) || (normalizedInputCostEstimate > 0 ? 'provider_usage' : 'estimated_tokens'),
-		id_run: cleanText(input.id_run, 240),
-		id_job: cleanText(input.id_job, 240),
-		id_app: cleanText(input.id_app, 240),
-		id_ticket: cleanText(input.id_ticket, 240),
-		is_manual: input.is_manual === true || cleanText(input.usage_source, 80) === 'manual_codex',
-		is_untracked: input.is_untracked === true,
-		untracked_reason: cleanText(input.untracked_reason, 500),
-		metadata: cleanMetadata(input.metadata)
-	});
-}
-
-export async function recordManualCodexUsageEstimate(input: Omit<OpenAIUsageRecordInput, 'usage_source' | 'is_manual'>): Promise<void> {
-	await recordOpenAIUsage({
-		...input,
-		usage_source: 'manual_codex',
-		usage_surface: input.usage_surface || 'manual',
-		cost_basis: input.cost_basis || 'manual_estimate',
-		is_manual: true,
-		is_untracked: input.is_untracked !== false,
-		untracked_reason: input.untracked_reason || 'Manual Codex session was outside the managed runner telemetry path.'
-	});
-}